scudco-taza 0.8.1

data/generators/site/templates/site.rb.erb

@@ -0,0 +1,10 @@
+require 'rubygems'
+require 'taza'
+
+module <%= name.camelize %>
+  include ForwardInitialization
+
+  class <%= name.camelize %> < ::Taza::Site
+
+  end
+end

data/generators/site/templates/site.yml.erb

@@ -0,0 +1,3 @@
+---
+isolation:
+    :url: http://www.google.com

data/lib/app_generators/taza/taza_generator.rb

@@ -0,0 +1,72 @@
+require 'rubygems'
+require 'rubigen'
+class TazaGenerator < RubiGen::Base
+  DEFAULT_SHEBANG = File.join(Config::CONFIG['bindir'],
+                              Config::CONFIG['ruby_install_name'])
+
+  default_options :author => nil
+
+  attr_reader :name
+
+  def initialize(runtime_args, runtime_options = {})
+    super
+    usage if args.empty?
+    @destination_root = File.expand_path(args.shift)
+    @name = base_name
+    extract_options
+  end
+
+  def manifest
+    record do |m|    
+      create_directories(m)
+      m.template "rakefile.rb.erb", "rakefile"
+      m.template "config.yml.erb", File.join("config","config.yml")
+      m.template "spec_helper.rb.erb", File.join("spec","spec_helper.rb")
+      m.dependency "install_rubigen_scripts", [destination_root, 'taza'],
+        :shebang => options[:shebang], :collision => :force
+    end
+  end
+
+  def create_directories(m)
+    BASEDIRS.each { |path| m.directory path }
+    m.directory File.join('lib','sites')
+    m.directory File.join('lib','flows')
+    m.directory File.join('spec','functional')
+    m.directory File.join('spec','integration')
+    m.directory File.join('spec','story')
+  end
+  
+  protected
+    def banner
+      <<-EOS
+USAGE: #{spec.name} path/for/your/test/project [options]
+EOS
+    end
+
+    def add_options!(opts)
+      opts.separator ''
+      opts.separator 'Options:'
+      # For each option below, place the default
+      # at the top of the file next to "default_options"
+      # opts.on("-a", "--author=\"Your Name\"", String,
+      #         "Some comment about this option",
+      #         "Default: none") { |options[:author]| }
+      opts.on("-v", "--version", "Show the #{File.basename($0)} version number and quit.")
+    end
+
+    def extract_options
+      # for each option, extract it into a local variable (and create an "attr_reader :author" at the top)
+      # Templates can access these value via the attr_reader-generated methods, but not the
+      # raw instance variable value.
+      # @author = options[:author]
+    end
+
+    # Installation skeleton.  Intermediate directories are automatically
+    # created so don't sweat their absence here.
+    BASEDIRS = %w(
+      lib
+      config
+      script
+      spec
+    )
+end

data/lib/app_generators/taza/templates/config.yml.erb

@@ -0,0 +1,3 @@
+---
+:browser: :firefox
+:driver: :selenium

data/lib/app_generators/taza/templates/rakefile.rb.erb

@@ -0,0 +1,3 @@
+<%= "#Generated at #{Time.now}" %>
+require 'rubygems'
+require 'taza/tasks'

data/lib/app_generators/taza/templates/spec_helper.rb.erb

@@ -0,0 +1,11 @@
+ENV['TAZA_ENV'] = "isolation" if ENV['TAZA_ENV'].nil?
+require 'rubygems'
+require 'spec'
+require 'mocha'
+
+lib_path = File.expand_path("#{File.dirname(__FILE__)}/../lib/sites")
+$LOAD_PATH.unshift lib_path unless $LOAD_PATH.include?(lib_path)
+
+Spec::Runner.configure do |config|
+  config.mock_with :mocha
+end

data/lib/extensions/array.rb

@@ -0,0 +1,10 @@
+class Array
+  # Returns true if the two arrays elements are equal ignoring order
+  # Example:
+  #  [1,2].equivalent([2,1])    # => true
+  #  [1,2,3].equivalent([2,1])  # => false
+  def equivalent?(other_array)
+    merged_array = self & other_array
+    merged_array.size == self.size && merged_array.size == other_array.size
+  end
+end

data/lib/extensions/hash.rb

@@ -0,0 +1,5 @@
+class Hash
+  def convert_hash_keys_to_methods(fixture) # :nodoc:
+    Taza::Entity.new(self,fixture)
+  end
+end

data/lib/extensions/object.rb

@@ -0,0 +1,24 @@
+# instance_exec comes with >1.8.7 thankfully
+if VERSION <= '1.8.6'
+  class Object
+    module InstanceExecHelper; end
+    include InstanceExecHelper
+    # instance_exec method evaluates a block of code relative to the specified object, with parameters whom come from outside the object.
+    def instance_exec(*args, &block)
+      begin
+        old_critical, Thread.critical = Thread.critical, true
+        n = 0
+        n += 1 while respond_to?(mname="__instance_exec#{n}")
+        InstanceExecHelper.module_eval{ define_method(mname, &block) }
+      ensure
+        Thread.critical = old_critical
+      end
+      begin
+        ret = send(mname, *args)
+      ensure
+        InstanceExecHelper.module_eval{ remove_method(mname) } rescue nil
+      end
+      ret
+    end
+  end
+end

