saki 0.0.4 → 0.1.0

data/README.markdown

@@ -1,17 +1,17 @@
 # Saki - For times when you can't swallow Cucumber
 
-Saki lets you do acceptance testing on top of RSpec.  It is considerably more terse than Cucumber, but does not sacrifice readability.  Saki also does not use Given/When/Then syntax because the thought is that there is little return other than familiarity for Cucumber users.
-
-Are you tired of having DRY code, but tests that seem to babble on "for the length of a bible"?  Me too.  How about RSpec code that is hard to follow, when Ruby itself is simple to follow?  I hate it too.
+Are you tired of having DRY code, but tests that seem to babble on "for the length of a bible"?  Me too.  How about test code that is hard to follow, when Ruby itself is clear as day?  I hate it too.
 
 Enter Saki stage left.
 
+Saki lets you do acceptance testing on top of RSpec.  It is considerably more terse than Cucumber, but does not sacrifice readability.  Saki also does not use Given/When/Then syntax because the thought is that there is little return other than familiarity for Cucumber users.
+
 ## How terse is it?
 
 Well, here's a sample that sets up contexts that create a user and then visit an edit path for that user.
 
 	with_existing :user do
-		on_visiting edit_path_for(:user) do
+		on_visiting edit_user_path do
 			it { should let_me_edit(@user) }
 		end
 	end
@@ -21,25 +21,31 @@ This code basically injects some "before blocks", so it would look like this in
 	context "a user exists" do
 		before { @user = Factory :user }
 		context "I visit the page for editing that user" do
-			before { visit edit_user_path(:user) }
+			before { visit "/users/#{@user.id}/user" }
 			it { should let_me_edit(@user) }
   		end
 	end
 
-I believe the Saki example has the following benefits:
+I believe the Saki example has the following benefits over vanilla RSpec:
 
 * It saves two lines of code.
-* It standardizes the code.  Whereas a context string might accidentally get out of sync with the code (unmaintained comments, anyone), with Saki this would probably cause a test to fail.
+* It standardizes the code.  Whereas a context string might accidentally get out of sync with the code (unmaintained comments, anyone?), with Saki this would probably cause a test to fail.
 * It is much more expressive.  You read the test and you immediately know what it does.
-* Any exceptions to the rule (complicated setups, etc.) now stick out like sore thumbs, as they should.
+* Any exceptions to the rule (complicated setups, etc.) would now stick out like sore thumbs, as they should.
 
-The only assumption is that you are using factories instead of fixtures.  You also get more out of it in a conventional RESTful application.
+The only assumption is that you are using factories instead of fixtures.  You also get more out of it in a conventional RESTful application, where the paths don't have too many gotchas.
 
-## What class-level methods does it use (for setting up contexts)?
+## Methods provided for setting up contexts
 
-`with_existing` takes a factory name as a symbol and assigns its created object to on instance variable with the same name.
+`with_existing` takes a factory name as a symbol and assigns its created object to an instance variable with the same name.  It also takes options so you can have blocks start with:
 
-`on_visiting` takes a path as a string, or a lambda that executes within a before block to set up the path.  It also takes a symbol which is the name of a method name.  This is useful when the code is dependent on an instance variable for path creation.
+    with_existing :user, :state => "happy" do...
+
+`on_visiting` preferably uses some dynamic functions for establishing a path: `new_X_path`, `Xs_path`, `edit_X_path`, `X_path` and `new_X_path`.  In these cases, substitute X for the resource name (e.g. `new_user_path`).  In cases where the resource is nested, it has a :parent => parent_resource option.  This lets you set up blocks like:
+
+    on_visiting auctions_path(:parent => :user) do ...
+
+`on_visiting` also takes a path as a string, or a lambda that executes within a before block to set up the path.  It also takes a symbol which is the name of a method name.  This is useful when the code is dependent on an instance variable for path creation.
 
     path_for_user = lambda { user_path(@user) }
 
@@ -53,13 +59,9 @@ or you can do
 
     on_visiting :my_user_path do ...
 
-`on_visiting` has several helper functions for establishing a path: `create_path_for`, `index_path_for`, `edit_path_for`, `show_path_for` and `new_path_for`.  These paths all take resource names for establishing a path.  In cases where the resource is nested, it has a :parent => parent_resource option.  This lets you set up blocks like:
-
-    on_visiting index_path_for(:auction)
-
 `on_following_link_to` works the same as on_visiting, but it first validates that the link exists, and then follows it.
 
-`where` is a function taking as a parameter lambda to execute in the before block.
+`where` is a function taking as a parameter a lambda to execute in the before block.
 
     def self.creating_a_user
         lambda {
@@ -69,7 +71,7 @@ or you can do
         }
     end
 
