Cucumber module

Module to add cucumber to a project

src/main/java/tech/jhipster/lite/generator/project/domain/GeneratorAction.java

@@ -67,6 +67,8 @@ private GeneratorAction() {}
   public static final String SPRINGDOC_OPENAPI = "springdoc-openapi";
   public static final String SPRINGDOC_OPENAPI_WITH_SECURIITY_JWT = "springdoc-openapi-with-security-jwt";
 
+  public static final String SPRINGBOOT_CUCUMBER = "springboot-cucumber";
+
   public static final String REACT = "react";
   public static final String REACT_STYLED = "react-styled";
 

src/main/java/tech/jhipster/lite/generator/server/springboot/cucumber/application/CucumberApplicationService.java

@@ -0,0 +1,26 @@
+package tech.jhipster.lite.generator.server.springboot.cucumber.application;
+
+import org.springframework.stereotype.Service;
+import tech.jhipster.lite.generator.module.JHipsterModules;
+import tech.jhipster.lite.generator.module.domain.JHipsterModule;
+import tech.jhipster.lite.generator.server.springboot.cucumber.domain.CucumberModuleFactory;
+import tech.jhipster.lite.generator.server.springboot.cucumber.domain.CucumberModuleProperties;
+
+@Service
+public class CucumberApplicationService {
+
+  private final JHipsterModules modules;
+  private final CucumberModuleFactory factory;
+
+  public CucumberApplicationService(JHipsterModules modules) {
+    this.modules = modules;
+
+    factory = new CucumberModuleFactory();
+  }
+
+  public void add(CucumberModuleProperties properties) {
+    JHipsterModule module = factory.buildModule(properties);
+
+    modules.apply(properties.indentation(), module);
+  }
+}

src/main/java/tech/jhipster/lite/generator/server/springboot/cucumber/domain/CucumberModuleFactory.java

@@ -0,0 +1,105 @@
+package tech.jhipster.lite.generator.server.springboot.cucumber.domain;
+
+import static tech.jhipster.lite.generator.module.domain.JHipsterModule.*;
+
+import tech.jhipster.lite.error.domain.Assert;
+import tech.jhipster.lite.generator.module.domain.JHipsterModule;
+import tech.jhipster.lite.generator.module.domain.JHipsterSource;
+import tech.jhipster.lite.generator.module.domain.javadependency.JavaDependency;
+import tech.jhipster.lite.generator.module.domain.javadependency.JavaDependencyScope;
+
+public class CucumberModuleFactory {
+
+  public JHipsterModule buildModule(CucumberModuleProperties properties) {
+    Assert.notNull("properties", properties);
+
+    String packagePath = properties.basePackage().path();
+    String applicationName = properties.projectBaseName().capitalized();
+    JHipsterSource source = from("server/springboot/cucumber");
+
+    //@formatter:off
+    return moduleForProject(properties.project())
+      .context()
+        .packageName(properties.basePackage())
+        .put("applicationName", applicationName)
+        .and()
+      .files()
+        .batch(source, toSrcTestJava().append(packagePath).append("cucumber"))
+          .add("AsyncElementAsserter.java")
+          .add("AsyncHeaderAsserter.java")
+          .add("AsyncResponseAsserter.java")
+          .add("Awaiter.java")
+          .add("CucumberAssertions.java")
+          .add("CucumberConfiguration.java")
+          .add("CucumberJson.java")
+          .add("CucumberTest.java")
+          .add("CucumberTestContext.java")
+          .add("CucumberTestContextUnitTest.java")
+          .add("ElementAsserter.java")
+          .add("ElementAssertions.java")
+          .add("HeaderAsserter.java")
+          .add("HeaderAssertions.java")
+          .add("ResponseAsserter.java")
+          .add("SyncElementAsserter.java")
+          .add("SyncHeaderAsserter.java")
+          .add("SyncResponseAsserter.java")
+          .and()
+        .add(source.template("cucumber.md"), to("documentation/cucumber.md"))
+        .add(source.file("gitkeep"), to("src/test/features/.gitkeep"))
+        .and()
+      .javaDependencies()
+        .add(CucumberJunitDependency())
+        .add(cucumberJavaDependency())
+        .add(cucumberSpringDependency())
+        .add(junitVintageDependency())
+        .add(testNgDependency())
+        .add(awaitilityDepencency())
+        .and()
+      .build();
+    //@formatter:on
+  }
+
+  private JavaDependency CucumberJunitDependency() {
+    return javaDependency()
+      .groupId("io.cucumber")
+      .artifactId("cucumber-junit")
+      .versionSlug("cucumber.version")
+      .scope(JavaDependencyScope.TEST)
+      .build();
+  }
+
+  private JavaDependency cucumberJavaDependency() {
+    return javaDependency()
+      .groupId("io.cucumber")
+      .artifactId("cucumber-java")
+      .versionSlug("cucumber.version")
+      .scope(JavaDependencyScope.TEST)
+      .build();
+  }
+
+  private JavaDependency cucumberSpringDependency() {
+    return javaDependency()
+      .groupId("io.cucumber")
+      .artifactId("cucumber-spring")
+      .versionSlug("cucumber.version")
+      .scope(JavaDependencyScope.TEST)
+      .build();
+  }
+
+  private JavaDependency junitVintageDependency() {
+    return javaDependency().groupId("org.junit.vintage").artifactId("junit-vintage-engine").scope(JavaDependencyScope.TEST).build();
+  }
+
+  private JavaDependency testNgDependency() {
+    return javaDependency()
+      .groupId("org.testng")
+      .artifactId("testng")
+      .versionSlug("testng.version")
+      .scope(JavaDependencyScope.TEST)
+      .build();
+  }
+
+  private JavaDependency awaitilityDepencency() {
+    return javaDependency().groupId("org.awaitility").artifactId("awaitility").scope(JavaDependencyScope.TEST).build();
+  }
+}

