fluent 0.1.0

data/lib/fluent/platform_watir/platform_object.rb

@@ -0,0 +1,112 @@
+module Fluent
+  module Platforms
+    module WatirWebDriver
+      class PlatformObject
+        
+        attr_reader :browser
+        
+        def initialize(browser)
+          @browser = browser
+        end
+        
+        ## Browser-Level Actions ##
+        
+        def visit(url)
+          browser.goto(url)
+        end
+        
+        ## Generator Actions ##
+        
+        def link(locator)
+          reference_web_element('link(locator)', WebElements::Link, locator)
+        end
+        
+        def link_click(locator)
+          browser.instance_eval('link(locator).click')
+        end
+        
+        def button(locator)
+          reference_web_element('button(locator)', WebElements::Button, locator)
+        end
+        
+        def button_click(locator)
+          browser.instance_eval('button(locator).click')
+        end
+        
+        def text_field(locator)
+          reference_web_element('text_field(locator)', WebElements::TextField, locator)
+        end
+        
+        def text_field_set(locator, value)
+          browser.instance_eval('text_field(locator).set(value)')
+        end
+        
+        def text_field_get(locator)
+          browser.instance_eval('text_field(locator).value')
+        end
+        
+        def checkbox(locator)
+          reference_web_element('checkbox(locator)', WebElements::CheckBox, locator)
+        end
+        
+        def checkbox_check_state(locator)
+          browser.instance_eval('checkbox(locator).set?')
+        end
+        
+        def checkbox_check(locator)
+          browser.instance_eval('checkbox(locator).set')
+        end
+        
+        def checkbox_uncheck(locator)
+          browser.instance_eval('checkbox(locator).clear')
+        end
+        
+        def select_list(locator)
+          reference_web_element('select_list(locator)', WebElements::SelectList, locator)
+        end
+        
+        def select_list_get_selected(locator)
+          browser.instance_eval('select_list(locator).selected_options[0].text')
+        end
+        
+        def select_list_set(locator, value)
+          browser.instance_eval('select_list(locator).select(value)')
+        end
+        
+        def select_list_get_value(locator)
+          browser.instance_eval('select_list(locator).value')
+        end
+        
+        def radio(locator)
+          reference_web_element('radio(locator)', WebElements::Radio, locator)
+        end
+        
+        def radio_select(locator)
+          browser.instance_eval('radio(locator).set')
+        end
+        
+        def radio_check_state(locator)
+          browser.instance_eval('radio(locator).set?')
+        end
+        
+        def paragraph(locator)
+          reference_web_element('p(locator)', WebElements::Paragraph, locator)
+        end
+        
+        def paragraph_text(locator)
+          browser.instance_eval('p(locator).text')
+        end
+        
+        def reference_web_element(action, object, locator)
+          element_object = browser.instance_eval(action)
+          object.new(element_object, :platform => :watir_webdriver)
+        end
+        
+      end
+    end
+  end
+end
+
+require 'fluent/web_elements/web_element'
+file_list = Dir["#{File.dirname(__FILE__)}/../web_elements/**/*.rb"].reject { |file| file =~ /web_element.rb/ }
+file_list.each { |file| require file }

data/lib/fluent/platform_watir/platform_web_elements/select_list.rb

@@ -0,0 +1,30 @@
+module Fluent
+  module Platforms
+    module WatirWebDriver
+      module SelectList
+        
+        def [](index)
+          ::Fluent::WebElements::Option.new(options[index], :platform => :watir_webdriver)
+        end
+        
+        # Provides an array of Option objects that are contained within
+        # a select list object.
+        #
+        # @return [Array] Fluent::WebElements::Option objects
+        def options
+          elements = []
+          options = web_element.wd.find_elements(:xpath, option_xpath)
+          options.each do |option|
+            elements << ::Fluent::WebElements::Option.new(option, :platform => :watir_webdriver)
+          end
+          elements
+        end
+        
+        def option_xpath
+          './/child::option'
+        end
+        
+      end
+    end
+  end
+end

data/lib/fluent/platform_watir/platform_web_elements/web_element.rb

@@ -0,0 +1,21 @@
+module Fluent
+  module Platforms
+    module WatirWebDriver
+      module WebElement
+
+        def text
+          web_element.text
+        end
+
+        def exists?
+          web_element.exists?
+        end
+
+        def visible?
+          web_element.present?
+        end
+        
+      end
+    end
+  end
+end

