Automocking dependencies typed with abstract class

[gabrielgasp]

As I understand, it's not possible to use automock to mock class dependencies that expect any implementation of an interface.

What about when the dependency expect an implementation of an abstract class? Is it possible?

[omermorad]

Hi @gabrielgasp,

I apologize for any confusion. Let me clarify regarding your questions about mocking class dependencies that expect an implementation of an interface or an abstract class.

Automock does support mocking such dependencies. The approach for mocking these dependencies may vary depending on the framework you are using. Let's consider the scenarios separately:

1. Mocking class dependencies that expect an implementation of an interface:

In order to mock an implementation of an interface, you typically need to provide a "token" that represents the interface. This token allows you to bind the interface to the desired mock implementation. One example is using NestJS, where you can use the @Inject() decorator with a token string.

interface Logger {
  // Interface methods here
}

class Foo {
  public constructor(@Inject('ActualLogger') private readonly logger: Logger) {
    // Class logic...
  }
}

By specifying the ActualLogger token, you can configure the dependency injection system to provide the desired implementation of the Logger interface during testing. With Automock, you can then create a mock implementation for the Logger interface using the TestBed API and inject it into the Foo class.

To provide a more specific solution, it would be helpful to know which framework you are using. Please let me know, and I can guide you accordingly.

2. Mocking dependencies that expect an implementation of an abstract class:

Similar to mocking interface implementations, you can also mock dependencies that expect an implementation of an abstract class. The process involves providing a mock implementation of the abstract class when configuring the dependency injection system.

If you can share an example of a dependency that expects an abstract class implementation, I can provide a more tailored solution for your specific case.

Please let me know the framework you are using and share any example code you have, and I'll be happy to suggest a suitable solution.

[gabrielgasp]

I greatly appreciate you answering my query.

I'm mostly using NestJS as you have probably guessed, but the question is purely theoretical. I don't have any concrete example on hand to give you.

I was aware of using the @Inject decorator to work with interfaces and abstract classes but I'm trying to avoid framework-specific code inside my application layer (besides the @Injectable decorator which is unavoidable).

I'll probably keep implementing my own mock classes for theses scenarios.