src/main/java/tech/jhipster/lite/generator/server/springboot/cucumber/domain/CucumberModuleProperties.java

@@ -0,0 +1,90 @@
+package tech.jhipster.lite.generator.server.springboot.cucumber.domain;
+
+import tech.jhipster.lite.error.domain.Assert;
+import tech.jhipster.lite.generator.module.domain.Indentation;
+import tech.jhipster.lite.generator.module.domain.JHipsterBasePackage;
+import tech.jhipster.lite.generator.module.domain.JHipsterProjectBaseName;
+import tech.jhipster.lite.generator.module.domain.JHipsterProjectFolder;
+import tech.jhipster.lite.generator.project.domain.Project;
+
+public class CucumberModuleProperties {
+
+  private final JHipsterProjectFolder project;
+  private final Indentation indentation;
+  private final JHipsterBasePackage basePackage;
+  private final JHipsterProjectBaseName projectBaseName;
+
+  private CucumberModuleProperties(CucumberModulePropertiesBuilder builder) {
+    project = new JHipsterProjectFolder(builder.project);
+    indentation = Indentation.from(builder.indentation);
+    basePackage = new JHipsterBasePackage(builder.basePackage);
+    projectBaseName = new JHipsterProjectBaseName(builder.projectBaseName);
+  }
+
+  public static CucumberModuleProperties from(Project project) {
+    Assert.notNull("project", project);
+
+    return builder()
+      .project(project.getFolder())
+      .indentation(project.getIntegerConfig("prettierDefaultIndent").orElse(null))
+      .basePackage(project.getPackageNamePath().orElse(null))
+      .projectBaseName(project.getBaseName().orElse(null))
+      .build();
+  }
+
+  public static CucumberModulePropertiesBuilder builder() {
+    return new CucumberModulePropertiesBuilder();
+  }
+
+  public JHipsterProjectFolder project() {
+    return project;
+  }
+
+  public Indentation indentation() {
+    return indentation;
+  }
+
+  public JHipsterBasePackage basePackage() {
+    return basePackage;
+  }
+
+  public JHipsterProjectBaseName projectBaseName() {
+    return projectBaseName;
+  }
+
+  public static class CucumberModulePropertiesBuilder {
+
+    private String project;
+    private Integer indentation;
+    private String basePackage;
+    private String projectBaseName;
+
+    public CucumberModulePropertiesBuilder project(String project) {
+      this.project = project;
+
+      return this;
+    }
+
+    public CucumberModulePropertiesBuilder indentation(Integer indentation) {
+      this.indentation = indentation;
+
+      return this;
+    }
+
+    public CucumberModulePropertiesBuilder basePackage(String basePackage) {
+      this.basePackage = basePackage;
+
+      return this;
+    }
+
+    public CucumberModulePropertiesBuilder projectBaseName(String projectBaseName) {
+      this.projectBaseName = projectBaseName;
+
+      return this;
+    }
+
+    public CucumberModuleProperties build() {
+      return new CucumberModuleProperties(this);
+    }
+  }
+}

src/main/java/tech/jhipster/lite/generator/server/springboot/cucumber/infrastructure/primary/CucumberResource.java

@@ -0,0 +1,37 @@
+package tech.jhipster.lite.generator.server.springboot.cucumber.infrastructure.primary;
+
+import io.swagger.v3.oas.annotations.Operation;
+import io.swagger.v3.oas.annotations.responses.ApiResponse;
+import io.swagger.v3.oas.annotations.tags.Tag;
+import org.springframework.web.bind.annotation.PostMapping;
+import org.springframework.web.bind.annotation.RequestBody;
+import org.springframework.web.bind.annotation.RequestMapping;
+import org.springframework.web.bind.annotation.RestController;
+import tech.jhipster.lite.generator.project.domain.GeneratorAction;
+import tech.jhipster.lite.generator.project.domain.Project;
+import tech.jhipster.lite.generator.project.infrastructure.primary.dto.ProjectDTO;
+import tech.jhipster.lite.generator.server.springboot.cucumber.application.CucumberApplicationService;
+import tech.jhipster.lite.generator.server.springboot.cucumber.domain.CucumberModuleProperties;
+import tech.jhipster.lite.technical.infrastructure.primary.annotation.GeneratorStep;
+
+@RestController
+@Tag(name = "Spring Boot")
+@RequestMapping("/api/servers/spring-boot/cucumber")
+class CucumberResource {
+
+  private final CucumberApplicationService cucumber;
+
+  public CucumberResource(CucumberApplicationService cucumber) {
+    this.cucumber = cucumber;
+  }
+
+  @PostMapping
+  @GeneratorStep(id = GeneratorAction.SPRINGBOOT_CUCUMBER)
+  @Operation(summary = "Add cucumber integration to project")
+  @ApiResponse(responseCode = "500", description = "An error occurred while adding cucumber elements")
+  public void addJavaBase(@RequestBody ProjectDTO projectDTO) {
+    Project project = ProjectDTO.toProject(projectDTO);
+
+    cucumber.add(CucumberModuleProperties.from(project));
+  }
+}

