mundo-pepino 0.1.0

data/Rakefile

@@ -0,0 +1,54 @@
+# gem stuff
+require 'rubygems'
+gem 'hoe', '>= 2.1.0'
+require 'hoe'
+require 'fileutils'
+require 'newgem/tasks'
+require 'lib/mundo_pepino/version'
+
+Hoe.plugin :newgem
+
+$hoe = Hoe.spec 'mundo-pepino' do
+  self.summary = 'MundoPepino is a set of reusable step definitions to test Rails apps with Cucumber'
+  self.version = MundoPepino::VERSION::STRING
+  self.developer 'Fernando García Samblas', 'fernando.garcia@the-cocktail.com'
+  self.rubyforge_name = self.name # TODO this is default value
+  self.extra_deps     = [['string-mapper','>= 0.1.0'],
+                         ['cucumber', '>=0.3.102']]
+end
+
+
+
+# build stuff
+require(File.join(File.dirname(__FILE__), 'features', 'support', 'app', 'config', 'boot'))
+
+require 'rake'
+require 'rake/testtask'
+require 'rake/rdoctask'
+
+require 'tasks/rails'
+
+
+unless ARGV.any? {|a| a =~ /^gems/}
+
+  begin
+    require 'cucumber/rake/task'
+    namespace :mundo_pepino do
+      Cucumber::Rake::Task.new({:es_ES => 'db:test:prepare'}) do |t|
+        t.cucumber_opts = "--require features/support/env.rb --require features/step_definitions/mundo_pepino_es_ES.rb --format progress --language es features/es_ES"
+      end
+  
+      desc 'Run all MundoPepino features on every supported language'
+      task :all => [:es_ES]
+    end
+  
+    task :default => 'mundo_pepino:es_ES'
+
+  rescue LoadError
+    desc 'cucumber rake task not available (cucumber not installed)'
+    task :cucumber do
+      abort 'Cucumber rake task is not available. Be sure to install cucumber as a gem or plugin'
+    end
+  end
+
+end

data/cucumber.yml

@@ -0,0 +1 @@
+default: --require features/support/env.rb --require features/step_definitions/mundo_pepino_es_ES.rb --language es features/es_ES/

data/init.rb

@@ -0,0 +1 @@
+$LOAD_PATH.unshift File.expand_path(File.join(File.dirname(__FILE__), 'lib'))

data/lib/mundo_pepino.rb

