mdoel-cukesteps 0.2.0 → 0.3.0

data/README.rdoc

@@ -4,17 +4,96 @@ cukesteps is a gem containing general purpose step definitions for the Cucumber
 
 Cucumber provides a single webrat_steps.rb file containing generic steps.  This gem provides more.
 
-To use it, add:
+The steps fall into three basic categories:
+- object creation steps
+- general debugging/development steps
+- content matching steps
 
-require 'mdoel-cukesteps'
+= Object creation step(s)
+Right now, there's just one and it is of the form:
 
-to your features/support/env.rb file
+    Given the following foo(s) exist
 
-= To Do
+This is expected to be used with a step table and allows for complex associations to be built up
+in concise language.  Consider an application with models for restaurant, brand, employee, and
+location.  You might want to create a test world like:
+
+    Given the following employees exist
+          | employee | name    |
+          | first    | joe     |
+          | second   | sally   |
+          | third    | william |
+    Given the following restaurants exist
+          | Location   | Brand     | Employees    |
+          | Miami, fl  | McDonalds | first        |
+          | Columbus   | Chipotle  | second,third |
+
+If you put the following in your features/support/env.rb file:
+
+    cuke_association_builders(:brand => :build_associated_via_find_by_name,
+                              :location => :from_factory)
+
+then each Restaurant object gets created and associated with three other model objects:
+- Brand - via a find_by_name lookup inside the brands table
+- Location - via the return of the Location#from_factory class method
+- Employee - from the objects created in the previous step
+
+Note that in the above, :build_associated_via_find_by_name is the only "magic" value to associate with
+a model/table column.
+
+= General Debugging/Development steps
+These steps are not typically ones you would leave inside your cucumber features file as they are
+primarily useful if you are trying to debug some issue rather than doing true acceptance testing.
+
+== Then I debug
+Use this in the middle of a scenario to stop running the scenario and dump you into the ruby debugger
+at this point.
+
+== Then save_and_open_page
+This uses webrats save_and_open_page method to capture the output of your scenario at some point and open it
+in your browser.
+
+== Then n foos should exist
+Verifies that the count of Foo records is n
 
-- make the gem usable with different testing frameworks and/or make it framework agnostic (currently uses Rspec)
-- test these tests (see http://github.com/mdoel/cukesteps-test/tree/master)
+== Then dump all foos to standard output
+Dumps the output of inspect for all ActiveRecord instances of Foo
+
+= Content Matching Steps
+These steps help encourage use of semantic IDs and Class Names in your markup.  The use of the
+articles "a" and "the" represent a class and ID respectively.  For example, "I should see a photo
+in the search results" ensures that the the page contains an element of class photo inside an element of ID 
+search-results.
+
+The steps available here are:
+- Then I should see the foo
+- Then I should see a|an foo
+- Then I should see a foo in the bar
+- Then I should see the foo in the bar
+- Then I should see n foos in the bar
+- Then I should see n to m foos in the bar
+- Then the baz in the bar should contain a foo
+
+The negation of each of the above is also available (e.g. Then I should not see a foo in the bar)
+
+= Installation/Use
+To install the gem, use:
+
+    gem sources add github.com   (only need to do this once)
+    gem install mikedoel-cukesteps
+
+To use it, add the following to your features/support/env.rb file:
+
+    require 'mdoel-cukesteps'
+    include CukeAssociationhelpers
+    cuke_association_builders(:model1 => :class_method_1,
+                              :model2 => :build_associated_via_find_by_name)
+
+
+= To Do
 
+- incorporate better testing (right now, testing is in a separate cukesteps-test project)
+- make this documentation better
 
 == Copyright
 

data/VERSION

@@ -1 +1 @@
-0.2.0
+0.3.0

data/cukesteps.gemspec

@@ -2,7 +2,7 @@
 
 Gem::Specification.new do |s|
   s.name = %q{cukesteps}
-  s.version = "0.2.0"
+  s.version = "0.3.0"
 
   s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
   s.authors = ["Mike Doel"]
@@ -23,7 +23,6 @@ Gem::Specification.new do |s|
      "lib/common_steps.rb",
      "lib/cuke_association_helpers.rb",
      "lib/cukesteps.rb",
-     "pkg/cukesteps-0.1.0.gem",
      "test/cukesteps_test.rb",
      "test/test_helper.rb"
   ]

data/lib/common_steps.rb

@@ -10,41 +10,55 @@ Then /^I wait for ([0-9]+) seconds$/ do |delay|
   sleep delay.to_i
 end
 
+Then /^(\d+) (\S+) should exist$/ do |count, element_class|
+  klass = element_class.singularize.capitalize.constantize
+  klass.count.should eql(count.to_i)
+end
+
+Then /^dump all (\S+) to standard output$/ do |klass|
+  klass_name = klass.singularize.capitalize.constantize
+  records = klass_name.send(:find, :all)
+  records.each { |record| puts record.inspect }
+end
+
+
 # Steps that are generally useful and help encourage use of semantic
 # IDs and Class Names in your markup.  In the steps below, a match following
 # "the" will verify the presences of an element with a given ID while a match following
 # "a" or "an" will verify the presence an element of a given class.