src/main/java/tech/jhipster/lite/generator/server/springboot/cucumber/package-info.java

@@ -0,0 +1,2 @@
+@tech.jhipster.lite.BusinessContext
+package tech.jhipster.lite.generator.server.springboot.cucumber;

src/main/resources/generator/dependencies/pom.xml

@@ -32,6 +32,8 @@
     <flyway.version>8.5.11</flyway.version>
     <mongock.version>5.0.41</mongock.version>
     <archunit-junit5.version>0.23.1</archunit-junit5.version>
+    <cucumber.version>7.3.4</cucumber.version>
+    <testng.version>7.6.0</testng.version>
   </properties>
 
   <dependencyManagement>
@@ -117,6 +119,40 @@
         <version>${archunit-junit5.version}</version>
         <scope>test</scope>
       </dependency>
+      <dependency>
+        <groupId>io.cucumber</groupId>
+        <artifactId>cucumber-junit</artifactId>
+        <version>${cucumber.version}</version>
+        <scope>test</scope>
+      </dependency>
+      <dependency>
+        <groupId>io.cucumber</groupId>
+        <artifactId>cucumber-java</artifactId>
+        <version>${cucumber.version}</version>
+        <scope>test</scope>
+      </dependency>
+      <dependency>
+        <groupId>io.cucumber</groupId>
+        <artifactId>cucumber-spring</artifactId>
+        <version>${cucumber.version}</version>
+        <scope>test</scope>
+      </dependency>
+      <dependency>
+        <groupId>org.junit.vintage</groupId>
+        <artifactId>junit-vintage-engine</artifactId>
+        <scope>test</scope>
+      </dependency>
+      <dependency>
+        <groupId>org.testng</groupId>
+        <artifactId>testng</artifactId>
+        <version>${testng.version}</version>
+        <scope>test</scope>
+      </dependency>
+      <dependency>
+        <groupId>org.awaitility</groupId>
+        <artifactId>awaitility</artifactId>
+        <scope>test</scope>
+      </dependency>
     </dependencies>
   </dependencyManagement>
 </project>

src/main/resources/generator/server/springboot/cucumber/AsyncElementAsserter.java.mustache

@@ -0,0 +1,73 @@
+package {{packageName}}.cucumber;
+
+import java.time.Duration;
+import java.util.Collection;
+import java.util.List;
+import java.util.Map;
+
+class AsyncElementAsserter implements ElementAsserter<AsyncResponseAsserter> {
+
+  private final Duration maxTime;
+  private final AsyncResponseAsserter responseAsserter;
+  private final ElementAssertions assertions;
+
+  AsyncElementAsserter(AsyncResponseAsserter responseAsserter, String jsonPath, Duration maxTime) {
+    this.responseAsserter = responseAsserter;
+    this.maxTime = maxTime;
+    assertions = new ElementAssertions(jsonPath);
+  }
+
+  @Override
+  public AsyncElementAsserter withValues(Collection<String> values) {
+    Awaiter.await(maxTime, () -> assertions.withValues(values));
+
+    return this;
+  }
+
+  @Override
+  public AsyncElementAsserter withElementsCount(int count) {
+    Awaiter.await(maxTime, () -> assertions.withElementsCount(count));
+
+    return this;
+  }
+
+  @Override
+  public AsyncElementAsserter withMoreThanElementsCount(int count) {
+    Awaiter.await(maxTime, () -> assertions.withMoreThanElementsCount(count));
+
+    return this;
+  }
+
+  @Override
+  public AsyncElementAsserter withValue(Object value) {
+    Awaiter.await(maxTime, () -> assertions.withValue(value));
+
+    return this;
+  }
+
+  @Override
+  public <Data> AsyncElementAsserter containingExactly(List<Map<String, Data>> responses) {
+    Awaiter.await(maxTime, () -> assertions.containingExactly(responses));
+
+    return this;
+  }
+
+  @Override
+  public <Data> AsyncElementAsserter containing(Map<String, Data> response) {
+    Awaiter.await(maxTime, () -> assertions.containing(response));
+
+    return this;
+  }
+
+  @Override
+  public <Data> AsyncElementAsserter containing(List<Map<String, Data>> responses) {
+    Awaiter.await(maxTime, () -> assertions.containing(responses));
+
+    return this;
+  }
+
+  @Override
+  public AsyncResponseAsserter and() {
+    return responseAsserter;
+  }
+}