Riutilizza i passaggi del cetriolo

Voglio riutilizzare alcuni gradini di cetriolo ma non riesco a trovare la strada giusta.

Voglio scrivere un passaggio come:

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

Ma poi fai un altro passaggio come:

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

Quindi, nel testare l'autenticazione dell'utente, posso usare il primo, ma nella maggior parte degli altri posti, posso usare il secondo e non devo effettivamente riprodurre il codice.

C'è un modo per chiamare quell'altro passaggio, o metto semplicemente la logica in un metodo di supporto e chiamo detto metodo da ogni attività (fondamentalmente un refactoring di estrazione del metodo, che, dopo aver letto la mia domanda, mi fa credere che sia effettivamente il modo migliore Comunque)?

AGGIORNAMENTO : il metodo descritto di seguito è stato deprecato. Il modo consigliato per chiamare un passaggio dall'interno di un altro passaggio ora è simile al seguente:

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

Vecchio metodo obsoleto (per riferimento):

Puoi richiamare i passaggi da altri passaggi come questo:

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

Se tutti gli scenari all'interno di una funzionalità richiedono questo (o altri passaggi), puoi anche aggiungere uno sfondo a ciascuna funzionalità, con i passaggi comuni, in questo modo:

Background:
  Given I log in with valid credentials

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

Tieni presente che il metodo per chiamare i passaggi all'interno di passaggi è cambiato nelle versioni recenti di cucumber, che vedrai se ricevi un errore del tipo "ATTENZIONE: l'utilizzo di" Dato / Quando / Allora "nelle definizioni dei passaggi è obsoleto, utilizza" passaggio "per chiama invece altri passaggi: /path/to/step_definitions/foo_steps.rb: 631: in `block in '". Vedi il wiki del cetriolo per i dettagli.

L'essenza del cambiamento è che ora dovresti usare i metodi stepo 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

Il richiamo dei passaggi dalle definizioni dei passaggi è una cattiva pratica e presenta alcuni svantaggi :

1. Se lo scenario fallisce e sono presenti richiami di passaggi nidificati, si otterrà solo l'ultima definizione di passaggio richiamato nella traccia dello stack. Potrebbe essere difficile trovare da quale posizione è stato chiamato l'ultimo stepdef
2. La chiamata a stepdef a volte è più difficile da trovare e leggere rispetto al metodo ruby
3. I metodi Ruby ti danno più potenza rispetto alla chiamata di passaggi da step defs

Aslak Hellesøy consiglia di estrarre le azioni popolari in World invece di riutilizzare i passaggi. Isola quelle azioni in un unico posto, rende questo codice più facile da trovare. Puoi anche estrarre il codice nelle normali classi o moduli Ruby.

#/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

Ecco un'utile discussione sull'argomento nella mailing list di Cucumber - link

È meglio racchiudere i passaggi in% {} anziché tra virgolette. Quindi, non è necessario sfuggire alle virgolette doppie che dovrai usare frequentemente .:

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

Riutilizzare le parole chiave nel file di funzionalità che fornirà la riusabilità del codice.

Si sconsiglia vivamente di chiamare step defs all'interno di step defs.

Scriverei il mio file delle caratteristiche in questo modo,

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       |

Nella mia definizione del passaggio, (Questo è 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
    }
}

In questo modo, c'è molta riusabilità del codice. Il tuo stesso dato e quindi gestisce scenari validi e non validi. Allo stesso tempo, il tuo file delle caratteristiche ha senso per i lettori.