taza 0.9.2.1 → 1.0

data/spec/taza/entity_spec.rb

@@ -4,32 +4,32 @@ require 'taza/entity'
 describe Taza::Entity do
   it "should add methods for hash string keys" do
     entity = Taza::Entity.new({'apple' => 'pie'},nil)
-    entity.should respond_to(:apple)
+    expect(entity).to respond_to :apple
   end
 
   it "should be accessible like a hash(foo[:bar])" do
     entity = Taza::Entity.new({:apple => 'pie'},nil)
-    entity[:apple].should eql('pie')
+    expect(entity[:apple]).to eql 'pie'
   end
 
   it "should be able to define methods for multiple levels" do
     entity = Taza::Entity.new({:fruits => {:apple => 'pie'} },nil)
-    entity.fruits.apple.should eql('pie')
+    expect(entity.fruits.apple).to eql 'pie'
   end
 
   it "should be able to return a hash object" do
     entity = Taza::Entity.new({:apple => 'pie' },nil)
-    entity.to_hash[:apple].should eql('pie')
+    expect(entity.to_hash[:apple]).to eql 'pie'
   end
 
   it "should be able to do string-to-symbol conversion for hash keys using to_hash" do
     entity = Taza::Entity.new({'apple' => 'pie' },nil)
-    entity.to_hash[:apple].should eql('pie')
+    expect(entity.to_hash[:apple]).to eql 'pie'
   end
 
   it "should be able to do string-to-symbol conversion for hash keys" do
     entity = Taza::Entity.new({'fruits' => {'apple' => 'pie' }},nil)
-    entity.to_hash[:fruits][:apple].should eql('pie')
+    expect(entity.to_hash[:fruits][:apple]).to eql 'pie'
   end
 
 end

data/spec/taza/fixture_spec.rb

@@ -12,33 +12,33 @@ describe Taza::Fixture do
     fixture = Taza::Fixture.new
     fixture.load_fixtures_from(@base_path)
     example = fixture.get_fixture_entity(:examples,'first_example')
-    example.name.should eql("first")
-    example.price.should eql(1)
+    expect(example.name).to eql "first"
+    expect(example.price).to eql 1
   end
 
   it "should use the spec fixtures folder as the base path" do
-    Taza::Fixture.base_path.should eql('./spec/fixtures/')
+    expect(Taza::Fixture.base_path).to eql './spec/fixtures/'
   end
 
   it "should know if a pluralized fixture of that name exists" do
     fixture = Taza::Fixture.new
     fixture.load_fixtures_from(@base_path)
-    fixture.pluralized_fixture_exists?('example').should be_true
-    fixture.pluralized_fixture_exists?('boo').should be_false
+    expect(fixture.pluralized_fixture_exists?('example')).to be true
+    expect(fixture.pluralized_fixture_exists?('boo')).to be false
   end
 
   it "should be able to get all fixtures loaded excluding sub-folder fixtures" do
     fixture = Taza::Fixture.new
     fixture.load_fixtures_from(@base_path)
-    fixture.fixture_names.should be_equivalent([:examples,:users,:foos])
+    expect(fixture.fixture_names).to be_equivalent [:examples,:users,:foos]
   end
 
   it "should be able to get specific fixture entities" do
     fixture = Taza::Fixture.new
     fixture.load_fixtures_from(@base_path)
     examples = fixture.specific_fixture_entities(:examples, ['third_example'])
-    examples.length.should eql(1)
-    examples['third_example'].name.should eql('third')
+    expect(examples.length).to eql 1
+    expect(examples['third_example'].name).to eql 'third'
   end
 
   it "should not modified the fixtures when you get specific entities off a fixture" do
@@ -46,7 +46,7 @@ describe Taza::Fixture do
     fixture.load_fixtures_from(@base_path)
     previous_count = fixture.get_fixture(:examples).length
     examples = fixture.specific_fixture_entities(:examples, ['third_example'])
-    fixture.get_fixture(:examples).length.should eql(previous_count)
+    expect(fixture.get_fixture(:examples).length).to eql previous_count
   end
 
  end

data/spec/taza/fixtures_spec.rb

