makevoid-taza 0.8.6

data/spec/browser_spec.rb

@@ -0,0 +1,86 @@
+require 'spec/spec_helper'
+require 'taza/browser'
+require 'taza/settings'
+require 'taza/options'
+require 'selenium'
+require 'watir'
+
+describe Taza::Browser do
+
+  before :each do
+    Taza::Settings.stubs(:config_file).returns({})
+    ENV['TAZA_ENV'] = 'isolation'
+    ENV['SERVER_PORT'] = nil
+    ENV['SERVER_IP'] = nil
+    ENV['BROWSER'] = nil
+    ENV['DRIVER'] = nil
+    ENV['TIMEOUT'] = nil
+  end
+
+  it "should raise unknown browser error for unsupported watir browsers" do
+    lambda { Taza::Browser.create(:browser => :foo_browser_9000,:driver => :watir) }.should raise_error(StandardError)
+  end
+
+  it "should use params browser type when creating selenium" do
+    browser_type = :opera
+    Selenium::SeleniumDriver.expects(:new).with(anything,anything,'*opera',anything)
+    Taza::Browser.create(:browser => browser_type, :driver => :selenium)
+  end
+  
+  it "should raise selenium unsupported browser error" do
+    Taza::Browser.create(:browser => :foo, :driver => :selenium)
+  end
+
+  it "should be able to create a selenium instance" do
+    browser = Taza::Browser.create(:browser => :firefox, :driver => :selenium)
+    browser.should be_a_kind_of(Selenium::SeleniumDriver)
+  end
+
+  it "should use environment settings for server port and ip" do
+    Taza::Settings.stubs(:path).returns(File.join('spec','sandbox'))
+    ENV['SERVER_PORT'] = 'server_port'
+    ENV['SERVER_IP'] = 'server_ip'
+    Selenium::SeleniumDriver.expects(:new).with('server_ip','server_port',anything,anything)
+    Taza::Browser.create(Taza::Settings.config("SiteName"))
+  end
+
+  it "should use environment settings for timeout" do
+    Taza::Settings.stubs(:path).returns(File.join('spec','sandbox'))
+    ENV['TIMEOUT'] = 'timeout'
+    Selenium::SeleniumDriver.expects(:new).with(anything,anything,anything,'timeout')
+    Taza::Browser.create(Taza::Settings.config("SiteName"))
+  end
+
+  it "should be able to give you the class of browser" do
+    Taza::Browser.expects(:watir_safari).returns(Object)
+    Taza::Browser.browser_class(:browser => :safari, :driver => :watir).should eql(Object) 
+  end
+  
+  it "should be able to attach to an open IE instance" do
+    require 'watir'
+    browser = Object.new
+    Watir::IE.stubs(:find).returns(browser)
+    Watir::IE.stubs(:new).returns(browser)
+    old_browser = Watir::IE.new
+    new_browser = Taza::Browser.create(:browser => :ie, :driver => :watir, :attach => true) 
+    new_browser.should eql(old_browser)
+  end
+  
+  it "should be able to open a new IE instance if there is no instance to attach to" do
+    require 'watir'
+    browser = Object.new
+    Watir::IE.stubs(:find).returns()
+    Watir::IE.stubs(:new).returns(browser)
+    new_browser = Taza::Browser.create(:browser => :ie, :driver => :watir) 
+    browser.nil?.should be_false 
+  end
+  it "should be able to open a new IE instance if attach not specified" do
+    require 'watir'
+    foo = Object.new
+    bar = Object.new
+    Watir::IE.stubs(:find).returns(foo)
+    Watir::IE.stubs(:new).returns(bar)
+    new_browser = Taza::Browser.create(:browser => :ie, :driver => :watir) 
+    new_browser.should_not eql(foo)
+  end
+end

data/spec/entity_spec.rb

@@ -0,0 +1,35 @@
+require 'spec/spec_helper'
+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)
+  end
+
+  it "should be accessible like a hash(foo[:bar])" do
+    entity = Taza::Entity.new({:apple => 'pie'},nil)
+    entity[:apple].should 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')
+  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')
+  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')
+  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')
+  end
+
+end

data/spec/fixture_spec.rb

@@ -0,0 +1,51 @@
+require 'spec/spec_helper'
+require 'taza/fixture'
+require 'extensions/array'
+
+describe Taza::Fixture do
+  before :each do
+    @base_path = File.join('.','spec','sandbox','fixtures','')
+  end
+
+  it "should be able to load entries from fixtures" 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)
+  end
+
+  it "should use the spec fixtures folder as the base path" do
+    Taza::Fixture.base_path.should 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
+  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])
+  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')
+  end
+
+  it "should not modified the fixtures when you get specific entities off a fixture" do
+    fixture = Taza::Fixture.new
+    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)
+  end
+
+ end

