Este artigo apresenta o método de integrar a inicialização da primavera no Cucumber (BDD) e o compartilha com você. Os detalhes são os seguintes:
1. Crie uma nova estrutura de projeto de trampolim da seguinte forma:
2. Adicione dependências de POM
<? xml versão = "1.0" coding = "utf-8"?> <Projeto xmlns = "http://maven.apache.org/pom/4.0.0" xmlns: xsi = "http://www.ww3.org/2001/xmlschaMance xsi: schemalocation = "http://maven.apache.org/pom/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd"> <modelVersion> 4.0.0 </modelVersion> <proupid> com.chhliu <TRAFACTID> Spring-Boot-Cucumber </ArtifactId> <versão> 0.0.1-Snapshot </siers> <bacaging> jar </acheging> <name> spring-boot-cucumber </name> <cription> Projeto DemOr para a inicialização da primavera e do comprimido </creption> <purin> <purumd> org.springframework.boot </cretion> <puri> <voupid> org.springframework.BOOT </Descrição </artifactId> <Versão> 1.5.6.reLease </sisters> <RelityPath/> <!-Lookup Parent from Repository-> </anterrons> <Perts> <cucumber.version> 1.2.4 </cucumber.version> <Projecties> <cucumber.version> 1.2.4 </cucumber.version> <Projecties> <project.reporting.outputEncoding>UTF-8</project.reporting.outputEncoding> <java.version>1.7</java.version> </properties> <dependencies> <dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-web</artifactId> </dependency> <Depencency> <PuerpId> info.cukes </frupid> <stifactId> cucumber-java </artifactId> <versão> $ {cucumber.version} </sipers> </dependency> <pendency> <purfty> info.cukes </groupid> <stifactId> CUCUMENCIDE </Artift> </dependency> <pendency> <purbrouid> info.cukes </frupiid> <ArtifactId> cucumber-spring </artifactId> <versão> $ {cucumber.version} </versão> </dependency> <idepence> <voupid> info.cukes </grupo> <tifactid> cucumber- jumd> <versão> $ {Cucumber.version} </version> <clusions> <clusion> <rugnid> junit </roupiid> <stifactId> junit </stutifactId> </exclusion> </clusions> </dependency> <pendency> <voundid> org.springFramework.Boot </Grupoid> <scope>test</scope> </dependency> </dependencies> <build> <plugins> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-maven-plugin</artifactId> <configuration> <source>1.7</source> <target>1.7</target> </configuration> </plugin> <plugin> <groupId>org.codehaus.mojo</groupId> <artifactId>exec-maven-plugin</artifactId> <configuration> <source>1.7</source> <target>1.7</target> </configuration> <executions> <execution> <phase>integration-test</phase> <goals> <goal>java</goal> </goals> <configuration> <classpathScope>test</classpathScope> <mainClass>com.chhliu.test.CucumberTest.java</mainClass> <arguments> <argument>--plugin</argument> <argument>pretty</argument> <argument>--glue</argument> <argument>src/test/resources/</argument> </arguments> </configuration> </execution> </executions> </plugin> </flugins> </fruct> </project>2. Escreva a interface de serviço e as classes de implementação
pacote com.chhliu.service; / ** * Login de simulação * @Author chhliu * */ interface pública UserInfoservicei {Login booleano (String UserName, String senha, String confirmpassword); } pacote com.chhliu.service; importar org.springframework.tereotype.service; @Service ("UserInfoservice") Classe pública UserInfoservice implementa UserInfoservicei {public boolean Login (String UserName, String senha, String confirmpassword) {return (undername.equals ("Chhliu") & & senha.equals ("123456") & confirms }} 3. Escreva arquivos de recursos
#language: zh-cn # "zh-cn": { # "mas": "*| mas <", # "e": "*| e <| e <| e <| ao mesmo tempo <", # "então": "*| "Antecedentes", # "cenário": "cenario_outline": "esboço do cenário | esboço do script", # "Exemplos": "Exemplos", # "dado": "*| se <| se <| se <| se <| se <| se <" #} @bank função: se eu se retirar, o banco no banco, se eu fizer logon if <| Se o saldo for de 500.000, cenário: retirar dinheiro em dinheiro se: eu faço login com "chhliu" e a senha inserida é "123456" quando: confirmar a senha também é "123456", então: o saldo do cartão bancário será "500.000" 4. Escreva aulas de teste
pacote com.chhliu.test; importar org.junit.runner.runwith; importar cucumber.api.cucumberOptions; importar cucumber.api.junit.cucumber; /** * @RunWith(Cucumber.class) This is a runner, which refers to using Cucumber to run tests* @CucumberOptions, which specifies the directory of the feature to be run in our project* @CucumberOptions format, which specifies the report to be generated when we run in our project, and then specifies that the corresponding test report can be found in the target directory* @CucumberOptions glue, used to Especifique o diretório que encontra o arquivo de definição de etapa quando o projeto é executado * * em projetos reais, à medida que o projeto progride, um projeto de teste pode consistir em vários arquivos de recursos e cada arquivo de recurso também pode consistir em vários cenários. Por padrão, * cada execução é executar todos os cenários em todos os recursos. Isso pode fazer com que o script de teste seja executado uma vez em circunstâncias normais, o que leva muito tempo para aguardar os resultados do teste. * No entanto, no processo real, os casos de teste são distinguidos pela prioridade. Por exemplo, SmokEtest, RegressionTest, etc. Ou, às vezes, existem casos de uso particularmente pequenos, como o nível é crítico, * esses casos de uso requerem operação a longo prazo para monitorar se o sistema não possui páginas brancas ou páginas 404. * Portanto, precisamos distinguir todos os cenários, para que, quando iniciamos o script de teste, podemos executar o cenário de quais módulos precisamos. No momento, podemos usar tags * no pepino, a tag adiciona diretamente qualquer número de tags com @prefixado para características ou cenários antes do recurso, cenário ou cenário esboço -palavras, e várias tags são separadas por spaces * @author chhliu * */ @runwith (cucumber.cl) @authortions (pluginj (@runwith (cucumber.cliSt) @author chhliu * */ @runwith (cucumber.cl) @authortions (cucumornj/ cUbumSon/ cucumSon (cucumber.cumj/ cUNCUMCTIONS (CUCUNDJ (CUCUMT.CUMT) "Pretty"}, recursos = "src/test/rources") public class cucumbertest {} 5. Execute a classe de teste e melhore as etapas indefinidas da saída de teste
pacote com.chhliu.test; importar javax.annotation.resource; importar org.junit.assert; importar com.chhliu.service.userinfoservicei; importar Cucumber.api.java.zh_cn.if; importar cucen.api.java.zh_cn.when; importar cucen.api.java.zh_cn.so; classe pública CUCUMER Integração Spring {@Resource (name = "userInfoservice") privado userInfoservicei serviço; Nome de usuário privado de string; senha de sequência privada; String privada confirmpassword; @IF ("^: eu faço login $ com/" ([^/"]*)/" $ ") public void I (string arg1) lança arremesso {this.username = arg1;} @if ("^: a senha inserida é/"([^/"]*)/"$") public void. } @When ("^: a senha também é/" ([^/"]*)/" $ ") public void A senha de confirmação também é _ (string arg1) lança arremesso {this.confirmpassword = arg1;} @then ("^: mostre o balanço do banco é/"([^/"]*)/"$") Public Void Shows Service.login (nome de usuário, senha, confirmpassword); if (islogin) {System.out.println ("Login com sucesso! O equilíbrio da consulta é o seguinte:"+arg1); Assert.assertequals ("500000", arg1); }}} 6. Adicione o suporte à anotação às etapas de teste
@Runwith (springjunit4classrunner.class) @ContextConfiguration // Se essa anotação não for adicionada, o feijão será injetado e não poderá ser injetado @springboottest mais // se esta anotação não for adicionada, o feijão não será encontrado em classe pública Cucumber Spring {}} 7. Resultados dos testes
2 cenários (2 passados)
11 etapas (11 passadas)
0M0.091S
8. Pontos de integração
Ao integrar a inicialização do Spring ao CUCUMER, há um ponto que precisa receber atenção, porque os defensores da inicialização da Spring Boots de-xmlização; portanto, da maneira tradicional, o CUCUMER lerá o arquivo de configuração do cuber.xml em ClassPath para inicializar o feijão. Após a integração com a primavera, esse método não pode ser usado. Você precisa usar a anotação @ContextConfiguration para implementar o carregamento da classe. Se o arquivo de configuração precisar ser carregado, você poderá usá -lo da seguinte forma:
@ContextConfiguration (Locations = {"ClassPath: ApplicationContext.xml"})Se você usar anotações para integrar, use o seguinte:
@ContextConfiguration (Classes = SpringbootCucumberApplication.class)
Ou diretamente
@ContextConfiguration
Nota especial: a anotação @ContextConfiguration deve ser adicionada, caso contrário, a injeção de feijão falhará.
Em seguida, vamos dar uma olhada no motivo pelo qual essa situação é causada pelo código -fonte.
O código envolvido nesta parte está na classe SpringFactory sob o pacote de primavera de pepino. Vamos dar uma olhada na aula seguinte:
public void start () {// Método de início do teste de pecumber if (StepClassWithSpringContext! = null) {// Se a anotação @ContextConfiguration for usada, isso não for nulo testContextManager = new CucumberTestContextManager (StepClassWithspringContextManager = } else {//, caso contrário, o StepClassWithsPringContext será nulo e entrará no seguinte ramo se (beanFactory == null) {beanFactory = createfallbackContext (); // Este método é o foco que queremos seguir}}}} notifyContextManageroutTestClassSTarteteted (); if (beanfactory == null || isnewContextCreated ()) {beanFactory = testContextManager.getBeanFactory (); para (classe <?> StepClass: StepClasses) {RegisterstepclassBeandEfinition (BeanFactory, StepClass); }} Gluecodecontext.instance.start (); } Vamos seguir o método CreateFallbackContext:
private configurableListableBeanFactory createfallbackContext () {configurableApplicationContext ApplicationContext; if (getClass (). getClassLoader (). getResource ("cucumber.xml")! = null) {// o <span style = "font-family: Arial, helvetica, sans-serif;"> configurableApplicationContext <xt> } else {// se cucumber.xml não estiver configurado, ele será novo genéricopplicationContext = new GenericApplicationContext (); } ApplicationContext.RegisterShutDownHook (); ConfigurableListableBeanFactory BeanFactory = ApplicationContext.getBeanFactory (); beanFactory.RegisterScope (gluecodescope.name, new GlueCodescope ()); para (classe <?> StepClass: StepClasses) {RegisterstepclassBeandEfinition (BeanFactory, StepClass); } retornar beanfactory; }Por fim, vamos falar sobre a classe GenericApplicationContext. Esta classe será baseada no tipo de feijão e depois na instância de NewInstance. No entanto, como outras classes são injetadas nessa classe, a classe injetada não pode ser inicializada através da nova instância, a injeção falhará e um ponteiro nulo será relatado.
O exposto acima é todo o conteúdo deste artigo. Espero que seja útil para o aprendizado de todos e espero que todos apoiem mais o wulin.com.