taza 0.8.0 → 0.8.2

data/lib/taza/flow.rb

@@ -12,15 +12,15 @@ module Taza
   #
   #   From here you can create the logic needed to perform these flows without ever referencing a browser object:
   #
-  #   class CreateAnAccount < Taza::Flow
-  #     alias :widgets_of_the_future :site
-  #
-  #     def run(params={})
-  #       widgets_of_the_future.home_page.create_an_account_link.click
-  #       widgets_of_the_future.create_an_account_page do |cap|
-  #         cap.email.set params[:email]
-  #         cap.password.set params[:password]
-  #         cap.submit.click
+  #   module WidgetsOfTheFuture
+  #     class WidgetsOfTheFuture < Taza::Site
+  #       def create_an_account_flow(params={})
+  #         home_page.create_an_account_link.click
+  #         create_an_account_page do |cap|
+  #           cap.email.set params[:email]
+  #           cap.password.set params[:password]
+  #           cap.submit.click
+  #         end
   #       end
   #     end
   #   end
@@ -31,15 +31,10 @@ module Taza
   #   describe "Widgets of the Future" do
   #     it "should do widgety things so that we can make more monies" do
   #       WidgetsOfTheFuture.new do |w|
-  #         w.flow :create_an_account, :email => "i.am@the.widget.store.com", :password => "secret"
+  #         w.create_an_account_flow :email => "i.am@the.widget.store.com", :password => "secret"
   #       end
   #     end
   #   end
   class Flow
-    attr_reader :site
-
-    def initialize(site_instance)
-      @site = site_instance
-    end
   end
 end

data/lib/taza/page.rb

@@ -1,17 +1,17 @@
 module Taza
   # An abstraction of a web page, place the elements you care about accessing in here as well as specify the filters that apply when trying to access the element.
-  # 
+  #
   # Example:
   #   require 'taza'
   #   class HomePage < Taza::Page
   #     element(:foo) {browser.element_by_xpath('some xpath')}
-  #     filter :title_given, :foo 
-  #   
+  #     filter :title_given, :foo
+  #
   #     def title_given
   #       browser.title.nil?
   #     end
   #   end
-  # 
+  #
   # homepage.foo will return the element specified in the block if the filter returned true
   class Page
     attr_accessor :browser
@@ -39,12 +39,12 @@ module Taza
     # Example:
     #   class HomePage < Taza::Page
     #     element(:foo) {browser.element_by_xpath('some xpath')}
-    #     filter :title_given, :foo 
+    #     filter :title_given, :foo
     #     #a filter will apply to all elements if none are specified
     #     filter :some_filter
     #     #a filter will also apply to all elements if the symbol :all is given
     #     filter :another_filter, :all
-    #     
+    #
     #     def some_filter
     #       true
     #     end
@@ -66,6 +66,7 @@ module Taza
 
     def initialize
       add_element_methods
+      @active_filters = []
     end
 
     def add_element_methods # :nodoc:
@@ -83,10 +84,14 @@ module Taza
         end
       end
     end
-    
+
     def check_filters(params) # :nodoc:
       params[:filters].each do |filter_method|
-        raise FilterError, "#{filter_method} returned false for #{params[:element_name]}" unless send(filter_method)
+        unless @active_filters.include?(filter_method)
+          @active_filters << filter_method
+          raise FilterError, "#{filter_method} returned false for #{params[:element_name]}" unless send(filter_method)
+          @active_filters.delete(filter_method)
+        end
       end
     end
   end

data/lib/taza/settings.rb

@@ -2,18 +2,29 @@ require 'activesupport'
 
 module Taza
   class Settings
+    # The config settings for a site.yml file.  ENV variables will override the settings:
+    #  Can override the browser in config via ENV['BROWSER']
+    #  Can override the driver in config via ENV['DRIVER']
+    #  Can override the timeout in config via ENV['TIMEOUT']
+    #  Can override the server_ip in config via ENV['SERVER_IP']
+    #  Can override the server_port in config via ENV['SERVER_PORT']
+    #
+    # Example:
+    #   Taza::Settings.Config('google')
     def self.config(site_name)
       env_settings = {}
-      env_settings[:browser] = ENV['browser'].to_sym if ENV['browser']
-      env_settings[:driver]  = ENV['driver'].to_sym if ENV['driver']
-      env_settings[:timeout] = ENV['timeout'] if ENV['timeout']
-      env_settings[:server_ip] = ENV['server_ip'] if ENV['server_ip']
-      env_settings[:server_port] = ENV['server_port'] if ENV['server_port']
+      env_settings[:browser] = ENV['BROWSER'].to_sym if ENV['BROWSER']
+      env_settings[:driver]  = ENV['DRIVER'].to_sym if ENV['DRIVER']
+      env_settings[:timeout] = ENV['TIMEOUT'] if ENV['TIMEOUT']
+      env_settings[:server_ip] = ENV['SERVER_IP'] if ENV['SERVER_IP']
+      env_settings[:server_port] = ENV['SERVER_PORT'] if ENV['SERVER_PORT']
       env_settings = {:browser=>:firefox,:driver=>:selenium}.merge(config_file.merge(env_settings))
       site_file(site_name).merge(env_settings)
     end
 