@@ -8,41 +8,41 @@ describe "Taza::Fixtures" do
   include Taza::Fixtures
 
   it "should be able to look up a fixture entity off fixture_methods module" do
-    examples(:first_example).name.should eql('first')
+    expect(examples(:first_example).name).to eql 'first'
   end
 
   it "should still raise method missing error" do
-    lambda{zomgwtf(:first_example)}.should raise_error(NoMethodError)
+    expect(lambda{zomgwtf(:first_example)}).to raise_error(NoMethodError)
   end
 
   #TODO: this test tests what is in entity's instance eval not happy with it being here
   it "should be able to look up a fixture entity off fixture_methods module" do
-    examples(:first_example).user.name.should eql(users(:shatner).name)
+    expect(examples(:first_example).user.name).to eql users(:shatner).name
   end
 
   it "should be able to resolve one to many relationships" do
-    foos(:gap).examples.length.should eql(2)
+    expect(foos(:gap).examples.length).to eql 2
   end
 
   it "should be able to get one to many entities" do
-    foos(:gap).examples['first_example'].name.should eql('first')
-    foos(:gap).examples['second_example'].name.should eql('second')
+    expect(foos(:gap).examples['first_example'].name).to eql 'first'
+    expect(foos(:gap).examples['second_example'].name).to eql 'second'
   end
 
   it "should not be able to access fixtures in sub-folders if not included" do
-    lambda{bars(:foo)}.should raise_error(NoMethodError)
+    expect(lambda{bars(:foo)}).to raise_error(NoMethodError)
   end
 
   it "should template fixture files" do
-    users(:shatner).age.should eql(66)
+    expect(users(:shatner).age).to eql 66
   end
 
   it "should be able to get one to many entities for hash[key] style" do
-    foos(:gap)['examples']['first_example']['name'].should eql('first')
+    expect(foos(:gap)['examples']['first_example']['name']).to eql 'first'
   end
 
   it "should be able to access multiple levels inside fixtures" do
-    examples(:forth_example).something.user.name.should eql('William Shatner')
+    expect(examples(:forth_example).something.user.name).to eql 'William Shatner'
   end
 
 end

data/spec/taza/hash_spec.rb

@@ -6,10 +6,10 @@ require 'extensions/hash'
 describe 'Hash Extensions' do
   it "should add methods for hash keys to some instance" do
     entity = {'apple' => 'pie'}.convert_hash_keys_to_methods(nil)
-    entity.should respond_to(:apple)
+    expect(entity).to respond_to :apple
   end
   it "should not add the methods to a hash" do
     entity = {'apple' => 'pie'}.convert_hash_keys_to_methods(nil)
-    entity.should_not be_a_instance_of(Hash)
+    expect(entity).to_not be_a_instance_of Hash
   end
 end

data/spec/taza/page_module_spec.rb

@@ -14,7 +14,7 @@ describe "Taza Page Module" do
   it "should execute elements in the context of their page module" do
     page = PageWithModule.new(:module)
     page.browser = :something
-    page.module_element.should eql(:something)
+    expect(page.module_element).to eql :something
   end
 
   class AnotherPageWithModule < ::Taza::Page
@@ -27,13 +27,13 @@ describe "Taza Page Module" do
 
 
   it "should not execute elements that belong to a page module but accessed without it" do
-    lambda { AnotherPageWithModule.new.another_module_element }.should raise_error(NoMethodError)
+    expect(lambda { AnotherPageWithModule.new.another_module_element }).to raise_error(NoMethodError)
   end
 
   it "should execute elements in the context of their page module when accessed with it" do
     page = AnotherPageWithModule.new(:other_module)
     page.browser = :another_thing
-    page.another_module_element.should eql(:another_thing)
+    expect(page.another_module_element).to eql :another_thing
   end
 
 
@@ -52,8 +52,8 @@ describe "Taza Page Module" do
   it "should execute elements with the same name but different page modules" do
     module_one = TestPageWithModules.new(:module_one)
     module_two = TestPageWithModules.new(:module_two)
-    module_one.some_module_element.should eql(:something)
-    module_two.some_module_element.should eql(:nothing)
+    expect(module_one.some_module_element).to eql :something
+    expect(module_two.some_module_element).to eql :nothing
   end
 
   class PageWithMultipleModuleElements < ::Taza::Page