data/spec/fixtures_spec.rb

@@ -0,0 +1,47 @@
+require 'spec/spec_helper'
+require 'taza/fixture'
+
+describe "Taza::Fixtures" do
+  Taza::Fixture.stubs(:base_path).returns('./spec/sandbox/fixtures/')  
+  require 'taza/fixtures'
+  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')
+  end
+  
+  it "should still raise method missing error" do
+    lambda{zomgwtf(:first_example)}.should 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)
+  end
+  
+  it "should be able to resolve one to many relationships" do
+    foos(:gap).examples.length.should 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')
+  end
+
+  it "should not be able to access fixtures in sub-folders if not included" do
+    lambda{bars(:foo)}.should raise_error(NoMethodError)
+  end
+
+  it "should template fixture files" do
+    users(:shatner).age.should 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')
+  end
+  
+  it "should be able to access multiple levels inside fixtures" do
+    examples(:forth_example).something.user('shatner').name.should eql('William Shatner') 
+  end
+
+end

data/spec/flow_generator_spec.rb

@@ -0,0 +1,50 @@
+require 'spec/spec_helper'
+require 'rubygems'
+require 'fileutils'
+require 'taza/site'
+
+class Taza::Site
+  def flows
+    flows = []
+    Dir.glob(File.join(path,'flows','*.rb')).each do |file|
+      require file
+
+      flows << "#{self.class.parent.to_s}::#{File.basename(file,'.rb').camelize}".constantize
+    end
+    flows
+  end
+end
+
+describe "Flow Generation" do
+  include RubiGen::GeneratorTestHelper
+  include Helpers::Generator
+  include Helpers::Taza
+
+  before :all do
+    @site_name = "Foo"
+    @site_folder = File.join(PROJECT_FOLDER,'lib','sites',"gap")
+    @site_file = File.join(PROJECT_FOLDER,'lib','sites',"gap.rb")
+    @flow_name = "CheckOut"
+  end
+
+  before :each do
+    run_generator('taza', [APP_ROOT], generator_sources)
+    @site_class = generate_site(@site_name)
+  end
+
+  after :each do
+    bare_teardown
+  end
+
+  it "should give you usage if you do not give two arguments" do
+    FlowGenerator.any_instance.expects(:usage)
+    lambda { run_generator('flow', [@flow_name], generator_sources) }.should raise_error
+  end
+
+  it "should give you usage if you give a site that does not exist" do
+    FlowGenerator.any_instance.expects(:usage)
+    $stderr.expects(:puts).with(regexp_matches(/NoSuchSite/))
+    lambda { run_generator('flow', [@flow_name,"NoSuchSite"], generator_sources) }.should raise_error
+  end
+
+end

data/spec/hash_spec.rb

@@ -0,0 +1,15 @@
+require 'spec/spec_helper'
+require 'taza/entity'
+require 'extensions/hash'
+
+# This is too tightly coupled to Taza::Entity
+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)
+  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)
+  end
+end

data/spec/object_spec.rb

@@ -0,0 +1,29 @@
+require 'spec/spec_helper'
+
+describe "Object" do
+  before :all do
+    @orig_version = VERSION
+    Object.send :remove_const, :VERSION
+    Object.const_set :VERSION, "1.8.6"
+    load 'lib/extensions/object.rb'
+  end
+
+  after :all do
+    Object.send :remove_const, :VERSION
+    Object.const_set :VERSION, @orig_version
+  end
+
+  it "should execute blocks with args in instance context" do
+    str = "string"
+
+    class << str
+      def my_singleton_method(arg)
+        arg
+      end
+    end
+
+    block = Proc.new { |arg| my_singleton_method(arg) }
+
+    str.instance_exec("foo",&block).should == "foo"
+  end
+end

data/spec/page_generator_spec.rb