@@ -0,0 +1,241 @@
+$:.unshift(File.dirname(__FILE__)) unless
+  $:.include?(File.dirname(__FILE__)) || $:.include?(File.expand_path(File.dirname(__FILE__)))
+
+require 'cucumber/rails/world'
+require 'mundo_pepino/resources_history'
+require 'mundo_pepino/visits_history'
+require 'mundo_pepino/version'
+
+require 'string-mapper'
+
+module MundoPepino
+
+  include ResourcesHistory
+  include VisitsHistory
+	
+  def real_value_for(v)
+    (v.is_a?(String) ? v.to_real_value : v )
+  end
+
+  def parsed_attributes(raw_attributes)
+    attributes = {}
+    raw_attributes.each do |k, v|
+      if k =~ /^(.+)_id$/
+        if polymorph = raw_attributes.delete($1 + '_type')
+          attributes[$1.to_sym] = polymorph.constantize.find(v.to_i)
+        else
+          attributes[$1.to_sym] = ($1.to_relation_model || $1.camelize.constantize).find(v.to_i)
+        end
+      else
+        attributes[k] = real_value_for(v)
+      end
+    end
+    attributes
+  end
+
+  def create(model, raw_attributes = {})
+    through = raw_attributes.delete(:through)
+    attributes = parsed_attributes(raw_attributes)
+    obj = if defined?(FixtureReplacement)
+      self.send "create_#{model.name.underscore}", attributes
+    elsif defined?(Machinist)
+      model.make attributes
+    elsif defined?(Factory)
+      Factory(model.name.underscore.to_sym, attributes)
+    else
+      model.create! attributes
+    end
+    if(through)
+      create through['model'], through['attributes'].merge(model.name.underscore.to_sym => obj)
+    end
+    obj
+  end
+
+  def find_or_create(model_or_modelo, attributes = {}, options = {}) 
+    model = if model_or_modelo.is_a?(String)
+      model_or_modelo.to_model
+    else
+      model_or_modelo
+    end
+    if attributes.any?
+      attribs = Hash.new
+      attributes.each do |key, value|
+        if child_model = (key.to_s.to_model || key.to_s.to_relation_model)
+          child = add_resource(child_model, field_for(child_model, 'nombre') => value)
+          field_name = key.to_s.to_relation_model ? key : child_model.name.underscore
+          attribs["#{field_name}_id"] = child.id
+        else
+          attribs[key] = value
+        end
+      end
+      if ((options[:force_creation].nil? || !options[:force_creation])  &&
+          obj = model.find(:first, :conditions => conditions_from_attributes(attribs)))
+        if(through = attribs[:through])
+          create through['model'], through['attributes'].merge(model.name.underscore.to_sym => obj)
+        end
+        obj
+      else
+        create model, attribs
+      end
+    else
+      create model
+    end
+  end
+
+  def conditions_from_attributes(attributes)
+    attribs = attributes.reject {|k,v| k == :through} 
+    [attribs.keys.map{|s| "#{s}=?"}.join(' AND ')] + attribs.values
+  end
+
+  def names_for_simple_creation(model, number, name_or_names, options = {})
+    base_hash = base_hash_for(options)
+    if name_or_names
+      field = field_for(model, 'nombre')
+      names = name_or_names.split(/ ?, | y /)
+      if names.size == number
+        names.map { |name| base_hash.dup.merge(field => name) }
+      else
+        [base_hash.dup.merge(field => name_or_names)] * number
+      end
+    else
+      [base_hash] * number
+    end
+  end
+
+  def field_for(model, campo = 'nombre')
+    "#{model && model.name}::#{campo}".to_field || campo.to_field
+  end
+  def shouldify(should_or_not)
+    affirmative = 'debo|debo ver|veo|deber[ií]a|deber[íi]a ver|leo|debo leer|deber[ií]a leer'
+    should_or_not =~ /^(#{affirmative})$/i ? :should : :should_not
+  end
+
+  def not_shouldify(should_or_not)
+    shouldify(should_or_not) == :should ? :should_not : :should
+  end
+
+  def relative_page(pagina)
+    if pagina =~ /la siguiente p[aá]gina|la p[aá]gina anterior/i
+      head, current, tail = if last_visited =~ /(.+page=)(\d+)(.*)/
+        [$1, $2.to_i, $3]
+      else
+        [last_visited + '?page=', 1, '']
+      end
+      (pagina =~ /siguiente/ ? current += 1 : current -= 1)
+      head + current.to_s + tail
+    else
+      nil
+    end
+  end
+
+  # Cucumber::Model::Table's hashes traduciendo nombres de campo
+  def translated_hashes(step_table, options = {})
+    base_hash = base_hash_for(options)
+    header = step_table[0].map do |campo| 
+      field_for(options[:model], campo) || campo 
+    end
+    step_table[1..-1].map do |row|
+      h = base_hash.dup
+      row.each_with_index do |v,n|
+        key = header[n]
+        h[key] = v
+      end
+      h
+    end
+  end
+
+  def base_hash_for(options) 
+    if options[:parent]
+      # polymorphic associations
+      if options[:polymorphic_as]
+        { "#{options[:polymorphic_as]}_id" => options[:parent].id,
+          "#{options[:polymorphic_as]}_type" => options[:parent].class.name }
+      else 
+        field_prefix = options[:parent].class.name.underscore
+        if options[:through]
+          {:through => {"model" => eval(options[:through].to_s.classify),
+                        "attributes" => {"#{field_prefix}_id"  => options[:parent].id}}}
+        else
+          { "#{field_prefix}_id" => options[:parent].id }
+        end
+      end
+    else
+      {}
+    end
+  end
+
+  def campo_to_field(campo, model = nil)
+    unless campo.nil? 
+      if field = field_for(model, campo.to_unquoted)
+        field
+      else
+        raise MundoPepino::FieldNotMapped.new(campo) 
+      end
+    end
+  end
+  
+  def last_mentioned_should_have_value(campo, valor)
+    res = last_mentioned
+    if child_model = campo.to_model
+      child = child_model.find_by_name(valor)
+      child_field = campo.to_field || child_model.name.underscore
+      (res.send child_field).should == child
+    elsif field = field_for(res.class, campo)
+      (res.send field).to_s.should == valor.to_s
+    else
+      raise FieldNotMapped.new(campo)
+    end
+  end
+  
+  def last_mentioned_should_have_child(child, name)
+    if child_model = child.to_model
+      child = child_model.find_by_name(name)
+      (last_mentioned.send child_model.table_name).detect do |c|
+        c.id == child.id 
+      end.should_not be_nil
+    else
+      raise ModelNotMapped.new(child)
+    end
+  end
+  
+  def find_field_and_do_with_webrat(action, campo, options = nil)
+    do_with_webrat action, campo.to_unquoted.to_translated, options # a pelo (localización vía labels)
+  rescue Webrat::NotFoundError
+    field = campo_to_field(campo, last_mentioned_model)
+    begin 
+      do_with_webrat action, field, options # campo traducido tal cual...
+    rescue Webrat::NotFoundError
+      if singular = last_mentioned_singular # traducido y con el modelo por delante
+        do_with_webrat action, singular + '_' + field.to_s, options # p.e.: user_name
+      else
+        raise
+      end
+    end
+  end
+
+  def do_with_webrat(action, field, options)
+    if options
+      if options[:path] and options[:content_type]
+        self.send action, field, options[:path], options[:content_type]
+      else
+        self.send action, field, options
+      end
+    else
+      self.send action, field
+    end
+  end
+
+  def parent_options(parent, child)
+   options = {:parent => parent}
+    # polymorphic associations
+    if reflections = parent.class.reflect_on_association(child.table_name.to_sym)
+      if reflections.options[:as]
+        options.merge!({:polymorphic_as => reflections.options[:as]})
+      elsif reflections.options[:through]
+        options.merge!({:through => reflections.options[:through]})
+      end
+    end
+    options
+  end
+
+end

data/lib/mundo_pepino/definitions/es_ES.rb

@@ -0,0 +1,420 @@
+begin
+  module Cucumber::StepMethods
+    alias_method :Dado, :Given
+    alias_method :Cuando, :When
+    alias_method :Entonces, :Then
+  end
+rescue
+  # NO NEED TO CREATE ALIASES IN post-0.2 Cucumbers
+end
+
+String.add_mapper(:real_value, {
+  /^verdader[oa]$/i  => true,
+  /^fals[ao]$/i      => false
+}) { |value| value }
+String.add_mapper :model
+String.add_mapper :relation_model
+String.add_mapper(:field) { |str| :name if str =~ /nombres?/ }
+String.add_mapper(:url, /^la (portada|home)/i => '/') do |string| 
+  string if string =~ /^\/.*$|^https?:\/\//i
+end
+
+String.add_mapper(:number, { 
+  /^un[oa]?$/i     => 1,
+  /^primer[oa]?$/i => 1,
+  :dos            => 2,
+  /^segund[oa]?$/i => 2,
+  :tres         => 3,
+  /^tercer[ao]/i => 3,
+  :cuatro      => 4,
+  /^cuart[ao]/i => 4,
+  :cinco       => 5,
+  /^quint[ao]/i => 5}) { |string| string.to_i }
+String.add_mapper(:crud_action,
+  /^alta$/i                  => 'new',
+  /^creaci[óo]n$/i           => 'new',
+  /^nuev(?:o|a|o\/a|a\/o)$/i => 'new',
+  /^cambio$/i                => 'edit',
+  /^modificaci[oó]n(?:es)?$/i       => 'edit',
+  /^edici[oó]n$/i            => 'edit')
+String.add_mapper(:month,
+  :enero           => 'January',
+  :febrero         => 'February',
+  :marzo           => 'March',
+  :abril           => 'April',
+  :mayo            => 'May',
+  :junio           => 'June',
+  :julio           => 'July',
+  :agosto          => 'August',
+  /^sep?tiembre$/i  => 'September',
+  :octubre         => 'October',
+  :noviembre       => 'November',
+  :diciembre       => 'December')
+String.add_mapper(:content_type,
+  /\.png$/   => 'image/png',
+  /\.jpe?g$/ => 'image/jpg',
+  /\.gif$/   => 'image/gif') { |str| 'text/plain' }
+String.add_mapper(:underscored) { |string| string.gsub(/ +/, '_') }
+String.add_mapper(:unquoted) { |str| str =~ /^['"](.*)['"]$/ ? $1 : str}
+String.add_mapper(:translated) { |str|
+  if str =~ /^[a-z_]+\.[a-z_]+[a-z_\.]+$/
+    I18n.translate(str, :default => str)
+  elsif str =~ /^([a-z_]+\.[a-z_]+[a-z_\.]+),(\{.+\})$/
+    I18n.translate($1, {:default => str}.merge(eval($2)))
+  else
+    str
+  end
+}
+
+
+
+numero = 'un|una|dos|tres|cuatro|cinco|\d+'
+cuyo = '(?:cuy[oa]s?|que tienen? como)'
+# Creación simple con nombre opcional
+Dado /^(?:que tenemos )?(#{numero}) (?!.+ #{cuyo})(.+?)(?: (?:llamad[oa]s? )?['"](.+)["'])?$/i do |numero, modelo, nombre|
+  if model = modelo.to_unquoted.to_model
+    number = numero.to_number
+    attribs = names_for_simple_creation(model, number, nombre)
+    add_resource(model, attribs, :force_creation => true)
+  else
+    raise MundoPepino::ModelNotMapped.new(modelo)
+  end
+end
+# Creación con asignación de valor en campo
+Dado /^(?:que tenemos )?(#{numero}) (.+) #{cuyo} (.+?) (?:(?:es|son) (?:de )?)?['"](.+)["'](?: .+)?$/i do |numero, modelo, campo, valor|
+  Dado "que tenemos #{numero} #{modelo}"
+  Dado "que dichos #{modelo} tienen como #{campo} '#{valor}'"
+end
+
+Dado /^(?:que tenemos )?(?:el|la|los|las|el\/la|los\/las) (?:siguientes? )?(.+):$/ do |modelo, tabla|
+  model = modelo.to_unquoted.to_model
+  add_resource model, translated_hashes(tabla.raw, :model => model), :force_creation => true
+end 
+
+Dado /^que (?:el|la) (.+) ['"](.+)["'] tiene como (.+) ['"](.+)["'](?: \w+)?$/ do |modelo, nombre, campo, valor|
+  if resource = last_mentioned_of(modelo, nombre)
+    if field = field_for(resource.class, campo)
+      resource.update_attribute field, real_value_for(valor)
+      pile_up resource
+    else
+      raise MundoPepino::FieldNotMapped.new(campo)
+    end
+  end
+end
+
+Dado /^que dich[oa]s? (.+) tienen? como (.+) ['"](.+)["'](?:.+)?$/i do |modelo, campo, valor|
+  if res = last_mentioned_of(modelo)
+    resources, field, values = resources_array_field_and_values(res, campo, valor)
+    if field
+      resources.each_with_index do |r, i| 
+        r.update_attribute field, real_value_for(values[i])
+      end
+      pile_up res
+    else
+      raise MundoPepino::FieldNotMapped.new(campo)
+    end
+  end
+end
+
+Dado /^que dich[oa]s? (.+) tienen? (un|una|dos|tres|cuatro|cinco|\d+) (.+?)(?: (?:llamad[oa]s? )?['"](.+)["'])?$/i do |modelo_padre, numero, modelo_hijos, nombres|
+  if mentioned = last_mentioned_of(modelo_padre.to_unquoted)
+    children_model = modelo_hijos.to_unquoted.to_model
+    resources = (mentioned.is_a?(Array) ? mentioned : [mentioned])
+    resources.each do |resource|
+      attribs = names_for_simple_creation(children_model, 
+        numero.to_number, nombres, parent_options(resource, children_model))
+      add_resource children_model, attribs, :force_creation => nombres.nil?
+    end
+    pile_up mentioned
+  end
+end
+
+Dado /^que dich[ao]s? (.+) tienen? (?:el|la|los|las) siguientes? (.+):$/i do |modelo_padre, modelo_hijos, tabla|
+  if mentioned = last_mentioned_of(modelo_padre.to_unquoted)
+    children_model = modelo_hijos.to_unquoted.to_model
+    resources = (mentioned.is_a?(Array) ? mentioned : [mentioned])
+    resources.each do |resource|
+      add_resource children_model, 
+        translated_hashes(tabla.raw, parent_options(resource, children_model))
+    end
+  end
+end
+
+
+###############################################################################
+
+pagina_re = '(?:p[áa]gina|portada|[íi]ndice|listado|colecci[óo]n)'
+Cuando /^(?:que )?visito (?:el|la) #{pagina_re} de ([\w]+|['"][\w ]+["'])$/i do |modelo_en_crudo|
+  modelo = modelo_en_crudo.to_unquoted
+  if model = modelo.to_model
+    pile_up model.new
+    do_visit eval("#{model.table_name}_path")
+  elsif url = "la página de #{modelo_en_crudo}".to_url
+    do_visit url
+  else
+    raise MundoPepino::ModelNotMapped.new(modelo)
+  end
+end
+
+Cuando /^(?:que )?visito (?:el|la) #{pagina_re} (?:del|de la) (.+) ['"](.+)["']$/i do |modelo, nombre|
+  if resource = last_mentioned_of(modelo, nombre)
+    do_visit eval("#{resource.class.name.underscore}_path(resource)")
+  else
+    raise MundoPepino::ResourceNotFound.new("model #{modelo}, name #{nombre}")
+  end
+end
+
+Cuando /^(?:que )?visito la p[áa]gina de (?!la)([\w\/]+) (?:de |de la |del )?(.+?)(?: (['"].+["']))?$/i do |accion, modelo, nombre|
+  action = accion.to_crud_action or raise(MundoPepino::CrudActionNotMapped.new(accion))
+  if action != 'new'
+    nombre, modelo = modelo, nil unless nombre
+    resource = if modelo && modelo.to_unquoted.to_model
+      last_mentioned_of(modelo, nombre.to_unquoted)
+    else
+      last_mentioned_called(nombre.to_unquoted)
+    end
+    if resource
+      do_visit eval("#{action}_#{resource.mr_singular}_path(resource)")
+    else
+      MundoPepino::ResourceNotFound.new("model #{modelo}, name #{nombre}")
+    end
+  else
+    model = modelo.to_unquoted.to_model or raise(MundoPepino::ModelNotMapped.new(modelo))
+    pile_up model.new
+    do_visit eval("#{action}_#{model.name.underscore}_path")
+  end
+end
+
+Cuando /^(?:que )?visito su (?:p[áa]gina|portada)$/i do
+  do_visit last_mentioned_url
+end
+
+negative_lookahead = '(?:la|el) \w+ del? |su p[aá]gina|su portada'
+Cuando /^(?:que )?visito (?!#{negative_lookahead})(.+)$/i do |pagina|
+  do_visit pagina.to_unquoted.to_url
+end
+
+Cuando /^(?:que )?(?:pulso|pincho) (?:en )?el bot[oó]n (.+)$/i do |boton|
+  click_button(boton.to_unquoted.to_translated)
+end
+
+Cuando /^(?:que )?(?:pulso|pincho) (?:en )?el (enlace|enlace ajax|enlace con efectos) (.+)$/i do |tipo, enlace|
+  options = {}
+  options[:wait] = case tipo.downcase
+  when 'enlace con efectos' then :effects
+  when 'enlace ajax' then :ajax
+  else :page
+  end
+  click_link(enlace.to_unquoted.to_translated, options)
+end
+
+Cuando /^(?:que )?(?:completo|relleno) (.+) con (?:el valor )?['"](.+)["']$/i do |campo, valor|
+  find_field_and_do_with_webrat :fill_in, campo, :with => valor
+end
+
+Cuando /^(?:que )?(?:completo|relleno):$/i do |tabla|
+  tabla.raw[1..-1].each do |row|
+    Cuando "relleno \"#{row[0].gsub('"', '\"')}\" con \"#{row[1].gsub('"', '\"')}\""
+  end
+end
+
+Cuando /^(?:que )?elijo (?:la|el)? ?(.+) ['"](.+)["']$/i do |campo, valor|
+  choose(campo_to_field(campo).to_s + '_' + valor.downcase.to_underscored)
+end
+
+Cuando /^(?:que )?marco (?:la|el)? ?(.+)$/i do |campo|
+  find_field_and_do_with_webrat :check, campo
+end
+
+Cuando /^(?:que )?desmarco (?:la|el)? ?(.+)$/i do |campo|
+  find_field_and_do_with_webrat :uncheck, campo
+end
+
+Cuando /^(?:que )?adjunto el fichero ['"](.*)["'] (?:a|en) (.*)$/ do |ruta, campo|
+  find_field_and_do_with_webrat :attach_file, campo, 
+    {:path => ruta, :content_type => ruta.to_content_type}
+end
+
+Cuando /^(?:que )?selecciono ["']([^"']+?)["'](?: en (?:el listado de )?(.+))?$/i do |valor, campo|
+  begin
+    if campo
+      select valor, :from => campo.to_unquoted.to_translated  # Vía label
+    else
+      select valor
+    end
+  rescue Webrat::NotFoundError
+    select(valor, :from => campo_to_field(campo)) # Sin label
+  end
+end
+
+Cuando /^(?:que )?selecciono ['"]?(\d\d?) de (\w+) de (\d{4}), (\d\d?:\d\d)["']? como fecha y hora(?: (?:de )?['"]?(.+?)["']?)?$/ do |dia, mes, anio, hora, etiqueta|
+# Cuando selecciono "25 de diciembre de 2008, 10:00" como fecha y hora
+# Cuando selecciono 23 de noviembre de 2004, 11:20 como fecha y hora "Preferida"
+# Cuando selecciono 23 de noviembre de 2004, 11:20 como fecha y hora de "Publicación"
+  time = Time.parse("#{mes.to_month} #{dia}, #{anio} #{hora}")
+  options = etiqueta ? { :from => etiqueta } : {}
+  select_datetime(time, options)
+end
+
+Cuando /^(?:que )?selecciono ['"]?(.*)["']? como (?:la )?hora(?: (?:(?:del?|para) (?:la |el )?)?['"]?(.+?)["']?)?$/ do |hora, etiqueta|
+  options = etiqueta ? { :from => etiqueta } : {}
+  select_time(hora, options)
+end
+
+Cuando /^(?:que )?selecciono ['"]?(\d\d?) de (\w+) de (\d{4})["']? como (?:la )?fecha(?: (?:(?:del?|para) (?:la |el )?)?['"]?(.+?)["']?)?$/ do |dia, mes, anio, etiqueta|
+  time = Time.parse("#{mes.to_month} #{dia}, #{anio} 12:00")
+  options = etiqueta ? { :from => etiqueta } : {}
+  select_date(time, options)
+end
+
+Cuando /^borro (?:el|la|el\/la) (.+) en (?:la )?(\w+|\d+)(?:ª|º)? posición$/ do |modelo, posicion|
+  pile_up modelo.to_unquoted.to_model.new
+  do_visit last_mentioned_url
+  within("table > tr:nth-child(#{posicion.to_number+1})") do
+    click_link "Borrar"
+  end
+end
+
+#############################################################################
+veo_o_no = '(?:no )?(?:veo|debo ver|deber[ií]a ver)'
+
+Entonces /^(#{veo_o_no}) el texto (.+)?$/i do |should, text|
+  eval('response.body.send(shouldify(should))') =~ /#{Regexp.escape(text.to_unquoted.to_translated)}/m
+end
+
+leo_o_no = '(?:no )?(?:leo|debo leer|deber[íi]a leer)'
+Entonces /^(#{leo_o_no}) el texto (.+)?$/i do |should, text|
+  begin
+    HTML::FullSanitizer.new.sanitize(response.body).send(shouldify(should)) =~ /#{Regexp.escape(text.to_unquoted.to_translated)}/m
+  rescue Spec::Expectations::ExpectationNotMetError
+    webrat.save_and_open_page
+    raise
+  end
+end
+
+Entonces /^(#{veo_o_no}) los siguientes textos:$/i do |should, texts|
+  texts.raw.each do |row|
+    Entonces "#{should} el texto #{row[0]}"
+  end
+end
+
+Entonces /^(#{leo_o_no}) los siguientes textos:$/i do |should, texts|
+  texts.raw.each do |row|
+    Entonces "#{should} el texto #{row[0]}"
+  end
+end
+
+Entonces /^(#{veo_o_no}) (?:en )?(?:el selector|la etiqueta|el tag) (["'].+?['"]|[^ ]+)(?:(?: con)? el (?:valor|texto) )?["']?([^"']+)?["']?$/ do |should, tag, value |
+  lambda {
+    if value
+      response.should have_tag(tag.to_unquoted, /.*#{value.to_translated}.*/i)
+    else
+      response.should have_tag(tag.to_unquoted)
+    end
+  }.send(not_shouldify(should), raise_error)  
+end
+
+Entonces /^(#{veo_o_no}) (?:las|los) siguientes (?:etiquetas|selectores):$/i do |should, texts|
+  check_contents, from_index = texts.raw[0].size == 2 ? [true, 1] : [false, 0]
+  texts.raw[from_index..-1].each do |row|
+    if check_contents
+      Entonces "#{should} el selector \"#{row[0]}\" con el valor \"#{row[1]}\""
+    else
+      Entonces "#{should} el selector \"#{row[0]}\""
+    end
+  end
+end
+
+
+
+Entonces /^(#{veo_o_no}) un enlace (?:a|para) (.+)?$/i do |should, pagina|
+  lambda {
+    href = relative_page(pagina) || pagina.to_unquoted.to_url 
+    response.should have_tag('a[href=?]', href)
+  }.send(not_shouldify(should), raise_error)
+end
+
+
+Entonces /^(#{veo_o_no}) marcad[ao] (?:la casilla|el checkbox)? ?(.+)$/ do |should, campo|
+  field_labeled(campo.to_unquoted).send shouldify(should), be_checked
+end
+
+Entonces /^(#{veo_o_no}) (?:una|la) tabla (?:(["'].+?['"]|[^ ]+) )?con (?:el|los) (?:siguientes? )?(?:valore?s?|contenidos?):$/ do |should, table_id, valores|
+  table_id = "##{table_id.to_unquoted}" if table_id
+  shouldified = shouldify(should)
+  response.send shouldified, have_selector("table#{table_id}")
+
+  if have_selector("table#{table_id} tbody").matches?(response)
+    start_row = 1
+    tbody = "tbody"
+  else
+    start_row = 2
+    tbody = ""
+  end
+
+  valores.raw[1..-1].each_with_index do |row, i|
+    row.each_with_index do |cell, j|
+      response.send shouldified, 
+      have_selector("table#{table_id} #{tbody} tr:nth-child(#{i+start_row})>td:nth-child(#{j+1})") { |td|
+        td.inner_text.should =~ /#{cell == '.*' ? cell : Regexp.escape((cell||"").to_translated)}/
+      }
+    end
+  end
+end
+
+Entonces /^(#{veo_o_no}) un formulario con (?:el|los) (?:siguientes? )?(?:campos?|elementos?):$/ do |should, elementos|
+  shouldified = shouldify(should)
+  response.send(shouldified, have_tag('form')) do
+    elementos.raw[1..-1].each do |row|
+      label, type = row[0].to_translated, row[1]
+      case type
+        when "submit":
+          with_tag "input[type='submit'][value='#{label}']"
+        when "radio":
+          with_tag('div') do
+            with_tag "label", label
+            with_tag "input[type='radio']"
+          end  
+        when "select", "textarea":
+          field_labeled(label).element.name.should == type
+        else  
+          field_labeled(label).element.attributes['type'].to_s.should == type
+      end
+    end
+  end
+end
+
+#BBDD
+en_bbdd_tenemos = '(?:en (?:la )?(?:bb?dd?|base de datos) tenemos|tenemos en (?:la )?(?:bb?dd?|base de datos))'
+tiene_en_bbdd = '(?:tiene en (?:la )?bbdd|en (?:la )?bbdd tiene|tiene en (?:la )?base de datos|en (?:la )?base de datos tiene)'
+Entonces /^#{en_bbdd_tenemos} (un|una|dos|tres|cuatro|cinco|\d+) ([^ ]+)(?: (?:llamad[oa]s? )?['"](.+)["'])?$/ do |numero, modelo, nombre|
+  model = modelo.to_unquoted.to_model
+  conditions = if nombre
+    {:conditions => [ "#{field_for(model, 'nombre')}=?", nombre ]}
+  else
+    {}
+  end
+  resources = model.find(:all, conditions)
+  resources.size.should == numero.to_number
+  if resources.size > 0
+    pile_up (resources.size == 1 ? resources.first : resources)
+  end
+end
+
+Entonces /^(?:el|la) (.+) "(.+)" #{tiene_en_bbdd} como (.+) "(.+)"(?: \w+)?$/ do |modelo, nombre, campo, valor|
+  add_resource_from_database(modelo, nombre)
+  last_mentioned_should_have_value(campo, valor.to_real_value)
+end
+
+Entonces /^#{tiene_en_bbdd} como (.+) "(.+)"(?: \w+)?$/ do |campo, valor|
+  last_mentioned_should_have_value(campo, valor.to_real_value)
+end
+
+Entonces /^(?:el|la) (.+) "(.+)" #{tiene_en_bbdd} una? (.+) "(.+)"$/ do |padre, nombre_del_padre, hijo, nombre_del_hijo|
+  add_resource_from_database(padre, nombre_del_padre)
+  last_mentioned_should_have_child(hijo, nombre_del_hijo)
+end
+
+Entonces /^#{tiene_en_bbdd} una? (.+) "(.+)"$/ do |hijo, nombre_del_hijo|
+  last_mentioned_should_have_child(hijo, nombre_del_hijo)
+end