watirsome 0.1.0

data/lib/watirsome.rb

@@ -0,0 +1,155 @@
+module Watirsome
+  class << self
+
+    # @attr [Regexp] region_matcher
+    attr_accessor :region_matcher
+
+    # @attr [Array<Symbol>] readable
+    attr_accessor :readable
+
+    # @attr [Array<Symbol>] clickable
+    attr_accessor :clickable
+
+    # @attr [Array<Symbol>] settable
+    attr_accessor :settable
+
+    # @attr [Array<Symbol>] selectable
+    attr_accessor :selectable
+
+    #
+    # Returns regular expression for region module names.
+    # @return [Regexp]
+    #
+    def region_matcher
+      @region_matcher ||= /^.+(Region)$/
+    end
+
+    #
+    # Returns array of readable elements.
+    # @return [Array<Symbol>]
+    #
+    def readable
+      @readable ||= [:div, :span, :p, :h1, :h2, :h3, :h4, :h5, :h6, :select_list, :text_field, :textarea]
+    end
+
+    #
+    # Returns array of clickable elements.
+    # @return [Array<Symbol>]
+    #
+    def clickable
+      @clickable ||= [:a, :link, :button]
+    end
+
+    #
+    # Returns array of settable elements.
+    # @return [Array<Symbol>]
+    #
+    def settable
+      @settable ||= [:text_field, :file_field, :textarea, :checkbox]
+    end
+
+    #
+    # Returns array of selectable elements.
+    # @return [Array<Symbol>]
+    #
+    def selectable
+      @selectable ||= [:select_list]
+    end
+
+    #
+    # Returns true if tag can have click accessor.
+    #
+    # @param [Symbol, String] method
+    # @return [Boolean]
+    #
+    def clickable?(tag)
+      clickable.include? tag.to_sym
+    end
+
+    #
+    # Returns true if tag can have set accessor.
+    #
+    # @param [Symbol, String] method
+    # @return [Boolean]
+    #
+    def settable?(tag)
+      settable.include? tag.to_sym
+    end
+
+    #
+    # Returns true if tag can have select accessor.
+    #
+    # @param [Symbol, String] method
+    # @return [Boolean]
+    #
+    def selectable?(tag)
+      selectable.include? tag.to_sym
+    end
+
+    #
+    # Returns true if tag can have text accessor.
+    #
+    # @param [Symbol, String] method
+    # @return [Boolean]
+    #
+    def readable?(tag)
+      readable.include? tag.to_sym
+    end
+
+    #
+    # Returns array of Watir element methods.
+    # @return [Array<Sybmol>]
+    #
+    def watir_methods
+      unless @watir_methods
+        @watir_methods = Watir::Container.instance_methods
+        @watir_methods.delete(:extract_selector)
+      end
+
+      @watir_methods
+    end
+
+    #
+    # Return true if method can be proxied to Watir, false otherwise.
+    #
+    # @param [Symbol] method
+    # @return [Boolean]
+    #
+    def watirsome?(method)
+      Watirsome.watir_methods.include? method.to_sym
+    end
+
+    #
+    # Returns true if method is element accessor in plural form.
+    #
+    # @example
+    #   Watirsome::Accessors.plural? :div   #=> false
+    #   Watirsome::Accessors.plural? :divs  #=> true
+    #
+    # @param [Symbol, String] method
+    # @return [Boolean]
+    # @api private
+    #
+    def plural?(method)
+      str = method.to_s
+      sym = method.to_sym
+      sgl = str.sub(/s$/, '').to_sym
+
+      /s$/ === str && Watirsome.watir_methods.include?(sym) && Watirsome.watir_methods.include?(sgl)
+    end
+
+  end # self
+
+  
+  def self.included(kls)
+    kls.extend         Watirsome::Accessors::ClassMethods
+    kls.send :include, Watirsome::Accessors::InstanceMethods
+    kls.send :include, Watirsome::Initializers
+  end
+
+end # Watirsome
+
+
+require 'watir-webdriver'
+require 'watirsome/accessors'
+require 'watirsome/initializers'

data/spec/lib/watirsome/accessors_spec.rb

@@ -0,0 +1,12 @@
+require 'spec_helper'
+
+describe Watirsome::Accessors do
+  include_context :page
+  include_context :element
+  
+  it_defines :element_accessor, %w(div a text_field select_list)
+  it_defines :read_accessor,    %w(div text_field select_list)
+  it_defines :click_accessor,   %w(a)
+  it_defines :set_accessor,     %w(text_field)
+  it_defines :select_accessor,  %w(select_list)
+end

