221.md

<details open><summary>Info</summary><p>

* **Did you know that with Automatic DI production wiring can be overwritten for integration testing?**

 * https://boost-ext.github.io/di/user_guide.html#di_bind

</p></details><details open><summary>Example</summary><p>

```cpp
class iapi {
 public:
  virtual ~iapi() = default;
  virtual auto call() const -> int = 0;
};

struct production_api : iapi { auto call() const -> int override { return {}; } };
struct fake_api       : iapi { auto call() const -> int override { return 42; } };

struct app {
  const iapi& api;
};

int main() {
  auto production = boost::di::make_injector(
    boost::di::bind<iapi>.to<production_api>()
  );

  assert(0 == boost::di::create<app>(production).api.call());

  auto testing = boost::di::make_injector(
    std::move(production), // include all production bindings
    boost::di::bind<iapi>.to<fake_api>() [ boost::di::override ]
  );

  assert(42 == boost::di::create<app>(testing).api.call());
}
```

> https://godbolt.org/z/cr597oPnY

</p></details><details open><summary>Puzzle</summary><p>

* **Can you implement `create` routine which construct type `T` with the production wiring overwritten by given fakes?**

```cpp
template<class T, class... TFakes>
constexpr auto create(auto&& production, const TFakes&... fakes) -> T; // TODO

int main() {
  using namespace boost::ut;

  bdd::gherkin::steps steps = [](auto& steps) {
    steps.feature("Production vs Integration Testing") = [&] {

      // Production wiring
      auto production = boost::di::make_injector(
        boost::di::bind<iapi>.to<production_api>()
      );

      steps.scenario("*") = [&] {
        constexpr auto expected_result = 42_i;

        steps.given("I have an app") = [&] {
          fakeit::Mock<iapi> fake_api{};
          fakeit::When(Method(fake_api, call)).Return(int(expected_result));
          auto sut = create<app>(production, fake_api.get());
          auto run_result = 0;

          steps.when("I call run on the app") = [&] {
            run_result = sut.run();
          };

          steps.then("I should get an expected result") = [&] {
            expect(run_result == expected_result);
          };
        };
      };
    };
  };

  "app"_test = steps | R"(
      Feature: Production vs Integration Testing
        Scenario: Dependency Injection
          Given I have an app
           When I call run on the app
           Then I should get an expected result
   )";
}
```

> https://godbolt.org/z/bdsqGrz73

</p></details><details><summary>Solutions</summary><p>

```cpp
template<class T, class... TFakes>
constexpr auto create(auto&& production, const TFakes&... fakes) {
  return boost::di::create<T>(boost::di::make_injector(
    std::move(production),
    boost::di::bind<TFakes>.to(fakes) [ boost::di::override ] ...
  ));
}
```

> https://godbolt.org/z/9e7aqsPdM

```cpp
template<class T, class TProduction, class... TFakes>
constexpr auto create(TProduction&& production, const TFakes&... fakes) -> T {
  auto i = boost::di::make_injector(std::forward<TProduction>(production),
                                    boost::di::bind<iapi>.to(fakes)[boost::di::override]...);
  return boost::di::create<T>(std::move(i));
}
```

> https://godbolt.org/z/x1ze7r44d

```cpp
template<class T, class... TFakes>
constexpr auto create(auto&& production, const TFakes&... fakes) -> T{
  auto testing = boost::di::make_injector(
    std::move(production), // include all production bindings
    boost::di::bind<TFakes>.to(fakes) [ boost::di::override ]...
  );
  return boost::di::create<T>(testing);
}
```

> https://godbolt.org/z/ojGzqK9Pf

```cpp
template<class T, class... TFakes>
constexpr auto create(auto&& production, const TFakes&... fakes) -> T
{
    auto testingInjector = boost::di::make_injector(
        //the production one
        std::move(production),
        //when we see something that can take a TFake use the one passed in
        boost::di::bind<TFakes>.to(fakes) [ boost::di::override ]...
    );
    return boost::di::create<T>(testingInjector);
}
```

> https://godbolt.org/z/Kfqsz9hrr