domkey 0.2.0 → 0.3.0

data/lib/domkey/view/page_object_collection.rb

@@ -18,7 +18,7 @@ module Domkey
     # TODO Example:
     class PageObjectCollection
 
-      include WidgetryPackage
+      include Widgetry::Package
       include Enumerable
 
       # @return [PageObject, Hash{Symbol => PageObjectCollection}]

data/lib/domkey/view/radio_group.rb

@@ -1,69 +1,20 @@
-require 'domkey/view/labeled_group'
+require 'domkey/view/option_selectable_group'
+
 module Domkey
 
   module View
 
     # RadioGroup allows you to interact with PageObjectCollection of radios as a single PageObject
-    # Radios collection is constrained by the same name attribute and behaves like one object.
-    # It behaves like a single Select list.
-    # When one radio is selected in the collection the others become unselected.
-    class RadioGroup < PageObjectCollection
-
-      # @param [String] match text in value attribute and set that radio
-      def set value
-        validate_scope
-        return unless value
-        [*value].each do |v|
-          e = case v
-              when String
-                element.find { |e| e.value == v }
-              when Regexp
-                element.find { |e| e.value.match(v) }
-              end
-          e ? e.set : fail(Exception::Error, "RadioGroup value not found: #{v.inspect}")
-        end
-      end
-
-      # @return [String] text in value attribute of currently set
-      def value
-        validate_scope
-        element.find_all { |r| r.set? }.map { |e| e.value }
-      end
-
-      def options
-        validate_scope
-        element.map { |e| e.value }
-      end
-
-      # convert to LabeledGroup settable by corresponding label text
-      def to_labeled
-        LabeledGroup.new(self)
-      end
-
-      # @yield [PageObject]
-      def each(&blk)
-        validate_scope
-        super(&blk)
-      end
-
-      # @return [Array<PageObject>]
-      def to_a
-        validate_scope
-        super
-      end
+    # Acts like OptionSelectable
+    # Radios collection is constrained by the same name attribute
+    # Behaves like a single Select list.
+    # It has one radio selected at all times
+    class RadioGroup < OptionSelectableGroup
 
       private
 
-      # precondition on acting on this collection
-      # @return [true] when all radios in collection share the same name attribute
-      # @raise [Exception::Error] when where is more than one unique name attribute
-      # --
-      # returns true on subsequent unless magically more radios show up after initial validation
-      def validate_scope
-        return if @validated
-        groups = element.map { |e| e.name }.uniq
-        fail(Exception::Error, "RadioGroup definition scope too broad: Found #{groups.count} radio groups with names: #{groups}") unless (groups.size == 1)
-        @validated = true
+      def before_set
+        validate_scope
       end
     end
   end

data/lib/domkey/view/select_list.rb

@@ -0,0 +1,67 @@
+require 'domkey/view/option_selectable'
+
+module Domkey
+  module View
+
+    class SelectList < PageObject
+
+      include OptionSelectable
+
+      def set_by_string value
+        element.select value
+      end
+
+      def set_by_regexp value
+        element.select value
+      end
+
+      def set_by_index value
+        case value
+        when Fixnum
+          element.options[value].select
+        when Array
+          value.each do |i|
+            element.options[i].select
+          end
+        end
+      end
+
+      def set_by_value value
+        case value
+        when String
+          element.select_value value
+        when Array
+          value.each { |v| element.select_value v }
+        end
+      end
+
+      def value_by_options opts
+        element.selected_options.map do |o|
+          Hash[opts.map { |opt| [opt, o.send(opt)] }]
+        end
+      end
+
+      def value_by_default
+        element.selected_options.map { |e| e.text }
+      end
+
+      # iffy
+      def options
+        element.options.map do |o|
+          {text:  o.text,
+           value: o.value,
+           index: o.index}
+        end
+      end
+
+
+      private
+
+      def before_set
+        element.clear if element.multiple?
+      end
+
+
+    end
+  end
+end

data/lib/domkey/view/widgetry/dispatcher.rb