data/lib/fluent/platforms.rb

@@ -0,0 +1,31 @@
+module Fluent
+  module Platforms
+    
+    @drivers = {}
+    
+    def self.register(driver, platform)
+      @drivers[driver] = platform
+    end
+    
+    def self.list
+      @drivers
+    end
+    
+    # This module determines what execution platform Fluent will use. The
+    # decision is based on the browser that has been established for the
+    # execution profile.
+    #
+    # @param browser [Object] the browser to establish the platform for
+    # @return [Object] a platform object to execute tests against
+    def get_platform_for(browser)
+      Fluent::Platforms.list.each_value do |driver|
+        return driver.create_platform_object_for(browser) if driver.works_with?(browser)
+      end
+      msg = "Unable to create a platform object for #{browser}."
+      raise Fluent::Errors::UnableToCreatePlatform, msg
+    end
+    
+  end
+end
+
+require 'fluent/platform_watir'

data/lib/fluent/version.rb

@@ -0,0 +1,3 @@
+module Fluent
+  VERSION = '0.1.0'
+end

data/lib/fluent/web_elements/button.rb

@@ -0,0 +1,16 @@
+module Fluent
+  module WebElements
+    class Button < WebElement
+
+      def initialize(web_element, platform)
+        @web_element = web_element
+        include_platform_specifics_for platform
+      end
+
+      def include_platform_specifics_for(platform)
+        super
+      end
+
+    end
+  end
+end

data/lib/fluent/web_elements/checkbox.rb

@@ -0,0 +1,16 @@
+module Fluent
+  module WebElements
+    class CheckBox < WebElement
+
+      def initialize(web_element, platform)
+        @web_element = web_element
+        include_platform_specifics_for platform
+      end
+
+      def include_platform_specifics_for(platform)
+        super
+      end
+
+    end
+  end
+end

data/lib/fluent/web_elements/link.rb

@@ -0,0 +1,16 @@
+module Fluent
+  module WebElements
+    class Link < WebElement
+      
+      def initialize(web_element, platform)
+        @web_element = web_element
+        include_platform_specifics_for platform
+      end
+      
+      def include_platform_specifics_for(platform)
+        super
+      end
+      
+    end
+  end
+end

data/lib/fluent/web_elements/option.rb

@@ -0,0 +1,16 @@
+module Fluent
+  module WebElements
+    class Option < WebElement
+
+      def initialize(web_element, platform)
+        @web_element = web_element
+        include_platform_specifics_for platform
+      end
+
+      def include_platform_specifics_for(platform)
+        super
+      end
+
+    end
+  end
+end

data/lib/fluent/web_elements/paragraph.rb

@@ -0,0 +1,16 @@
+module Fluent
+  module WebElements
+    class Paragraph < WebElement
+
+      def initialize(web_element, platform)
+        @web_element = web_element
+        include_platform_specifics_for platform
+      end
+
+      def include_platform_specifics_for(platform)
+        super
+      end
+
+    end
+  end
+end

data/lib/fluent/web_elements/radio.rb

@@ -0,0 +1,16 @@
+module Fluent
+  module WebElements
+    class Radio < WebElement
+
+      def initialize(web_element, platform)
+        @web_element = web_element
+        include_platform_specifics_for platform
+      end
+
+      def include_platform_specifics_for(platform)
+        super
+      end
+
+    end
+  end
+end

data/lib/fluent/web_elements/select_list.rb

@@ -0,0 +1,20 @@
+module Fluent
+  module WebElements
+    class SelectList < WebElement
+
+      def initialize(web_element, platform)
+        @web_element = web_element
+        include_platform_specifics_for platform
+      end
+
+      def include_platform_specifics_for(platform)
+        super
+        if platform[:platform] == :watir_webdriver
+          require 'fluent/platform_watir/platform_web_elements/select_list'
+          self.class.send :include, Fluent::Platforms::WatirWebDriver::SelectList
+        end
+      end
+
+    end
+  end
+end

data/lib/fluent/web_elements/text_field.rb

@@ -0,0 +1,16 @@
+module Fluent
+  module WebElements
+    class TextField < WebElement
+
+      def initialize(web_element, platform)
+        @web_element = web_element
+        include_platform_specifics_for platform
+      end
+
+      def include_platform_specifics_for(platform)
+        super
+      end
+
+    end
+  end
+end

