Byclosure-common_steps 0.0.2 → 0.0.3

data/VERSION

@@ -1 +1 @@
-0.0.2
+0.0.3

data/common_steps.gemspec

@@ -5,11 +5,11 @@
 
 Gem::Specification.new do |s|
   s.name = %q{common_steps}
-  s.version = "0.0.2"
+  s.version = "0.0.3"
 
   s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
   s.authors = ["Vasco Andrade e Silva", "Duarte Henriques"]
-  s.date = %q{2009-09-15}
+  s.date = %q{2009-09-23}
   s.description = %q{common_steps. Some common cucumber step definitions, rake tasks, and rspec matchers}
   s.email = ["vasco@byclosure.com", "duarte@byclosure.com"]
   s.extra_rdoc_files = [
@@ -30,6 +30,7 @@ Gem::Specification.new do |s|
      "lib/common_steps/helpers.rb",
      "lib/common_steps/helpers/conditions.treetop",
      "lib/common_steps/helpers/conditions_parser.rb",
+     "lib/common_steps/helpers/navigation_helper.rb",
      "lib/common_steps/helpers/rake_helper.rb",
      "lib/common_steps/helpers/record_helper.rb",
      "lib/common_steps/matchers/count.rb",
@@ -42,9 +43,11 @@ Gem::Specification.new do |s|
      "lib/common_steps/support/spec.rb",
      "lib/common_steps/tasks/cucumber.rake",
      "lib/common_steps/tasks/rspec.rake",
-     "spec/common_steps/common_steps_spec.rb",
      "spec/common_steps/helpers/conditions_parser_spec.rb",
      "spec/common_steps/helpers/record_helper_spec.rb",
+     "spec/common_steps/helpers/step_mother_helper.rb",
+     "spec/common_steps/navigation_steps_spec.rb",
+     "spec/common_steps/record_steps_spec.rb",
      "spec/common_steps_helper.rb",
      "spec/spec.opts",
      "spec/spec_helper.rb",
@@ -53,23 +56,24 @@ Gem::Specification.new do |s|
      "tasks/roodi.rake",
      "tasks/rspec.rake"
   ]