@@ -0,0 +1,51 @@
+module Domkey
+  module View
+    module Widgetry
+
+      # Dispatcher chooser for a given Element
+      # @param object [Element] thing that needs to be interacted with, i.e. Watir::Select, Watir::CheckBox, Selenium::Element etc...
+      # @return [Widgetry::Dispatcher] (or subclass of) that handles the strategy for interacting with the element
+      def self.dispatcher(object)
+        object_class_name = object.class.name.split('::').last
+        if const_defined? object_class_name.to_sym
+          const_get("#{self}::#{object_class_name}").new(object)
+        else
+          Dispatcher.new(object)
+        end
+      end
+
+      # Widgetry::Dispatcher is a communication object responsible for
+      # receiving and transmitting messages to PageObject Element.
+      # Client should subclass and provide desired interaction strategy that may differ from provided by default
+      class Dispatcher < SimpleDelegator
+
+        # @param [Element] thing that needs to be set i.e. Watir::Select, Watir::CheckBox etc...
+        def initialize(object)
+          __setobj__(object)
+        end
+
+        # @return [Element] subclasses use this to interact with original Elment wrapped by Dispacher
+        def original
+          __getobj__
+        end
+
+        # @return [Array<Option>] defaults to [] if original.options.empty?
+        def options
+          o = original.options
+          o.count == 0 ? [] : o
+        end
+
+      end
+
+      class Radio < Dispatcher
+
+        # because radio.set does not take args
+        def set value
+          original.set
+        end
+      end
+
+
+    end
+  end
+end

data/lib/domkey/view/widgetry/package.rb

@@ -0,0 +1,49 @@
+module Domkey
+  module View
+    module Widgetry
+
+      module Package
+
+        attr_accessor :package, :container
+
+        # initialize PageObject or PageObjectCollection
+        # for PageObject expects WebdriverElement a single element definition i.e text_field, checkbox
+        # for PageObjectCollection expects WebdriverElement a collection definition i.e. text_fields, checkboxes
+        # @param package [Proc(WebdriverElement)]
+        # @param package [PageObject]
+        # @param package [Hash{Symbol => Proc(WebdriverElement)]
+        # @param package [Hash{Symbol => PageObject]
+        def initialize package, container=lambda { Domkey.browser }
+          @container = container
+          @package   = initialize_this package
+        end
+
+        # access widgetry of watir elements composing this page object
+        # @param [Symbol] (false)
+        # @return [Hash{Symbol => WebdriverElement}]
+        # @return [Element] raw element, i.e. Watir::Select, Watir::CheckBox (not wrapped with Dispatcher strategy)
+        def element(key=false)
+          return instantiator unless package.respond_to?(:each_pair)
+          return package.fetch(key).element if key
+          Hash[package.map { |key, package| [key, package.element] }]
+        end
+
+        private
+
+        # talks to the browser
+        # returns runtime element in a specified container
+        # @return [WebdriverElement]
+        def instantiator
+          container_instantiator.instance_exec(&package)
+        end
+
+        # talks to the browser
+        # returns runtime container element in a browser/driver
+        # @return [WebdriverElement]
+        def container_instantiator
+          container.respond_to?(:call) ? container.call : container.send(:instantiator)
+        end
+      end
+    end
+  end
+end

data/spec/checkbox_group_spec.rb

@@ -39,16 +39,20 @@ describe Domkey::View::CheckboxGroup do
 
     it 'initial value on test page' do
       @v.group.value.should eql ['other']
+      @v.group.value(:value, :index, :label).should eql [value: 'other', index: 2, label: 'Other']
     end
 
-    it 'set value attribute by default. value returns array of value attribute' do
+    it 'set string' do
       @v.group.set 'tomato'
       @v.group.value.should eql ['tomato']
+    end
+
+    it 'set regexp' do
       @v.group.set /^othe/
       @v.group.value.should eql ['other']
     end
 
-    it 'set array of value attribute. value returns array of value attribute' do
+    it 'set array of strings or regexp' do
       @v.group.set ['tomato']
       @v.group.value.should eql ['tomato']
 
@@ -56,12 +60,12 @@ describe Domkey::View::CheckboxGroup do
       @v.group.value.should eql ['tomato', 'other']
     end
 
-    it 'set false clears all. value is empty array' do
+    it 'set false clears all' do
       @v.group.set false
       @v.group.value.should eql []
     end
 
-    it 'set empty array clears all. value is empty array' do
+    it 'set empty array clears all' do
       @v.group.set []
       @v.group.value.should eql []
     end
@@ -74,8 +78,80 @@ describe Domkey::View::CheckboxGroup do
       expect { @v.group.set /balaba/ }.to raise_error
     end
 
