Byclosure-common_steps 0.0.1 → 0.0.2

data/spec/common_steps/common_steps_spec.rb

@@ -1,7 +1,258 @@
-require File.expand_path(File.dirname(__FILE__) + '/spec_helper')
+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"
 
-describe "CommonSteps" do
-  it "fails" do
-    fail "hey buddy, you should probably rename this file and start specing for real"
+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
+
+# In order to use features without bugs
+# As a developer
+# I want to test my applications using record steps beginning with Given
+describe "Cucumber instance with record_steps.rb and World(RecordHelper) loaded" do
+  extend StepMotherHelper
+  
+  before do
+    @step_mother = Cucumber::Cli::Main.step_mother
+    @step_mother.load_code_file(File.expand_path(File.dirname(__FILE__) + "/../../lib/common_steps/step_definitions/record_steps.rb"))
+    @dsl = Object.new
+    @dsl.extend(Cucumber::RbSupport::RbDsl)
+    @dsl.World(RecordHelper)
+    @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'
+  step_should_match 'there is 0 artists'
+  step_should_match 'there is a artist'
+  step_should_match 'there is an artist'
+  step_should_match 'there is 1 artist'
+  step_should_match 'there are 3 artists'
+
+  # 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"'
+  step_should_match 'there is an artist with a name of "John"'
+  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'
+  
+  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
+    end
+    
+    artist_should_count(0, 'there are 0 artists with a name of "John"')
+    artist_should_count(0, 'there are no artists with a name of "John"')
+    
+    artist_should_count_and_be(1, {:name => "John"}, 'there is 1 artist with a name of "John"')
+    artist_should_count_and_be(1, {:name => "John"}, 'there is an artist with a name of "John"')
+    artist_should_count_and_be(1, {:name => "John"}, 'there is a artist with a name of "John"')
+    artist_should_count_and_be(3, {:name => "John"}, 'there are 3 artists with a name of "John"')
+    artist_should_count_and_be(1, {:name => "John", :age => 32}, 'there are 1 artists with a name of "John", and age of 32')
+    
+    # To discuss later
+    #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
+  
+  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
+  
+  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
+   
+  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']])
+    artists_in_table_should_be @cucumber_table, 'the following artists'
+  end
+
+  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
+    end
+    
+    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
+      Artist.create!(:name => "John", :age => 32)
+    end
+
+    it "should not raise error when I invoke StepMatch[there should be 1 artist with a name of 'John']" do
+      lambda do
+        m = @step_mother.step_match('there should be 1 artist with a name of "John"')
+        m.invoke(nil)
+      end.should_not raise_error 
+    end
+    
+    it "should not raise error when I invoke StepMatch['there should be an artist with a name of \"John\"']" do
+      lambda do
+        m = @step_mother.step_match('there should be an artist with a name of "John"')
+        m.invoke(nil)
+      end.should_not raise_error 
+    end
+
+    it "should not raise error when I invoke StepMatch[''there should be a artist with a name of \"John\"'']" do
+      lambda do
+        m = @step_mother.step_match('there should be a artist with a name of "John"')
+        m.invoke(nil)
+      end.should_not raise_error 
+    end
+    
+    it "should not raise error when I invoke StepMatch['there should be 1 artists with a name of \"John\", and age of 32']" do
+      lambda do
+        m = @step_mother.step_match('there should be 1 artists with a name of "John", and age of 32')
+        m.invoke(nil)
+      end.should_not raise_error 
+    end
+  end
+    
+  describe "where 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)
+      Artist.create!(:name => "Mary", :age => 34)
+    end
+    
+    it "should not raise error when I invoke StepMatch[there should be the following (\w+):?] with [{:name => 'John', :age => 12}, {:name => 'Mary', :age => 34}]" do
+      lambda do
+        m = @step_mother.step_match("there should be the following artists")
+        m.invoke(Cucumber::Ast::Table.new(
+            [['name', 'age'],
+              ['John', '12'],
+              ['Mary', '34']]))
+      end.should_not raise_error 
+    end
+    
+    it "should raise error when I invoke StepMatch[there should be the following (\w+):?] with [{:name => 'Ann', :age => 12}]" do
+      lambda do
+        m = @step_mother.step_match("there should be the following artists")
+        m.invoke(Cucumber::Ast::Table.new(
+            [['name', 'age'],
+              ['Ann', '12']]))
+      end.should raise_error
+    end
+
+    it "should raise error when I invoke StepMatch[there should be the following (\w+):?] with [{:name => 'John', :age => 12}, {:name => 'Mary', :age => 34}, {:name => 'Andrea', :age => 22}]" do
+      lambda do
+        m = @step_mother.step_match("there should be the following artists")
+        m.invoke(Cucumber::Ast::Table.new(
+            [['name', 'age'],
+              ['John', '12'],
+              ['Mary', '34'],
+              ['Andrea', '22']]))
+      end.should raise_error      
+    end
   end
 end