data/lib/fluent/web_elements/web_element.rb

@@ -0,0 +1,33 @@
+module Fluent
+  module WebElements
+    class WebElement
+      
+      attr_reader :web_element
+      
+      def initialize(web_element, platform)
+        @web_element = web_element
+        include_platform_specifics_for platform
+      end
+      
+      def click
+        web_element.click
+      end
+      
+      def enabled?
+        web_element.enabled?
+      end
+      
+      def disabled?
+        not enabled?
+      end
+      
+      def include_platform_specifics_for(platform)
+        if platform[:platform] == :watir_webdriver
+          require 'fluent/platform_watir/platform_web_elements/web_element'
+          self.class.send :include, ::Fluent::Platforms::WatirWebDriver::WebElement
+        end
+      end
+      
+    end
+  end
+end

data/spec/fluent_spec.rb

@@ -0,0 +1,9 @@
+require 'spec_helper'
+
+describe Fluent do
+  
+  it 'should return version information' do
+    Fluent.version.should == "Fluent v#{Fluent::VERSION}"
+  end
+  
+end

data/spec/generators/button_generators_spec.rb

@@ -0,0 +1,77 @@
+require_relative '../spec_helper'
+
+class ButtonGenerators
+  include Fluent
+
+  button :submit, id: 'submit'
+end
+
+describe Fluent::Generators do
+  let(:watir_browser)    { mock_browser_for_watir }
+  let(:watir_definition) { ButtonGenerators.new(watir_browser) }
+
+  describe 'button generators' do
+    context 'when declared on a page definition' do
+      it 'should generate methods for referencing the button' do
+        watir_definition.should respond_to(:submit_object)
+        watir_definition.should respond_to(:submit_element)
+        watir_definition.should respond_to(:submit_button)
+      end
+
+      it 'should generate methods for interacting with the button' do
+        watir_definition.should respond_to(:submit)
+        watir_definition.should respond_to(:submit_exists?)
+        watir_definition.should respond_to(:submit_visible?)
+        watir_definition.should respond_to(:submit_enabled?)
+        watir_definition.should respond_to(:submit?)
+        watir_definition.should respond_to(:submit_?)
+        watir_definition.should respond_to(:submit!)
+        watir_definition.should respond_to(:submit_button_exists?)
+        watir_definition.should respond_to(:submit_button_visible?)
+        watir_definition.should respond_to(:submit_button_enabled?)
+        watir_definition.should respond_to(:submit_button?)
+        watir_definition.should respond_to(:submit_button_?)
+        watir_definition.should respond_to(:submit_button!)
+      end
+    end
+
+    context 'when used by the watir platform' do
+      it 'should locate the button' do
+        watir_browser.should_receive(:button).and_return(watir_browser)
+        web_element = watir_definition.submit_object
+        web_element.should_not be_nil
+        web_element.should be_instance_of Fluent::WebElements::Button
+      end
+
+      it 'should click the button' do
+        watir_browser.should_receive(:button).and_return(watir_browser)
+        watir_browser.should_receive(:click)
+        watir_definition.submit
+      end
+
+      it 'should determine if a button exists' do
+        watir_browser.should_receive(:button).exactly(3).times.and_return(watir_browser)
+        watir_browser.should_receive(:exists?).exactly(3).times.and_return(watir_browser)
+        watir_definition.submit?.should be_true
+        watir_definition.submit_exists?.should be_true
+        watir_definition.submit_button_exists?.should be_true
+      end
+
+      it 'should determine if a button is visible' do
+        watir_browser.should_receive(:button).exactly(3).times.and_return(watir_browser)
+        watir_browser.should_receive(:present?).exactly(3).times.and_return(watir_browser)
+        watir_definition.submit_?.should be_true
+        watir_definition.submit_visible?.should be_true
+        watir_definition.submit_button_visible?.should be_true
+      end
+
+      it 'should determine if a button is enabled' do
+        watir_browser.should_receive(:button).exactly(3).times.and_return(watir_browser)
+        watir_browser.should_receive(:enabled?).exactly(3).times.and_return(watir_browser)
+        watir_definition.submit!.should be_true
+        watir_definition.submit_enabled?.should be_true
+        watir_definition.submit_button_enabled?.should be_true
+      end
+    end
+  end
+end