scudco-taza 0.8.1

data/lib/taza/settings.rb

@@ -0,0 +1,47 @@
+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=>:firefox,:driver=>:selenium}.merge(config_file.merge(env_settings))
+      site_file(site_name).merge(env_settings)
+    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,145 @@
+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() {}
+    # 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
+    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
+      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 = '#{page_class}'.constantize.new
+          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,50 @@
+require 'rake'
+require 'rake/testtask'
+require 'rubygems'
+require 'taglob/rake/tasks'
+require 'spec/rake/spectask'
+
+def tags
+  ENV['TAGS']
+end
+
+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
+
+  desc "Run all functional specs"
+  Spec::Rake::SpecTask.new :functional do |t|
+    t.spec_files = Dir.taglob('spec/functional/**/*_spec.rb',tags)
+    t.spec_opts << format_options("functional/all")
+  end
+  desc "Run all integration specs"
+  Spec::Rake::SpecTask.new :integration do |t|
+    t.spec_files = Dir.taglob('spec/integration/**/*_spec.rb',tags)
+    t.spec_opts << format_options("integration/all")
+  end
+
+  namespace :functional do
+    Dir.glob('./spec/functional/*/').each do |dir|
+      site_name = File.basename(dir)
+      desc "Run all functional specs for #{site_name}"
+      Spec::Rake::SpecTask.new site_name.to_sym do |t|
+        t.spec_files = Dir.taglob("#{dir}**/*_spec.rb",tags)
+        t.spec_opts << format_options("functional/#{site_name}/all")
+      end
+      namespace site_name.to_sym do
+        Dir.glob("./spec/functional/#{site_name}/*_spec.rb").each do |page_spec_file|
+          page_spec_name = File.basename(page_spec_file)
+          page_name = page_spec_name.chomp('_spec.rb')
+          Spec::Rake::SpecTask.new page_name.to_sym do |t|
+            t.spec_files = page_spec_file
+            t.spec_opts << format_options("functional/#{site_name}/#{page_name}")
+          end
+        end
+      end
+    end
+  end
+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/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,63 @@
+require 'spec/spec_helper'
+require 'taza/browser'
+require 'taza/settings'
+require 'selenium'
+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
+
+  module Watir
+    class Safari
+    end
+  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'
+    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'
+    Selenium::SeleniumDriver.expects(:new).with(anything,anything,anything,'timeout')
+    Taza::Browser.create(Taza::Settings.config("SiteName"))
+  end
+
+  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

data/spec/flow_generator_spec.rb

@@ -0,0 +1,50 @@
+require 'spec/spec_helper'
+require 'rubygems'
+require 'fileutils'
+require 'taza'
+
+class Taza::Site
+  def flows
+    flows = []
+    Dir.glob(File.join(path,'flows','*.rb')).each do |file|
+      require file
+
+      flows << "#{self.class.parent.to_s}::#{File.basename(file,'.rb').camelize}".constantize
+    end
+    flows
+  end
+end
+
+describe "Flow Generation" do
+  include RubiGen::GeneratorTestHelper
+  include Helpers::Generator
+  include Helpers::Taza
+
+  before :all do
+    @site_name = "Foo"
+    @site_folder = File.join(PROJECT_FOLDER,'lib','sites',"gap")
+    @site_file = File.join(PROJECT_FOLDER,'lib','sites',"gap.rb")
+    @flow_name = "CheckOut"
+  end
+
+  before :each do
+    run_generator('taza', [APP_ROOT], generator_sources)
+    @site_class = generate_site(@site_name)
+  end
+
+  after :each do
+    bare_teardown
+  end
+
+  it "should give you usage if you do not give two arguments" do
+    FlowGenerator.any_instance.expects(:usage)
+    lambda { run_generator('flow', [@flow_name], generator_sources) }.should raise_error
+  end
+
+  it "should give you usage if you give a site that does not exist" do
+    FlowGenerator.any_instance.expects(:usage)
+    $stderr.expects(:puts).with(regexp_matches(/NoSuchSite/))
+    lambda { run_generator('flow', [@flow_name,"NoSuchSite"], generator_sources) }.should raise_error
+  end
+
+end