@@ -67,15 +67,16 @@ describe "Taza Page Module" do
 
   it "should execute elements with the same name but different page modules" do
     page_module = PageWithMultipleModuleElements.new(:module)
-    page_module.module_element.should eql(:something)
-    page_module.another_module_element.should eql(:nothing)
+    expect(page_module.module_element).to eql :something
+    expect(page_module.another_module_element).to eql :nothing
   end
 
   class PageWithFilterAndModule < ::Taza::Page
     page_module :module do
-      element(:sample_element) {:something}
+      element(:sample_element) { :something }
     end
     filter :sample_filter, :module
+
     def sample_filter
       true
     end
@@ -83,14 +84,15 @@ describe "Taza Page Module" do
 
   it "should execute filters for page modules" do
     page = PageWithFilterAndModule.new(:module)
-    page.sample_element.should eql(:something)
+    expect(page.sample_element).to eql :something
   end
 
- class PageWithFalseFilterAndModule < ::Taza::Page
+  class PageWithFalseFilterAndModule < ::Taza::Page
     page_module :module do
-      element(:sample_element) {:something}
+      element(:sample_element) { :something }
     end
     filter :false_filter, :module
+
     def false_filter
       false
     end
@@ -98,14 +100,15 @@ describe "Taza Page Module" do
 
   it "should raise an error for page-module filters that return false" do
     page = PageWithFalseFilterAndModule.new(:module)
-    lambda { page.sample_element }.should raise_error(Taza::FilterError)
+    expect(lambda { page.sample_element }).to raise_error(Taza::FilterError)
   end
 
   class PageWithFilterAndModuleElements < ::Taza::Page
     page_module :module do
-      element(:sample_element) {:something}
+      element(:sample_element) { :something }
     end
     page_module_filter :sample_filter, :module, :sample_element
+
     def sample_filter
       false
     end
@@ -113,19 +116,22 @@ describe "Taza Page Module" do
 
   it "should execute filters for elements inside page modules" do
     page = PageWithFilterAndModuleElements.new(:module)
-    lambda { page.sample_element }.should raise_error(Taza::FilterError)
+    expect(lambda { page.sample_element }).to raise_error(Taza::FilterError)
   end
 
   class PageWithFiltersAndModuleElements < ::Taza::Page
     page_module :module do
-      element(:sample_element) {:something}
-      element(:another_sample_element) {:something}
+      element(:sample_element) { :something }
+      element(:another_sample_element) { :something }
     end
     page_module_filter :sample_filter, :module
+
     def sample_filter
       true
     end
+
     page_module_filter :another_sample_filter, :module, :sample_element
+
     def another_sample_filter
       false
     end
@@ -133,22 +139,25 @@ describe "Taza Page Module" do
 
   it "should execute filters for specific and all elements inside page modules" do
     page = PageWithFiltersAndModuleElements.new(:module)
-    lambda { page.sample_element }.should raise_error(Taza::FilterError)
-    page.another_sample_element.should eql(:something)
+    expect(lambda { page.sample_element }).to raise_error(Taza::FilterError)
+    expect(page.another_sample_element).to eql :something
   end
 
   class PageWithFiltersAndModulesAndElements < ::Taza::Page
     page_module :foo_module do
-      element(:sample_element) {:something}
+      element(:sample_element) { :something }
     end
     page_module_filter :foo_filter, :foo_module
+
     def foo_filter
       true
     end
+
     page_module :bar_module do
-      element(:sample_element) {:nothing}
+      element(:sample_element) { :nothing }
     end
     page_module_filter :bar_filter, :bar_module
+
     def bar_filter
       false
     end
@@ -156,10 +165,9 @@ describe "Taza Page Module" do
 
   it "should execute page module filters for identical element names appropriately" do
     foo = PageWithFiltersAndModulesAndElements.new(:foo_module)
-    foo.sample_element.should eql(:something)
+    expect(foo.sample_element).to eql :something
     bar = PageWithFiltersAndModulesAndElements.new(:bar_module)
