Réutiliser les étapes de concombre

Je veux réutiliser certaines étapes du concombre mais je n'arrive pas à trouver le bon chemin.

Je veux écrire une étape comme:

Given /^I login with (.*) credentials$/ |type|
  # do stuff with type being one of "invalid" or "valid"
end

Mais alors ayez une autre étape comme:

Given /^I login successfully$
  # call "Given I login with valid credentials"
end

Donc, en testant l'authentification des utilisateurs, je peux utiliser le premier, mais dans la plupart des autres endroits, je peux utiliser le second, sans avoir à reproduire le code.

Existe-t-il un moyen d'appeler cette autre étape, ou est-ce que je mets simplement la logique dans une méthode d'aide et appelle-t-elle ladite méthode à partir de chaque tâche (essentiellement un refactoring d'extraction de méthode, qui, après avoir lu ma question, me fait croire que c'est en fait le meilleur moyen en tous cas)?

MISE À JOUR : la méthode décrite ci-dessous est obsolète. La méthode recommandée pour appeler une étape à partir d'une autre étape ressemble maintenant à ceci:

Given /^I login successfully$/
    step "I login with valid credentials" 
end 

Ancienne méthode obsolète (pour référence):

Vous pouvez appeler des étapes d'autres étapes comme celle-ci:

Given /^I login successfully$/
  Given "I login with valid credentials"
  Then "I should be logged in"
end

Si tous les scénarios d'une fonctionnalité nécessitent cette étape (ou d'autres étapes), vous pouvez également ajouter un arrière-plan à chaque fonctionnalité, avec les étapes courantes, comme ceci:

Background:
  Given I log in with valid credentials

Scenario: Change my password
  Given I am on the account page

Notez que la méthode d'appel des étapes dans les étapes a changé dans les versions récentes de concombre, ce que vous verrez si vous obtenez une erreur du type "AVERTISSEMENT: l'utilisation de 'Compte tenu / Quand / Alors' dans les définitions d'étape est obsolète, utilisez 'step' pour appelez d'autres étapes à la place: /path/to/step_definitions/foo_steps.rb: 631: in `block in '". Voir le wiki du concombre pour plus de détails.

L'essentiel du changement est que vous devez maintenant utiliser les méthodes stepou steps.

When /^I make all my stuff shiny$/
  step "I polish my first thing"
end

When /^I make all my stuff shiny$/
  steps %Q{
    When I polish my first thing
    When I shine my second thing
  }
end

L'appel d'étapes à partir de définitions d'étape est une mauvaise pratique et présente certains inconvénients :

1. Si le scénario échoue et qu'il existe des appels d'étape imbriqués, vous n'obtiendrez que la dernière définition d'étape appelée dans la trace de pile. Il peut être difficile de trouver à partir de quel endroit ce dernier stepdef a été appelé
2. L'appel à stepdef est parfois plus difficile à trouver et à lire que la méthode ruby
3. Les méthodes Ruby vous donnent plus de puissance que d'appeler des étapes à partir des définitions d'étape

Aslak Hellesøy recommande d'extraire les actions populaires dans World au lieu de réutiliser les étapes. Il isole ces actions en un seul endroit, facilite la recherche de ce code. Vous pouvez également extraire du code vers des classes ou des modules Ruby habituels.

#/support/world_extensions.rb
module KnowsUser
  def login
    visit('/login')
    fill_in('User name', with: user.name)
    fill_in('Password', with: user.password)
    click_button('Log in')
  end

  def user
    @user ||= User.create!(:name => 'Aslak', :password => 'xyz')
  end
end
World(KnowsUser)

#/step_definitions/authentication_steps.rb
When /^I login$/ do
  login
end

Given /^a logged in user$/ do
  login
end

Voici une discussion utile sur le sujet dans la liste de diffusion Cucumber - lien

Mieux vaut encapsuler vos étapes en% {} plutôt qu'en guillemets. Ensuite, vous n'avez pas besoin d'échapper aux guillemets doubles que vous devrez utiliser fréquemment:

Given /^I login successfully$
  step %{I login with valid credentials}
end

Given /^I login with (.*) credentials$/ |type|
  # do stuff with type being one of "invalid" or "valid"
end

Réutilisez les mots-clés dans le fichier d'entités qui fourniront la réutilisabilité du code.

Il n'est pas recommandé d'appeler step defs dans step defs.

J'écrirais mon fichier d'entités de cette façon,

Scenario Outline: To check login functionality
    Given I login with "<username>" and "<password>"
    Then I "<may or may not>" login successfully

Examples:
    |username|password|may or may not|
    |paul    |123$    |may           |
    |dave    |1111    |may not       |

Dans ma définition d'étape, (c'est Java)

@Given(I login with \"([^\"]*)\" and \"([^\"]*)\"$)
public void I_login_with_and(String username, String password){

   //login with username and password

}

@Then(I \"([^\"]*)\" login successfully$)
public void I_login_successully_if(String validity){

    if(validity.equals("may")){
        //assert for valid login
    }
    else
    if(validity.equals("may not")){
        //assert for invalid login
    }
}

De cette façon, il y a beaucoup de réutilisabilité du code. Votre même Étant donné et Alors gère les scénarios valides et non valides. En même temps, votre fichier d'entités a du sens pour les lecteurs.