¿Hay algún complemento de Rails que pueda generar modelos, vistas, etc. utilizando los escenarios de Cucumber?

Question

Estoy planeando crear un complemento que genere código de aplicación basado en escenarios de pepino, pero quiero asegurarme de que no estoy reinventando la rueda aquí. ¿Alguien conoce un plugin que funciona con Cucumber y genera modelos, controladores y vistas?

Solo un poco de información sobre lo que estoy tratando de hacer en caso de que esto no tenga sentido. Cuando creo una nueva aplicación aquí está mi flujo de trabajo:

1. Dibuje 2 tipos de diseños de alto nivel en mi pizarra. 1 que muestra modelos y relaciones y otro que muestra algunas pantallas primitivas para diseños, formularios, etc.

2. Escribe escenarios de pepino basados ​​en el diseño de alto nivel (pero más fino). Muchos de estos pasos solo describen lo que veré en una vista particular y también describen el flujo de la aplicación. Encuentro que crear todos los escenarios en los que puedo pensar antes de comenzar a codificar es mejor que hacer uno a la vez y codificar después de escribir cada escenario.

3. Ejecuto los escenarios de pepino y miro la primera falla y comienzo la codificación desde allí. Normalmente tengo una configuración adicional antes de este paso para configurar mi aplicación Rails según mis preferencias e incluir gemas que sé que usaré. También encuentro un orden lógico para ejecutar mis archivos de funciones, ya que algunos dependen de otros. Obviamente, comienza con cosas como la autenticación.

4. Luego uso los generadores de Rails (andamio o solo modelo) para ayudarme a crear el código que necesito para aprobar un escenario. Modifico algunas de las plantillas de generador para darme lo que quiero.

5. Luego modifico el código generado si es necesario. La mayoría de las veces esto implica establecer relaciones en el modelo, trabajar con las asociaciones en las vistas y cualquier otra funcionalidad no estándar que los andamios no puedan proporcionar.

6. dirigir mi migraciones si es necesario

7. Entonces vuelva a ejecutar mis escenarios y repetir las medidas en 4-6 hasta que pase el escenario.

8. Repita los pasos 4 a 7 hasta que pasen todos los escenarios.

Puedo estar equivocado, pero creo que muchas personas probablemente usan un enfoque similar a este. Lo que me molesta es que veo mucha duplicación entre escribir los escenarios y generar/ajustar el código. Quiero poder generar el esqueleto de mi aplicación con mis escenarios de pepino y usar las definiciones de pasos para ayudarme a personalizar lo que se genera. He aquí un ejemplo:

Scenario: MODEL widget exists 
    Given a widget model exists 
    Then it should belong to a "manufacturer" 
    And it should have a "quantity:integer" field 
    And it should validate the presence of "quantity" 
    And it should have many "wadgets" 
    And it should accept nested attributes for "wadgets" 
    #etc... 

Scenario: VIEW new widget page 
    Given I am on the new widgets page 
    Then I should see a "quantity" field 
    And I should see a "wadgets:name" nested field 
    And I should see a button with text "Save Widget" 

Scenario: CONTROLLER widget is created 
    Given a new widget is created 
    Then I should be on the widgets page 

esto generaría código de este modo:

#FROM SCENARIO 1 
class Widget < ActiveRecord::Base 
    has_many :wadgets 
    belongs_to :manufacturer 
    validates_presence_of :quantity 
    accepts_nested_attributes_for :wadgets 
end 

#FROM SCENARIO 1  
class CreateWidget < ActiveRecord::Migration 
    def self.up 
    create_table :widgets do |t| 
     t.integer :quantity, :null=>false 
     t.integer :manufacturer_id 

     t.timestamps 
    end 
    end 

    def self.down 
    drop_table :widgets 
    end 
end 

#FROM SCENARIO 2 
#new.html.haml (using formtastic helpers) 
=semantic_form_for(@widget) do |f| 
    = f.inputs do 
    = f.input :quantity 
    = f.semantic_fields_for :wadgets do |wadget| 
     = location.input :name 
    = f.buttons 
    =f.commit_button "Save Widget" 

