avaje / avaje-inject Goto Github PK

@ExtendWith({SeleniumExtension.class})
public class InternalRestTest {

    private final Long expectedChecksum = 101010101L;

    @BeforeEach
    public void beforeEach(SeleniumHelper sh) throws Exception {
        sh.navigateTo("/");
    }

    @Test
    public void test_getBundleChecksum(SeleniumHelper sh) {

        InternalController internalRest = Mockito.spy(InternalController.class);
        doReturn(expectedChecksum).when(internalRest).getBundleChecksum();

        try (Context context = SystemContext.swapBean(internalRest)) { //<-- this would be nice
            //Not working with context here but Im expecting a different behavior from allready
            //started server

            Long response = sh.await("internalRest.getBundleChecksum()", Long.class);
            assertThat(response).isEqualTo(expectedChecksum);
        }
    }
}

public class SeleniumExtension implements BeforeAllCallback, BeforeEachCallback, AfterEachCallback, ParameterResolver {

    private WebDriver driver;
    private final int port = 80;

    @Override
    public void beforeAll(ExtensionContext ec) throws Exception {
        Application.main(null);
        WebDriverManager.chromedriver().setup();
    }

    @Override
    public void beforeEach(ExtensionContext ec) throws Exception {
        System.setProperty("webdriver.chrome.silentOutput", "true");
        ChromeOptions options = new ChromeOptions();
        if (equalsIgnoreCase(System.getProperty("selenium.headless"), "true")) {
            options.addArguments("headless");
        }
        driver = new ChromeDriver(options);
        driver.manage().window().setSize(new Dimension(1_440, 1_050));
        driver.manage().timeouts().implicitlyWait(10, SECONDS);
        driver.manage().timeouts().setScriptTimeout(10, SECONDS);
    }

    @Override
    public void afterEach(ExtensionContext ec) throws Exception {
        driver.quit();
    }

    @Override
    public boolean supportsParameter(ParameterContext pc, ExtensionContext ec) throws ParameterResolutionException {
        return pc.getParameter().getType() == SeleniumHelper.class;
    }

    @Override
    public Object resolveParameter(ParameterContext pc, ExtensionContext ec) throws ParameterResolutionException {
        return new SeleniumHelper(driver, port);
    }
}

public class Application {

    public static void main(String[] args) {

        InternalController internalController = getBean(InternalController .class);
        Security securityController = getBean(Security.class);

        Javalin javalin = Javalin.create()
                .disableStartupBanner()
                .enableCaseSensitiveUrls()
                .enableStaticFiles("/static")
                .accessManager(securityController)
                .start(80);

        javalin.post("/login", securityController::login, ANONYMOUS.asSet());
        javalin.get("/logout", securityController::logout, AUTHENTICATED.asSet());

        javalin.register(internalController);
    }
}

        BootContext bootContext = new BootContext();
        bootContext.withSpy(AppleService.class);
        BeanContext beanContext = bootContext.load();

        AppleService appleServiceSpy = beanContext.getBean(AppleService.class);

        doNothing()
                .when(appleServiceSpy)
                .foo(anyString(), anyString(), anyString());

        System.out.println(appleServiceSpy);
        System.out.println(appleServiceSpy.bananaService); //<- is null but should not
        System.out.println(appleServiceSpy.peachService);  //<- is null but should not

  @Test
  public void withMockitoSpy_whenPrimary_expect_spyUsed() {

    try (BeanContext context = new BootContext()
      .withSpy(PEmailer.class) // has a primary
      .load()) {

      UserOfPEmailer user = context.getBean(UserOfPEmailer.class);
      PEmailer emailer = context.getBean(PEmailer.class);

      user.email();
      verify(emailer).email();
    }
  }

package de.testung.example;

import com.fasterxml.jackson.databind.ObjectMapper;
import de.testung.example.ObjectMapperFactory;
import io.dinject.core.Builder;
import javax.annotation.Generated;

@Generated("io.dinject.generator")
public class ObjectMapperFactory$di  {

  public static void build(Builder builder) {
    if (builder.isAddBeanFor(ObjectMapperFactory.class)) {
      ObjectMapperFactory bean = new ObjectMapperFactory();
      builder.register(bean, null);
    }
  }

  public static void build_createObjectMapper(Builder builder) {
    if (builder.isAddBeanFor(ObjectMapper.class)) {
      ObjectMapperFactory factory = builder.get(ObjectMapperFactory.class);
      ObjectMapper bean = factory.createObjectMapper();
      builder.register(bean, null, Versioned.class, Serializable.class);
    }
  }
}

  @Test
  public void withBean_expect_testDoublePumpUsed() {

    TDPump testDoublePump = new TDPump();

    try (BeanContext context = new BootContext()
       // Use/inject this instance rather than the normal one AND the normally created bean is skipped 
      .withBean(testDoublePump) 
      .load()) {

      String makeIt = context.getBean(CoffeeMaker.class).makeIt();
      assertThat(makeIt).isEqualTo("done");

      assertThat(testDoublePump.steam).isEqualTo(1);
      assertThat(testDoublePump.water).isEqualTo(1);
    }
  }

  /**
   * Our test double that we want to wire.
   */
  class TDPump implements Pump {

    int water;
    int steam;

    @Override
    public void pumpWater() {
      water++;
    }

    @Override
    public void pumpSteam() {
      steam++;
    }
  }
