Good Practice Variablen zwischen Gurken-jvm passieren Schritte

Question

Um Variablen zwischen den Schritten passieren nun so etwas wie das Beispiel, das ich mache, wie folgt:

Feature: Demo 

    Scenario: Create user 
    Given User creation form management 
    When Create user with name "TEST" 
    Then User is created successfully 

Java-Klasse mit den Schritten Definitionen:

public class CreateUserSteps { 

    private String userName; 

    @Given("^User creation form management$") 
    public void User_creation_form_management() throws Throwable { 
     // ... 
    } 

    @When("^Create user with name \"([^\"]*)\"$") 
    public void Create_user_with_name(String userName) throws Throwable { 
     //... 
     this.userName = userName; 
    } 

    @Then("^User is created successfully$") 
    public void User_is_created_successfully() throws Throwable { 
     // Assert if exists an user with name equals to this.userName 
    } 

Meine Frage ist, ob dies eine gute Praxis ist, Informationen zwischen den Schritten zu teilen? Oder wäre besser definieren die Funktion als:

Then User with name "TEST" is created successfully 

Ich bin neu mit Gurken-jvm so leid, wenn es sich um eine hirnlose Frage ist.

Jede Hilfe wäre willkommen. Danke

Answer 1

Um Gemeinsamkeiten zwischen den Schritten teilen Sie ein World verwenden müssen. In Java ist es nicht so klar wie in Ruby.

Zitat der Schöpfer der Gurke.

Der Zweck einer "Welt" ist eine doppelte:

1) Zustand zwischen den Szenarien isolieren.

2) Teilen Sie Daten zwischen Schrittdefinitionen und Hooks innerhalb eines Szenarios.

Wie dies implementiert wird, ist sprachspezifisch. Zum Beispiel in Ruby, die implizite self Variable innerhalb einer Schrittdefinition zeigt auf das aktuelle Szenario World-Objekt. Dies ist standardmäßig eine Instanz von Object, aber es kann alles sein, was Sie wollen, wenn Sie den World Hook verwenden.

In Java haben Sie viele (möglicherweise verbundene) World-Objekte.

Das Äquivalent der Welt in Cucumber-Java ist alle Objekte mit Hook oder Stepdef Annotationen. Mit anderen Worten, jede Klasse mit Methoden, die mit @Before, @After, @Given usw. versehen sind, wird genau einmal für jedes Szenario instanziiert.

Dies erreicht das erste Ziel. das zweite Ziel zu erreichen, haben Sie zwei Ansätze:

a) für alle Ihre Schritt Definitionen eine einzige Klasse verwenden und Haken

b) mehrere Klassen von Verantwortung geteilt Verwenden Sie [1] und die Abhängigkeit Injektion verwenden [ 2] um sie miteinander zu verbinden.

Option a) bricht schnell zusammen, weil Ihr Schrittdefinitionscode ein Chaos wird. Deshalb neigen Leute dazu, b) zu benutzen.

[1] https://github.com/cucumber/cucumber/wiki/Step-Organization

[2] PicoContainer, Spring, Guice, Weld, OpenEJB, Nadel

Die verfügbaren Injection Dependency Module sind:

• cucumber-picocontainer
• Gurken-Guice
• Gurke-Openejb
• Gurken-Feder
• Gurken-Schweiß
• Gurken-Nadel

Original-Beitrag hier https://groups.google.com/forum/#!topic/cukes/8ugcVreXP0Y.

Hoffe, das hilft.

Answer 2

Es ist in Ordnung, Daten zwischen Schritten innerhalb einer Klasse mit einer Instanzvariable zu teilen. Wenn Sie Daten zwischen Schritten in verschiedenen Klassen teilen müssen, sollten Sie sich die DI-Integrationen ansehen (PicoContainer ist die einfachste).

In dem Beispiel, das Sie zeigen, würde ich fragen, ob überhaupt "TEST" im Szenario angezeigt wird. Die Tatsache, dass der Benutzer TEST genannt wird, ist ein nebensächliches Detail und macht das Szenario weniger lesbar. Warum nicht einen zufälligen Namen (oder harten Code etwas) in Create_user_with_name() erzeugen?

Answer 3