-  s.has_rdoc = true
   s.homepage = %q{http://github.com/Byclosure/common_steps}
   s.rdoc_options = ["--charset=UTF-8"]
   s.require_paths = ["lib"]
-  s.rubygems_version = %q{1.3.1}
+  s.rubygems_version = %q{1.3.5}
   s.summary = %q{common_steps. Some common cucumber step definitions, rake tasks, and rspec matchers}
   s.test_files = [
-    "spec/spec_helper.rb",
-     "spec/common_steps_helper.rb",
+    "spec/common_steps/helpers/conditions_parser_spec.rb",
      "spec/common_steps/helpers/record_helper_spec.rb",
-     "spec/common_steps/helpers/conditions_parser_spec.rb",
-     "spec/common_steps/common_steps_spec.rb"
+     "spec/common_steps/helpers/step_mother_helper.rb",
+     "spec/common_steps/navigation_steps_spec.rb",
+     "spec/common_steps/record_steps_spec.rb",
+     "spec/common_steps_helper.rb",
+     "spec/spec_helper.rb"
   ]
 
   if s.respond_to? :specification_version then
     current_version = Gem::Specification::CURRENT_SPECIFICATION_VERSION
-    s.specification_version = 2
+    s.specification_version = 3
 
     if Gem::Version.new(Gem::RubyGemsVersion) >= Gem::Version.new('1.2.0') then
       s.add_development_dependency(%q<rspec>, [">= 0"])

data/lib/common_steps/helpers.rb

@@ -1,8 +1,8 @@
-require "activesupport"
+require 'activesupport'
 
 common_step_mods = []
 
-Dir[File.dirname(__FILE__) + "/helpers/*.rb"].each do |filename|
+Dir[File.dirname(__FILE__) + "/helpers/*_helper.rb"].each do |filename|
   require filename
   module_name = filename.chomp(".rb").classify.demodulize
   mod = module_name.constantize rescue warn("unable to load: module `#{module_name}' in file #{filename}")
@@ -10,4 +10,3 @@ Dir[File.dirname(__FILE__) + "/helpers/*.rb"].each do |filename|
 end
 
 Cucumber::RbSupport::RbDsl.build_rb_world_factory(common_step_mods, nil)
-

data/lib/common_steps/helpers/navigation_helper.rb

@@ -0,0 +1,4 @@
+module NavigationHelper  
+#  def visit_homepage
+#  end
+end

data/lib/common_steps/helpers/record_helper.rb

@@ -1,6 +1,6 @@
 module RecordHelper
   def record_singular_name(record_name)
-    record_name.gsub('_', ' ').downcase.singularize
+    record_name.gsub(' ', '_').downcase.singularize
   end
 
   def record_name_to_class(record_name)
@@ -89,7 +89,6 @@ module RecordHelper
 #      base[attr_from_name(class_record, attr_name)] = value_from_str(value_str)
 #      base
 #    end
-
     conds.inject({}) {|base, (attr, value_str)| base[attr] = instance_eval(value_str); base}
   end
 

data/lib/common_steps/step_definitions.rb

@@ -1,3 +1,3 @@
 Dir[File.dirname(__FILE__) + "/step_definitions/*.rb"].each do |filename|
   require filename
-end
+end

data/lib/common_steps/step_definitions/navigation_steps.rb

@@ -4,40 +4,42 @@ end
 
 When /^I go to "([^\"]*)"$/ do |page_name|
   visit page_name
+  @can_follow_url = page_name
+  @can_take_screeshot = true
 end
 
 When /^I go to the homepage$/ do
-  When 'I go to "/"'
+  visit_homepage
 end
 
-Given /^I am on the new (\w+) page$/ do |record_name|
+Given /^I am on the new (.+) page$/ do |record_name|
   When "I go to the new #{record_name} page"
 end
 
-When /^I go to the new (\w+) page$/ do |record_name|
+When /^I go to the new (.+) page$/ do |record_name|
   record_class = record_name_to_class(record_name)
-  When "I go to \"/#{record_class_to_path(record_class)}/new\""
+  When "I go to \"#{record_class_to_path(record_class)}/new\""
 end
 
-When /^I go to the list page of (\w+)$/ do |record_name|
-  path = record_name.pluralize # TODO refact
+When /^I go to the list page of (.+)$/ do |record_name|
+  path = record_name.pluralize # TODO refact record_class_to_path(record_class)
   When "I go to \"/#{path}\""
 end
 
-Given /^I am on the edit page of the (\w+) with (a|an) (.*)$/ do |record_name, _, record_conditions|
+Given /^I am on the edit page of the (.+) with (a|an) (.*)$/ do |record_name, _, record_conditions|
   When "I go to the edit page of the #{record_name} with a #{record_conditions}"
 end
 
-When /^I go to the edit page of the (\w+) with (a|an) (.*)$/ do |record_name, _, record_conditions|
+When /^I go to the edit page of the (.+) with (a|an) (.*)$/ do |record_name, _, record_conditions|
   record_class = record_name_to_class(record_name)
   record = find_record(record_class, record_conditions)
-  When "I go to \"/#{record_class_to_path(record_class)}/#{record.id}/edit\""
+  When "I go to \"#{record_class_to_path(record_class)}/#{record.id}/edit\""
 end
 
-When /^I go to the show page of the (\w+) with (a|an) (.*)$/ do |record_name, _, record_conditions|
+When /^I go to the show page of the (.+) with (a|an) (.*)$/ do |record_name, _, record_conditions|
   record_class = record_name_to_class(record_name)
   record = find_record(record_class, record_conditions)
-  When "I go to \"/#{record_class_to_path(record_class)}/#{record.id}\""
+  When "I go to \"#{record_class_to_path(record_class)}/#{record.id}\""
 end
 
 #When /^I go to the delete page of (\w+) with (.*)$/ do |record_name|
@@ -48,20 +50,36 @@ Then /^I should be on "([^\"]*)"$/ do |page_name|
   URI.parse(current_url).path.should == page_name
 end
 
-Then /^I should be on the show page of the (\w+) with (a|an) (.*)$/ do |record_name, _,record_conditions|
+Then /^I should be on the show page of the (.+) with (a|an) (.*)$/ do |record_name, _,record_conditions|
   record_class = record_name_to_class(record_name)
   record = find_record(record_class, record_conditions)
-  path = "/#{record_class_to_path(record_class)}/#{record.id}"
+  path = "#{record_class_to_path(record_class)}/#{record.id}"
   URI.parse(current_url).path.should match(/#{path}/)
 end
 
-Then /^I should be on the edit page of the (\w+) with (a|an) (.*)$/ do |record_name, _,record_conditions|
+Then /^I should be on the edit page of the (.+) with (a|an) (.*)$/ do |record_name, _,record_conditions|
   record_class = record_name_to_class(record_name)
   record = find_record(record_class, record_conditions)
-  path = "/#{record_class_to_path(record_class)}/#{record.id}"
+  path = "#{record_class_to_path(record_class)}/#{record.id}"
+  URI.parse(current_url).path.should match(/#{path}/)
+end
+
+Then /^I should be on the "(.+)" create page$/ do |record_name|
+  record_class = record_name_to_class(record_name)
+  path = "#{record_class_to_path(record_class)}/new"
   URI.parse(current_url).path.should match(/#{path}/)
 end
 
 Then /the field with label "([^\"]*)" should contain "([^\"]*)"/ do |field_name, content|
   field_labeled(field_name).value.should == content
 end
+
+# webrat steps
+
+#When /^I press "([^\"]*)"$/ do |button|
+#  click_button(button)
+#end
+
+#Then /^I should see "([^\"]*)"$/ do |text|
+#  response.should contain(text)
+#end

data/lib/common_steps/step_definitions/record_steps.rb

@@ -1,44 +1,43 @@
-Given /^there (is|are) (\w+) (\w+) with a (.*)$/ do |_, count_str, record_name, record_conditions|
+Given /^there (is|are) (\w+) (.*) with (a|an) (.*)$/ do |_, count_str, record_name, _, record_conditions|
   singular_record_name = record_singular_name(record_name)
   conditions = conditions_from_str(record_conditions)
-  record_name_to_class(record_name).delete_all
+  # record_name_to_class(record_name).delete_all
   num = str_to_num(count_str)
-  num.times { Factory(singular_record_name, conditions) }
+  num.times { Factory(singular_record_name.gsub(/\s/, "_"), conditions) }
 end
 
-Given /^there (is|are) (\w+) (\w*)$/ do |_, count_str, record_name|
+Given /^there (is|are) (\w+) (\w+)$/ do |_, count_str, record_name|
   singular_record_name = record_singular_name(record_name)
   num = str_to_num(count_str)
-  num.times { Factory(singular_record_name) }
-end
-
-Then /^there should be (\w+) (\w+)$/ do |count_str, record_name|
-  num = str_to_num(count_str)
-  record_name_to_class(record_name).should count(num)
+  num.times { Factory(singular_record_name.gsub(/\s/, "_")) }
 end
 
 Given /^the following (\w+):?$/ do |record_name, table|
   recordize!(record_name, table)
   singular_record_name = record_singular_name(record_name)
   table.hashes.each do |hash|
-    Factory(singular_record_name, hash)
+    Factory(singular_record_name.gsub(/\s/, "_"), hash)
   end
 end
 
-Then /^there should be (\w+) (\w+) with a (.*)$/ do |count_str, record_name, record_conditions|
-  class_name = record_name_to_class(record_name)
-  conditions = conditions_from_str(record_conditions)
+Then /^there should be (\d+) (.+)$/ do |count_str, record_name|
   num = str_to_num(count_str)
-  class_name.count(:conditions => conditions).should == num
+  record_name_to_class(record_name).should count(num)
 end
 
-Then /^there should be the following (\w+):?$/ do |record_name, table|
+Then /^there should be the following (.+):?$/ do |record_name, table|
   recordize!(record_name, table)
   class_name = record_name_to_class(record_name)
   table.hashes.each do |hash|
     class_name.exists?(hash).should == true # TODO vasco: make a matcher for this
   end
 end
+Then /^there should be (\w+) (\w+) with a (.*)$/ do |count_str, record_name, record_conditions|
+  class_name = record_name_to_class(record_name)
+  conditions = conditions_from_str(record_conditions)
+  num = str_to_num(count_str)
+  class_name.count(:conditions => conditions).should == num
+end
 
 Then /^I should see the following (\w+) in order$/ do |record_name, table|
   class_name = record_name_to_class(record_name)
@@ -48,132 +47,4 @@ Then /^I should see the following (\w+) in order$/ do |record_name, table|
     actual_table << [record.name]
   end
   table.diff!(actual_table)
-end
-
-
-=begin
-class_name = model_name.gsub(' ', '_').singularize
-model_class = nil
-begin
-  model_class = class_name.classify.constantize
-rescue
-  # do nothing
-end
-model_class.delete_all if model_class
-table.hashes.each do |hash|
-  attr_hash = hash.inject({}) do |attr_hash, (attr_name, attr_value)|
-    if attr_name == 'user' && !attr_value.is_a?(User) # hack
-      attr_hash[attr_name] = find_or_create_valid_user(:login => attr_value)
-    elsif attr_name == "published_at" && hash['published_as'] == "draft" # hack
-      attr_hash[attr_name] = nil
-    elsif (model_class && (association = model_class.reflect_on_all_associations(:has_many).detect { |a| attr_name =~ /^(#{a.name})(_.*)/ }))
-      find_suffix = $2
-      attr_hash[association.name] = if attr_value.nil?
-        []
-      else
-        association_class = association.class_name.constantize
-        attr_value.split(", ").map do |v|
-          association_class.send("find_by#{find_suffix}", v)
-        end
-      end
-    else
-      attr_hash[attr_name] = attr_value
-    end
-    attr_hash
-  end
- 
-  approve = attr_hash.delete("approve")
-  model = Factory(class_name.to_sym, attr_hash)
-  if approve == "true"
-    model.approve!
-  end
-  model
-end
-=end
-
-=begin
-Given /^the following (.+) records?$/ do |model_name, table|
-  class_name = model_name.gsub(' ', '_').singularize
-  model_class = class_name.classify.constantize
-  model_class.delete_all
-  has_many_opts = model_class.reflect_on_all_associations(:has_many)
-  table.hashes.each do |hash|
-    attr_hash = hash.inject({}) do |attr_hash, (attr_name, attr_value)|
-      if attr_name == 'user' && !attr_value.is_a?(User) # hack
-        attr_hash[attr_name] = find_or_create_valid_user(:login => attr_value)
-      elsif attr_name == "published_at" && hash['published_as'] == "draft" # hack
-        attr_hash[attr_name] = nil
-      elsif (association = has_many_opts.detect { |a| attr_name =~ /^(#{a.name})(_.*)/ })
-        find_suffix = $2
-        attr_hash[association.name] = if attr_value.nil?
-          []
-        else
-          association_class = association.class_name.constantize
-          attr_value.split(", ").map do |v|
-            association_class.send("find_by#{find_suffix}", v)
-          end
-        end
-      else
-        attr_hash[attr_name] = attr_value
-      end
-      attr_hash
-    end
-   
-    approve = attr_hash.delete("approve")
-    model = Factory(class_name.to_sym, attr_hash)
-    if approve == "true"
-      model.approve!
-    end
-    model
-  end
-end
-
-
-Given /^there is a ([^\" ]+)$/ do |resource|
-  instance_variable_set(:"@#{resource.gsub(' ', '_')}", respond_to?(:"create_valid_#{resource.gsub(' ', '_')}") ? send(:"create_valid_#{resource.gsub(' ', '_')}") : Factory(:"#{resource.gsub(' ', '_')}"))
-end
-Given /^there is a (.+) with (.+) "([^\"]*)"$/ do |resource, field, value|
-  resource_name = resource.gsub(' ', '_')
-  resource_name.classify.constantize.find(:all, :conditions => {field => value}).map(&:destroy) rescue nil # in case there is a uniqueness validation
-  method = :"create_valid_#{resource_name}"
-  instance_variable_set(:"@#{resource_name}", respond_to?(method) ? send(method, field.to_sym => value) : Factory(resource_name, field.to_sym => value))
-end
-Given /^there is an (.+) with (.+) "([^\"]*)"$/ do |resource, field, value|
-  resource_name = resource.gsub(' ', '_')
-  resource_name.classify.constantize.find(:all, :conditions => {field => value}).map(&:destroy) rescue nil # in case there is a uniqueness validation
-  method = :"create_valid_#{resource_name}"
-  instance_variable_set(:"@#{resource_name}", respond_to?(method) ? send(method, field.to_sym => value) : Factory(resource_name, field.to_sym => value))
-end
-#Given /^I have only one (.+)$/ do |resource|
-#  @myself.send(resource.pluralize).delete_all
-#  instance_variable_set(:"@#{resource.gsub(' ', '_')}", send(:"create_valid_#{resource.gsub(' ', '_')}"))
-#end
-Given /^I have only one (.+) with (.+) "([^\"]*)"$/ do |resource, field, value|
-  @myself.send(resource.pluralize).delete_all
-  resource.classify.constantize.find(:all, :conditions => {field => value}).map(&:destroy) rescue nil # in case there is a uniqueness validation
-  instance_variable_set(:"@#{resource.gsub(' ', '_')}", send(:"create_valid_#{resource.gsub(' ', '_')}", field.to_sym => value, :user => @myself))
-end
-Given /^I have a (.+) with (.+) "([^\"]*)"$/ do |resource, field, value|
-  resource.classify.constantize.find(:all, :conditions => {field => value}).map(&:destroy) rescue nil # in case there is a uniqueness validation
-  instance_variable_set(:"@#{resource.gsub(' ', '_')}", send(:"create_valid_#{resource.gsub(' ', '_')}", field.to_sym => value, :user => @myself))
-end
-
-Then /^there should be ([0-9]+) (.+)$/ do |count, resource|
-  resource.singularize.classify.constantize.count.should == count.to_i
-end
-
-Then /^I should have ([0-9]+) (.+)$/ do |count, resource|
-  @myself.send(resource.pluralize).count.should == count.to_i
-end
-
-Given /^there are no ([^ ]+)$/ do |resource|
-  resource.singularize.classify.constantize.delete_all
-end
-
-Then /^that (.+) should be deleted$/ do |resource|
-  lambda { instance_variable_get(:"@#{resource}").reload }.should raise_error ActiveRecord::RecordNotFound
-end
-Then /^that (.+) should no longer exist$/ do |resource|
-  lambda { instance_variable_get(:"@#{resource}").reload }.should raise_error ActiveRecord::RecordNotFound
-end
-=end
+end

data/lib/common_steps/step_definitions/webrat_steps.rb

@@ -14,11 +14,12 @@ When /^I follow "([^\"]*)"$/ do |link|
 end
 
 When /^I fill in "([^\"]*)" with "([^\"]*)"$/ do |field, value|
-  fill_in(field, :with => value) 
+  fill_in(field, :with => value)
+  @can_take_screeshot = true
 end
 
 When /^I select "([^\"]*)" from "([^\"]*)"$/ do |value, field|
-  select(value, :from => field) 
+  select(value, :from => field)
 end
 
 # Use this step in conjunction with Rail's datetime_select helper. For example:

data/spec/common_steps/helpers/step_mother_helper.rb

@@ -0,0 +1,37 @@
+module StepMotherHelper
+  def step_should_match(step_string)
+    it { @step_mother.should step_match(step_string) }  
+  end  
+  
+  def artist_should_count(n, step_string)
+    plural_or_singular = n == 1 ? "" : "s" 
+    it "should count #{n} Artist#{plural_or_singular} when I call '#{step_string}'" do
+      m = @step_mother.step_match(step_string)
+      m.invoke(nil)
+      Artist.should count(n)
+    end
+  end  
+  
+  def artist_should_be(hash, step_string)
+    it "should contain #{hash.inspect} when I call '#{step_string}'" do
+      m = @step_mother.step_match(step_string)
+      m.invoke(nil)
+      Artist.should exist_given(hash)
+    end
+  end
+  
+  def artist_should_count_and_be(n, hash, step_string)
+    artist_should_count(n, step_string)
+    artist_should_be(hash, step_string)
+  end
+  
+  def artists_in_table_should_be(table, step_string)
+    it "should contain the table #{table.hashes.inspect} when I call '#{step_string}" do  
+      m = @step_mother.step_match('the following artists')
+      m.invoke(table)
+      table.hashes.each do |hash|
+        Artist.should exist_given(hash)
+      end
+    end
+  end
+end

data/spec/common_steps/navigation_steps_spec.rb

@@ -0,0 +1,39 @@
+# Specs from navigation_steps.rb
+require File.expand_path(File.dirname(__FILE__) + '/../spec_helper')
+require File.expand_path(File.dirname(__FILE__) + '/../common_steps_helper')
+require 'common_steps/helpers/record_helper'
+require 'common_steps/helpers/navigation_helper'
+require 'common_steps/helpers/step_mother_helper'
+
+
+describe 'Cucumber instance with navigation_steps.rb and World(RecordHelper, NavigationHelper) loaded' do
+  extend StepMotherHelper
+  
+  before do
+    #include 'ruby-debug'
+    #debugger
+    @step_mother = Cucumber::Cli::Main.step_mother
+    @step_mother.load_code_file(File.expand_path(File.dirname(__FILE__) + "/../../lib/common_steps/step_definitions/navigation_steps.rb"))
+
+    @dsl = Object.new
+    @dsl.extend(Cucumber::RbSupport::RbDsl)
+    @dsl.World(RecordHelper, NavigationHelper) 
+    @step_mother.load_programming_language('rb').begin_rb_scenario
+    @current_world = Cucumber::RbSupport::RbDsl.instance_variable_get(:@rb_language).current_world
+  end
+  
+  step_should_match 'I go to the homepage'
+  step_should_match 'I go to "/asdkjasd/asdasd"'
+  step_should_match 'I go to "asdkjasd/asdasd"'
+  
+  describe 'when I invoke homepage with homepage redirecting to "/"' do
+    it 'should call homepage method' do
+      @current_world.should_receive(:visit_homepage).with(no_args)
+      m = @step_mother.step_match('I go to the homepage')
+      m.invoke(nil)
+    end
+  end
+  
+  step_should_match 'I go to "/something.something/something"'
+  
+end

data/spec/common_steps/{common_steps_spec.rb → record_steps_spec.rb}

@@ -1,44 +1,9 @@
+# Specs from record_steps.rb
+
 require File.expand_path(File.dirname(__FILE__) + '/../spec_helper')
 require File.expand_path(File.dirname(__FILE__) + '/../common_steps_helper')
 require "common_steps/helpers/record_helper"
-
-module StepMotherHelper
-  def step_should_match(step_string)
-    it { @step_mother.should step_match(step_string) }  
-  end  
-  
-  def artist_should_count(n, step_string)
-    plural_or_singular = n == 1 ? "" : "s" 
-    it "should count #{n} Artist#{plural_or_singular} when I call '#{step_string}'" do
-      m = @step_mother.step_match(step_string)
-      m.invoke(nil)
-      Artist.should count(n)
-    end
-  end  
-  
-  def artist_should_be(hash, step_string)
-    it "should contain #{hash.inspect} when I call '#{step_string}'" do
-      m = @step_mother.step_match(step_string)
-      m.invoke(nil)
-      Artist.should exist_given(hash)
-    end
-  end
-  
-  def artist_should_count_and_be(n, hash, step_string)
-    artist_should_count(n, step_string)
-    artist_should_be(hash, step_string)
-  end
-  
-  def artists_in_table_should_be(table, step_string)    
-    it "should contain the table #{table.hashes.inspect} when I call '#{step_string}" do  
-      m = @step_mother.step_match('the following artists')
-      m.invoke(table)
-      table.hashes.each do |hash|
-        Artist.should exist_given(hash)
-      end
-    end
-  end
-end
+require 'common_steps/helpers/step_mother_helper'
 
 # In order to use features without bugs
 # As a developer
@@ -55,9 +20,9 @@ describe "Cucumber instance with record_steps.rb and World(RecordHelper) loaded"
     @step_mother.load_programming_language('rb').begin_rb_scenario
   end
   
-  # Specs from record_steps.rb
-  #
+  ####################
   # there (is|are) (\w+) (\w*)
+  ####################
   step_should_match 'there are no artists'
   step_should_match 'there is no artists'
   step_should_match 'there are no artist'
@@ -67,7 +32,23 @@ describe "Cucumber instance with record_steps.rb and World(RecordHelper) loaded"
   step_should_match 'there is 1 artist'
   step_should_match 'there are 3 artists'
 
+  # there (is|are) (\w+) (\w*)
+  describe "StepMatch[there (is|are) (\w+) (.*)] invocation, with no artists" do
+    before do
+      Artist.destroy_all # there are no artist - FIXME I shouldn't have to care about this
+    end
+    
+    artist_should_count 0, 'there are 0 artists'
+    artist_should_count 0, 'there are no artists'
+    artist_should_count 1, 'there is 1 artist'
+    artist_should_count 1, 'there is an artist'
+    artist_should_count 1, 'there is a artist'
+    artist_should_count 3, 'there are 3 artists'
+  end  
+  
+  ####################
   # there (is|are) (\w+) (\w+) with a (.*)
+  ####################
   step_should_match 'there are 0 artists with a name of "John"'
   step_should_match 'there are no artists with a name of "John"'
   step_should_match 'there is 1 artist with a name of "John"'
@@ -75,42 +56,8 @@ describe "Cucumber instance with record_steps.rb and World(RecordHelper) loaded"
   step_should_match 'there is a artist with a name of "John"'
   step_should_match 'there are 3 artists with a name of "John"'
   step_should_match 'there are 1 artists with a name of "John", an age of 32 and a country of "Portugal"'
-      
-  # there should be (\w+) (\w+)
-  step_should_match 'there should be no artists'
-  step_should_match 'there should be no artists'
-  step_should_match 'there should be no artist'
-  step_should_match 'there should be 0 artists'
-  step_should_match 'there should be a artist'
-  step_should_match 'there should be an artist'
-  step_should_match 'there should be 1 artist'
-  step_should_match 'there should be 3 artists'
 
-  #the following (\w+):
-  step_should_match 'the following artists'
-  step_should_match 'the following artists:'
-  step_should_match 'the following artist'
-  step_should_match 'the following artist:'
-  
-  # there should be (\w+) (\w+) with a (.*)
-  step_should_match 'there should be 0 artists with a name of "John"'
-  step_should_match 'there should be no artists with a name of "John"'
-  step_should_match 'there should be 1 artist with a name of "John"'
-  step_should_match 'there should be an artist with a name of "John"'
-  step_should_match 'there should be a artist with a name of "John"'
-  step_should_match 'there should be 3 artists with a name of "John"'
-  step_should_match 'there should be 1 artist with a name of "John", an age of 32 and a country of "Portugal"'
-  
-  # there should be the following (\w+):?
-  step_should_match 'there should be the following artists'
-  step_should_match 'there should be the following artists:'
-  step_should_match 'there should be the following artist'
-  step_should_match 'there should be the following artist:'
-  
-  # I should see the following (\w+) in order
-  step_should_match 'I should see the following artists in order'
-  step_should_match 'I should see the following artist in order'
-  
+  # there (is|are) (\w+) (\w+) with a (.*)
   describe "StepMatch[there (is|are) (\w+) (\w+) with a (.*)] invocation, with no artists" do
     before do
       Artist.destroy_all # there are no artist - FIXME I shouldn't have to care about this
@@ -129,51 +76,66 @@ describe "Cucumber instance with record_steps.rb and World(RecordHelper) loaded"
     #artist_should_count_and_be(1, {:name => "John", :age => 32}, 'there are 1 artists with a name of "John", and age of 32')
   end
   
-  describe "StepMatch[there (is|are) (\w+) (.*)] invocation, with no artists" do
-    before do
-      Artist.destroy_all # there are no artist - FIXME I shouldn't have to care about this
-    end
-    
-    artist_should_count 0, 'there are 0 artists'
-    artist_should_count 0, 'there are no artists'
-    artist_should_count 1, 'there is 1 artist'
-    artist_should_count 1, 'there is an artist'
-    artist_should_count 1, 'there is a artist'
-    artist_should_count 3, 'there are 3 artists'
-  end
-  
+  ####################
+  # there should be (\w+) (\w+)
+  ####################
+  step_should_match 'there should be no artists'
+  step_should_match 'there should be no artists'
+  step_should_match 'there should be no artist'
+  step_should_match 'there should be 0 artists'
+  step_should_match 'there should be a artist'
+  step_should_match 'there should be an artist'
+  step_should_match 'there should be 1 artist'
+  step_should_match 'there should be 3 artists'
+
+  # there should be (\w+) (\w+)
   describe "StepMatch[there should be (\w+) (\w+)] invocation with 1 artist, with no artists" do
     before do
       Artist.destroy_all # there are no artist - FIXME I shouldn't have to care about this
     end
-    
     artist_should_count 0, 'there should be 0 artists'
     artist_should_count 0, 'there should be no artists'
   end
   
+  # there should be (\w+) (\w+)
   describe "StepMatch[there should be (\w+) (\w+)] invocation with 1 artist, with 1 artist" do
     before do
       Artist.destroy_all # there are no artist - FIXME I shouldn't have to care about this
       Factory(:artist)
     end
-
     artist_should_count 1, 'there should be 1 artist'
     artist_should_count 1, 'there should be an artist'
     artist_should_count 1, 'there should be a artist'   
   end
    
+  ####################
+  # the following (\w+)
+  ####################
+  step_should_match 'the following artists'
+  step_should_match 'the following artists:'
+  step_should_match 'the following artist'
+  step_should_match 'the following artist:'
+
+  # the following (\w+)
   describe "StepMatch[Given the following artists] invoked with table of attributes" do
     before do
       Artist.destroy_all # there are no artist - FIXME I shouldn't have to care about this
     end
-    
-    @cucumber_table = Cucumber::Ast::Table.new(
-      [['name', 'age'],
-        ['John', '12'],
-        ['Mary', '34']])
+    @cucumber_table = Cucumber::Ast::Table.new([['name', 'age'], ['John', '12'], ['Mary', '34']])
     artists_in_table_should_be @cucumber_table, 'the following artists'
   end
 
+  ####################
+  # there should be (\w+) (\w+) with a (.*)
+  ####################
+  step_should_match 'there should be 0 artists with a name of "John"'
+  step_should_match 'there should be no artists with a name of "John"'
+  step_should_match 'there should be 1 artist with a name of "John"'
+  step_should_match 'there should be an artist with a name of "John"'
+  step_should_match 'there should be a artist with a name of "John"'
+  step_should_match 'there should be 3 artists with a name of "John"'
+  step_should_match 'there should be 1 artist with a name of "John", an age of 32 and a country of "Portugal"'
+
   describe "StepMatch[there should be (\w+) (\w+) with a (.*)] with no artists" do
     before do
       Artist.destroy_all # there are no artist - FIXME I shouldn't have to care about this
@@ -182,7 +144,7 @@ describe "Cucumber instance with record_steps.rb and World(RecordHelper) loaded"
     artist_should_count(0, 'there should be 0 artists with a name of "John"')
     artist_should_count(0, 'there should be no artists with a name of "John"')
   end
-  
+
   describe "StepMatch[there should be (\w+) (\w+) with a (.*)] with 1 artist" do
     before do
       Artist.destroy_all # there are no artist - FIXME I shouldn't have to care about this
@@ -217,8 +179,16 @@ describe "Cucumber instance with record_steps.rb and World(RecordHelper) loaded"
       end.should_not raise_error 
     end
   end
-    
-  describe "where there are 2 artists [{:name => 'John', :age => 12}, {:name => 'Mary', :age => 34}]" do
+  
+  ####################
+  # there should be the following (\w+):?
+  ####################
+  step_should_match 'there should be the following artists'
+  step_should_match 'there should be the following artists:'
+  step_should_match 'there should be the following artist'
+  step_should_match 'there should be the following artist:'
+
+  describe "there are 2 artists [{:name => 'John', :age => 12}, {:name => 'Mary', :age => 34}]" do
     before do
       Artist.destroy_all # there are no artist - FIXME I shouldn't have to care about this
       Artist.create!(:name => "John", :age => 12)
@@ -252,7 +222,14 @@ describe "Cucumber instance with record_steps.rb and World(RecordHelper) loaded"
               ['John', '12'],
               ['Mary', '34'],
               ['Andrea', '22']]))
-      end.should raise_error      
+      end.should raise_error
     end
   end
+
+  ####################
+  # I should see the following (\w+) in order
+  ####################
+  step_should_match 'I should see the following artists in order'
+  step_should_match 'I should see the following artist in order'
+
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification 
 name: Byclosure-common_steps
 version: !ruby/object:Gem::Version 
-  version: 0.0.2
+  version: 0.0.3
 platform: ruby
 authors: 
 - Vasco Andrade e Silva
@@ -10,7 +10,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2009-09-15 00:00:00 -07:00
+date: 2009-09-23 00:00:00 -07:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency 
@@ -78,6 +78,7 @@ files:
 - lib/common_steps/helpers.rb
 - lib/common_steps/helpers/conditions.treetop
 - lib/common_steps/helpers/conditions_parser.rb
+- lib/common_steps/helpers/navigation_helper.rb
 - lib/common_steps/helpers/rake_helper.rb
 - lib/common_steps/helpers/record_helper.rb
 - lib/common_steps/matchers/count.rb
@@ -90,9 +91,11 @@ files:
 - lib/common_steps/support/spec.rb
 - lib/common_steps/tasks/cucumber.rake
 - lib/common_steps/tasks/rspec.rake
-- spec/common_steps/common_steps_spec.rb
 - spec/common_steps/helpers/conditions_parser_spec.rb
 - spec/common_steps/helpers/record_helper_spec.rb
+- spec/common_steps/helpers/step_mother_helper.rb
+- spec/common_steps/navigation_steps_spec.rb
+- spec/common_steps/record_steps_spec.rb
 - spec/common_steps_helper.rb
 - spec/spec.opts
 - spec/spec_helper.rb
@@ -100,7 +103,7 @@ files:
 - tasks/rdoc.rake
 - tasks/roodi.rake
 - tasks/rspec.rake
-has_rdoc: true
+has_rdoc: false
 homepage: http://github.com/Byclosure/common_steps
 licenses: 
 post_install_message: 
@@ -125,11 +128,13 @@ requirements: []
 rubyforge_project: 
 rubygems_version: 1.3.5
 signing_key: 
-specification_version: 2
+specification_version: 3
 summary: common_steps. Some common cucumber step definitions, rake tasks, and rspec matchers
 test_files: 
-- spec/spec_helper.rb
-- spec/common_steps_helper.rb
-- spec/common_steps/helpers/record_helper_spec.rb
 - spec/common_steps/helpers/conditions_parser_spec.rb
-- spec/common_steps/common_steps_spec.rb
+- spec/common_steps/helpers/record_helper_spec.rb
+- spec/common_steps/helpers/step_mother_helper.rb
+- spec/common_steps/navigation_steps_spec.rb
+- spec/common_steps/record_steps_spec.rb
+- spec/common_steps_helper.rb
+- spec/spec_helper.rb