taza 0.5.0 → 0.8.0

data/lib/taza/settings.rb

@@ -0,0 +1,36 @@
+require 'activesupport'
+
+module Taza
+  class Settings
+    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
+
+    def self.config_file # :nodoc:
+      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

@@ -2,27 +2,138 @@ 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
-    def initialize
+    @@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={})
+      @module_name = self.class.parent.to_s
+      @class_name  = self.class.to_s.split("::").last
       define_site_pages
+      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])
+
+      if block_given?
+        begin
+          yield self
+        rescue => site_block_exception
+        ensure
+          begin
+            @@before_browser_closes.call(browser)
+          rescue => before_browser_closes_block_exception
+          end
+          close_browser_and_raise_if site_block_exception || before_browser_closes_block_exception
+        end
+      end
     end
 
-    def define_site_pages
-      Dir.glob(path) do |file|
-        require file
+    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
+        if @i_created_browser
+          @browser.close
+        end
+      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}
-            yield '#{page_name}'.camelcase.constantize.new
-          end
+        def #{page_name}
+          page = '#{page_class}'.constantize.new
+          page.browser = @browser
+          yield page if block_given?
+          page
+        end
         EOS
       end
     end
 
-    def path
-      File.join('pages',self.class.to_s.underscore,'*.rb')
+    # 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 flow(name,params={})
+      require File.join(path,'flows',name.to_s.underscore)
+      flow_class = "#{@module_name}::#{name.to_s.camelize}".constantize
+      flow_class.new(self).run(params)
+    end
+
+    def pages_path # :nodoc:
+      File.join(path,'pages','*.rb')
+    end
+
+    def path # :nodoc:
+      File.join(base_path,'lib','sites',@class_name.underscore)
     end
-  end 
-end
 
+    def base_path # :nodoc:
+      '.'
+    end
+  end
+end

data/lib/taza/tasks.rb

@@ -1,46 +1,38 @@
 require 'rake'
 require 'rake/testtask'
 require 'rubygems'
-require 'taglob'
+require 'taglob/rake/tasks'
 require 'spec/rake/spectask'
-require 'taza/generators'
 
-private
-def get_tagged_files(test_file_pattern)
-  Dir.taglob(test_file_pattern,ENV['tags'])
-end
-
-def validate_required_environment_input_present(error_message, *environment_variable_keys)
-  environment_variable_keys.each do |environment_variable_key|
-    if ENV[environment_variable_key].nil?
-      STDERR.puts error_message
-      exit 1
-    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
-end
-
-public
 
-desc "invoke tests by tag"
-Rake::TestTask.new :test_tag do |t|
-  t.test_files = get_tagged_files('test/**/test_*.rb')
-end
+  desc "Run all functional specs"
+  Spec::Rake::SpecTask.new :functional do |t|
+    t.spec_files = 'spec/functional/**/*_spec.rb'
+    t.spec_opts << format_options("functional/all")
+  end
+  desc "Run all integration specs"
+  Spec::Rake::SpecTask.new :integration do |t|
+    t.spec_files = 'spec/integration/**/*_spec.rb'
+    t.spec_opts << format_options("integration/all")
+  end
 
-desc "invoke specs by tag"
-Spec::Rake::SpecTask.new :spec_tag do |t|
-  t.spec_files = get_tagged_files('spec/**/*_spec.rb')
-end
+  namespace :functional do
+    Dir.glob('./spec/functional/*/').each do |dir|
+      site_name = File.basename(dir)
 
-namespace :generate do
-  desc "generate a site(rake generate:site name=foo)"
-  task :site do
-    validate_required_environment_input_present("Usage: rake generate:site name=the_site_name",'name')
-    Taza::Generators::Site.new(ENV['name']).generate
-  end
+      desc "Run all functional specs for #{site_name}"
+      Spec::Rake::SpecTask.new site_name.to_sym do |t|
+        t.spec_files = "#{dir}**/*_spec.rb"
+        t.spec_opts << format_options("functional/#{site_name}/all")
+      end
 
-  desc "generate a page(rake generate:page site=foo page=bar)"
-  task :page do
-    validate_required_environment_input_present("Usage: rake generate:page name=the_page_name site=the_site_name",'name','site')
-    Taza::Generators::Page.new(ENV['name'],ENV['site']).generate
+    end
   end
 end

data/spec/browser_spec.rb