-    def self.config_file # :nodoc:
+    # Loads the config file for the entire project and returns the hash.
+    # Does not override settings from the ENV variables.
+    def self.config_file
       YAML.load_file(config_file_path)
     end
 

data/lib/taza/site.rb

@@ -45,10 +45,11 @@ module Taza
     # Sites can take a couple of parameters in the constructor:
     #   :browser => a browser object to act on instead of creating one automatically
     #   :url => the url of where to start the site
-    def initialize(params={})
+    def initialize(params={},&block)
       @module_name = self.class.parent.to_s
       @class_name  = self.class.to_s.split("::").last
       define_site_pages
+      define_flows
       config = Settings.config(@class_name)
       if params[:browser]
         @browser = params[:browser]
@@ -57,18 +58,20 @@ module Taza
         @i_created_browser = true
       end
       @browser.goto(params[:url] || config[:url])
+      execute_block_and_close_browser(browser,&block) if block_given?
+    end
 
-      if block_given?
+    def execute_block_and_close_browser(browser)
+      begin
+        yield self
+      rescue => site_block_exception
+      ensure
         begin
-          yield self
-        rescue => site_block_exception
-        ensure
-          begin
-            @@before_browser_closes.call(browser)
-          rescue => before_browser_closes_block_exception
-          end
-          close_browser_and_raise_if site_block_exception || before_browser_closes_block_exception
+          @@before_browser_closes.call(browser)
+        rescue => before_browser_closes_block_exception
+          "" # so basically rcov has a bug where it would insist this block is uncovered when empty
         end
+        close_browser_and_raise_if site_block_exception || before_browser_closes_block_exception
       end
     end
 
@@ -78,9 +81,7 @@ module Taza
 
     def close_browser_and_raise_if original_error # :nodoc:
       begin
-        if @i_created_browser
-          @browser.close
-        end
+        @browser.close if @i_created_browser
       ensure
         raise original_error if original_error
       end
@@ -102,6 +103,12 @@ module Taza
       end
     end
 
+    def define_flows # :nodoc:
+      Dir.glob(flows_path) do |file|
+        require file
+      end
+    end
+
     # This is used to call a flow belonging to the site
     #
     # Example:
@@ -118,14 +125,13 @@ module Taza
     #      google.submit.click
     #    end
     #  end
-    def flow(name,params={})
-      require File.join(path,'flows',name.to_s.underscore)
-      flow_class = "#{@module_name}::#{name.to_s.camelize}".constantize
-      flow_class.new(self).run(params)
-    end
 
     def pages_path # :nodoc:
-      File.join(path,'pages','*.rb')
+      File.join(path,'pages','**','*.rb')
+    end
+
+    def flows_path # :nodoc:
+      File.join(path,'flows','*.rb')
     end
 
     def path # :nodoc:

data/lib/taza/tasks.rb

@@ -1,38 +1,54 @@
-require 'rake'
-require 'rake/testtask'
 require 'rubygems'
+require 'rake'
 require 'taglob/rake/tasks'
 require 'spec/rake/spectask'
 
-namespace :spec do
-  def format_options(file_name)
-    file_name = "artifacts/#{file_name}/index.html"
-    dir_name = File.dirname(file_name)
-    FileUtils.mkdir_p(dir_name) unless File.directory?(dir_name)
-    ["--format","html:#{file_name}","--format","p"]
-  end
+def tags
+  ENV['TAGS']
+end
 
-  desc "Run all functional specs"
-  Spec::Rake::SpecTask.new :functional do |t|
-    t.spec_files = 'spec/functional/**/*_spec.rb'
-    t.spec_opts << format_options("functional/all")
-  end
-  desc "Run all integration specs"
-  Spec::Rake::SpecTask.new :integration do |t|
-    t.spec_files = 'spec/integration/**/*_spec.rb'
-    t.spec_opts << format_options("integration/all")
-  end
+module Taza
+  module Rake
+    class Tasks
+      attr_accessor :spec_opts
 
-  namespace :functional do
-    Dir.glob('./spec/functional/*/').each do |dir|
-      site_name = File.basename(dir)
+      def initialize
+        yield self if block_given?
+        define
+      end
 
-      desc "Run all functional specs for #{site_name}"
-      Spec::Rake::SpecTask.new site_name.to_sym do |t|
-        t.spec_files = "#{dir}**/*_spec.rb"
-        t.spec_opts << format_options("functional/#{site_name}/all")
+      def define_spec_task(name,glob_path)
+        Spec::Rake::SpecTask.new name do |t|
+          t.spec_files = Dir.taglob(glob_path,tags)
+          t.spec_opts << spec_opts
+        end
       end
 
