taza 0.5.0 → 0.8.0

data/spec/page_spec.rb

@@ -0,0 +1,82 @@
+require 'spec/spec_helper'
+require 'taza/page'
+
+describe Taza::Page do
+  
+  class ElementAndFilterContextExample < Taza::Page
+    element(:sample_element) {browser}
+    filter:sample_filter, :sample_element
+    def sample_filter
+      browser
+    end
+  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"
+  end
+  
+  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)
+  end
+  
+  it "should add a filter to the classes filters" do
+    ElementAndFilterContextExample.filters.size.should 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"
+  end
+
+  class FilterAllElements < Taza::Page
+    element(:foo) {}
+    element(:apple) {}
+    filter :false_filter
+
+    def false_filter
+      false
+    end
+  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)
+  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
+  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
+  end
+
+  class FilterAnElement < Taza::Page
+    attr_accessor :called_element_method
+    element(:false_item) { @called_element_method = true}
+    filter :false_filter, :false_item
+
+    def false_filter
+      false
+    end
+  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)
+  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
+  end
+end

data/spec/platform/osx/browser_spec.rb

@@ -0,0 +1,14 @@
+require 'spec/spec_helper'
+require 'taza/browser'
+
+describe "Taza::Browser with Safari Watir" do
+  it "should be able to make a safari watir instance" do
+    browser = nil
+    begin
+      browser = Taza::Browser.create({:browser => :safari, :driver => :watir,:url =>'http://www.google.com'})
+      browser.should be_a_kind_of(Watir::Safari)
+    ensure
+      browser.close if browser.is_a?(Watir::Safari)
+    end
+  end
+end

data/spec/platform/windows/browser_spec.rb

@@ -0,0 +1,14 @@
+require 'spec/spec_helper'
+require 'taza/browser'
+
+describe "Taza::Browser with watir ie" do
+  it "should be able to make watir ie instance" do
+    browser = nil
+    begin 
+      browser =  Taza::Browser.create({:browser => :ie,:driver =>:watir,:url => 'http://www.google.com'})
+      browser.should be_a_kind_of(Watir::IE)
+    ensure
+      browser.close if browser.respond_to?(:close)
+    end
+  end  
+end

data/spec/project_generator_spec.rb

@@ -0,0 +1,42 @@
+require 'spec/spec_helper'
+require 'rubygems'
+require 'rake'
+require 'fileutils'
+require 'taza'
+require 'vendor/gems/gems/rubigen-1.3.2/test/test_generator_helper'
+
+describe "Project Generator" do
+  include RubiGen::GeneratorTestHelper
+
+  before :all do
+    @spec_helper = File.join(TMP_ROOT,PROJECT_NAME,'spec','spec_helper.rb')
+  end
+
+  before :each do
+    bare_setup
+  end
+
+  after :each do
+    bare_teardown
+  end
+
+  it "should generate a spec helper that can be required" do
+    run_generator('taza', [APP_ROOT], generator_sources)
+    system("ruby -c #{@spec_helper} > #{null_device}").should be_true
+  end
+
+  it "spec helper should set the TAZA_ENV variable if it is not provided" do
+    ENV['TAZA_ENV'] = nil
+    run_generator('taza', [APP_ROOT], generator_sources)
+    load @spec_helper
+    ENV['TAZA_ENV'].should eql("isolation")
+  end
+  
+  it "spec helper should not override the TAZA_ENV variable if was provided" do
+    ENV['TAZA_ENV'] = 'orange pie? is there such a thing?'
+    run_generator('taza', [APP_ROOT], generator_sources)
+    load @spec_helper
+    ENV['TAZA_ENV'].should eql('orange pie? is there such a thing?')
+  end
+
+end

data/spec/sandbox/config.yml

@@ -0,0 +1,3 @@
+---
+:browser: :default_browser
+:driver: :default_driver

data/spec/sandbox/config/config.yml

@@ -0,0 +1 @@
+:nothing: :something

data/spec/sandbox/config/site_name.yml

@@ -0,0 +1,5 @@
+---
+isolation: 
+    :url: http://google.com
+clown_shoes:
+    :url: http://clownshoes.com

data/spec/sandbox/flows/batman.rb

@@ -0,0 +1,2 @@
+class Batman < ::Taza::Flow
+end

data/spec/sandbox/flows/robin.rb

@@ -0,0 +1,4 @@
+class Robin < ::Taza::Flow
+  def run(params)
+  end
+end

data/spec/sandbox/pages/foo/bar.rb

@@ -0,0 +1,9 @@
+class Bar < Taza::Page
+  element :foo do
+    browser
+  end
+
+  filter :name => :baz, :elements => [:foo] do
+    true
+  end
+end