@@ -0,0 +1,56 @@
+require 'spec/spec_helper'
+require 'rubygems'
+require 'fileutils'
+require 'taza/page'
+
+describe "Page Generation" do
+  include RubiGen::GeneratorTestHelper
+  include Helpers::Generator
+  include Helpers::Taza
+
+  before :all do
+    @page_name = "CheckOut"
+  end
+
+  before :each do
+    run_generator('taza', [APP_ROOT], generator_sources)
+    @site_class = generate_site('Gap')
+  end
+
+  after :each do
+    bare_teardown
+  end
+  
+  it "should give you usage if you do not give two arguments" do
+    PageGenerator.any_instance.expects(:usage)
+    lambda { run_generator('page', [@page_name], generator_sources) }.should raise_error
+  end
+
+  it "should give you usage if you give a site that does not exist" do
+    PageGenerator.any_instance.expects(:usage)
+    $stderr.expects(:puts).with(regexp_matches(/NoSuchSite/))
+    lambda { run_generator('page', [@page_name,"NoSuchSite"], generator_sources) }.should raise_error
+  end
+
+  it "should generate a page spec that can be required" do
+    run_generator('page', [@page_name,@site_class.to_s], generator_sources)
+    page_functional_spec = File.join(PROJECT_FOLDER,'spec','isolation',@site_class.to_s.underscore,'check_out_page_spec.rb')
+    system("ruby -c #{page_functional_spec} > #{null_device}").should be_true
+  end
+
+  it "should be able to access the generated page from the site" do
+    run_generator('page', [@page_name,@site_class.to_s], generator_sources)
+    stub_settings
+    stub_browser
+    @site_class.new.check_out_page
+  end
+
+  it "should be able to access the generated page for its site" do
+    stub_browser
+    stub_settings
+    new_site_class = generate_site('Pag')
+    run_generator('page', [@page_name,@site_class.to_s], generator_sources)
+    run_generator('page', [@page_name,new_site_class.to_s], generator_sources)
+    new_site_class.new.check_out_page.class.should_not eql(@site_class.new.check_out_page.class)
+  end
+end

data/spec/page_module_spec.rb

@@ -0,0 +1,165 @@
+require 'spec/spec_helper'
+require 'taza/page'
+
+describe "Taza Page Module" do
+
+  class PageWithModule < ::Taza::Page
+
+    page_module :module do
+      element(:module_element) { browser }
+    end
+
+  end
+
+  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)
+  end
+
+  class AnotherPageWithModule < ::Taza::Page
+
+    page_module :other_module do
+      element(:another_module_element) { browser }
+    end
+
+  end
+
+
+  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)
+  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)
+  end
+
+
+  class TestPageWithModules < ::Taza::Page
+
+    page_module :module_one do
+      element(:some_module_element) { :something }
+    end
+
+    page_module :module_two do
+      element(:some_module_element) { :nothing }
+    end
+
+  end
+
+  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)
+  end
+
+  class PageWithMultipleModuleElements < ::Taza::Page
+
+    page_module :module do
+      element(:module_element) { :something }
+      element(:another_module_element) { :nothing }
+    end
+
+  end
+
+  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)
+  end
+
+  class PageWithFilterAndModule < ::Taza::Page
+    page_module :module do
+      element(:sample_element) {:something}
+    end
+    filter :sample_filter, :module
+    def sample_filter
+      true
+    end
+  end
+
+  it "should execute filters for page modules" do
+    page = PageWithFilterAndModule.new(:module)
+    page.sample_element.should eql(:something)
+  end
+
+ class PageWithFalseFilterAndModule < ::Taza::Page
+    page_module :module do
+      element(:sample_element) {:something}
+    end
+    filter :false_filter, :module
+    def false_filter
+      false
+    end
+  end
+
+  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)
+  end
+
+  class PageWithFilterAndModuleElements < ::Taza::Page
+    page_module :module do
+      element(:sample_element) {:something}
+    end
+    page_module_filter :sample_filter, :module, :sample_element
+    def sample_filter
+      false
+    end
+  end
+
+  it "should execute filters for elements inside page modules" do
+    page = PageWithFilterAndModuleElements.new(:module)
+    lambda { page.sample_element }.should raise_error(Taza::FilterError)
+  end
+
+  class PageWithFiltersAndModuleElements < ::Taza::Page
+    page_module :module do
+      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
+  end
+
+  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)
+  end
+  
+  class PageWithFiltersAndModulesAndElements < ::Taza::Page
+    page_module :foo_module do
+      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}
+    end
+    page_module_filter :bar_filter, :bar_module
+    def bar_filter
+      false
+    end
+  end
+
+  it "should execute page module filters for identical element names appropriately" do
+    foo = PageWithFiltersAndModulesAndElements.new(:foo_module)
+    foo.sample_element.should eql(:something)
+    bar = PageWithFiltersAndModulesAndElements.new(:bar_module)
+    lambda { bar.sample_element }.should raise_error(Taza::FilterError)
+ end
+
+
+end