-    it 'options' do
+    it 'set by index single' do
+      @v.group.set index: 1
+      @v.group.value.should eql ['tomato']
+    end
+
+    it 'set by index array' do
+      @v.group.set index: [0, 2, 1]
+      @v.group.value.should eql ['cucumber', 'tomato', 'other']
+    end
+
+    it 'set by label string' do
+      @v.group.set label: 'Tomatorama'
+      @v.group.value.should eql ['tomato']
+    end
+
+    it 'set by label regexp' do
+      @v.group.set label: /umberama/
+      @v.group.value([:index, :value, :text, :label]).should eql [{:index=>0, :value=>"cucumber", :text=>"Cucumberama", :label=>"Cucumberama"}]
+    end
+
+
+    it 'set by index array string, regex' do
+      @v.group.set label: ['Cucumberama', /atorama/]
+      @v.group.value.should eql ['cucumber', 'tomato']
+    end
+
+
+    it 'value options single selected' do
+      @v.group.set [/tomat/]
+      @v.group.value.should eql ['tomato']
+
+      @v.group.value(:label).should eql [{:label=>"Tomatorama"}]
+      @v.group.value([:label]).should eql [{:label=>"Tomatorama"}]
+      @v.group.value(:label, :value, :index).should eql [{:label=>"Tomatorama", :value=>"tomato", :index=>1}]
+    end
+
+    it 'value options many selected' do
+      @v.group.set ['other', /tomat/, /cucum/]
+      @v.group.value.should eql ['cucumber', 'tomato', 'other']
+
+      @v.group.value(:label).should eql [{:label=>"Cucumberama"}, {:label=>"Tomatorama"}, {:label=>"Other"}]
+      @v.group.value(:label, :index, :value).should eql [{:label=>"Cucumberama", :index=>0, :value=>"cucumber"},
+                                                         {:label=>"Tomatorama", :index=>1, :value=>"tomato"},
+                                                         {:label=>"Other", :index=>2, :value=>"other"}]
+    end
+
+    it 'value options none selected' do
+      @v.group.set []
+      @v.group.value.should eql []
+      @v.group.value(:label).should eql []
+      @v.group.value(:label, :index, :value).should eql []
+    end
+
+    it 'options by default' do
       @v.group.options.should eql ["cucumber", "tomato", "other"]
     end
+
+    it 'options by opts single' do
+      @v.group.options(:value).should eql [{:value=>"cucumber"}, {:value=>"tomato"}, {:value=>"other"}]
+      @v.group.options([:value]).should eql [{:value=>"cucumber"}, {:value=>"tomato"}, {:value=>"other"}]
+    end
+
+    it 'options by label' do
+      @v.group.options(:label).should eql [{:label=>"Cucumberama"}, {:label=>"Tomatorama"}, {:label=>"Other"}]
+      @v.group.options([:label]).should eql [{:label=>"Cucumberama"}, {:label=>"Tomatorama"}, {:label=>"Other"}]
+    end
+
+    it 'options by opts many' do
+      expected = [{:value=>"cucumber", :index=>0, :label=>"Cucumberama", :text=>"Cucumberama"},
+                  {:value=>"tomato", :index=>1, :label=>"Tomatorama", :text=>"Tomatorama"},
+                  {:value=>"other", :index=>2, :label=>"Other", :text=>"Other"}]
+
+      @v.group.options(:value, :index, :label, :text).should eql expected
+      @v.group.options([:value, :index, :label, :text]).should eql expected
+    end
   end
 end

data/spec/option_selectable_spec.rb

@@ -0,0 +1,57 @@
+require 'spec_helper'
+
+describe Domkey::View::OptionSelectable do
+
+  class OptionSelectableFaker
+    include Domkey::View::OptionSelectable
+  end
+
+  before :all do
+    @widget = OptionSelectableFaker.new
+  end
+
+  it 'set string' do
+    expect { @widget.set('fake') }.to raise_error(Domkey::Exception::NotImplementedError)
+  end
+
+  it 'set regex' do
+    expect { @widget.set(/fake/) }.to raise_error(Domkey::Exception::NotImplementedError)
+  end
+
+  it 'set :label' do
+    expect { @widget.set(:label => 'fake') }.to raise_error(Domkey::Exception::NotImplementedError)
+  end
+
+  it 'set :text' do
+    expect { @widget.set(:text => 'fake') }.to raise_error(Domkey::Exception::NotImplementedError)
+  end
+
+  it 'set :index' do
+    expect { @widget.set(:index => 3) }.to raise_error(Domkey::Exception::NotImplementedError)
+  end
+
+  it 'set :value' do
+    expect { @widget.set(:value => 'fake') }.to raise_error(Domkey::Exception::NotImplementedError)
+  end
+
+  it 'value default' do
+    expect { @widget.value }.to raise_error(Domkey::Exception::NotImplementedError)
+  end
+
+  it 'value option' do
+    expect { @widget.value(:foo) }.to raise_error(Domkey::Exception::NotImplementedError)
+  end
+
+  it 'options default' do
+    expect { @widget.options }.to raise_error(Domkey::Exception::NotImplementedError)
+  end
+
+  it 'options opt' do
+    expect { @widget.options(:foo) }.to raise_error(Domkey::Exception::NotImplementedError)
+  end
+
+end
+
+
+
+