``

@Factory
public class MyFactory {

  @Bean
  @Named("green")
  Otherthing greenOther() {
    return () -> "green";
  }

  @Bean
  @Named("yellow")
  Otherthing yellowOther() {
    return () -> "yellow";
  }
}

  private final Otherthing green;
  private final Otherthing yellow;

  MultipleOtherThings(@Named("green") Otherthing green, @Named("yellow") Otherthing yellow) {
    this.green = green;
    this.yellow = yellow;
  }

        BootContext bootContext = new BootContext();
        bootContext.withSpy(EmailService.class);
        beanContext = bootContext.load();

        EmailService emailService = beanContext.getBean(EmailService.class);
		
        System.out.println(emailService.getClass()); 
	// output--> class de.yaskor.autocontract.service.EmailService
		
        doNothing().when(emailService).sendEmail(anyString(), anyString(), anyString());

	BootContext bootContext = new BootContext();
        bootContext.withMock(EmailService.class);
        beanContext = bootContext.load();

        EmailService emailService = beanContext.getBean(EmailService.class);
        
        System.out.println(emailService.getClass()); 
	// output--> class de.yaskor.autocontract.service.EmailService$$EnhancerByMockitoWithCGLIB$$72a6db8a
		
        doNothing().when(emailService).sendEmail(anyString(), anyString(), anyString());

@Singleton
public class Foo {

  private final List<SomeInteface> somes;

  @Inject
  public Foo(List<SomeInteface> somes) {
    this.somes = somes;
  }

@Factory
public class Configuration {

  private final StartConfig startConfig;

  @Inject // ... factory can have dependencies ...
  public Configuration(StartConfig startConfig) {
    this.startConfig = startConfig;
  }

  @Bean  // a simple factory method
  public AFact buildA() {
    ...
  }

  @Bean  // a factory method with a dependency
  public BFact buildB(Other other) {
    ...
  }

  @Override
  public BeanContext createContext(Builder parent) {
    builder.setParent(parent);
    // other builders
    build_MyClass2();
    // other builders
    build_MyClass();
    return builder.build();
  }

@Qualifier
@Retention(RUNTIME)
public @interface Blue {
}

@Blue
@Singleton
public class BlueStore implements SomeStore {
...

@Singleton
public class StoreManagerWithQualifier {

  private final SomeStore store;

  public StoreManagerWithQualifier(@Blue SomeStore store) {
    this.store = store;
  }

@Singleton
public class StoreManagerWithFieldQualifier {

  @Inject
  @Blue
  SomeStore store;

public interface Repository<T,I> {
  T findById(I id);
}

@Singleton
public class HazRepo implements Repository<Haz,Long> {

  @Override
  public Haz findById(Long id) {
    ...
  }
}

@Singleton
public class HazManager  {

  private final Repository<Haz,Long> hazRepo;

  @Inject
  public HazManager(Repository<Haz, Long> hazRepo) {
    this.hazRepo = hazRepo;
  }

  public Haz find(Long id) {
    return hazRepo.findById(id);
  }
}

@Factory
public class MyFactory {

  @Bean
  SomeBean buildSomeBean() {
    return ...;
  }

  /**
   * A factory method that has dependencies and returns void.
   */
  @Bean
  void useSomeBean(SomeBean someBean) {

  }

  @Bean
  void another(SomeBean someBean) {

  }
}

private final List<Class> withMocks;
private final List<Class> withSpies;

private ContextExtension(List<Class> withMocks, List<Class> withSpies) {
	this.withMocks = withMocks;
	this.withSpies = withSpies;
}
		
...
		
BootContext bootContext = new BootContext();
withMocks.forEach(mock -> bootContext.withMock(mock));
withSpies.forEach(spy -> bootContext.withSpy(spy));
beanContext = bootContext.load();

@Controller
@Path("/foo")
public class AController {

  @Inject
  SomeService service;  // a normal dependency

  @Inject
  Context context;   // controller that injects the javalin context

  @Get
  public String get() {
    return "hi " + context.toString() + service.hi();
  }

// exclude all other modules ... just wire this module (for testing purposes)
bootContext.withExludeModules();

import javax.inject.Provider;
import javax.inject.Singleton;

@Singleton
public class FooProvider implements Provider<Foo> {

  private final SomeDependency bar;

  FooProvider(SomeDependency bar) {
    this.bar = bar;
  }

  @Override
  public Foo get() {
    ...
    return new Foo(...);
  }
}

  @Test
  public void withMockitoSpy_postLoadSetup_expect_spyUsed() {

    try (BeanContext context = new BootContext()
      .withSpy(Pump.class)
      .withSpy(Grinder.class) // HERE
      .load()) {

      ...

      CoffeeMaker coffeeMaker = context.getBean(CoffeeMaker.class);
      coffeeMaker.makeIt();

      ...

      Grinder grinder = context.getBean(Grinder.class);
      verify(grinder).grindBeans(); // throws IllegalStateException
    }
  }