bret-watircraft 0.4.0

data/spec/page_generator_spec.rb

@@ -0,0 +1,111 @@
+require 'spec/spec_helper'
+require 'spec/spec_generator_helper'
+require 'rubygems'
+require 'fileutils'
+require 'taza'
+
+describe "Page Generation" do
+  include RubiGen::GeneratorTestHelper
+  include Helpers::Generator
+  include Helpers::Taza
+
+  before :each do
+    generate_project
+    @site_class = generate_site('Gap')
+    @site_name = @site_class.to_s.underscore
+  end
+
+  after :each do
+    bare_teardown   
+  end
+  
+  # Negative
+  
+  it "should give you usage if you provide no arguments" do
+    lambda { run_generator('page', [], generator_sources) }.
+      should raise_error(RubiGen::UsageError)
+  end
+
+  it "should give you usage if you provide two arguments" do
+    lambda { run_generator('page', ['simple', 'extra'], generator_sources) }.
+      should raise_error(RubiGen::UsageError)
+  end
+
+  it "should display an error if no site is specified in the config.yml" do
+    PageGenerator.any_instance.stubs(:configured_site).returns(nil)
+    lambda { run_generator('page', ['simple'], generator_sources) }.
+      should raise_error(RubiGen::UsageError, "Error. A site must first be specified in config.yml")
+  end
+
+  it "should display an error if the site in config.yml can't be found" do
+    PageGenerator.any_instance.stubs(:configured_site).returns('no_such_site')
+    lambda { run_generator('page', ['simple'], generator_sources) }.
+      should raise_error(RubiGen::UsageError, /Error\. Site file .*lib\/no_such_site.rb not found\./)
+  end
+    
+  # Positive
+
+  it "should be able to access the generated page from the site" do
+    PageGenerator.any_instance.stubs(:configured_site).returns(@site_name)    
+    run_generator('page', ['simple'], generator_sources)
+    stub_settings
+    stub_browser
+    @site_class.new.simple_page
+  end
+
+  it "should be able to access the generated page when it has a space" do
+    PageGenerator.any_instance.stubs(:configured_site).returns(@site_name)    
+    run_generator('page', ['check out'], generator_sources)
+    stub_settings
+    stub_browser
+    @site_class.new.check_out_page
+  end
+
+  it "should be able to access the generated page when it has an underscore" do
+    PageGenerator.any_instance.stubs(:configured_site).returns(@site_name)    
+    run_generator('page', ['check_any'], generator_sources)
+    stub_settings
+    stub_browser
+    @site_class.new.check_any_page
+  end
+  
+  it "should be able to generate a page using the project default" do
+    lambda{run_generator('page', ['simple'], generator_sources)}.
+      should_not raise_error
+  end
+  
+  it "should provide the module name of the site" do
+    PageGenerator.any_instance.stubs(:configured_site).returns(@site_name)
+    generator = PageGenerator.new(['sample'])
+    generator.site_module.should == @site_class.to_s
+  end
+  it "should provide the name of the page class" do
+    PageGenerator.any_instance.stubs(:configured_site).returns(@site_name)
+    generator = PageGenerator.new(['sample'])
+    generator.page_class.should == 'SamplePage'
+    generator.page_file.should == 'sample_page.rb'
+  end
+  
+  it "should work when when the provided page name includes a space" do
+    PageGenerator.any_instance.stubs(:configured_site).returns(@site_name)
+    generator = PageGenerator.new(['check out'])
+    generator.page_class.should == 'CheckOutPage'
+    generator.page_file.should == 'check_out_page.rb'
+  end
+
+  it "should work when when the provided page name includes an underscore" do
+    PageGenerator.any_instance.stubs(:configured_site).returns(@site_name)
+    generator = PageGenerator.new(['check_out'])
+    generator.page_class.should == 'CheckOutPage'
+    generator.page_file.should == 'check_out_page.rb'
+  end
+
+  it "should work when when the provided page is in camel case" do
+    PageGenerator.any_instance.stubs(:configured_site).returns(@site_name)
+    generator = PageGenerator.new(['CheckOut'])
+    generator.page_class.should == 'CheckOutPage'
+    generator.page_file.should == 'check_out_page.rb'
+  end
+    
+    
+end

data/spec/page_spec.rb