-    on_following_link_to create_path_for(:user) do
+    on_following_link_to new_user_path do
         where creating_a_user do
             specify { page.should have_content(@user.email) }
         end
@@ -77,7 +79,7 @@ or you can do
 
 Obviously the return for this is where you have functions acting as "reusable steps" in the style of Cucumber.  In addition your "before blocks" are more expressive.
 
-Finally, to simplify setting up integration tests, anything you wrap in an `integrate` block (like `describe`) sets the test type to acceptance.
+Finally, to simplify setting up integration tests, anything you wrap in an `integrate` block (like `describe`) sets the test type to acceptance. This is the default `describe` function of the generators, but feel free to use the regular describe block as long as you set its :type option to :acceptance.
 
 ## Installation
 
@@ -89,11 +91,28 @@ Then to fill out the directories run:
 
     rails generate saki:install
 
-Then, as long as your acceptance specs require the acceptance_helper file you should be good to go.
-    
-## What assumptions does it make?  
+You can generate new acceptance tests with `rails generate saki:spec SPEC_NAME`.  This automatically generates tests like
+
+    require File.dirname(__FILE__) + '/acceptance_helper'
 
-It assumes that you are using factory_girl and capybara or webrat, though it probably would work fine with other test factories.  If you need another factory in the mix, just redefine the `default_factory` method to behave how you want.
+    integrate "author resource" do
+
+        on_visiting new_author_path do
+            specify { fail "not implemented" }
+        end
+
+        with_existing :author do
+            on_visiting edit_author_path do
+                specify { fail "not implemented" }
+            end
+            on_visiting author_path do
+                specify { fail "not implemented" }
+            end
+            on_visiting authors_path do
+                specify { fail "not implemented" }
+            end
+        end
+    end
 
 ## References
 
@@ -101,7 +120,7 @@ The motivation behind my migration from Cucumber and to Saki, are described in b
 
 ## Thanks
 
-The generators are stolen directly from Steak with some minor adjustments.
+The generators are stolen directly from Steak with some adjustments.
 
 ## Note on Patches/Pull Requests
  

data/VERSION

@@ -1 +1 @@
-0.0.4
+0.1.0

data/lib/generators/saki/spec_generator.rb

@@ -0,0 +1,31 @@
+require 'rails/generators'
+
+module Saki
+  class SpecGenerator < Rails::Generators::NamedBase
+
+    def resource_name
+      file_name.tableize.singularize
+    end
+
+    source_root File.join(File.dirname(__FILE__), 'templates')
+
+    desc <<-DESC
+Description:
+Create an acceptance spec for the feature NAME in the
+'spec/acceptance' folder.
+
+Example:
+`rails generate saki:spec author`
+
+Creates an acceptance spec for the "author" feature:
+spec/acceptance/author_spec.rb
+DESC
+
+    def manifest
+      empty_directory File.join('spec/acceptance', class_path)
+      file_name.gsub!(/_spec$/,"")
+      template 'acceptance_spec.rb', File.join('spec/acceptance', class_path, "#{file_name}_spec.rb")
+    end
+  end
+end
+

data/lib/generators/saki/templates/acceptance_spec.rb

@@ -0,0 +1,21 @@
+require File.dirname(__FILE__) + '/acceptance_helper'
+
+integrate "<%= resource_name %> resource" do
+
+  on_visiting new_<%= resource_name %>_path do
+    specify { fail "not implemented" }
+  end
+
+  with_existing :<%= resource_name %> do
+    on_visiting edit_<%= resource_name %>_path do
+       specify { fail "not implemented" }
+    end
+    on_visiting <%= resource_name %>_path do
+       specify { fail "not implemented" }
+    end
+    on_visiting <%= resource_name.pluralize %>_path do
+       specify { fail "not implemented" }
+    end
+  end
+
+end

data/lib/saki.rb

@@ -4,8 +4,8 @@ module Saki
   module AcceptanceHelpers
     extend ActiveSupport::Concern
 
-    def default_factory(name)
-      Factory name
+    def default_factory(name, opts = {})
+      Factory name, opts
     end
 
     def get_path(path)
@@ -18,7 +18,7 @@ module Saki
       end
     end
 
-    def add_opts(link, opts)
+    def add_opts(link, opts = {})
       if opts[:parent]
         link = "/#{opts[:parent].class.to_s.tableize}/#{opts[:parent].id}" + link
       end
@@ -64,17 +64,14 @@ module Saki
       else
         current_path.should match(page_name)
       end
-    end    
-
-    def index_path_for(model)
-      "/#{model}"
     end
 
-
     module ClassMethods