data/spec/common_steps/helpers/conditions_parser_spec.rb

@@ -0,0 +1,288 @@
+require File.expand_path(File.dirname(__FILE__) + "/../../spec_helper")
+require "common_steps/helpers/conditions_parser"
+
+module ParserHelper
+  module InputHelper
+    def should_be_instance_of(klass)
+      it { @parse_tree.should be_instance_of(klass) }
+    end
+    
+    def should_be_a(klass)
+      it { @parse_tree.should be_a(klass) }
+    end
+    
+    alias_method :instance_of, :should_be_instance_of
+    alias_method :be_a, :should_be_a
+    
+    def conditions_should_be(*conditions)
+      it "conditions should be of type: #{conditions.inspect}" do
+        @parse_tree.splited_conditions.map(&:class).should == conditions
+      end
+    end
+    
+    def conditions_hash_should_be(hash)
+      it "conditions hash should be #{hash.inspect}" do
+        @parse_tree.conditions_hash.should == hash
+      end
+    end
+    
+    alias_method :conditions_hash, :conditions_hash_should_be
+  end
+  
+  def should_parse(input, &block)
+    it { @conditions_parser.should treetop_parse(input) }
+    describe_input input, &block if block_given?
+  end
+  
+  def should_not_parse(input)
+    it { @conditions_parser.should_not treetop_parse(input) }
+  end
+  
+  def describe_input(input, &block)
+    describe "with input `#{input}'" do
+      extend InputHelper
+      before do
+        @parse_tree = @conditions_parser.parse input
+      end
+      instance_eval(&block)
+    end
+  end
+end
+
+describe "ConditionsParser" do
+  extend ParserHelper
+  include TreetopParserMatchers
+  
+  before do
+    @conditions_parser = ConditionsParser.new
+  end
+  
+  # of separators
+  should_parse "word of 'foo'" do
+    instance_of(OfCondition)
+    conditions_hash 'word' => 'foo'
+  end
+  should_parse "word         of        'foo'" do
+    instance_of(OfCondition)
+    conditions_hash 'word' => 'foo'
+  end
+  should_parse "two words of 'foo'" do
+    instance_of(OfCondition)
+    conditions_hash 'two words' => 'foo'
+  end
+  should_parse "of of 'foo'" do
+    instance_of(OfCondition)
+    conditions_hash 'of' => 'foo'
+  end
+  should_parse "word of of 'foo'" do
+    instance_of(OfCondition)
+    conditions_hash 'word of' => 'foo'
+  end
+  should_parse "two of words of 'foo'" do
+    instance_of(OfCondition)
+    conditions_hash 'two of words' => 'foo'
+  end
+  should_parse "of word of 'foo'" do
+    instance_of(OfCondition)
+    conditions_hash 'of word' => 'foo'
+  end
+  should_parse "of word of 'foo'" do
+    instance_of(OfCondition)
+    conditions_hash 'of word' => 'foo'
+  end
+  should_parse "belonging to of 'boo'" do
+    instance_of(OfCondition)
+    conditions_hash 'belonging to' => 'boo'
+  end
+  should_parse "belonging    to    of 'boo'"  do
+    instance_of(OfCondition)
+    conditions_hash 'belonging to' => 'boo'
+  end
+  should_parse "something belonging to of 'boo'" do
+    instance_of(OfCondition)
+    conditions_hash 'something belonging to' => 'boo'
+  end
+  should_parse "something belonging to someone of 'boo'" do
+    instance_of(OfCondition)
+    conditions_hash 'something belonging to someone' => 'boo'
+  end
+  should_parse "belonging to someone of 'boo'" do
+    instance_of(OfCondition)
+    conditions_hash 'belonging to someone' => 'boo'
+  end
+  should_parse "belonging to someone with of 'boo'" do
+    instance_of(OfCondition)
+    conditions_hash 'belonging to somenone with' => 'boo'
+  end
+  should_parse "belonging to someone with name of 'boo'" do
+    instance_of(OfCondition)
+    conditions_hash 'belonging to someone with name' => 'boo'
+  end
+  should_parse "belonging to someone with a of 'boo'" do
+    instance_of(OfCondition)
+    conditions_hash 'belonging to someone with a' => 'boo'
+  end
+  should_parse "belonging to someone with an of 'boo'" do
+    instance_of(OfCondition)
+    conditions_hash 'belonging to someone with an' => 'boo'
+  end
+  should_not_parse "separatorof'foo'"
+  should_not_parse "of 'foo'"
+  
+  # => separator
+  should_parse "word => 'foo'" do
+    instance_of(ArrowCondition)
+    conditions_hash 'word' => 'foo'
+  end
+  should_parse "word      =>      'foo'" do
+    instance_of(ArrowCondition)
+    conditions_hash 'word' => 'foo'
+  end
+  should_parse "word=>'foo'" do
+    instance_of(ArrowCondition)
+    conditions_hash 'word' => 'foo'
+  end
+  should_parse "word of => 'foo'" do
+    instance_of(ArrowCondition)
+    conditions_hash "word of" => 'foo'
+  end
+  # should_parse "belonging to foo => ''"
+  should_parse "belonging to => 'boo'" do
+    instance_of(ArrowCondition)
+    conditions_hash "belonging to" => 'boo'
+  end
+  should_parse "belonging    to    => 'boo'" do
+    instance_of(ArrowCondition)
+    conditions_hash "belonging to" => 'boo'
+  end
+  should_parse "word of => 'foo'" do
+    instance_of(ArrowCondition)
+    conditions_hash 'word of' => 'foo'
+  end
+  
+  # values
+  should_parse "string => 'foo'" do
+    instance_of(ArrowCondition)
+    conditions_hash 'string' => 'foo'
+  end
+  should_parse 'string => "foo"' do
+    instance_of(ArrowCondition)
+    conditions_hash 'string' => 'foo'
+  end
+  # should_parse "string => 'f\\'o\\'o'" future
+  # should_parse 'string => "f\\"o\\"o"' future
+  should_parse "integer => 23" do
+    instance_of(ArrowCondition)
+    conditions_hash 'integer' => 23
+  end
+  should_parse "float => 23.000" do
+    instance_of(ArrowCondition)
+    conditions_hash 'float' => 23.0
+  end
+  should_parse "float => .5" do
+    instance_of(ArrowCondition)
+    conditions_hash 'float' => 0.5
+  end
+  should_parse "boolean => true" do
+    instance_of(ArrowCondition)
+    conditions_hash 'boolean' => true
+  end
+  should_parse "boolean => false" do
+    instance_of(ArrowCondition)
+    conditions_hash 'boolean' => false
+  end
+  should_parse "symbol => :foo" do
+    instance_of(ArrowCondition)
+    conditions_hash 'symbol' => :foo
+  end
+  should_parse "null => nil" do
+    instance_of(ArrowCondition)
+    conditions_hash "null" => nil
+  end
+  should_parse "two words => 'foo'" do
+    instance_of(ArrowCondition)
+    conditions_hash 'two words' => 'foo'
+  end
+  should_parse "two    words => 'foo'" do
+    instance_of(ArrowCondition)
+    conditions_hash 'two words' => 'foo'
+  end
+  should_parse "one_word => 'foo'" do
+    instance_of(ArrowCondition)
+    conditions_hash 'one_word' => 'foo'
+  end
+  
+  should_not_parse "bar => foo" # future meth (or #meth)
+  should_not_parse "date => Date.today" # future
+
+
+  should_parse "name of 'boo' and age of 23" do
+    be_a(SplitConditions)
+    conditions_should_be OfCondition, OfCondition
+    conditions_hash 'name' => 'boo', 'age' => 23
+  end
+  should_parse "name of 'boo', age => 23, internal => true" do
+    be_a(SplitConditions)
+    conditions_should_be OfCondition, ArrowCondition, ArrowCondition
+    conditions_hash 'name' => 'boo', 'age' => 23, 'internal' => true
+  end  
+  should_parse "name => 'boo', age of 23, and internal of true" do
+    be_a(SplitConditions)
+    conditions_should_be ArrowCondition, OfCondition, OfCondition
+    conditions_hash 'name' => 'boo', 'age' => 23, 'internal' => true
+  end
+  should_parse "name => 'boo', age of 23 and internal of true" do
+    be_a(SplitConditions)
+    conditions_should_be ArrowCondition, OfCondition, OfCondition
+    conditions_hash 'name' => 'boo', 'age' => 23, 'internal' => true
+  end
+  should_parse "name => 'boo',           age => 23.0       ,      and      internal => true" do
+    be_a(SplitConditions)
+    conditions_should_be ArrowCondition, ArrowCondition, ArrowCondition
+    conditions_hash 'name' => 'boo', 'age' => 23.0, 'internal' => true
+  end
+  
+  should_parse "belonging to artist with a name of 'boo'" do
+    instance_of(BelongingToCondition)
+    conditions_hash 'artist' => {'name' => 'boo'}
+  end
+=begin  
+  should_parse "belonging to magnific artist with a name of 'boo'" do
+    instance_of(BelongingToCondition)
+    conditions_hash 'magnific artist' => {'name' => 'boo'}
+  end
+  should_parse "belonging to artist with a name of 'boo', and age of 23" do
+    instance_of(BelongingToCondition)
+    conditions_hash 'artist' => {'name' => 'boo', 'age' => 23}
+  end
+  should_parse "belonging to artist with a name of 'boo'; and age of 50" do
+    be_a(SplitConditions)
+    conditions_should_be BelongingToCondition, OfCondition
+    conditions_hash 'artist' => {'name' => 'boo', 'age' => 50}
+  end
+  should_parse "belonging to artist with with a name of 'boo'; and age of 50" do
+    be_a(SplitConditions)
+    conditions_should_be BelongingToCondition, OfCondition
+    conditions_hash 'artist' => {'name' => 'boo'}, 'age' => 50
+  end
+  should_parse "belonging to with artist with a name of 'boo'; and age of 50" do
+    be_a(SplitConditions)
+    conditions_should_be BelongingToCondition, OfCondition
+    conditions_hash 'with artist' => {'name' => 'boo'}, 'age' => 50
+  end
+  should_parse "age of 50, belonging to artist with a name of 'foo'" do
+    be_a(SplitConditions)
+    conditions_should_be OfCondition, BelongingToCondition, OfCondition
+    conditions_hash 'age' => 50, 'artist' => {'name' => 'foo'}
+  end
+  should_not_parse "belonging to artist"
+  should_not_parse "belonging to artist with a"
+=end
+=begin  
+  it do
+    p = @conditions_parser.parse("string => 'foo'")
+    debugger
+    nil
+  end
+=end
+end