@@ -0,0 +1,342 @@
+require 'spec/spec_helper'
+require 'taza/page'
+require 'taza/site'
+
+describe Taza::Page do
+  before :each do
+    @page_class = Class.new(Taza::Page)
+  end
+  
+  class ElementAndFilterContextExample < Taza::Page
+    element(:sample_element) {browser}
+    filter:sample_filter, :sample_element
+    def sample_filter
+      browser
+    end
+  end
+
+  class RecursiveFilterExample < Taza::Page
+    element(:foo) {}
+    filter :sample_filter
+    def sample_filter
+      foo
+      true
+    end
+  end
+
+  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
+  end
+
+  it "should execute an element's block with the params provided for its method" do
+    @page_class.element(:boo){|baz| baz}
+    @page_class.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
+    @page_class.element(:foo) do
+      "bar"
+    end
+    @page_class.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 = @page_class
+    foo.elements.should_not be_nil
+    foo.elements.should be_empty
+  end
+
+  it "should have empty filters on a new class" do
+    foo = @page_class
+    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
+
+  class CheckOutPage < Taza::Page
+    url 'check_out'
+  end
+  
+  it "should goto the url relative to the site url" do
+    browser = stub
+    browser.expects(:goto).with('http://www.llamas.com')
+    browser.expects(:goto).with('http://www.llamas.com/check_out')
+    Taza::Settings.stubs(:config).returns(:url => 'http://www.llamas.com')    
+    page = CheckOutPage.new
+    page.site = Class.new(Taza::Site).new(:browser => browser)
+    page.goto
+  end  
+
+  it "should report the full url of the page" do
+    browser = stub
+    browser.stubs(:goto)
+    Taza::Settings.stubs(:config).returns(:url => 'http://www.llamas.com')    
+    page = CheckOutPage.new
+    page.site = Class.new(Taza::Site).new(:browser => browser)
+    page.full_url.should == 'http://www.llamas.com/check_out'
+  end
+    
+  it "should create elements for fields" do    
+    @page_class.field(:foo) {'element'}
+    @page_class.new.foo_field.should == 'element'
+  end
+  
+  it "should allow you to override the suffix for fields" do
+    @page_class.field(:foo, 'link') {'link element'}
+    @page_class.new.foo_link.should == 'link element'
+  end
+  
+  it "should return the display_value of the field's element" do
+    element = stub
+    element.stubs(:display_value).with().returns('tomorrow')
+    @page_class.field(:foo) {element}
+    page = @page_class.new
+    page.foo_field.display_value.should == 'tomorrow'
+    page.foo.should == 'tomorrow'
+  end
+  
+  it "should call the set method of the element when the field= method is called" do
+    element = stub
+    element.stubs(:set).with('never').returns(nil)
+    @page_class.field(:end_date) {element}
+    page = @page_class.new
+    page.end_date = 'never'
+  end
+  
+  def uses_soldier_page
+    name_element = stub
+    rank_element = stub
+    serial_no_element = stub
+    @page_class.class_eval do
+      field(:name){name_element}
+      field(:rank){rank_element}
+      field(:serial_no){serial_no_element}
+    end
+    @soldier_page = @page_class.new
+    @soldier_page.name_field.stubs(:display_value).returns('Zachary Taylor')
+    @soldier_page.rank_field.stubs(:display_value).returns('General')
+    @soldier_page.serial_no_field.stubs(:display_value).returns('unknown')
+  end
+  
+  it "should populate the fields corresponding to the keys in the hash" do
+    uses_soldier_page
+    @soldier_page.name_field.expects(:set).with('Zachary Taylor')
+    @soldier_page.rank_field.expects(:set).with('General')
+    @soldier_page.populate :name => 'Zachary Taylor', :rank => 'General'
+  end
+
+  it "should validate a page" do
+    uses_soldier_page
+    @soldier_page.validate :name => 'Zachary Taylor', :rank => 'General'
+  end
+
+  it "should allow you to define elements using human-form names" do
+    @page_class.element('User Name'){'Tertulian'}
+    @page_class.new.user_name.should == 'Tertulian'
+  end
+  
+  it "should allow you to define fields using human-form names" do
+    @page_class.field('User Name'){'Tertulian'}
+    @page_class.new.user_name_field.should == 'Tertulian'
+  end  
+
+  def simple_page
+    @page_class.class_eval do
+      element(:link){}
+      field(:name){}
+    end
+    @page_class.new
+  end
+
+  it "should list the page's elements" do
+    simple_page.elements.should == ['link', 'name_field']
+  end
+
+  it "should list the page's fields" do
+    simple_page.fields.should == ['name']
+  end
+  
+  it "should list the values of all the fields" do
+    uses_soldier_page
+    @soldier_page.values.should == 
+      {:name => 'Zachary Taylor', :rank => 'General', :serial_no => 'unknown'}
+  end
+  
+  it "should list the values of the specified fields" do
+    uses_soldier_page
+    @soldier_page.values(['name', 'rank']).should ==
+      {:name => 'Zachary Taylor', :rank => 'General'}
+  end
+  
+  def exists_page
+    link1_element = stub
+    link1_element.stubs(:exist?).returns(true)
+    link2_element = stub
+    link2_element.stubs(:exist?).returns(false)
+    @page_class.class_eval do
+      element(:link1){link1_element}
+      element(:link2){link2_element}
+    end
+    @page_class.new    
+  end
+  
+  it "should determine whether an element exists" do
+    page = exists_page
+    page.element_exists?(:link1).should be_true
+    page.element_exist?(:link1).should be_true
+    page.element_exists?(:link2).should be_false
+  end
+
+  it "should report which defined elements exist" do
+    page = exists_page
+    expectation = {:link1 => true, :link2 => false}
+    page.elements_exist?.should == expectation
+    page.elements_exists?.should == expectation
+  end
+  
+  it "should report whether selected elements exist" do
+    page = exists_page
+    expectation = {:link1 => true}
+    page.elements_exist?([:link1]).should == expectation
+  end
+  
+  it "should report that elements don't exist when not found errors are thrown" do
+    link3_element = stub
+    link3_element.stubs(:exist?).raises(Watir::Exception::UnknownFrameException)
+    link4_element = stub
+    link4_element.stubs(:exist?).raises(Watir::Exception::UnknownObjectException)
+    @page_class.class_eval do
+      element(:link3){link3_element}
+      element(:link4){link4_element}
+    end
+    page = @page_class.new    
+    page.element_exists?(:link3).should == false
+    page.element_exists?(:link4).should == false
+  end
+  
+  describe "tables" do
+    
+    it "you should be able to create and reference" do
+      @page_class.class_eval do
+        element(:results_table){}
+        table(:results) {}
+      end
+      @page_class.new.results.should be_a(WatirCraft::Table)
+    end
+    
+    require 'spec/fake_table'
+    it "should report whether a table has a specified row" do
+      @page_class.class_eval do
+        element(:results_table){FakeTable.new [:name => 'x']}
+        table(:results) do
+          field(:name){@row.element(:name)}
+        end
+      end
+      
+      @page_class.new.results.row(:name => 'x').should_not be_nil
+    end
+    
+    def uses_table_page
+      fake_table = FakeTable.new [
+          {:letter => 'x', :number => 1}, 
+          {:letter => 'y', :number => 2}
+          ]
+      @page_class.class_eval do
+        element(:results_table) {fake_table}
+        table(:results) do
+          field(:name){@row.element(:letter)}
+          field(:phone){@row.element(:number)}
+        end
+      end
+      @table_page = @page_class.new
+      @fake_table = fake_table
+    end
+    
+    it "should allow you to reference another field in a selected row" do
+      uses_table_page
+      @table_page.results.row(:name => 'x').phone.should == 1
+      @table_page.results.row(:phone => 2).name.should == 'y'
+    end
+    
+    it "fields should have underlying elements" do
+      uses_table_page
+      @table_page.results.row(:name => 'x').phone_element.should exist
+    end
+    
+    it "should have elements" do
+      @page_class.class_eval do
+        element(:results_table) do FakeTable.new [
+          {:letter => 'x', :number => 1}, 
+          {:letter => 'y', :number => 2}
+          ]
+        end
+        table(:results) do
+          field(:name){@row.element(:letter)}
+          element(:phone){@row.element(:number)}
+        end
+      end
+      @table_page = @page_class.new
+      @table_page.results.row(:name => 'x').phone.should be_a(FakeElement)
+    end
+    
+    it "should allow you to set a field in a row" do
+      uses_table_page
+      @table_page.results.row(:name => 'x').phone = '22'
+      @fake_table.rows[0].element(:number).display_value.should == '22'
+    end
+
+    it "rows should exist" do
+      uses_table_page
+      @table_page.results.row(:name => 'x').should exist
+    end
+        
+
+  
+  end
+  
+end