data/lib/extensions/string.rb

@@ -0,0 +1,11 @@
+require 'rubygems'
+require 'activesupport'
+
+class String
+  # pluralizes a string and turns it into a symbol
+  # Example:
+  #  "apple".pluralize_to_sym    # => :apples
+  def pluralize_to_sym
+    self.pluralize.to_sym
+  end
+end

data/lib/taza/browser.rb

@@ -0,0 +1,33 @@
+module Taza
+  class Browser
+    
+    # Create a browser instance depending on configuration.  Configuration should be read in via Taza::Settings.config.
+    # 
+    # Example:
+    #     browser = Taza::Browser.create(Taza::Settings.config)
+    #
+    def self.create(params={})
+      self.send("create_#{params[:driver]}".to_sym,params)
+    end
+    
+    def self.browser_class(params)
+      self.send("#{params[:driver]}_#{params[:browser]}".to_sym)
+    end
+
+    private    
+
+    def self.create_watir(params)
+      require 'watir'
+      Watir::Browser.default = params[:browser].to_s
+      Watir::Browser.new
+    end
+
+    def self.create_selenium(params)
+      require 'selenium'
+      Selenium::SeleniumDriver.new(params[:server_ip],params[:server_port],'*' + params[:browser].to_s,params[:timeout])
+    end
+
+  end
+  
+end
+

data/lib/taza/entity.rb

@@ -0,0 +1,34 @@
+module Taza
+  class Entity
+    #Creates a entity, pass in a hash to be methodized and the fixture to look up other fixtures (not entirely happy with this abstraction)
+    def initialize(hash,fixture)
+      @hash = hash
+      @fixture = fixture
+      define_methods_for_hash_keys
+    end
+    
+    #This method converts hash keys into methods onto the entity
+    def define_methods_for_hash_keys
+      @hash.keys.each do |key|
+        create_method(key) do
+          get_value_for_entry(key)
+        end
+      end
+    end
+
+    #This method will lookup another fixture if a pluralized fixture exists otherwise return the value in the hash
+    def get_value_for_entry(key) # :nodoc:
+      if @fixture.pluralized_fixture_exists?(key)
+        @fixture.get_fixture_entity(key.pluralize_to_sym,@hash[key])
+      else
+        @hash[key]
+      end
+    end
+
+    private
+    def create_method(name, &block) # :nodoc:
+      self.class.send(:define_method, name, &block)
+    end
+
+  end
+end

data/lib/taza/fixture.rb

@@ -0,0 +1,66 @@
+module Taza
+  class Fixture # :nodoc:
+
+    def initialize # :nodoc:
+      @fixtures = {}
+    end
+
+    def load_all # :nodoc:
+      Dir.glob(fixtures_pattern) do |file|
+        entitized_fixture = {}
+        YAML.load_file(file).each do |key, value|
+          entitized_fixture[key] = value.convert_hash_keys_to_methods(self)
+        end
+        @fixtures[File.basename(file,'.yml').to_sym] = entitized_fixture
+      end
+    end
+    
+    def fixture_names # :nodoc:
+      @fixtures.keys
+    end
+    
+    def get_fixture_entity(fixture_file_key,entity_key) # :nodoc:
+      @fixtures[fixture_file_key][entity_key]
+    end
+
+    def pluralized_fixture_exists?(singularized_fixture_name) # :nodoc:
+      fixture_names.include?(singularized_fixture_name.pluralize_to_sym)
+    end
+
+    def fixtures_pattern # :nodoc:
+      File.join(base_path, 'fixtures','*.yml')
+    end
+
+    def base_path # :nodoc:
+      File.join('.','spec')
+    end
+  end
+  
+  # The module that will mixin methods based on the fixture files in your 'spec/fixtures'
+  # 
+  # Example:
+  #   describe "something" do
+  #     it "should test something" do
+  #       users(:jane_smith).first_name.should eql("jane")
+  #     end
+  #   end
+  # 
+  #  where there is a spec/fixtures/users.yml file containing a entry of:
+  # jane_smith:
+  #   first_name: jane
+  #   last_name: smith
+  module Fixtures
+    def Fixtures.included(other_module) # :nodoc:
+      fixture = Fixture.new
+      fixture.load_all
+      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
+
+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,95 @@
+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)
+      self.elements[name] = block
+    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 initialize
+      add_element_methods
+    end
+
+    def add_element_methods # :nodoc:
+      self.class.elements.each do |element_name,element_block|
+        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
+
+    def add_element_method(params) # :nodoc:
+      self.class.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|
+        raise FilterError, "#{filter_method} returned false for #{params[:element_name]}" unless send(filter_method)
+      end
+    end
+  end
+
+  class FilterError < StandardError; end
+end