-    lambda { bar.sample_element }.should raise_error(Taza::FilterError)
- end
-
+    expect(lambda { bar.sample_element }).to raise_error(Taza::FilterError)
+  end
 
 end

data/spec/taza/page_spec.rb

@@ -22,12 +22,12 @@ describe Taza::Page do
 
   it "should not enter a infinite loop if you call a filtered element inside of a filter" do
     page = RecursiveFilterExample.new
-    lambda { page.foo }.should_not raise_error
+    expect(lambda { page.foo }).to_not raise_error
   end
 
   it "should execute an element's block with the params provided for its method" do
     Taza::Page.element(:boo){|baz| baz}
-    Taza::Page.new.boo("rofl").should == "rofl"
+    expect(Taza::Page.new.boo("rofl")).to eql 'rofl'
     end
 
   it "element's name can not be nil" do
@@ -37,18 +37,18 @@ describe Taza::Page do
   it "should execute elements and filters in the context of the page instance" do
     page = ElementAndFilterContextExample.new
     page.browser = :something
-    page.sample_element.should eql(:something)
+    expect(page.sample_element).to eql :something
   end
 
   it "should add a filter to the classes filters" do
-    ElementAndFilterContextExample.filters.size.should eql(1)
+    expect(ElementAndFilterContextExample.filters.size).to eql 1
   end
 
   it "should store the block given to the element method in a method with the name of the parameter" do
     Taza::Page.element(:foo) do
       "bar"
     end
-    Taza::Page.new.foo.should == "bar"
+    expect(Taza::Page.new.foo).to eql 'bar'
   end
 
   class FilterAllElements < Taza::Page
@@ -62,20 +62,20 @@ describe Taza::Page do
   end
 
   it "should filter all elements if element argument is not provided" do
-    lambda { FilterAllElements.new.apple }.should raise_error(Taza::FilterError)
-    lambda { FilterAllElements.new.foo }.should raise_error(Taza::FilterError)
+    expect(lambda { FilterAllElements.new.apple }).to raise_error(Taza::FilterError)
+    expect(lambda { FilterAllElements.new.foo }).to raise_error(Taza::FilterError)
   end
 
   it "should have empty elements on a new class" do
     foo = Class::new(superclass=Taza::Page)
-    foo.elements.should_not be_nil
-    foo.elements.should be_empty
+    expect(foo.elements).to_not be_nil
+    expect(foo.elements).to be_empty
   end
 
   it "should have empty filters on a new class" do
     foo = Class::new(superclass=Taza::Page)
-    foo.filters.should_not be_nil
-    foo.filters.should be_empty
+    expect(foo.filters).to_not be_nil
+    expect(foo.filters).to be_empty
   end
 
   class FilterAnElement < Taza::Page
@@ -89,21 +89,21 @@ describe Taza::Page do
   end
 
   it "should raise a error if an elements is called and its filter returns false" do
-    lambda { FilterAnElement.new.false_item }.should raise_error(Taza::FilterError)
+    expect(lambda { FilterAnElement.new.false_item }).to raise_error(Taza::FilterError)
   end
 
   it "should not call element block if filters fail" do
     page = FilterAnElement.new
-    lambda { page.false_item }.should raise_error
-    page.called_element_method.should_not be_true
+    expect(lambda { page.false_item }).to raise_error(Taza::FilterError)
+    expect(page.called_element_method).to_not be true
   end
 
   it "should not allow more than one element descriptor with the same element name" do
-    lambda{
+    expect(lambda{
     class DuplicateElements < Taza::Page
       element(:foo) { true }
       element(:foo) { false }
     end
-    }.should raise_error(Taza::ElementError)
+    }).to raise_error(Taza::ElementError)
   end
 end

data/spec/taza/settings_spec.rb

@@ -20,44 +20,44 @@ describe Taza::Settings do
   it "should use environment variable for browser settings" do
     Taza::Settings.stubs(:path).returns("#{@original_directory}/spec/sandbox")
     ENV['BROWSER'] = 'foo'
-    Taza::Settings.config(@site_name)[:browser].should eql('foo')
+    expect(Taza::Settings.config(@site_name)[:browser]).to eql 'foo'
   end
 
   it "should provide default values if no config file or environment settings provided" do
     Taza::Settings.stubs(:path).returns("#{@original_directory}/spec/sandbox")
