How to use dependency injection pattern in Elixir?

Hey @kostonstyle could you provide a more practical example of what you want to do? Two things you may be interested in are:

1. Module module, which has functions like concat which let you dynamically build module namespaces.

2. The Kernel.apply/3 function which let’s yous dynamically call function passing their module and function name as an atom

For example, to write a testable module that make an http request to the server. In test, I need a fake server.

If you are looking for full fledged DI framework that will instantiate dependencies recursively based on say behaviors it does not exist.

But on the other hand if you can live with something simple as passing a module name as default argument to a function, and providing custom module name in tests that will work.

Yes, that is what I mean. The problem is only the dynamic typing. How can I ensure, when someone use the function, that will pass the right module?

I’ve find this Writing extensible Elixir with Behaviours article, but do not know, if it is the right way.

Dependency injection is bad pattern used in OO languages to overcome weakness of these languages.
DI frameworks are very dangerous (they do many things under which you don’t have control of)
For this reason I will never use Angular
In Java the example of DI is Spring Framework

Dependencies are not good, they are bad! They should be things that we try to avoid wherever possible.
https://dzone.com/articles/dependency-injection-makes

Functional languages don’t need DI.
In functional languages you just compose functions.
For testing you just mock function like GitHub - jjh42/mock: Mocking library for Elixir language · GitHub

Could you show me an example?

I was just trying to google something like that for you. Yes, behaviors is the fairly simple way to go and it’ll ensure the interface used in tests actually matches the one used in production (although the implementation differs).

And @mkunikow a lot of bad things can be said about mocks as well. My usual biggest concern is that you build the system that works in tests with mocks, but there can be mismatch between your mock’s interface and actual interface that you’ll miss and learn about it the hard way. Maintaining mocks, making sure everything’s mocked properly is also a considerable effort. It simply can be easier to build your own “null object” and pass it as a DI, or function parameter call it like you want, rather than trying to stub everything out.

@kostonstyle and you know about this, right: GitHub - BlakeWilliams/pact: Better dependency injection in Elixir · GitHub
?

Not sure what is so unpredictable about injecting based on interface or in case of Elixir say based on the behavior.