data/spec/common_steps/helpers/record_helper_spec.rb

@@ -0,0 +1,133 @@
+require File.expand_path(File.dirname(__FILE__) + "/../../spec_helper")
+require "common_steps/helpers/record_helper"
+
+class Artist; end
+class MagnificArtist; end
+module Admin
+  class Painting; end
+end
+describe RecordHelper, "with Artist, MagnificArtist, ::Admin::Painting defined" do
+  before do
+    @env = Object.new
+    @env.extend(RecordHelper)
+  end
+  
+  it { @env.should respond_to(:recordize!) }
+  
+  it { @env.should respond_to(:record_singular_name) }
+  it "#record_singular_name('aRtIsTs') should == 'artist'" do
+    @env.record_singular_name('aRtIsTs').should == 'artist'
+  end  
+  it "#record_singular_name('ArTiSt') should == 'artist'" do
+    @env.record_singular_name('ArTiSt').should == 'artist'
+  end
+  it "#record_singular_name('ReCiPe iNgReDiEnTs') should == 'recipe ingredient'" do
+    @env.record_singular_name('ReCiPe iNgReDiEnTs').should == 'recipe ingredient'
+  end
+  
+  it { @env.should respond_to(:record_name_to_class) }
+  it "#record_name_to_class('ArTiSt') should == Artist" do
+    @env.record_name_to_class('ArTiSt').should == Artist
+  end
+  it "#record_name_to_class('aRtIsTs') should == Artist" do
+    @env.record_name_to_class('aRtIsTs').should == Artist
+  end
+  it "#record_name_to_class('magnific artist') should == MagnificArtist" do
+    @env.record_name_to_class('magnific artist').should == MagnificArtist
+  end
+  it "#record_name_to_class('magnific artists') should == MagnificArtist" do
+    @env.record_name_to_class('magnific artists').should == MagnificArtist
+  end
+  
+  it { @env.should respond_to(:str_to_num) }
+  it "#str_to_num('a') should == 1" do
+    @env.str_to_num('a').should == 1
+  end
+  it "#str_to_num('an') should == 1" do
+    @env.str_to_num('an').should == 1
+  end
+  it "#str_to_num('no') should == 0" do
+    @env.str_to_num('no').should == 0
+  end
+  it "#str_to_num(something_else) should hit something_else with #to_i" do
+    something_else = mock("something_else")
+    something_else.should_receive(:to_i).once.with(no_args)
+    @env.str_to_num(something_else)
+  end
+  
+  it { @env.should respond_to(:conditions_from_str) }
+  it "#conditions_from_str(\"name of 'foo'\") should == {'name' => 'foo'}" do
+    @env.conditions_from_str("name of 'foo'").should == {"name" => "foo"}
+  end
+  it "#conditions_from_str(\"name => 'foo'\") should == {'name' => 'foo'}" do
+    @env.conditions_from_str("name => 'foo'").should == {"name" => "foo"}
+  end
+  it "#conditions_from_str(\"age of 23\") should == {'age' => 23}" do
+    @env.conditions_from_str("age of 23").should == {"age" => 23}
+  end
+  it "#conditions_from_str(\"age => 23\") should == {'age' => 23}" do
+    @env.conditions_from_str("age => 23").should == {"age" => 23}
+  end
+  it "#conditions_from_str(\"lame of true\") should == {'lame' => true}" do
+    @env.conditions_from_str("lame of true").should == {"lame" => true}
+  end
+  it "#conditions_from_str(\"lame => true\")" do
+    @env.conditions_from_str("lame => true").should == {"lame" => true}
+  end
+  it "#conditions_from_str(\"full name => meth\"), with #meth defined and returning 'bar', should == {'full_name'=>'bar'}" do
+    @env.should_receive(:meth).and_return('bar')
+    @env.conditions_from_str("full name => meth").should == {"full_name" => 'bar'}
+  end
+  it "#conditions_from_str(\"full_name of meth\"), with #meth defined and returning 'bar', should == {'full_name'=>'bar'}" do
+    @env.should_receive(:meth).and_return('bar')
+    @env.conditions_from_str("full_name of meth").should == {"full_name" => 'bar'}
+  end
+  it "#conditions_from_str(\"date => Date.today\") should == {'date' => #{Date.today}}" do
+    @env.conditions_from_str("date => Date.today").should == {"date" => Date.today}
+  end
+  it "#conditions_from_str(\"date of Date.today\") should == {'date' => #{Date.today}}" do
+    @env.conditions_from_str("date => Date.today").should == {"date" => Date.today}
+  end
+  
+  it "#conditions_from_str(\"name of 'boo' and age of 23\") should == {'name' => 'boo', 'age' => 23}" do
+    @env.conditions_from_str("name of 'boo' and age of 23").should == {"name" => "boo", "age" => 23}
+  end
+  it "#conditions_from_str(\"name of 'boo', age => 23, internal => true\") should == {'name' => 'boo', 'age' => 23, 'internal' => true}" do
+    @env.conditions_from_str("name of 'boo', age => 23, internal => true").should == {"name" => "boo", "age" => 23, "internal" => true}
+  end
+  it "#conditions_from_str(\"name => 'boo', age of 23, and internal of true\") should == {'name' => 'boo', 'age' => 23, 'internal' => true}" do
+    @env.conditions_from_str("name => 'boo', age of 23, and internal of true").should == {"name" => "boo", "age" => 23, "internal" => true}
+  end
+  it "#conditions_from_str(\"name => meth, age of 23, and internal of true\"), with #meth defined and returning 'bar', should == {'name'=>'bar','age'=>23,'internal'=>true}" do
+    @env.should_receive(:meth).and_return('bar')
+    @env.conditions_from_str("name => meth, age of 23, and internal of true").should == {"name"=>"bar", "age"=>23, "internal"=>true}
+  end
+  
+  it { @env.should respond_to(:find_record) }
+  describe "find_record(Artist, \"'name of 'Foo', internal => true\")" do
+    it "should hit Artist with #find(:all, :conditions => {'name' => 'Foo', internal => true}) and return mock('artist')" do
+      artist = mock("artist")
+      Artist.should_receive(:find).with(:first, :conditions => {'name' => 'Foo', "internal" => true}).and_return(artist)
+      @env.find_record(Artist, "name of 'Foo', internal => true")
+    end
+  end
+  describe "when Artist.find(:first, :conditions => {'name' => 'Bar'}) return nil find_record(Artist, \"name => 'Bar'\") should raise error" do
+    it do
+      Artist.should_receive(:find).with(:first, :conditions => {'name' => 'Bar'}).and_return(nil)
+      lambda do
+        @env.find_record(Artist, "name => 'Bar'")
+      end.should raise_error("Couldn't found any record for `Artist' with conditions: `{\"name\"=>\"Bar\"}'")
+    end
+  end
+  
+  it { @env.should respond_to(:record_class_to_path) }
+  it "#record_class_to_path(Artist) should == '/artists'" do
+    @env.record_class_to_path(Artist).should == '/artists'
+  end
+  it "#record_class_to_path(MagnificArtist) should == '/magnific_artist'" do
+    @env.record_class_to_path(MagnificArtist).should == '/magnific_artists'
+  end
+  it "#record_class_to_path(::Admin::Painting) should == '/admin/paintings'" do
+    @env.record_class_to_path(::Admin::Painting).should == '/admin/paintings'
+  end
+end