-    Taza::Settings.config(@site_name)[:driver].should eql('selenium')
-    Taza::Settings.config(@site_name)[:browser].should eql('firefox')
-    Taza::Settings.config(@site_name)[:attach].should eql(false)
+    expect(Taza::Settings.config(@site_name)[:driver]).to eql 'selenium'
+    expect(Taza::Settings.config(@site_name)[:browser]).to eql 'firefox'
+    expect(Taza::Settings.config(@site_name)[:attach]).to eql false
   end
 
   it "should use environment variable for driver settings" do
     Taza::Settings.stubs(:path).returns("#{@original_directory}/spec/sandbox")
     ENV['DRIVER'] = 'bar'
-    Taza::Settings.config(@site_name)[:driver].should eql('bar')
+    expect(Taza::Settings.config(@site_name)[:driver]).to eql 'bar'
   end
 
   it "should be able to load the site yml" do
     Taza::Settings.stubs(:path).returns("#{@original_directory}/spec/sandbox")
-    Taza::Settings.config("SiteName")[:url].should eql('http://google.com')
+    expect(Taza::Settings.config("SiteName")[:url]).to eql 'http://google.com'
   end
 
   it "should be able to load a alternate site url" do
     ENV['TAZA_ENV'] = 'clown_shoes'
     Taza::Settings.stubs(:path).returns("#{@original_directory}/spec/sandbox")
-    Taza::Settings.config("SiteName")[:url].should eql('http://clownshoes.com')
+    expect(Taza::Settings.config("SiteName")[:url]).to eql 'http://clownshoes.com'
   end
 
   it "should use the config file's variable for browser settings if no environment variable is set" do
     UserChoices::YamlConfigFileSource.any_instance.stubs(:format_specific_reading).returns({'browser' => 'fu'})
     Taza::Settings.stubs(:path).returns("#{@original_directory}//spec/sandbox")
-    Taza::Settings.config(@site_name)[:browser].should eql('fu')
+    expect(Taza::Settings.config(@site_name)[:browser]).to eql 'fu'
   end
 
   it "should use the ENV variables if specfied instead of config files" do
     ENV['BROWSER'] = 'opera'
     UserChoices::YamlConfigFileSource.any_instance.stubs(:format_specific_reading).returns({'browser' => 'fu'})
     Taza::Settings.stubs(:path).returns("#{@original_directory}/spec/sandbox")
-    Taza::Settings.config(@site_name)[:browser].should eql('opera')
+    expect(Taza::Settings.config(@site_name)[:browser]).to eql 'opera'
   end
 
   it "should use the correct config file to set defaults" do
@@ -67,17 +67,17 @@ describe Taza::Settings do
 
   it "should raise error for a config file that doesnot exist" do
     Taza::Settings.stubs(:path).returns("#{@original_directory}/spec/sandbox/file_not_exists.yml")
-    lambda {Taza::Settings.config}.should raise_error
+    expect(lambda {Taza::Settings.config}).to raise_error(ArgumentError)
   end
 
   it "should path point at root directory" do
-    Taza::Settings.path.should eql('.')
+    expect(Taza::Settings.path).to eql '.'
   end
 
   it "should use the config file's variable for driver settings if no environment variable is set" do
     UserChoices::YamlConfigFileSource.any_instance.stubs(:format_specific_reading).returns({'driver' => 'fun'})
     Taza::Settings.stubs(:path).returns("#{@original_directory}/spec/sandbox")
-    Taza::Settings.config(@site_name)[:driver].should eql('fun')
+    expect(Taza::Settings.config(@site_name)[:driver]).to eql 'fun'
   end
 
   class SiteName < Taza::Site
@@ -86,7 +86,7 @@ describe Taza::Settings do
 
   it "a site should be able to load its settings" do
     Taza::Settings.stubs(:path).returns("#{@original_directory}/spec/sandbox")
-    SiteName.settings[:url].should eql('http://google.com')
+    expect(SiteName.settings[:url]).to eql 'http://google.com'
   end
 
 end