data/spec/project_generator_spec.rb

@@ -0,0 +1,103 @@
+require 'spec/spec_helper'
+require 'spec/spec_generator_helper'
+require 'rubygems'
+require 'rake'
+require 'fileutils'
+require 'taza'
+
+describe "Project Generator" do
+  include RubiGen::GeneratorTestHelper
+  
+  def project_file relative_path
+    File.join(TMP_ROOT, PROJECT_NAME, relative_path)
+  end
+
+  before :each do
+    @spec_helper = project_file 'test/specs/spec_helper.rb'
+    @initializer = project_file 'lib/initialize.rb'
+    ENV['ENVIRONMENT'] = nil
+    bare_setup
+  end
+
+  after :each do
+    bare_teardown
+  end
+
+  def should_be_loadable file, options=[]
+    options = [options] unless options.is_a? Array
+    generator_args = [APP_ROOT] + options
+    run_generator('watircraft', generator_args, generator_sources)
+    load_path = File.dirname(__FILE__) + '/../lib'
+    system("ruby -I#{load_path} #{file} > #{null_device}").should be_true
+  end
+
+  it "should generate a spec helper that can be required even when site name is different" do
+    should_be_loadable @spec_helper, ['--site=another_name', '--driver=fake']
+  end
+
+  it "should generate a feature helper that can be required" do
+    feature_helper = project_file 'test/features/feature_helper.rb'
+    should_be_loadable feature_helper, '--driver=fake'
+  end
+
+  it "should generate a world file that can be required" do
+    world = project_file 'lib/steps/world.rb'
+    should_be_loadable world, '--driver=fake'
+  end
+
+  it "should generate a rakefile that can be required" do
+    rakefile = project_file 'rakefile'
+    should_be_loadable rakefile
+  end
+  
+  it "should generate an initializer that can be required" do
+    should_be_loadable @initializer
+  end
+  
+  it "should be able to update an existing project and figure out the site name" do
+    run_generator('watircraft', [APP_ROOT, '--site=crazy'], generator_sources)
+    run_generator('watircraft', [APP_ROOT], generator_sources)
+    Taza::Settings.config[:site].should == 'crazy'
+  end
+
+  it "initializer should set the ENVIRONMENT variable if it is not provided" do
+    run_generator('watircraft', [APP_ROOT], generator_sources)
+    load @initializer
+    ENV['ENVIRONMENT'].should eql("test")
+  end
+  
+  it "initializer should not override the ENVIRONMENT variable if was provided" do
+    ENV['ENVIRONMENT'] = 'orange pie? is there such a thing?'
+    run_generator('watircraft', [APP_ROOT], generator_sources)
+    load @initializer
+    ENV['ENVIRONMENT'].should eql('orange pie? is there such a thing?')
+  end
+  
+  it "should configure a project for watir, implicitly" do
+    run_generator('watircraft', [APP_ROOT], generator_sources)
+    Taza::Settings.stubs(:path).returns(APP_ROOT)
+    ENV['ENVIRONMENT'] = 'test'
+    Taza::Settings.config[:driver].should == :watir
+  end
+
+  it "should allow a site name to be specified" do
+    run_generator('watircraft', [APP_ROOT, '--site=site_name'], generator_sources)
+    Taza::Settings.stubs(:path).returns(APP_ROOT)
+    ENV['ENVIRONMENT'] = 'test'
+    Taza::Settings.config[:site].should == 'site_name'
+  end
+  
+  it "should allow a browser driver to be specified" do
+    run_generator('watircraft', [APP_ROOT, '--driver=nine_iron'], generator_sources)
+    Taza::Settings.stubs(:path).returns(APP_ROOT)
+    ENV['ENVIRONMENT'] = 'test'
+    Taza::Settings.config[:driver].should == :nine_iron
+  end
+  
+  it "should generate a script/console" do
+    run_generator('watircraft', [APP_ROOT], generator_sources)
+    File.exist?(project_file('script/console')).should be_true
+    File.exist?(project_file('script/console.cmd')).should be_true
+  end
+
+end

data/spec/sandbox/config/config.yml

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

data/spec/sandbox/config/environments.yml

@@ -0,0 +1,4 @@
+test: 
+    :url: http://google.com
+clown_shoes:
+    :url: http://clownshoes.com

data/spec/sandbox/config/simpler.yml

@@ -0,0 +1 @@
+browser: opera

data/spec/sandbox/config/simpler_site.yml

@@ -0,0 +1,2 @@
+test: 
+    url: http://makezine.com

data/spec/sandbox/config.yml

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

data/spec/sandbox/fixtures/examples.yml

@@ -0,0 +1,8 @@
+first_example:
+  name: first
+  user: shatner
+  price: 1
+second_example:
+  name: second
+  price: 2
+  user: shatner

data/spec/sandbox/fixtures/users.yml

@@ -0,0 +1,2 @@
+shatner:
+  name: William Shatner

data/spec/sandbox/flows/batman.rb

@@ -0,0 +1,5 @@
+class Barz
+  def batman_flow
+    "i am batman"
+  end
+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_page.rb

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

data/spec/sandbox/pages/foo/partials/partial_the_reckoning.rb

@@ -0,0 +1,2 @@
+class PartialTheReckoning < Taza::Page
+end