-Then /^I should see a (\S+) in the (\S+)$/ do |element, containing_element|
-  response.should have_tag("##{containing_element} .#{element}")
-end
-
-Then /^I should see the (\S+) in the (\S+)$/ do |element, containing_element|
-  response.should have_tag("##{containing_element} ##{element}")
+Then /^I should( not)? see the (\S+)$/ do |negation, element_id|
+  matcher = negation.blank? ? :should : :should_not
+  response.send matcher, have_tag("##{element_id}")
 end
 
-Then /^I should see (\d+) (\S+) in the (\S+)$/ do |count, element, containing_element|
-  response.should have_tag("##{containing_element} .#{element.singularize}",:count => count.to_i)
+Then /^I should( not)? see an? (\S+)$/ do |negation, element_class|
+  matcher = negation.blank? ? :should : :should_not
+  response.send matcher, have_tag(".#{element_class}")
 end
 
-Then /^I should see (\d+) to (\d+) (\S+) in the (\S+)$/ do |min, max, element, containing_element|
-  response.should have_tag("##{containing_element} .#{element.singularize}",min.to_i..max.to_i)
+Then /^I should( not)? see an? (\S+) in the (\S+)$/ do |negation, element, containing_element|
+  matcher = negation.blank? ? :should : :should_not
+  response.send matcher, have_tag("##{containing_element} .#{element}")
 end
 
-Then /^the (\S+) in the (\S+) should contain (a|an|the) (\S+)$/ do |middle_element, outer_element, a, inner_element|
-  response.should have_tag("##{outer_element} .#{middle_element} .#{inner_element}")
+Then /^I should( not)? see the (\S+) in the (\S+)$/ do |negation, element, containing_element|
+  matcher = negation.blank? ? :should : :should_not
+  response.send matcher, have_tag("##{containing_element} ##{element}")
 end
 
-Then /^I should see the (\S+)$/ do |element_id|
-  response.should have_tag("##{element_id}")
+Then /^I should( not)? see (\d+) (\S+) in the (\S+)$/ do |negation, count, element, containing_element|
+  matcher = negation.blank? ? :should : :should_not
+  response.send matcher, have_tag("##{containing_element} .#{element.singularize}",:count => count.to_i)
 end
 
-Then /^I should see (a|an) (\S+)$/ do |a, element_class|
-  response.should have_tag(".#{element_class}")
+Then /^I should( not)? see (\d+) to (\d+) (\S+) in the (\S+)$/ do |negation, min, max, element, containing_element|
+  matcher = negation.blank? ? :should : :should_not
+  response.send matcher, have_tag("##{containing_element} .#{element.singularize}",min.to_i..max.to_i)
 end
 
-Then /^(\d+) (\S+) should exist$/ do |count, element_class|
-  klass = element_class.singularize.capitalize.constantize
-  klass.count.should eql(count.to_i)
+Then /^the (\S+) in the (\S+) should( not)? contain an? (\S+)$/ do |middle_element, outer_element, negation, inner_element|
+  matcher = negation.blank? ? :should : :should_not
+  response.send matcher, have_tag("##{outer_element} ##{middle_element} .#{inner_element}")
 end
 
 # Steps for creating objects that can be associated with other objects

data/lib/cuke_association_helpers.rb

@@ -35,16 +35,23 @@ module CukeAssociationHelpers
   def assemble_attributes(hash,object_name)
     attributes = {}
     hash.each do |key,value|
+      cached_key = key.singularize.downcase
       symbolized_key = key.downcase.gsub(' ','_').to_sym
-      if @created_objects[key].nil?
+      if @created_objects[cached_key].nil?
         attributes[symbolized_key] = build_value(symbolized_key,value)
       else
-        attributes[symbolized_key] = @created_objects[key][value]
+        attributes[symbolized_key] = saved_objects(cached_key,value)
       end
     end
     attributes
   end
 
+  def saved_objects(klass,value)
+    objects = []
+    value.split(",").each {|o| objects << @created_objects[klass][o]}
+    objects
+  end
+
   def build_value(key,value)
     if @@associated_cuke_builders[key].nil?
       value

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification 
 name: mdoel-cukesteps
 version: !ruby/object:Gem::Version 
-  version: 0.2.0
+  version: 0.3.0
 platform: ruby
 authors: 
 - Mike Doel
@@ -32,7 +32,6 @@ files:
 - lib/common_steps.rb
 - lib/cuke_association_helpers.rb
 - lib/cukesteps.rb
-- pkg/cukesteps-0.1.0.gem
 - test/cukesteps_test.rb
 - test/test_helper.rb
 has_rdoc: false