+      def define
+        namespace :spec do
+          desc "Run all functional specs"
+          define_spec_task(:functional,'spec/functional/**/*_spec.rb')
+          desc "Run all integration specs"
+          define_spec_task(:integration,'spec/integration/**/*_spec.rb')
+
+          namespace :functional do
+            Dir.glob('./spec/functional/*/').each do |dir|
+              site_name = File.basename(dir)
+              desc "Run all functional specs for #{site_name}"
+              define_spec_task(site_name,"#{dir}**/*_spec.rb")
+
+              namespace site_name do
+                Dir.glob("./spec/functional/#{site_name}/*_spec.rb").each do |page_spec_file|
+                  page_name = File.basename(page_spec_file,'_spec.rb')
+                  define_spec_task(page_name,page_spec_file)
+                end
+              end
+
+            end
+          end
+
+        end
+      end
     end
   end
 end

data/spec/array_spec.rb

@@ -0,0 +1,16 @@
+require 'spec/spec_helper'
+
+describe 'Array Extensions' do
+  it "should know if elements are not equivilent to a subset of those elements" do
+    [1,2,3].should_not be_equivalent([2,3])
+  end
+  it "should know if elements are not equivilent to a larger set including those elements" do
+    [1,2,3].should_not be_equivalent([1,2,3,4])
+  end  
+  it "should know it is equivalent if the same order" do
+    [1,2,3].should be_equivalent([1,2,3])
+  end
+  it "should know it is equivalent if the different orders" do
+    [1,2,3].should be_equivalent([2,1,3])
+  end
+end

data/spec/browser_spec.rb

@@ -2,37 +2,22 @@ require 'spec/spec_helper'
 require 'taza/browser'
 require 'taza/settings'
 require 'selenium'
-require 'firewatir'
+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 be able to create a watir driver" do
-    Taza::Browser.expects(:create_watir_ie)
-    Taza::Browser.create(:browser => :ie, :driver => :watir)
-  end
-
-  it "should be able to create a firewatir driver" do
-    Taza::Browser.expects(:create_watir_firefox)
-    Taza::Browser.create(:browser => :firefox,:driver => :watir)
-  end
-
-  it "should be able to create a safariwatir driver" do
-    Taza::Browser.expects(:create_watir_safari)
-    Taza::Browser.create(:browser => :safari,:driver => :watir)
+    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(BrowserUnsupportedError)
+    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
@@ -52,21 +37,22 @@ describe Taza::Browser do
 
   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'
+    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'
+    ENV['TIMEOUT'] = 'timeout'
     Selenium::SeleniumDriver.expects(:new).with(anything,anything,anything,'timeout')
     Taza::Browser.create(Taza::Settings.config("SiteName"))
   end
 
-  it "should create firewatir instance" do
-    FireWatir::Firefox.expects(:new)
-    Taza::Browser.create(:browser => :firefox, :driver => :watir)
+  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
+  
 end

data/spec/entity_spec.rb

@@ -0,0 +1,9 @@
+require 'spec/spec_helper'
+require 'taza'
+
+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
+end

data/spec/fixture_spec.rb

@@ -0,0 +1,34 @@
+require 'spec/spec_helper'
+require 'taza'
+
+describe Taza::Fixture do
+  
+  it "should be able to load entries from fixtures" do
+    Taza::Fixture.any_instance.stubs(:base_path).returns('./spec/sandbox')
+    fixture = Taza::Fixture.new
+    fixture.load_all
+    example = fixture.get_fixture_entity(:examples,'first_example')
+    example.name.should eql("first")
+    example.price.should eql(1)
+  end
+
+  it "should use the spec folder as the base path" do
+    Taza::Fixture.new.base_path.should eql('./spec')
+  end
+
+  it "should know if a pluralized fixture of that name exists" do
+    Taza::Fixture.any_instance.stubs(:base_path).returns('./spec/sandbox')
+    fixture = Taza::Fixture.new
+    fixture.load_all
+    fixture.pluralized_fixture_exists?('example').should be_true
+    fixture.pluralized_fixture_exists?('foo').should be_false
+  end
+  
+  it "should be able to get all fixtures loaded" do
+    Taza::Fixture.any_instance.stubs(:base_path).returns('./spec/sandbox')
+    fixture = Taza::Fixture.new
+    fixture.load_all
+    fixture.fixture_names.should be_equivalent([:examples,:users])
+  end
+
+end

data/spec/fixtures_spec.rb

@@ -0,0 +1,21 @@
+require 'spec/spec_helper'
+require 'taza/fixture'
+
+describe Taza::Fixtures do
+  Taza::Fixture.any_instance.stubs(:base_path).returns('./spec/sandbox')  
+  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
+  
+end