Ich würde sagen, dass es Gründe gibt, Informationen zwischen den Schritten zu teilen, aber ich denke nicht, dass das in diesem Szenario der Fall ist. Wenn Sie den Benutzernamen über die Testschritte weitergeben, ist es nicht wirklich klar aus dem Feature, was vor sich geht. Ich denke, es ist besser, im Szenario konkret zu sagen, was erwartet wird. Ich würde wahrscheinlich etwas tun:

Feature: Demo 

    Scenario: Create user 
    Given User creation form management 
    When Create user with name "TEST" 
    Then A user named "TEST" has been created 

Dann Ihre eigentliche Prüfschritte könnte etwa so aussehen:

@When("^Create user with name \"([^\"]*)\"$") 
public void Create_user_with_name(String userName) throws Throwable { 
    userService.createUser(userName); 
} 

@Then("^A user named \"([^\"]*)\" has been created$") 
public void User_is_created_successfully(String userName) throws Throwable { 
    assertNotNull(userService.getUser(userName)); 
} 

Answer 4

In reinem Java verwende ich nur ein Singleton-Objekt, das einmal erstellt und nach Tests gelöscht wird.

public class TestData_Singleton { 
    private static TestData_Singleton myself = new TestData_Singleton(); 

    private TestData_Singleton(){ } 

    public static TestData_Singleton getInstance(){ 
     if(myself == null){ 
      myself = new TestData_Singleton(); 
     } 

     return myself; 
    } 

    public void ClearTestData(){ 
     myself = new TestData_Singleton(); 
    } 

Answer 5

Wenn Sie Serenity Framework mit Gurke verwenden, können Sie aktuelle Sitzung verwenden.

Serenity.getCurrentSession() 

mehr über diese Funktion in http://thucydides-webtests.com/2012/02/22/managing-state-between-steps/. (Serenity wurde vor Thukydides genannt)

Answer 6

Hier ist meine Art und Weise: Ich definiere einen benutzerdefinierten Szenario-Scope mit Feder jedes neue Szenario gibt es einen frischen Kontext sein

Feature  @Dummy 
    Scenario: zweites Scenario 
    When Eins 
    Then Zwei 

1: Verwenden Sie Feder

<properties> 
<cucumber.version>1.2.5</cucumber.version> 
<junit.version>4.12</junit.version> 
</properties> 

<!-- cucumber section --> 


<dependency> 
    <groupId>info.cukes</groupId> 
    <artifactId>cucumber-java</artifactId> 
    <version>${cucumber.version}</version> 
    <scope>test</scope> 
</dependency> 
<dependency> 
    <groupId>info.cukes</groupId> 
    <artifactId>cucumber-junit</artifactId> 
    <version>${cucumber.version}</version> 
    <scope>test</scope> 
</dependency> 
<dependency> 
    <groupId>junit</groupId> 
    <artifactId>junit</artifactId> 
    <version>${junit.version}</version> 
    <scope>test</scope> 
</dependency> 

<dependency> 
    <groupId>info.cukes</groupId> 
    <artifactId>cucumber-spring</artifactId> 
    <version>${cucumber.version}</version> 
    <scope>test</scope> 
</dependency> 


<!-- end cucumber section --> 

<!-- spring-stuff --> 
<dependency> 
     <groupId>org.springframework</groupId> 
     <artifactId>spring-test</artifactId> 
       <version>4.3.4.RELEASE</version> 
     <scope>test</scope> 
</dependency> 

    <dependency> 
     <groupId>org.springframework</groupId> 
     <artifactId>spring-context</artifactId> 
       <version>4.3.4.RELEASE</version> 
     <scope>test</scope> 
    </dependency> 
    <dependency> 
     <groupId>org.springframework</groupId> 
     <artifactId>spring-tx</artifactId> 
     <version>4.3.4.RELEASE</version> 
     <scope>test</scope> 
    </dependency> 
    <dependency> 
     <groupId>org.springframework</groupId> 
     <artifactId>spring-core</artifactId> 
     <version>4.3.4.RELEASE</version> 
     <scope>test</scope> 
     <exclusions> 
      <exclusion> 
       <groupId>commons-logging</groupId> 
       <artifactId>commons-logging</artifactId> 
      </exclusion> 
     </exclusions> 
    </dependency> 
    <dependency> 
     <groupId>org.springframework</groupId> 
     <artifactId>spring-beans</artifactId> 
       <version>4.3.4.RELEASE</version> 
     <scope>test</scope> 
    </dependency> 

