taza 0.5.0 → 0.8.0

data/generators/site/site_generator.rb

@@ -0,0 +1,55 @@
+require 'rubygems'
+require 'rubigen'
+require 'activesupport'
+
+class SiteGenerator < RubiGen::Base
+  default_options :author => nil
+  attr_reader :name
+
+  def initialize(runtime_args, runtime_options = {})
+    super
+    usage if args.empty?
+    @name = args.shift
+    extract_options
+  end
+
+  def manifest
+    record do |m|
+      site_path = File.join('lib','sites')
+      m.template "site.rb.erb", File.join(site_path,"#{name.underscore}.rb")
+      m.directory File.join(site_path,"#{name.underscore}")
+      m.directory File.join(site_path,("#{name.underscore}"),"flows")
+      m.directory File.join(site_path,("#{name.underscore}"),"pages")
+      m.directory File.join('spec','functional',name.underscore)
+      m.template "site.yml.erb", File.join('config',"#{name.underscore}.yml")
+    end
+  end
+
+  protected
+  def banner
+    <<-EOS
+    Creates a taza site.
+
+    USAGE: #{$0} #{spec.name} name
+    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
+
+end

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,76 @@
+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|
+      # Ensure appropriate folder(s) exists
+      
+      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.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")
+      
+      # Create stubs
+      # m.template_copy_each ["template.rb", "template2.rb"]
+      # m.file     "file",         "some_file_copied"
+      # m.file_copy_each ["path/to/file", "path/to/file2"]
+
+      m.dependency "install_rubigen_scripts", [destination_root, 'taza'],
+        :shebang => options[:shebang], :collision => :force
+    end
+  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/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/taza.rb

@@ -1,13 +1,52 @@
-require 'taza/generators'
 require 'taza/page'
 require 'taza/site'
-require 'taza/tasks'
+require 'taza/browser'
+require 'taza/settings'
+require 'taza/flow'
 
 module Taza
-  VERSION = '0.5.0'
-  
+  VERSION = '0.8.0'
+
   def self.windows?
     PLATFORM.include?("mswin")  
   end 
-  
+  def self.osx?
+    PLATFORM.include?("darwin")
+  end
+end
+
+module ForwardInitialization
+  module ClassMethods
+    def new(*args,&block)
+      const_get("#{name.split("::").last}").new(*args,&block)
+    end
+  end
+
+  def self.included(klass)
+    klass.extend(ClassMethods)
+  end
+end
+
+# instance_exec comes with >1.8.7 thankfully
+if VERSION <= '1.8.6'
+  class Object
+    module InstanceExecHelper; end
+    include InstanceExecHelper
+    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/taza/browser.rb

@@ -0,0 +1,40 @@
+require 'taza/browsers/ie_watir'
+require 'taza/browsers/safari_watir'
+
+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
+
+
+    private    
+
+    def self.create_watir(params)
+      method = "create_watir_#{params[:browser]}"
+      raise BrowserUnsupportedError unless self.respond_to?(method)
+      watir = self.send(method)
+      watir
+    end
+
+    def self.create_selenium(params)
+      require 'selenium'
+      Selenium::SeleniumDriver.new(params[:server_ip],params[:server_port],'*' + params[:browser].to_s,params[:timeout])
+    end
+    
+    def self.create_watir_firefox
+      require 'firewatir'
+      FireWatir::Firefox.new()
+    end
+        
+  end
+end
+
+class BrowserUnsupportedError < StandardError
+end

data/lib/taza/browsers/ie_watir.rb

@@ -0,0 +1,8 @@
+module Taza
+  class Browser
+    def self.create_watir_ie
+      require 'watir'
+      Watir::IE.new
+    end
+  end
+end

data/lib/taza/browsers/safari_watir.rb

@@ -0,0 +1,8 @@
+module Taza
+  class Browser
+    def self.create_watir_safari
+      require 'safariwatir'
+      Watir::Safari.new
+    end
+  end
+end

data/lib/taza/flow.rb

@@ -0,0 +1,45 @@
+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:
+  #
+  #   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
+  #       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.flow :create_an_account, :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,21 +1,66 @@
 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
-      attr_accessor :filters, :elements
+      def elements # :nodoc:
+        @elements ||= {}
+      end
+      def filters # :nodoc:
+        @filters ||= Hash.new { [] }
+      end
     end
 
-    self.filters = Hash.new { [] }
-    self.elements = {}
-
+    # 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
 
-    def self.filter(params,&block)
-      params[:elements] = [:all] unless params.has_key? :elements
-
-      params[:elements].each do |element|
-        self.filters[element] = self.filters[element] << [params[:name],block]
+    # 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
 
@@ -23,25 +68,27 @@ module Taza
       add_element_methods
     end
 
-    def add_element_methods
+    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, :method_name => element_name, :method_block => element_block)
+        add_element_method(:filters => filters, :element_name => element_name, :element_block => element_block)
       end
     end
 
-    def add_element_method(params)
+    def add_element_method(params) # :nodoc:
       self.class.class_eval do
-        define_method(params[:method_name]) do
-          params[:filters].each do |(filter_name,filter_block)|
-            unless filter_block.call
-              raise FilterError, "#{filter_name} returned false for #{params[:method_name]}"
-            end
-          end
-          params[:method_block].call
+        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