mappers | Declarative mappers to domain entities

The "no attribute id" error occurs because SQLAlchemy interprets 'entry.id' as referring to the underlying Table object, rather than the model. Fix this by using either 'Entry.id' (model reference) or 'entry.c.id' (table reference).

Additionally, use back_populates rather than backref to configure the reverse relationships:

The problem is that you've nested your record to have a type like this

You mocked your object under test and stubbed method under test - and you correctly concuded that such a test brings no benefit.

You are checking that you can stub a method, not your production code.

The main problem is your assumption that you need to mock every 3rd party class. This is wrong way of thinking - you should try to mock collaborators of your class (especially ones that cause side-effects unwanted in the test environment), but not the classes which are critical part of implementation of your class. The line might be sometimes blurry, but in this concrete example I strongly recommend NOT mocking the mapper:

• your 3rd party class is driven by annotations
• the annotations must correspond to your DTOs fields
• the field names in annotations are Strings, their presence is DTOs is not enforced by compiler
• all mapping is done in the memory

Creating a test that exercises production code gives you confidence that:

• field names are correct
• corresponding mapped fields have correct types (for example, you are not mapping int to boolean)

The linked test of the service is somewhat different: it tests a Spring service which calls the repository. The repository presumably represents some DB, which interacts with the outside world - it is a good candidate for a mock. To my eyes the service method only forwards the call to the repository - which is a trivial behaviour - so the test is trivial, but this setup will scale for more complicated service methods.

Update

Mocking source class for MapStruct.

If ModelObject is complicated to create, consider using mocks for some of its constructor parameters.

MapStruct currently can only use other mappers with a single source parameter. There is an open feature request mapstruct/mapstruct#2081 about this functionality.

What you could do is to use a wrapper object instead of multiple source parameters.

Did some testing, without the componentModel set to cdi what you have would generate what you expect. But with it you need to wildcard the generic typing of the input enum, after that it should work.

If the EnumUtil would look like this:

No, you can't define "global mappers". Scope can be used for this "global" approach. Use some your default scope (scope which is executed implicitly), which is default for all your clients, (for example profile scope usually) and define your "global" mapper(s) there.

So I discovered what the problem was. The issue really wasn't the database's fault or even the queries that were being used. It turns out that our system was using the same Transaction subsystem for both it our Data Source (Postgres Database) and our JMS messaging system. When a JMS message was sent, it created a transaction and every transactional based action that followed during the life cycle of that tread/transaction would be treated as part of that original transaction. Which includes all of our database calls.....

This explains why a query as simple as insert into a message log was touching all of our relations in the database. The debug queries only showed me the first query/statement sent to the database, not all of the others that were used during the life cycle of the JMS message. There were several ways to fix this but my team opted for the easiest which was preventing the Data Source from using the JBoss provided Transaction Manager.

MapStruct has a way to use custom mapping between some fields. So in your case you can do someting like:

this happening because the .ToAsyncEnumerable() will execute the db call when you are using the object (lazy loaded). ToList() will execute the db call immediately. So when you are using this inside a using statement, the DbContext is disposed while the return object is returned. the .ToList() is the right solution in this situation.

How ever, I am having doubts about your approach of creating and disposing of DbContext because it might leads to other problems later (like updating a object which is being tracked in another context instance etc). Also you will lose some benefits like, caching of results.