-      def with_existing resource, &block
+      def with_existing resource, opts={}, &block
         context "with exisiting #{resource}" do
-          before { eval "@#{resource} = default_factory :#{resource}" }
+          before do
+            instance_variable_set "@#{resource}", default_factory(resource, opts)
+          end
           module_eval &block
         end
       end
@@ -99,6 +96,7 @@ module Saki
         end
       end
 
+
       def add_opts(link, opts, context)
         if opts[:parent]
           "/#{opts[:parent].to_s.pluralize}/#{(context.instance_variable_get('@' + opts[:parent].to_s)).id}" + link
@@ -112,7 +110,7 @@ module Saki
           add_opts "/#{resource.to_s.pluralize}/#{(context.instance_variable_get('@' + resource.to_s)).id}/edit", opts, context
         end
       end
-      
+
       def show_path_for(resource, opts = {})
         lambda do |context|
           add_opts "/#{resource.to_s.pluralize}/#{(context.instance_variable_get('@' + resource.to_s)).id}", opts, context
@@ -142,15 +140,43 @@ module Saki
 end
 
 class RSpec::Core::ExampleGroup
-      def method_missing(methId)
+
+      def self.method_missing(methId, *args)
+        parse_opts = lambda {|link , opts, context|
+          opts ||= {}
+          if opts[:parent]
+            "/#{opts[:parent].to_s.pluralize}/#{(context.instance_variable_get('@' + opts[:parent].to_s)).id}" + link
+          else
+            link
+          end
+        }
+
         str = methId.id2name
-        if str.match /(.*)_path/
-          index_path_for($1)
+        if str.match /new_(.*)_path/
+             lambda { |context|
+               parse_opts.call "/#{$1.pluralize}/new", args.first, context
+             }
+        elsif str.match /edit_(.*)_path/
+            lambda { |context|
+                model = context.instance_variable_get "@#{$1}"
+                parse_opts.call "/#{model.class.to_s.tableize}/#{model.id}/edit", args.first, context
+            }
+        elsif str.match /(.*)_path/
+          pluralized = $1.pluralize
+          if pluralized == $1
+            lambda { |context|  parse_opts.call "/#{$1}", args.first, context }
+          else
+            lambda { |context|
+                model = context.instance_variable_get "@#{$1}"
+                parse_opts.call "/#{model.class.to_s.tableize}/#{model.id}", args.first, context
+            }
+          end
         else
           super(methId, [])
         end
 
       end
+
 end
 
 module RSpec::Core::ObjectExtensions
@@ -161,6 +187,4 @@ module RSpec::Core::ObjectExtensions
   end
 end
 
-
-
 RSpec.configuration.include Saki::AcceptanceHelpers, :type => :acceptance

data/saki.gemspec

@@ -5,11 +5,11 @@
 
 Gem::Specification.new do |s|
   s.name = %q{saki}
-  s.version = "0.0.4"
+  s.version = "0.1.0"
 
   s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
   s.authors = ["Nate Kidwell"]
-  s.date = %q{2010-08-30}
+  s.date = %q{2010-08-31}
   s.description = %q{Cucumber scenarios are long and confusing sometimes.  Release yourself from the tyranny of client-centered specing!}
   s.email = %q{nate@ludicast.com}
   s.extra_rdoc_files = [
@@ -24,7 +24,9 @@ Gem::Specification.new do |s|
      "Rakefile",
      "VERSION",
      "lib/generators/saki/install_generator.rb",
+     "lib/generators/saki/spec_generator.rb",
      "lib/generators/saki/templates/acceptance_helper.rb",
+     "lib/generators/saki/templates/acceptance_spec.rb",
      "lib/generators/saki/templates/helpers.rb",
      "lib/saki.rb",
      "saki.gemspec",

metadata

@@ -1,13 +1,13 @@
 --- !ruby/object:Gem::Specification 
 name: saki
 version: !ruby/object:Gem::Version 
-  hash: 23
+  hash: 27
   prerelease: false
   segments: 
   - 0
+  - 1
   - 0
-  - 4
-  version: 0.0.4
+  version: 0.1.0
 platform: ruby
 authors: 
 - Nate Kidwell
@@ -15,7 +15,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2010-08-30 00:00:00 -04:00
+date: 2010-08-31 00:00:00 -04:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency 
@@ -49,7 +49,9 @@ files:
 - Rakefile
 - VERSION
 - lib/generators/saki/install_generator.rb
+- lib/generators/saki/spec_generator.rb
 - lib/generators/saki/templates/acceptance_helper.rb
+- lib/generators/saki/templates/acceptance_spec.rb
 - lib/generators/saki/templates/helpers.rb
 - lib/saki.rb
 - saki.gemspec