    <dependency> 
     <groupId>org.springframework.ws</groupId> 
     <artifactId>spring-ws-core</artifactId> 
     <version>2.4.0.RELEASE</version> 
     <scope>test</scope> 
    </dependency> 

2: bauen benutzerdefinierten Bereich Klasse

import org.springframework.context.annotation.Scope; 
import org.springframework.stereotype.Component; 

@Component 
@Scope(scopeName="scenario") 
public class ScenarioContext { 

    public Scenario getScenario() { 
     return scenario; 
    } 

    public void setScenario(Scenario scenario) { 
     this.scenario = scenario; 
    } 

    public String shareMe; 
} 

3: Nutzung in s tepdef

@ContextConfiguration(classes = { CucumberConfiguration.class }) 
public class StepdefsAuskunft { 

private static Logger logger = Logger.getLogger(StepdefsAuskunft.class.getName()); 

@Autowired 
private ApplicationContext applicationContext; 

// Inject service here : The impl-class need @Primary @Service 
// @Autowired 
// IAuskunftservice auskunftservice; 


public ScenarioContext getScenarioContext() { 
    return (ScenarioContext) applicationContext.getBean(ScenarioContext.class); 
} 


@Before 
public void before(Scenario scenario) { 

    ConfigurableListableBeanFactory beanFactory = ((GenericApplicationContext) applicationContext).getBeanFactory(); 
    beanFactory.registerScope("scenario", new ScenarioScope()); 

    ScenarioContext context = applicationContext.getBean(ScenarioContext.class); 
    context.setScenario(scenario); 

    logger.fine("Context für Scenario " + scenario.getName() + " erzeugt"); 

} 

@After 
public void after(Scenario scenario) { 

    ScenarioContext context = applicationContext.getBean(ScenarioContext.class); 
    logger.fine("Context für Scenario " + scenario.getName() + " gelöscht"); 

} 



@When("^Eins$") 
public void eins() throws Throwable { 
    System.out.println(getScenarioContext().getScenario().getName()); 
    getScenarioContext().shareMe = "demo" 
    // you can save servicecall here 
} 

@Then("^Zwei$") 
public void zwei() throws Throwable { 
    System.out.println(getScenarioContext().getScenario().getName()); 
    System.out.println(getScenarioContext().shareMe); 
    // you can use last service call here 
} 


@Configuration 
    @ComponentScan(basePackages = "i.am.the.greatest.company.cucumber") 
    public class CucumberConfiguration { 
    } 

der Umfang Klasse

import java.util.Collections; 
import java.util.HashMap; 
import java.util.Map; 

import org.springframework.beans.factory.ObjectFactory; 
import org.springframework.beans.factory.config.Scope; 


public class ScenarioScope implements Scope { 


    private Map<String, Object> objectMap = Collections.synchronizedMap(new HashMap<String, Object>()); 

    /** (non-Javadoc) 
    * @see org.springframework.beans.factory.config.Scope#get(java.lang.String, org.springframework.beans.factory.ObjectFactory) 
    */ 
    public Object get(String name, ObjectFactory<?> objectFactory) { 
     if (!objectMap.containsKey(name)) { 
      objectMap.put(name, objectFactory.getObject()); 
     } 
     return objectMap.get(name); 

    } 

    /** (non-Javadoc) 
    * @see org.springframework.beans.factory.config.Scope#remove(java.lang.String) 
    */ 
    public Object remove(String name) { 
     return objectMap.remove(name); 
    } 

    /** (non-Javadoc) 
    * @see org.springframework.beans.factory.config.Scope#registerDestructionCallback(java.lang.String, java.lang.Runnable) 
    */ 
    public void registerDestructionCallback(String name, Runnable callback) { 
     // do nothing 
    } 

    /** (non-Javadoc) 
    * @see org.springframework.beans.factory.config.Scope#resolveContextualObject(java.lang.String) 
    */ 
    public Object resolveContextualObject(String key) { 
     return null; 
    } 

    /** (non-Javadoc) 
    * @see org.springframework.beans.factory.config.Scope#getConversationId() 
    */ 
    public String getConversationId() { 
     return "VolatileScope"; 
    } 

    /** 
    * vaporize the beans 
    */ 
    public void vaporize() { 
     objectMap.clear(); 
    } 


}