data/spec/settings_spec.rb

@@ -0,0 +1,88 @@
+require 'spec/spec_helper'
+require 'rubygems'
+require 'taza'
+
+describe Taza::Settings do
+  
+  before :all do
+    @site_name = 'SiteName'
+  end
+  
+  before :each do
+    ENV['TAZA_ENV'] = 'isolation'
+    ENV['browser'] = nil
+    ENV['driver'] = nil
+  end
+
+  it "should use environment variable for browser settings" do
+    Taza::Settings.stubs(:path).returns("spec/sandbox")
+    ENV['browser'] = 'foo'
+    Taza::Settings.config(@site_name)[:browser].should eql(:foo)
+  end
+  
+  it "should provide default values if no config file or environment settings provided" do
+    Taza::Settings.stubs(:path).returns("spec/sandbox")
+    Taza::Settings.config(@site_name)[:driver].should eql(:selenium)
+    Taza::Settings.config(@site_name)[:browser].should eql(:firefox)
+  end
+  
+  it "should use environment variable for driver settings" do
+    Taza::Settings.stubs(:path).returns("spec/sandbox")
+    ENV['driver'] = 'bar'
+    Taza::Settings.config(@site_name)[:driver].should eql(:bar)
+  end
+  
+  it "should be able to load the site yml" do
+    Taza::Settings.stubs(:path).returns("spec/sandbox")
+    Taza::Settings.config("SiteName")[:url].should 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("spec/sandbox")
+    Taza::Settings.config("SiteName")[:url].should eql('http://clownshoes.com')
+  end
+
+  it "should use the config file's variable for browser settings if no environment variable is set" do
+    Taza::Settings.expects(:config_file).returns({:browser => :fu})
+    Taza::Settings.stubs(:path).returns("spec/sandbox")
+    Taza::Settings.config(@site_name)[:browser].should eql(:fu)
+  end
+
+  it "should use the ENV variables if specfied instead of config files" do
+    ENV['browser'] = 'opera'
+    Taza::Settings.expects(:config_file).returns({:browser => :fu})
+    Taza::Settings.stubs(:path).returns("spec/sandbox")
+    Taza::Settings.config(@site_name)[:browser].should eql(:opera)
+  end
+
+  it "should use the correct config file to set defaults" do
+    Taza::Settings.stubs(:path).returns("spec/sandbox")
+    Taza::Settings.stubs(:config_file_path).returns('spec/sandbox/config.yml')
+  end
+  
+  it "should raise error for a config file that doesnot exist" do
+    Taza::Settings.stubs(:path).returns('spec/sandbox/file_not_exists.yml')
+    lambda {Taza::Settings.config}.should raise_error
+  end
+  
+  it "should path point at root directory" do
+    Taza::Settings.path.should eql('.')
+  end
+  
+  it "should use the config file's variable for driver settings if no environment variable is set" do
+    Taza::Settings.stubs(:path).returns("spec/sandbox")
+    Taza::Settings.stubs(:config_file).returns({:driver => :fun})
+    Taza::Settings.config(@site_name)[:driver].should eql(:fun)    
+  end
+
+  class SiteName < Taza::Site
+
+  end
+
+  it "a site should be able to load its settings" do
+    Taza::Settings.stubs(:path).returns("spec/sandbox")
+    SiteName.settings[:url].should eql('http://google.com')
+  end
+
+end

data/spec/site_generator_spec.rb

@@ -0,0 +1,53 @@
+require 'spec/spec_helper'
+require 'rubygems'
+require 'fileutils'
+require 'taza'
+require 'vendor/gems/gems/rubigen-1.3.2/test/test_generator_helper'
+
+describe "Site Generation" do
+  include RubiGen::GeneratorTestHelper
+  include Helpers::Generator
+  include Helpers::Taza
+  
+  before :all do
+    @spec_helper = File.join(TMP_ROOT,PROJECT_NAME,'spec','spec_helper.rb')
+    @site_name = "WikipediaFoo"
+    @site_file = File.join(PROJECT_FOLDER,'lib','sites' , "wikipedia_foo.rb")
+    @site_folder = File.join(PROJECT_FOLDER,'lib','sites' , "wikipedia_foo")
+  end
+
+  before :each do
+    bare_setup
+    run_generator('taza', [APP_ROOT], generator_sources)
+  end
+
+  after :each do
+    bare_teardown
+  end
+
+  it "should generate configuration file for a site" do
+    run_generator('site', [@site_name], generator_sources)
+    File.exists?(File.join(PROJECT_FOLDER,'config','wikipedia_foo.yml')).should be_true
+  end
+
+  it "should generate a site path for pages" do
+    run_generator('site', [@site_name], generator_sources)
+    File.directory?(@site_folder).should be_true
+  end
+
+  it "should generate a folder for a sites functional tests" do
+    run_generator('site', [@site_name], generator_sources)
+    File.directory?(File.join(PROJECT_FOLDER,'spec','functional','wikipedia_foo')).should be_true
+  end
+  
+  it "generated site that uses the block given in new" do
+    @site_class = generate_site(@site_name)
+    stub_settings
+    stub_browser
+    foo = nil
+    @site_class.new {|site| foo = site}
+    foo.should_not be_nil
+    foo.should be_a_kind_of(Taza::Site)
+  end
+
+end

