makevoid-taza 0.8.6

data/lib/taza/fixtures.rb

@@ -0,0 +1,24 @@
+require 'taza/fixture'
+
+module Taza
+  dirs = Dir.glob(File.join(Fixture.base_path,'*/'))
+  dirs.unshift Fixture.base_path
+  dirs.each do |dir|
+    mod = dir.sub(Fixture.base_path,File.join(File.basename(Fixture.base_path),'')).camelize.sub(/::$/,'')
+    self.class_eval <<-EOS
+      module #{mod}
+        def self.included(other_module) 
+          fixture = Fixture.new
+          fixture.load_fixtures_from('#{dir}')
+          fixture.fixture_names.each do |fixture_name|
+            self.class_eval do
+              define_method(fixture_name) do |entity_key|
+                fixture.get_fixture_entity(fixture_name,entity_key.to_s)
+              end
+            end
+          end
+        end
+      end
+      EOS
+  end
+end

data/lib/taza/flow.rb

@@ -0,0 +1,40 @@
+module Taza
+  # Flows provide a way to write and manage common actions on a site.
+  # For instance, on an e-commerce site you may have multiple tests where a user is supposed to create a 
+  # new account and add a product to the shopping bag. In this case you could have two flows. create_an_account 
+  # and add_product_to_bag.
+  #
+  # Here's how you would get this started where your site is called Widgets of the Future:
+  #   $ ./script/generate flow create_an_account widgets_of_the_future
+  #   $ ./script/generate flow add_product_to_bag widgets_of_the_future
+  #
+  #   This will generate flows for you in lib/sites/widgets_of_the_future/flows/
+  #
+  #   From here you can create the logic needed to perform these flows without ever referencing a browser object:
+  #
+  #   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
+  #
+  #
+  #   Then inside a spec or test you could run this flow like:
+  #
+  #   describe "Widgets of the Future" do
+  #     it "should do widgety things so that we can make more monies" do
+  #       WidgetsOfTheFuture.new do |w|
+  #         w.create_an_account_flow :email => "i.am@the.widget.store.com", :password => "secret"
+  #       end
+  #     end
+  #   end
+  class Flow
+  end
+end

data/lib/taza/page.rb

@@ -0,0 +1,128 @@
+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
+  #
+  #     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
+    class << self
+      def elements # :nodoc:
+        @elements ||= {}
+      end
+      def filters # :nodoc:
+        @filters ||= Hash.new { [] }
+      end
+    end
+
+    # A element on a page
+    #
+    # Watir Example:
+    #   class HomePage < Taza::Page
+    #     element(:foo) {browser.element_by_xpath('some xpath')}
+    #   end
+    # homepage.foo.click
+    def self.element(name,&block)
+      if !@module.nil?
+        self.elements[@module] = Hash.new if self.elements[@module].nil?
+        self.elements[@module] = self.elements[@module].merge({ name => block })
+      elsif !self.elements[name].nil?
+        raise ElementError,"Duplicate definations for Element - #{name} on Page - #{self.to_s}"
+      else
+        self.elements[name] = block
+      end
+    end
+
+    # A filter for elemenet(s) on a page
+    # Example:
+    #   class HomePage < Taza::Page
+    #     element(:foo) {browser.element_by_xpath('some xpath')}
+    #     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
+    #
+    #     def some_filter
+    #       true
+    #     end
+    #
+    #     def title_given
+    #       browser.title.nil?
+    #     end
+    #   end
+    def self.filter(method_name, *elements)
+      elements = [:all] if elements.empty?
+      elements.each do |element|
+        self.filters[element] = self.filters[element] << method_name
+      end
+    end
+
+    def self.page_module(name,&block)
+      @module = name
+      yield(block)
+      @module = nil
+    end
+    
+    def self.page_module_filter(method_name, page_module_name, *elements)
+      elements = [page_module_name] if elements.empty?
+      elements.each do |element|
+        self.filters[element] = self.filters[element] << method_name
+      end
+    end
+
+    def initialize(page_module = nil)
+      add_element_methods(page_module)
+      @active_filters = []
+    end
+
+    def add_element_methods(page_module = nil) # :nodoc:
+      self.class.elements.each do |element_name,element_block|
+        if (element_block.is_a?(Hash) && !page_module.nil? && page_module==element_name)
+          element_block.each do |key,value|
+            filters = self.class.filters[element_name] + self.class.filters[:all] + self.class.filters[key]
+            add_element_method(:filters => filters, :element_name => key, :element_block => value)
+          end
+        else
+          filters = self.class.filters[element_name] + self.class.filters[:all]
+          add_element_method(:filters => filters, :element_name => element_name, :element_block => element_block)
+        end
+      end
+    end
+
+    def add_element_method(params) # :nodoc:
+      metaclass.class_eval do
+        define_method(params[:element_name]) do |*args|
+          check_filters(params)
+          self.instance_exec(*args,&params[:element_block])
+        end
+      end
+    end
+
+    def check_filters(params) # :nodoc:
+      params[:filters].each do |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
+
+  class FilterError < StandardError; end
+  class ElementError < StandardError; end
+end

data/lib/taza/settings.rb