@@ -0,0 +1,72 @@
+require 'spec/spec_helper'
+require 'taza/browser'
+require 'taza/settings'
+require 'selenium'
+require 'firewatir'
+
+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
+
+  it "should be able to create a watir driver" do
+    Taza::Browser.expects(:create_watir_ie)
+    Taza::Browser.create(:browser => :ie, :driver => :watir)
+  end
+
+  it "should be able to create a firewatir driver" do
+    Taza::Browser.expects(:create_watir_firefox)
+    Taza::Browser.create(:browser => :firefox,:driver => :watir)
+  end
+
+  it "should be able to create a safariwatir driver" do
+    Taza::Browser.expects(:create_watir_safari)
+    Taza::Browser.create(:browser => :safari,:driver => :watir)
+  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(BrowserUnsupportedError)
+  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 create firewatir instance" do
+    FireWatir::Firefox.expects(:new)
+    Taza::Browser.create(:browser => :firefox, :driver => :watir)
+  end
+end

data/spec/flow_generator_spec.rb

@@ -0,0 +1,70 @@
+require 'spec/spec_helper'
+require 'rubygems'
+require 'fileutils'
+require 'taza'
+require 'vendor/gems/gems/rubigen-1.3.2/test/test_generator_helper'
+
+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
+
+  it "should generate flows that will not have namespace collisions with pages" do
+    flow_name = "SignIn"
+    run_generator('flow', [flow_name,@site_class.to_s], generator_sources)
+    run_generator('page', [flow_name,@site_class.to_s], generator_sources)
+    stub_settings
+    stub_browser
+    site = @site_class.new
+    site.flow(:sign_in)
+    site.sign_in_page
+  end
+
+  it "should generate flows that will not have namespace collisions with other sites' flows" do
+    new_site_class = generate_site('Pag')
+    run_generator('flow', [@flow_name,@site_class.to_s], generator_sources)
+    run_generator('flow', [@flow_name,new_site_class.to_s], generator_sources)
+    stub_settings
+    stub_browser
+    (@site_class.new.flows & new_site_class.new.flows).should be_empty
+  end
+end

data/spec/page_generator_spec.rb

@@ -0,0 +1,57 @@
+require 'spec/spec_helper'
+require 'rubygems'
+require 'fileutils'
+require 'taza'
+require 'vendor/gems/gems/rubigen-1.3.2/test/test_generator_helper'
+
+describe "Page Generation" do
+  include RubiGen::GeneratorTestHelper
+  include Helpers::Generator
+  include Helpers::Taza
+
+  before :all do
+    @page_name = "CheckOut"
+  end
+
+  before :each do
+    run_generator('taza', [APP_ROOT], generator_sources)
+    @site_class = generate_site('Gap')
+  end
+
+  after :each do
+    bare_teardown
+  end
+  
+  it "should give you usage if you do not give two arguments" do
+    PageGenerator.any_instance.expects(:usage)
+    lambda { run_generator('page', [@page_name], generator_sources) }.should raise_error
+  end
+
+  it "should give you usage if you give a site that does not exist" do
+    PageGenerator.any_instance.expects(:usage)
+    $stderr.expects(:puts).with(regexp_matches(/NoSuchSite/))
+    lambda { run_generator('page', [@page_name,"NoSuchSite"], generator_sources) }.should raise_error
+  end
+
+  it "should generate a page spec that can be required" do
+    run_generator('page', [@page_name,@site_class.to_s], generator_sources)
+    page_functional_spec = File.join(PROJECT_FOLDER,'spec','functional',@site_class.to_s.underscore,'check_out_page_spec.rb')
+    system("ruby -c #{page_functional_spec} > #{null_device}").should be_true
+  end
+
+  it "should be able to access the generated page from the site" do
+    run_generator('page', [@page_name,@site_class.to_s], generator_sources)
+    stub_settings
+    stub_browser
+    @site_class.new.check_out_page
+  end
+
+  it "should be able to access the generated page for its site" do
+    stub_browser
+    stub_settings
+    new_site_class = generate_site('Pag')
+    run_generator('page', [@page_name,@site_class.to_s], generator_sources)
+    run_generator('page', [@page_name,new_site_class.to_s], generator_sources)
+    new_site_class.new.check_out_page.class.should_not eql(@site_class.new.check_out_page.class)
+  end
+end