ruby - reciclados - como hacer un bolso de jeans viejos

Reutilizar los pasos de pepino

Question

Quiero reutilizar algunos pasos de Pepino, pero parece que no puedo encontrar el camino correcto.

Quiero escribir un paso como:

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

Pero luego da otro paso como:

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

Así que al probar la autenticación de usuario puedo usar el primero, pero en la mayoría de los otros lugares, puedo usar el último y no tener que reprogramar.

¿Hay alguna manera de llamar a ese otro paso, o simplemente pongo la lógica en un método auxiliar, y llamo a dicho método desde cada tarea (básicamente una refactorización de extracción de métodos, que después de leer mi pregunta me hace creer que es la mejor manera) de todas formas)?

Answer 1

Llamar a los pasos de las definiciones de pasos es una mala práctica y tiene algunas desventajas :

1. Si el escenario falla y hay invocaciones de paso anidadas, obtendrá solo la última definición de paso invocado en el seguimiento de la pila. Puede ser difícil encontrar desde qué lugar se llamó ese último paso.
2. Llamar a stepdef a veces es más difícil de encontrar y leer que el método ruby
3. Los métodos de Ruby te dan más poder que llamar pasos desde pasos definidos

Aslak Hellesøy recommends extraer acciones populares a World lugar de reutilizar pasos. Aísla esas acciones en un solo lugar, hace que este código sea más fácil de encontrar. También puede extraer el código a las clases o módulos de Ruby habituales.

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

Aquí hay una discusión útil sobre el tema en la lista de correo de Cucumber - link

Answer 2

Mejor ajuste sus pasos en% {} en lugar de comillas. Entonces, no necesita escapar las comillas dobles que necesitará usar con frecuencia:

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

Answer 3

Reutilice palabras clave en el archivo de características que proporcionará la reutilización del código.

NO se recomienda llamar a pasos defs dentro de los pasos definidos.

Escribiría mi archivo de características de esta manera,

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       |

En mi definición de paso, (Esto es 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 esta manera, hay una gran cantidad de reutilización de código. Su mismo Given y luego maneja escenarios válidos y no válidos. Al mismo tiempo, su archivo de características tiene sentido para los lectores.

Answer 4

Tenga en cuenta que el método para llamar pasos en pasos ha cambiado en las versiones recientes de pepino, que verá si obtiene un error como "ADVERTENCIA: Usar ''Dado / Cuándo / Luego'' en las definiciones de paso está en desuso, use ''paso'' para llame a otros pasos: /path/to/step_definitions/foo_steps.rb: 631: in `block in ''". Vea la wiki de pepino para más detalles.

La esencia del cambio es que ahora debe usar los métodos de step o 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

Answer 5

ACTUALIZACIÓN : el método descrito a continuación ha quedado obsoleto. La forma recomendada de llamar a un paso desde otro paso ahora se ve así:

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

Método antiguo, obsoleto (para referencia):

Puede llamar a los pasos de otros pasos como este:

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

Si todos los escenarios dentro de una característica requieren esto (u otros pasos), también puede agregar un Fondo a cada característica, con los pasos comunes, como sigue:

Background:
  Given I log in with valid credentials

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