data/spec/lib/watirsome/initializers_spec.rb

@@ -0,0 +1,47 @@
+require 'spec_helper'
+
+describe Watirsome::Initializers do
+  include_context :page
+
+  describe '#initialze' do
+    it 'does not initalize page if there is no constructor defined' do
+      page = Page.dup
+      page.class_eval { remove_method :initialize_page }
+      page.should_not_receive :initialize_page
+      page.new(watir)
+    end
+
+    it 'initializes page if there is constructor defined' do
+      page.instance_variable_get(:@initialized).should == true
+    end
+    
+    it 'initalizes regions' do
+      Page.any_instance.should_receive :initialize_regions
+      Page.new(watir)
+    end
+  end
+  
+  describe '#initialize_regions' do
+    it 'initalizes included regions' do
+      page.instance_variable_get(:@included_initialized).should == 1
+    end
+    
+    it 'initalizes extended regions' do
+      page.instance_variable_get(:@extended_initialized).should == 1
+    end
+    
+    it 'does not initalize modules with incorrect name' do
+      page.instance_variable_get(:@helper_initialized).should == nil
+    end
+    
+    it 'uses Watirsome.region_matcher to match module name' do
+      Watirsome.should_receive(:region_matcher).and_return ''
+      page
+    end
+    
+    it 'caches initalized regions' do
+      page.initialize_regions
+      page.instance_variable_get(:@included_initialized).should == 1
+    end
+  end
+end

data/spec/lib/watirsome_spec.rb