@@ -0,0 +1,33 @@
+require 'activesupport'
+require 'taza/options'
+
+module Taza
+  class Settings
+    #   Taza::Settings.Config('google')
+    def self.config(site_name)
+      site_file(site_name).merge(Options.new.execute)
+    end
+
+    # 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
+
+    def self.config_file_path # :nodoc:
+      File.join(config_folder,'config.yml')
+    end
+    
+    def self.config_folder # :nodoc:
+      File.join(path,'config')
+    end
+    
+    def self.site_file(site_name) # :nodoc:
+      YAML.load_file(File.join(config_folder,"#{site_name.underscore}.yml"))[ENV['TAZA_ENV']]
+    end
+
+    def self.path # :nodoc:
+      '.'
+    end
+  end
+end

data/lib/taza/site.rb

@@ -0,0 +1,150 @@
+require 'rubygems'
+require 'activesupport'
+
+module Taza
+  # An abstraction of a website, but more really a container for a sites pages.
+  #
+  # You can generate a site by performing the following command:
+  #   $ ./script/generate site google
+  #
+  # This will generate a site file for google, a flows folder, and a pages folder in lib
+  #
+  # Example:
+  #
+  #   require 'taza'
+  #
+  #   class Google < Taza::Site
+  #
+  #   end
+  class Site
+    @@before_browser_closes = Proc.new() {}
+    @@donot_close_browser = false
+    # Use this to do something with the browser before it closes, but note that it is a class method which
+    # means that this will get called for any instance of a site.
+    #
+    # Here's an example of how you might use it to print the DOM output of a browser before it closes:
+    #
+    #   Taza::Site.before_browser_closes do |browser|
+    #     puts browser.html
+    #   end
+    def self.before_browser_closes(&block)
+      @@before_browser_closes = block
+    end
+
+    def self.donot_close_browser
+      @@donot_close_browser = true
+    end
+    attr_accessor :browser
+
+    # A site can be called a few different ways
+    #
+    # The following example creates a new browser object and closes it:
+    #  Google.new do
+    #    google.search.set "taza"
+    #    google.submit.click
+    #  end
+    #
+    # This example will create a browser object but not close it:
+    #  Google.new.search.set "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={},&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]
+      else
+        @browser = Browser.create(config)
+        @i_created_browser = true
+      end
+      @browser.goto(params[:url] || config[:url])
+      execute_block_and_close_browser(browser,&block) if block_given?
+    end
+
+    def execute_block_and_close_browser(browser)
+      begin
+        yield self
+      rescue => site_block_exception
+      ensure
+        begin
+          @@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
+
+    def self.settings # :nodoc:
+      Taza::Settings.site_file(self.name.to_s.split("::").last)
+    end
+
+    def close_browser_and_raise_if original_error # :nodoc:
+      begin
+        @browser.close if (@i_created_browser && !@@donot_close_browser)
+      ensure
+        raise original_error if original_error
+      end
+    end
+
+    def define_site_pages # :nodoc:
+      Dir.glob(pages_path) do |file|
+        require file
+        page_name = File.basename(file,'.rb')
+        page_class = "#{@module_name}::#{page_name.camelize}"
+        self.class.class_eval <<-EOS
+        def #{page_name}(page_module = nil)
+          page = '#{page_class}'.constantize.new(page_module)
+          page.browser = @browser
+          yield page if block_given?
+          page
+        end
+        EOS
+      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:
+    #  Google.new do |google|
+    #    google.flow(:perform_search, :query => "taza")
+    #  end
+    #
+    # Where the flow would be defined under lib/sites/google/flows/perform_search.rb and look like:
+    #  class PerformSearch < Taza::Flow
+    #    alias :google :site
+    #
+    #    def run(params={})
+    #      google.search.set params[:query]
+    #      google.submit.click
+    #    end
+    #  end
+
+    def pages_path # :nodoc:
+      File.join(path,'pages','**','*.rb')
+    end
+
+    def flows_path # :nodoc:
+      File.join(path,'flows','*.rb')
+    end
+
+    def path # :nodoc:
+      File.join(base_path,'lib','sites',@class_name.underscore)
+    end
+
+    def base_path # :nodoc:
+      '.'
+    end
+  end
+end

data/lib/taza/tasks.rb

@@ -0,0 +1,54 @@
+require 'rubygems'
+require 'rake'
+require 'taglob'
+require 'spec/rake/spectask'
+
+def tags
+  ENV['TAGS']
+end
+
+module Taza
+  module Rake
+    class Tasks
+      attr_accessor :spec_opts
+
+      def initialize
+        yield self if block_given?
+        define
+      end
+
+      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
+          Dir.glob('./spec/*/').each do |dir|
+            recurse_to_create_rake_tasks(dir)
+          end
+        end
+      end
+
+      def recurse_to_create_rake_tasks(dir)
+        basename = File.basename(dir)
+        spec_pattern = File.join(dir,"**","*_spec.rb")
+        if (not Dir.glob(spec_pattern).empty?)
+          define_spec_task(basename,spec_pattern)
+          namespace basename do
+            Dir.glob(File.join(dir,"*_spec.rb")).each do |spec_file|
+              spec_name = File.basename(spec_file,'_spec.rb')
+              define_spec_task(spec_name,spec_file)
+            end
+            Dir.glob(File.join(dir,"*/")).each do |sub_dir|
+              recurse_to_create_rake_tasks(sub_dir)
+            end
+          end
+        end
+      end
+
+    end
+  end
+end

data/spec/array_spec.rb

@@ -0,0 +1,17 @@
+require 'spec/spec_helper'
+require 'extensions/array'
+
+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