data/spec/site_spec.rb

@@ -0,0 +1,239 @@
+require 'spec/spec_helper'
+require 'rubygems'
+require 'taza'
+
+describe Taza::Site do
+
+  before :all do
+    @pages_path = File.join("spec","sandbox","pages","foo","*.rb")
+    Foo = Class.new(Taza::Site)
+  end
+
+  before :each do
+    Foo.any_instance.stubs(:pages_path).returns(@pages_path)
+    ENV['browser'] = nil
+    ENV['driver'] = nil
+    Taza::Settings.stubs(:config_file).returns({})
+    Taza::Settings.stubs(:site_file).returns({})
+    Taza::Site.before_browser_closes {}
+  end
+
+  it "pages_path should contain the site class name" do
+    browser = stub_browser
+    Taza::Browser.stubs(:create).returns(browser)
+    Bax = Class.new(Taza::Site)
+    Bax.new.pages_path.should eql("./lib/sites/bax/pages/*.rb")
+  end
+
+  it "should execute a flow with given parameters" do
+    browser = stub_browser
+    Taza::Browser.stubs(:create).returns(browser)
+    params = {}
+    require 'spec/sandbox/flows/batman'
+    Batman.any_instance.expects(:run).with(params)
+    Barz = Class.new(Taza::Site)
+    Barz.any_instance.stubs(:path).returns('spec/sandbox')
+    Barz.new.flow(:batman,params)
+  end
+
+  it "should require a flow once it is called" do
+    browser = stub_browser
+    Taza::Browser.stubs(:create).returns(browser)
+    Class.constants.include?('Robin').should be_false
+    Bayz = Class.new(Taza::Site)
+    Bayz.any_instance.stubs(:path).returns('spec/sandbox')
+    Bayz.new.flow(:robin,{})
+    Robin
+  end
+
+  it "should create a browser using environment variables" do
+    browser = stub_browser
+    browser.stubs(:goto)
+    Taza::Browser.expects(:create_watir_ie).returns browser
+    ENV['browser'] = 'ie'
+    ENV['driver'] = 'watir'
+    f = Foo.new
+  end
+
+  it "should open watir browsers at the configuration URL" do
+    browser = stub_browser
+    browser.expects(:goto).with('a_url')
+    Taza::Browser.stubs(:create).returns(browser)
+    Taza::Settings.stubs(:config).returns(:url => 'a_url')
+    Foo.new
+  end
+
+  it "should yield an instance of a page class" do
+    f = Foo.new(:browser => stub_browser)
+    barzor = nil
+    f.bar do |bar|
+      barzor = bar
+    end
+    barzor.should be_an_instance_of(Bar)
+  end
+
+  it "should accept a browser instance" do
+    browser = stub_browser
+    foo = Foo.new(:browser => browser)
+    foo.browser.should eql(browser)
+
+  end
+
+  it "should create a browser instance if one is not provided" do
+    browser = stub_browser
+    Taza::Browser.stubs(:create).returns(browser)
+    foo = Foo.new
+    foo.browser.should eql(browser)
+  end
+
+  it "should still close browser if an error is raised" do
+    browser = stub_browser
+    browser.expects(:close)
+    Taza::Browser.stubs(:create).returns(browser)
+    lambda { Foo.new { |site| raise StandardError}}.should raise_error
+  end
+
+  it "should not close browser if block not given" do
+    browser = stub
+    browser.stubs(:goto)
+    browser.expects(:close).never
+    Taza::Browser.stubs(:create).returns(browser)
+    Foo.new
+  end
+
+  it "should not close browser if an error is raised on browser goto" do
+    browser = Object.new
+    browser.stubs(:goto).raises(StandardError,"ErrorOnBrowserGoto")
+    browser.expects(:close).never
+    Taza::Browser.stubs(:create).returns(browser)
+    lambda { Foo.new }.should raise_error(StandardError,"ErrorOnBrowserGoto")
+  end
+
+  it "should raise browser close error if no other errors" do
+    browser = stub_browser
+    browser.expects(:close).raises(StandardError,"BrowserCloseError")
+    Taza::Browser.stubs(:create).returns(browser)
+    lambda { Foo.new {}}.should raise_error(StandardError,"BrowserCloseError")
+  end
+
+  it "should raise error inside block if both it and browser.close throws an error" do
+    browser = stub_browser
+    browser.expects(:close).raises(StandardError,"BrowserCloseError")
+    Taza::Browser.stubs(:create).returns(browser)
+    lambda { Foo.new { |site| raise StandardError, "innererror" }}.should raise_error(StandardError,"innererror")
+  end
+
+  it "should close a browser if block given" do
+    browser = stub_browser
+    browser.expects(:close)
+    Taza::Browser.stubs(:create).returns(browser)
+    Foo.new do |site|
+    end
+  end
+
+  it "should yield itself upon initialization" do
+    Taza::Browser.stubs(:create).returns(stub_browser)
+    foo = nil
+    f = Foo.new do |site|
+      foo = site
+    end
+    foo.should eql(f)
+  end
+
+  it "should yield after page methods have been setup" do
+    Taza::Browser.stubs(:create).returns(stub_browser)
+    klass = Class::new(Taza::Site)
+    klass.any_instance.stubs(:pages_path).returns(@pages_path)
+    klass.new do |site|
+      site.should respond_to(:bar)
+    end
+  end
+  it "should yield after browser has been setup" do
+    Taza::Browser.stubs(:create).returns(stub_browser)
+    klass = Class::new(Taza::Site)
+    klass.any_instance.stubs(:pages_path).returns(@pages_path)
+    klass.new do |site|
+      site.browser.should_not be_nil
+    end
+  end
+
+  it "should pass its browser instance to its pages " do
+    browser = stub_browser
+    Taza::Browser.stubs(:create).returns(browser)
+    foo = Foo.new
+    foo.bar.browser.should eql(browser)
+  end
+
+  it "should have a way to evaluate a block of code before site closes the browser" do
+    browser = stub()
+    browser.stubs(:goto)
+    Taza::Browser.stubs(:create).returns(browser)
+    browser_state = states('browser_open_state').starts_as('on')
+    browser.expects(:close).then(browser_state.is('off'))
+    browser.expects(:doit).when(browser_state.is('on'))
+    Taza::Site.before_browser_closes { |browser| browser.doit }
+    Foo.new {}
+  end
+
+  it "should have a way to evaluate a block of code before site closes the browser if an error occurs" do
+    browser = stub()
+    browser.stubs(:goto)
+    Taza::Browser.stubs(:create).returns(browser)
+    browser_state = states('browser_open_state').starts_as('on')
+    browser.expects(:close).then(browser_state.is('off'))
+    browser.expects(:doit).when(browser_state.is('on'))
+    Taza::Site.before_browser_closes { |browser| browser.doit }
+    lambda { Foo.new { |site| raise StandardError, "innererror" }}.should raise_error(StandardError,"innererror")
+  end
+
+  it "should still close its browser if #before_browser_closes raises an exception" do
+    browser = stub()
+    browser.stubs(:goto)
+    Taza::Browser.stubs(:create).returns(browser)
+    browser.expects(:close)
+    Taza::Site.before_browser_closes { |browser| raise StandardError, 'foo error' }
+    lambda { Foo.new {} }.should raise_error(StandardError,'foo error')
+  end
+
+  it "should not close a browser it did not make" do
+    browser = stub()
+    browser.stubs(:goto)
+    browser.expects(:close).never
+    Foo.new(:browser => browser) {}
+  end
+
+  it "should close a browser it did make" do
+    browser = stub()
+    Taza::Browser.stubs(:create).returns(browser)
+    browser.stubs(:goto)
+    browser.expects(:close)
+    Foo.new() {}
+  end
+
+    
+  module Zoro
+    class Zoro < ::Taza::Site
+    end
+  end
+    
+  it "should pass in the class name to settings config" do
+    browser = stub()
+    browser.stubs(:goto)
+    Taza::Browser.stubs(:create).returns(browser)
+    Taza::Settings.expects(:config).with('Zoro').returns({})
+    Zoro::Zoro.new
+  end
+  
+  it "should load settings based on the sites class name" do
+    Taza::Settings.expects(:site_file).with('Zoro').returns({})
+    Zoro::Zoro.settings
+  end
+  
+  def stub_browser
+    browser = stub()
+    browser.stubs(:close)
+    browser.stubs(:goto)
+    browser
+  end
+
+end