bret-watircraft 0.4.0

data/lib/taza/site.rb

@@ -0,0 +1,227 @@
+require 'rubygems'
+require 'activesupport'
+require 'taza/settings'
+
+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
+    
+    # These methods are available for user contexts, including Site itself
+    module Methods
+      attr_accessor :browser, :site
+      
+      # Return an instance of the specified page. The name
+      # Given should be the human-form of the page, without the
+      # "page" suffix.
+      # If a block is given, it yields to the page.
+      def page(page_name, &block)
+        method_name = page_name.computerize + '_page'
+        send method_name, &block
+      end
+
+      # Send the browser to a url, relative to the site origin.
+      def goto relative_url
+        destination = File.join(@site.origin, relative_url) 
+        @browser.goto destination
+      end
+      
+      def pages
+        @pages || @site.pages
+      end
+
+    end
+    
+    @@before_browser_closes = Proc.new() {}
+    # 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
+
+    # Site
+    attr_accessor :methods_module
+
+    # 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
+    # (not sure if this is a useful feature or not)
+    def initialize(params={}, &block)
+      @site = self
+      @module_name = self.class.parent.to_s
+      @class_name  = self.class.to_s.split("::").last
+
+      define_flows
+
+      if params[:browser]
+        @browser = params[:browser]
+      else
+        @browser = Browser.create(config)
+        @i_created_browser = true
+      end
+
+      page_loader = PageLoader.new(@module_name, pages_path)
+      @pages = page_loader.page_names
+      @methods_module = page_loader.page_methods
+      @methods_module.send(:include, Methods)
+      self.extend(@methods_module)
+      
+      @browser.goto origin
+
+      execute_block_and_close_browser(&block) if block_given?
+    end
+
+    def config
+      Settings.config(@class_name)
+    end
+    
+    # The base url of the site. This is configured in environments.yml.
+    def origin
+      config[:url]
+    end
+
+    def execute_block_and_close_browser
+      begin
+        yield self
+      rescue => site_block_exception
+      ensure
+        begin
+          close
+        rescue => close_exception
+          ""
+        end
+        exception = site_block_exception || close_exception
+        raise exception if exception
+      end
+    end
+    private :execute_block_and_close_browser
+
+    def close
+      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
+      begin
+        @browser.close if @i_created_browser
+      ensure
+        raise before_browser_closes_block_exception if before_browser_closes_block_exception
+      end
+    end
+
+    # Return a context that supports the "watircraft" commands. 
+    # Currently used by the script\console
+    def execution_context
+      initialize_context!(Object.new)
+    end
+    
+    def initialize_context!(context)
+      context.extend @methods_module
+      context.site = @site
+      context.browser = @site.browser
+      context
+    end
+    
+    private
+    def pages_path # :nodoc:
+      File.join(path,'pages','**','*.rb') # does this need to include partials?
+    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
+
+    #
+    # methods that neither depend on or modify state
+    #
+
+    private
+    def flows_path # :nodoc:
+      File.join(path,'flows','*.rb')
+    end
+
+    def path # :nodoc:
+      File.join(base_path,'lib')
+    end
+
+    def base_path # :nodoc:
+      APP_ROOT
+    end
+    
+    class PageLoader
+      attr_reader :page_methods, :page_names
+      def initialize site_module, pages_path
+        @site_module = site_module
+        @pages_path = pages_path
+        @page_methods = Module.new
+        @page_names = []
+        define_site_pages
+      end
+      private
+      def define_site_pages # :nodoc:
+        Dir.glob(@pages_path) do |file|
+          require file
+          page_name = File.basename(file,'.rb')
+          @page_names << page_name
+          page_class = "#{@site_module}::#{page_name.camelize}"
+          @page_methods.module_eval <<-EOS
+          def #{page_name}
+            page = #{page_class}.new
+            page.browser = @browser
+            page.site = @site
+            yield page if block_given?
+            page
+          end
+          EOS
+        end
+      end
+    end
+  end
+end

data/lib/taza/tasks.rb

@@ -0,0 +1,30 @@
+require 'rake'
+require 'rake/testtask'
+require 'rubygems'
+require 'taglob/rake/tasks'
+require 'spec/rake/spectask'
+
+def tags
+  ENV['TAGS']
+end
+
+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
+
+desc "Run all functional specs"
+Spec::Rake::SpecTask.new :spec do |t|
+  t.spec_files = Dir.taglob('test/specs/**/*_spec.rb',tags)
+  t.spec_opts << format_options("functional/all")
+end
+task :specs => :spec
+
+require 'cucumber/rake/task'
+Cucumber::Rake::Task.new do |t|
+  t.cucumber_opts = '--format pretty'
+  t.step_pattern = "lib/steps/**/*.rb"
+  t.feature_pattern = "test/features/**/*.feature"
+end

data/lib/taza.rb

@@ -0,0 +1,35 @@
+require 'taza/page'
+require 'taza/site'
+require 'taza/browser'
+require 'taza/settings'
+require 'taza/flow'
+require 'taza/entity'
+require 'taza/fixture'
+require 'extensions/object'
+require 'extensions/string'
+require 'extensions/hash'
+require 'extensions/array'
+
+module Taza
+  VERSION = '0.8.1'
+
+  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
+

data/lib/watircraft/generator_helper.rb

@@ -0,0 +1,27 @@
+require 'taza/settings'
+
+module WatirCraft
+  # Assumes #site_name and #destination_root and #usage methods are defined.
+  module GeneratorHelper
+    protected
+    def configured_validated_site
+      site = configured_site
+      check_if_site_exists site
+      site
+    end
+    def configured_site
+      site_name = Taza::Settings.config_file[:site]
+    end
+    def check_if_site_exists site_name=@site_name
+      if site_name.nil?
+        raise RubiGen::UsageError, 
+          "Error. A site must first be specified in config.yml"
+      end
+      site_file = File.join(destination_root,'lib',"#{site_name.underscore}.rb")
+      unless File.exists?(site_file)
+        raise RubiGen::UsageError, 
+          "Error. Site file #{site_file} not found. (Check config.yml)"
+      end
+    end    
+  end
+end