#FROM SCENARIO 3 (using inherited resources) 
class WidgetsController < InheritedResources::Base 
    def create 
    create!{ widget_urls } 
    end 
end 

esto es sólo pseudo en este punto, pero creo que sería un gran ahorro de tiempo para definir su aplicación en Escenarios de pepino y luego generar el código en función de lo que está en estos escenarios. Esto le permitiría crear pruebas y escribir código al mismo tiempo. Y no tendrías que escribir todos los campos para la línea de comando del generador de andamios, y establecería automáticamente las asociaciones y crearía los tipos de campos apropiados en la vista. Además, le permitirá mantener todo su diseño de características en un solo archivo.Usando este enfoque, primero ejecutaría el generador en el escenario y luego ejecutaría las pruebas de pepino después de la generación. Si se configuró correctamente, todo pasaría la primera vez y tendrías un prototipo bastante sólido que podrías personalizar.

¿Hay algún complemento que se asemeje a este tipo de pruebas & generación combinada?

Y gracias si se tomaron el tiempo para leer esto ... Sé que fue un poco largo.

Answer 1

Creo que su uso de pepino aquí no es como estaba previsto.

Supongo que todos estamos de acuerdo en que las características del pepino deberían describir ciertas características que el cliente desea ver; básicamente, traducen las fichas del cuento (requisitos) en pruebas ejecutables. Estas historias no deben preocuparse por la implementación de sus modelos, controladores y vistas. Debería probar cosas como "cuando hago clic en el botón X, me llevan a la página Y y mi envío debe ser aprobado". Es solo una gran prueba de integración que simula la interacción entre el usuario y su sitio. En su ejemplo, busca campos específicos en la página, que podrían verificarse implícitamente diciendo "cuando complete el campo de cantidad con 5".

Para probar el comportamiento de los modelos y la forma en que interactúan con la lógica de negocios, sería mejor utilizar RSpec o Test :: Unit: es mucho más fácil escribir pruebas y hacer burlas. Estoy seguro de que hay complementos que generan pruebas de RSpec para cada campo/relación en su modelo. Los generadores rspec-rails ya son la mayor parte del trabajo para usted, p. rails generate rspec:scaffold Post

Creo que la mejor mejora para los raíles de pepino sería dejar las pruebas de modelo y controlador a RSpec, pero luego ser capaz de generar acciones CRUD estándar para un recurso dado con características de pepino generadas, como "Un usuario debe capaz de crear una X. "

Answer 2

Tuve la misma idea hace un par de días. Sin embargo, después de pensarlo un poco más, abandono las ideas de generar los modelos a partir de los archivos de características. En cambio, estoy jugando con un dsl que genera los modelos/andamios/recursos usando el generador de rieles desde el dsl.

Después de que esto funcione, estaba pensando en enganchar generadores para crear archivos de características basadas en la dsl.

que tienen un rodaje pico que tiene la siguiente entrada:

application :test do 
    model :survey do 
    attribute :name, :string 
    has_many :questions 
    end 
    model :question do 
    has_many :options 
    has_many :answers 
    belongs_to :survey 
    attribute :body, :string 
    end 
    model :option do 
    belongs_to :question 
    attribute :body, :string 
    attribute :selector, :string 

    end 
    model :result do 
    belongs_to :survey 
    has_many :answers 
    end 
    model :answer do 
    belongs_to :result 
    belongs_to :question 
    attribute :value, :string 
    end 
    gen 
end 

e imprime el siguiente resultado:

rails new test 
cd test 
rails generate model survey name:string 
rails generate model question survey_id:integer body:string 
rails generate model option question_id:integer body:string selector:string 
rails generate model result survey_id:integer 
rails generate model answer result_id:integer question_id:integer value:string 
Updating class: Survey 
    has_many:questions 
Updating class: Question 
    belongs_to:survey 
    has_many:options 
    has_many:answers 
Updating class: Option 
    belongs_to:question 
Updating class: Result 
    belongs_to:survey 
    has_many:answers 
Updating class: Answer 
    belongs_to:result 
    belongs_to:question 

Steve