data/spec/radio_group_spec.rb

@@ -41,11 +41,19 @@ describe Domkey::View::RadioGroup do
 
     it 'initial value on test page' do
       @v.group.value.should eql ['other']
+      @v.group.value(:index, :value, :label, :text).should eql [{:index=>2, :value=>"other", :label=>"Other", :text=>"Other"}]
+      @v.group.value([:index, :value, :label, :text]).should eql [{:index=>2, :value=>"other", :label=>"Other", :text=>"Other"}]
+      @v.group.value([:index]).should eql [{:index=>2}]
+      @v.group.value([:value]).should eql [{:value=>'other'}]
     end
 
-    it 'set value attribute by default. value returns that value attribute' do
+    it 'set string' do
       @v.group.set 'tomato'
       @v.group.value.should eql ['tomato']
+      @v.group.value(:value).should eql [{value: 'tomato'}]
+    end
+
+    it 'set regexp' do
       @v.group.set /^oth/
       @v.group.value.should eql ['other']
     end
@@ -56,14 +64,15 @@ describe Domkey::View::RadioGroup do
 
       @v.group.set ['other', 'tomato', /cucu/]
       @v.group.value.should eql ['cucumber']
+      @v.group.value([:index, :label]).should eql [{:index=>0, :label=>"Cucumber"}]
     end
 
-    it 'set false has no effect. value is initial value on the page' do
+    it 'set false has no effect' do
       @v.group.set false
       @v.group.value.should eql ['other']
     end
 
-    it 'set empty array clears all. value is empty array' do
+    it 'set empty array has no effect' do
       @v.group.set []
       @v.group.value.should eql ['other']
     end
@@ -76,10 +85,59 @@ describe Domkey::View::RadioGroup do
       expect { @v.group.set /balaba/ }.to raise_error
     end
 
-    it 'options' do
+
+    it 'set by index single' do
+      @v.group.set index: 1
+      @v.group.value.should eql ['tomato']
+    end
+
+    it 'set by index array' do
+      @v.group.set index: [0, 2, 1]
+      @v.group.value.should eql ['tomato']
+    end
+
+    it 'set by label string' do
+      @v.group.set label: 'Tomato'
+      @v.group.value.should eql ['tomato']
+      @v.group.value(:text).should eql [{text: 'Tomato'}]
+    end
+
+    it 'set by label regexp' do
+      @v.group.set label: /umber/
+      @v.group.value.should eql ['cucumber']
+    end
+
+
+    it 'set by index array string, regex' do
+      @v.group.set label: ['Cucumber', /mato/]
+      @v.group.value.should eql ['tomato']
+    end
+
+    it 'options by default' do
       @v.group.options.should eql ["cucumber", "tomato", "other"]
     end
 
+    it 'options by opts single' do
+      @v.group.options(:value).should eql [{:value=>"cucumber"}, {:value=>"tomato"}, {:value=>"other"}]
+      @v.group.options([:value]).should eql [{:value=>"cucumber"}, {:value=>"tomato"}, {:value=>"other"}]
+    end
+
+    it 'options by label' do
+      expected = [{:label=>"Cucumber"}, {:label=>"Tomato"}, {:label=>"Other"}]
+      @v.group.options(:label).should eql expected
+      @v.group.options([:label]).should eql expected
+    end
+
+    it 'options by opts many' do
+      expected = [{:value=>"cucumber", :index=>0, :label=>"Cucumber", :text=>"Cucumber"},
+                  {:value=>"tomato", :index=>1, :label=>"Tomato", :text=>"Tomato"},
+                  {:value=>"other", :index=>2, :label=>"Other", :text=>"Other"}]
+
+      @v.group.options(:value, :index, :label, :text).should eql expected
+      @v.group.options([:value, :index, :label, :text]).should eql expected
+    end
+
+
   end
 
 end