data/lib/watircraft/table.rb

@@ -0,0 +1,56 @@
+module WatirCraft
+  class Table
+    class << self
+      def row_class
+        @row_class ||= Class.new(Row)
+      end
+      def field(name, &block)
+        row_class.field(name, &block)
+      end
+      def element(name, &block)
+        row_class.element(name, &block)
+      end
+    end
+    def initialize watir_table, &block
+      @watir_table = watir_table
+    end
+    def row selector
+      @watir_table.rows.each do | row |
+        wrapped = self.class.row_class.new row
+        # note: we are only looking at the first key/value
+        method = selector.keys[0]
+        value = selector[method]
+        return wrapped if wrapped.send(method) == value
+      end
+      nil
+    end
+  end
+  
+  class Row
+    class << self
+      def element name, &block
+        define_method(name) do
+          instance_eval &block
+        end
+      end
+      def field name, &block
+        element_name = "#{name}_element"
+        element element_name, &block
+        define_method(name) do
+          send(element_name).display_value
+        end
+        define_method("#{name}=") do | value |
+          send(element_name).set value
+        end
+      end
+    end
+    def initialize watir_row
+      @row = watir_row
+    end
+    # Returns true. If the row doesn't exist, you'll get nil as the return
+    # value of Table#row.
+    def exist?
+      true
+    end
+  end
+end

data/lib/watircraft/version.rb

@@ -0,0 +1,3 @@
+# This file is autogenerated. Do not edit.
+# Use 'rake version.rb' to update.
+module WatirCraft; VERSION = '0.4.0'; end

data/lib/watircraft.rb

@@ -0,0 +1 @@
+require 'watircraft/version'

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

@@ -0,0 +1,68 @@
+require 'spec/spec_helper'
+require 'taza/browser'
+require 'taza/settings'
+require 'selenium'
+require 'watir'
+
+describe Taza::Browser do
+
+  before :each do
+    reset_env_vars
+    Taza::Settings.stubs(:config_file).returns({})
+    ENV['ENVIRONMENT'] = 'test'
+  end
+
+  after :all do
+    reset_env_vars
+  end
+  def reset_env_vars
+    ENV['ENVIRONMENT'] = nil
+    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(StandardError)
+  end
+
+  it "should use params browser type when creating selenium" do
+    browser_type = :opera
+    Selenium::SeleniumDriver.expects(:new).with(anything,anything,'*opera',anything)
+    Taza::Browser.create(:browser => browser_type, :driver => :selenium)
+  end
+
+  it "should raise selenium unsupported browser error" do
+    Taza::Browser.create(:browser => :foo, :driver => :selenium)
+  end
+
+  it "should be able to create a selenium instance" do
+    browser = Taza::Browser.create(:browser => :firefox, :driver => :selenium)
+    browser.should be_a_kind_of(Selenium::SeleniumDriver)
+  end
+
+  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['DRIVER'] = 'selenium'
+    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['DRIVER'] = 'selenium'
+    Selenium::SeleniumDriver.expects(:new).with(anything,anything,anything,'timeout')
+    Taza::Browser.create(Taza::Settings.config("SiteName"))
+  end
+
+  # a test of a stub for testing the test harness of our tests
+  it "should provide a fake browser, so we can test our test harness" do
+    Taza::Browser.create(:driver => :fake).should be_a(Taza::FakeBrowser)
+  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/fake_table.rb

@@ -0,0 +1,34 @@
+require 'ostruct'
+
+# Replaces watir table in WatirCraft unit tests
+class FakeTable
+  attr_accessor :rows
+  def initialize structure
+    @rows = structure.map {|hash| FakeRow.new(hash)}
+  end
+end
+
+class FakeRow
+  def initialize hash
+    @hash = hash
+  end
+  def element name
+    FakeElement.new @hash, name
+  end
+end
+
+class FakeElement
+  def initialize hash, name
+    @hash = hash
+    @name = name
+  end
+  def display_value
+    @hash[@name]
+  end
+  def exist?
+    true
+  end
+  def set value
+    @hash[@name] = value
+  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

data/spec/hash_spec.rb

@@ -0,0 +1,12 @@
+require 'spec/spec_helper'
+
+describe 'Hash Extensions' do
+  it "should add methods for hash keys to some instance" do
+    entity = {'apple' => 'pie'}.convert_hash_keys_to_methods(nil)
+    entity.should respond_to(:apple)
+  end
+  it "should not add the methods to a hash" do
+    entity = {'apple' => 'pie'}.convert_hash_keys_to_methods(nil)
+    entity.should_not be_a_instance_of(Hash)
+  end
+end

data/spec/object_spec.rb

@@ -0,0 +1,29 @@
+require 'spec/spec_helper'
+
+describe "Object" do
+  before :all do
+    @orig_version = VERSION
+    Object.send :remove_const, :VERSION
+    Object.const_set :VERSION, "1.8.6"
+    load 'lib/extensions/object.rb'
+  end
+
+  after :all do
+    Object.send :remove_const, :VERSION
+    Object.const_set :VERSION, @orig_version
+  end
+
+  it "should execute blocks with args in instance context" do
+    str = "string"
+
+    class << str
+      def my_singleton_method(arg)
+        arg
+      end
+    end
+
+    block = Proc.new { |arg| my_singleton_method(arg) }
+
+    str.instance_exec("foo",&block).should == "foo"
+  end
+end