@@ -0,0 +1,98 @@
+require 'spec_helper'
+
+describe Watirsome do
+  describe '.region_matcher' do
+    it 'returns region matcher regexp' do
+      described_class.region_matcher.should be_a(Regexp)
+    end
+  end
+  
+  %w(readable clickable settable selectable).each do |method|
+    describe ".#{method}" do
+      it 'returns array of accessors' do
+        accessors = described_class.send(method)
+        accessors.should be_an(Array)
+        accessors.each do |accessor|
+          accessor.should be_a(Symbol)
+        end
+      end
+
+      it 'allows to add custom accessors' do
+        described_class.send(method) << :custom
+        described_class.send(method).should include(:custom)
+      end
+    end
+
+    describe ".#{method}?" do
+      let(:tag) do
+        case method
+        when 'readable'   then :div
+        when 'clickable'  then :button
+        when 'settable'   then :text_field
+        when 'selectable' then :select_list
+        end
+      end
+
+      it "returns true if element is #{method}" do
+        described_class.send(:"#{method}?", tag).should == true
+      end
+
+      it "returns false if element is not #{method}" do
+        described_class.send(:"#{method}?", :foo).should == false
+      end
+    end
+  end
+
+  
+  describe '.watir_methods' do
+    it 'returns array of watir container methods' do
+      described_class.watir_methods.each do |method|
+        Watir::Container.instance_methods.should include(method)
+      end
+    end
+  end
+
+  describe '.watirsome?' do
+    it 'returns true if method is watir-contained' do
+      described_class.watirsome?(:div).should == true
+    end
+
+    it 'returns false if method is not watir-contained' do
+      described_class.watirsome?(:foo).should == false
+    end
+  end
+
+  describe '.plural?' do
+    it 'returns true if watir-contained method is plural' do
+      described_class.plural?(:divs).should == true
+    end
+
+    it 'returns false if watir-contained method is singular' do
+      described_class.plural?(:div).should == false
+    end
+
+    it 'returns false if method is not watir-contained' do
+      described_class.plural?(:foo).should == false
+    end
+  end
+  
+  context 'when included' do
+    include_context :page
+
+    it 'adds accessor class methods' do
+      page.class.should respond_to(:div)
+    end
+
+    it 'does not add #extract_selector' do
+      page.class.should_not respond_to(:extract_selector)
+    end
+
+    it 'adds accessor instance methods' do
+      page.private_methods.should include(:grab_elements)
+    end
+
+    it 'adds regions initializer' do
+      page.should respond_to(:initialize_regions)
+    end
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,31 @@
+require 'simplecov'
+require 'coveralls'
+
+SimpleCov.formatter = SimpleCov::Formatter::MultiFormatter[
+  SimpleCov::Formatter::HTMLFormatter,
+  Coveralls::SimpleCov::Formatter
+]
+SimpleCov.start do
+  add_filter "/spec/" 
+  add_filter "/vendor/" 
+end
+
+require 'watir-webdriver'
+require 'watirsome'
+
+Dir['spec/support/**/*.rb'].each do |file|
+  require file.sub(/spec\//, '')
+end
+
+RSpec.configure do |spec|
+  spec.alias_it_should_behave_like_to :it_defines, 'it defines'
+  
+  shared_context :page do
+    let(:watir) { stub('watir')    }
+    let(:page)  { Page.new(watir)  }
+  end
+  
+  shared_context :element do
+    let(:element) { stub('element', visible?: true) }
+  end
+end

data/spec/support/page.rb

@@ -0,0 +1,49 @@
+module IncludedRegion
+  def initialize_region
+    @included_initialized ||= 0
+    @included_initialized += 1
+  end
+end # IncludedRegion
+
+
+module ExtendedRegion
+  def initialize_region
+    @extended_initialized = 1
+  end
+end # ExtendedRegion
+
+
+module Helper
+  def initialize_region
+    @helper_initialized = 1
+  end
+end # Helper
+
+
+class Page
+  include Watirsome
+  include IncludedRegion
+  include Helper
+
+  def initialize_page
+    extend ExtendedRegion
+    @initialized = true
+  end
+
+  %w(div a text_field select_list).each do |tag|
+    send tag, :"#{tag}1"
+    send tag, :"#{tag}2", id: tag
+    send tag, :"#{tag}3", id: tag, class: /#{tag}/
+    send tag, :"#{tag}4", id: tag, class: tag, visible: true
+    send tag, :"#{tag}5", proc { @browser.send(tag, id: tag) }
+    send tag, :"#{tag}6", -> { @browser.send(tag, id: tag) }
+    # set/select accessor cannot have block arguments
+    case tag
+    when 'div', 'a'
+      send(tag, :"#{tag}7") { |id| @browser.send(tag, id: id) }    
+    when 'text_field', 'select_list'
+      send(tag, :"#{tag}7") { @browser.send(tag, id: tag) }    
+    end
+  end
+
+end # Page

data/spec/support/shared_examples/click_accessor.rb

@@ -0,0 +1,52 @@
+shared_examples_for :click_accessor do |tags|
+  tags.each do |tag|
+    context tag do 
+      def accessor(tag, index, *args)
+        page.send :"#{tag}#{index}", *args
+      end
+
+      it 'clicks element with no locators' do
+        watir.should_receive(tag).with(no_args).and_return(element)
+        element.should_receive(:click).with(any_args)
+        accessor(tag, 1)
+      end
+
+      it 'clicks element with single watir locator' do
+        watir.should_receive(tag).with(id: tag).and_return(element)
+        element.should_receive(:click).with(any_args)
+        accessor(tag, 2)
+      end
+
+      it 'clicks element with multiple watir locator' do
+        watir.should_receive(tag).with(id: tag, class: /#{tag}/).and_return(element)
+        element.should_receive(:click).with(any_args)
+        accessor(tag, 3)
+      end
+
+      it 'clicks element with custom locator' do
+        element2 = stub('element', visible?: false)
+        watir.should_receive(:"#{tag}s").with(id: tag, class: tag).and_return([element, element2])
+        element.should_receive(:click).with(any_args)
+        accessor(tag, 4)
+      end
+
+      it 'clicks element with proc' do
+        watir.should_receive(tag).with(id: tag).and_return(element)
+        element.should_receive(:click).with(any_args)
+        accessor(tag, 5)
+      end
+
+      it 'clicks element with lambda' do
+        watir.should_receive(tag).with(id: tag).and_return(element)
+        element.should_receive(:click).with(any_args)
+        accessor(tag, 6)
+      end
+
+      it 'clicks element with block and custom arguments' do
+        watir.should_receive(tag).with(id: tag).and_return(element)
+        element.should_receive(:click).with(any_args)
+        accessor(tag, 7, tag)
+      end
+    end
+  end
+end

data/spec/support/shared_examples/element_accessor.rb

@@ -0,0 +1,47 @@
+shared_examples_for :element_accessor do |tags|
+  tags.each do |tag|
+    context tag do 
+      def accessor(tag, index, *args)
+        page.send :"#{tag}#{index}_#{tag}", *args
+      end
+
+      it 'finds element with no locators' do
+        watir.should_receive(tag).with(no_args).and_return(element)
+        accessor(tag, 1).should == element
+      end
+
+      it 'finds element with single watir locator' do
+        watir.should_receive(tag).with(id: tag).and_return(element)
+        accessor(tag, 2).should == element
+      end
+
+      it 'finds element with multiple watir locator' do
+        watir.should_receive(tag).with(id: tag, class: /#{tag}/).and_return(element)
+        accessor(tag, 3).should == element
+      end
+
+      it 'finds element with custom locator' do
+        element2 = stub('element')
+        watir.should_receive(:"#{tag}s").with(id: tag, class: tag).and_return([element, element2])
+        element.should_receive(:visible?).with(no_args).and_return(true)
+        element2.should_receive(:visible?).with(no_args).and_return(false)
+        accessor(tag, 4).should == element
+      end
+
+      it 'finds element with proc' do
+        watir.should_receive(tag).with(id: tag).and_return(element)
+        accessor(tag, 5).should == element
+      end
+
+      it 'finds element with lambda' do
+        watir.should_receive(tag).with(id: tag).and_return(element)
+        accessor(tag, 6).should == element
+      end
+
+      it 'finds element with block and custom arguments' do
+        watir.should_receive(tag).with(id: tag).and_return(element)
+        accessor(tag, 7, tag).should == element
+      end
+    end
+  end
+end

data/spec/support/shared_examples/read_accessor.rb

@@ -0,0 +1,67 @@
+shared_examples_for :read_accessor do |tags|
+  tags.each do |tag|
+    context tag do 
+      def accessor(tag, index, *args)
+        page.send :"#{tag}#{index}", *args
+      end
+      
+      def read_expectation(tag)
+        case tag
+        when 'text_field'
+          element.should_receive(:value).and_return('text')  
+        when 'select_list'
+          option1 = stub('option1', selected?: true)
+          option2 = stub('option2', selected?: false)
+          element.should_receive(:options).and_return([option1, option2])
+          option1.should_receive(:text).and_return('text')
+          option2.should_not_receive(:text)
+        else
+          element.should_receive(:text).and_return('text')  
+        end
+      end
+
+      it 'gets text from element with no locators' do
+        watir.should_receive(tag).with(no_args).and_return(element)
+        read_expectation(tag)
+        accessor(tag, 1).should == 'text'
+      end
+
+      it 'gets text from element with single watir locator' do
+        watir.should_receive(tag).with(id: tag).and_return(element)
+        read_expectation(tag)
+        accessor(tag, 2).should == 'text'
+      end
+
+      it 'gets text from element with multiple watir locator' do
+        watir.should_receive(tag).with(id: tag, class: /#{tag}/).and_return(element)
+        read_expectation(tag)
+        accessor(tag, 3).should == 'text'
+      end
+
+      it 'gets text from element with custom locator' do
+        element2 = stub('element', visible?: false)
+        watir.should_receive(:"#{tag}s").with(id: tag, class: tag).and_return([element, element2])
+        read_expectation(tag)
+        accessor(tag, 4).should == 'text'
+      end
+
+      it 'gets text from element with proc' do
+        watir.should_receive(tag).with(id: tag).and_return(element)
+        read_expectation(tag)
+        accessor(tag, 5).should == 'text'
+      end
+
+      it 'gets text from element with lambda' do
+        watir.should_receive(tag).with(id: tag).and_return(element)
+        read_expectation(tag)
+        accessor(tag, 6).should == 'text'
+      end
+
+      it 'gets text from element with block and custom arguments' do
+        watir.should_receive(tag).with(id: tag).and_return(element)
+        read_expectation(tag)
+        accessor(tag, 7, tag).should == 'text'
+      end
+    end
+  end
+end

data/spec/support/shared_examples/select_accessor.rb

@@ -0,0 +1,46 @@
+shared_examples_for :select_accessor do |tags|
+  tags.each do |tag|
+    context tag do 
+      def accessor(tag, index, *args)
+        page.send :"#{tag}#{index}=", *args
+      end
+
+      it 'selects option for element with no locators' do
+        watir.should_receive(tag).with(no_args).and_return(element)
+        element.should_receive(:select).with('value')
+        accessor(tag, 1, 'value')
+      end
+
+      it 'selects option for element with single watir locator' do
+        watir.should_receive(tag).with(id: tag).and_return(element)
+        element.should_receive(:select).with('value')
+        accessor(tag, 2, 'value')
+      end
+
+      it 'selects option for element with multiple watir locator' do
+        watir.should_receive(tag).with(id: tag, class: /#{tag}/).and_return(element)
+        element.should_receive(:select).with('value')
+        accessor(tag, 3, 'value')
+      end
+
+      it 'selects option for element with custom locator' do
+        element2 = stub('element', visible?: false)
+        watir.should_receive(:"#{tag}s").with(id: tag, class: tag).and_return([element, element2])
+        element.should_receive(:select).with('value')
+        accessor(tag, 4, 'value')
+      end
+
+      it 'selects option for element with proc' do
+        watir.should_receive(tag).with(id: tag).and_return(element)
+        element.should_receive(:select).with('value')
+        accessor(tag, 5, 'value')
+      end
+
+      it 'selects option for element with lambda' do
+        watir.should_receive(tag).with(id: tag).and_return(element)
+        element.should_receive(:select).with('value')
+        accessor(tag, 6, 'value')
+      end
+    end
+  end
+end

data/spec/support/shared_examples/set_accessor.rb

@@ -0,0 +1,53 @@
+shared_examples_for :set_accessor do |tags|
+  tags.each do |tag|
+    context tag do 
+      def accessor(tag, index, *args)
+        page.send :"#{tag}#{index}=", *args
+      end
+
+      it 'sets value on element with no locators' do
+        watir.should_receive(tag).with(no_args).and_return(element)
+        element.should_receive(:set).with('value')
+        accessor(tag, 1, 'value')
+      end
+
+      it 'sets value on element with single watir locator' do
+        watir.should_receive(tag).with(id: tag).and_return(element)
+        element.should_receive(:set).with('value')
+        accessor(tag, 2, 'value')
+      end
+
+      it 'sets value on element with multiple watir locator' do
+        watir.should_receive(tag).with(id: tag, class: /#{tag}/).and_return(element)
+        element.should_receive(:set).with('value')
+        accessor(tag, 3, 'value')
+      end
+
+      it 'sets value on element with custom locator' do
+        element2 = stub('element', visible?: false)
+        watir.should_receive(:"#{tag}s").with(id: tag, class: tag).and_return([element, element2])
+        element.should_receive(:set).with('value')
+        accessor(tag, 4, 'value')
+      end
+
+      it 'sets value on element with proc' do
+        watir.should_receive(tag).with(id: tag).and_return(element)
+        element.should_receive(:set).with('value')
+        accessor(tag, 5, 'value')
+      end
+
+      it 'sets value on element with lambda' do
+        watir.should_receive(tag).with(id: tag).and_return(element)
+        element.should_receive(:set).with('value')
+        accessor(tag, 6, 'value')
+      end
+      
+      it 'sends keys if element cannot be set' do
+        watir.should_receive(tag).with(no_args).and_return(element)
+        element.stub(:respond_to?).with(:set).and_return(false)
+        element.should_receive(:send_keys).with('value')
+        accessor(tag, 1, 'value')
+      end
+    end
+  end
+end

data/watirsome.gemspec

@@ -0,0 +1,26 @@
+$:.push File.expand_path('../lib', __FILE__)
+require 'watirsome/version'
+
+Gem::Specification.new do |s|
+  s.name        = 'watirsome'
+  s.version     = Watirsome::VERSION
+  s.platform    = Gem::Platform::RUBY
+  s.author      = 'Alex Rodionov'
+  s.email       = 'p0deje@gmail.com'
+  s.homepage    = 'http://github.com/p0deje/watirsome'
+  s.summary     = 'Awesome page objects with Watir'
+  s.description = 'Pure dynamic Watir-based page object DSL'
+
+  s.files         = `git ls-files`.split("\n")
+  s.test_files    = `git ls-files -- {test,spec,features}/*`.split("\n")
+  s.executables   = `git ls-files -- bin/*`.split("\n").map{ |f| File.basename(f) }
+  s.require_paths = %w(lib)
+
+  s.add_dependency 'watir-webdriver'
+
+  s.add_development_dependency 'rspec'
+  s.add_development_dependency 'rake'
+  s.add_development_dependency 'fuubar'
+  s.add_development_dependency 'simplecov'
+  s.add_development_dependency 'coveralls'
+end