domkey 0.1.0 → 0.2.0

data/spec/labeled_group_spec.rb

@@ -0,0 +1,118 @@
+require 'spec_helper'
+
+describe Domkey::View::LabeledGroup do
+
+  class LabeledGroupExampleView
+    include Domkey::View
+
+    def radio_group
+      RadioGroup.new -> { radios(name: 'tool') }
+    end
+
+    #labeled radio_group with tool: as semantic descriptor
+    def tool
+      LabeledGroup.new(radio_group)
+    end
+
+    def checkbox_group
+      CheckboxGroup.new -> { checkboxes(name: 'fruit') }
+    end
+
+    #labeled checkbox_group with fruit: as semantic descriptor
+    def fruit
+      LabeledGroup.new(checkbox_group)
+    end
+  end
+
+  let(:view) { LabeledGroupExampleView.new }
+
+  before :all do
+    goto_html("test.html")
+  end
+
+  context 'radio group' do
+
+    context 'wrapped directly' do
+
+      it 'set string' do
+        view.tool.set 'Tomato'
+        view.tool.value.should eql ['Tomato']
+      end
+
+      it 'set regex' do
+        view.tool.set /umber$/
+        view.tool.value.should eql ['Cucumber']
+      end
+
+      it 'set array' do
+        view.tool.set ['Tomato', 'Cucumber']
+        view.tool.value.should eql ['Cucumber']
+      end
+
+      it 'set array string and regex' do
+        view.tool.set ['Tomato', /cumber$/]
+        view.tool.value.should eql ['Cucumber']
+      end
+
+      it 'set value text not found should error' do
+        expect { view.tool.set 'yepyep' }.to raise_error
+      end
+
+      it 'set value regexp not found should error' do
+        expect { view.tool.set /fofofo/ }.to raise_error
+      end
+
+      it 'options' do
+        view.tool.options.should eql ["Cucumber", "Tomato", "Other"]
+      end
+
+    end
+
+    context 'to_labeled' do
+
+      it 'set string' do
+        view.tool.to_labeled.set 'Tomato'
+        view.tool.to_labeled.value.should eql ['Tomato']
+      end
+
+      it 'set array' do
+        view.tool.to_labeled.set ['Tomato', 'Cucumber']
+        view.tool.to_labeled.value.should eql ['Cucumber']
+      end
+
+    end
+  end
+
+  context 'checkbox group' do
+
+    context 'wrapped directly' do
+
+      it 'set single' do
+        view.fruit.set 'Tomatorama'
+        view.fruit.value.should eql ['Tomatorama']
+      end
+
+      it 'set array' do
+        view.fruit.set ['Tomatorama', 'Cucumberama']
+        view.fruit.value.should eql ['Cucumberama', 'Tomatorama']
+      end
+
+      it 'options' do
+        view.fruit.options.should eql ["Cucumberama", "Tomatorama", "Other"]
+      end
+    end
+
+    context 'to_labeled' do
+
+      it 'set single' do
+        view.fruit.to_labeled.set 'Tomatorama'
+        view.fruit.to_labeled.value.should eql ['Tomatorama']
+      end
+
+      it 'set array' do
+        view.fruit.to_labeled.set ['Tomatorama', 'Cucumberama']
+        view.fruit.to_labeled.value.should eql ['Cucumberama', 'Tomatorama']
+      end
+    end
+  end
+end

data/spec/page_object_collection_spec.rb

@@ -3,26 +3,26 @@ require 'spec_helper'
 describe Domkey::View::PageObjectCollection do
 
   before :all do
-    Domkey.browser.goto("file://" + __dir__ + "/html/test.html")
+    goto_html("test.html")
   end
 
   it 'init error' do
-    # TODO. tighter scope what can be a watirproc
+    # TODO. tighter scope what can be a package
     expect { Domkey::View::PageObjectCollection.new 'foo' }.to raise_error(Domkey::Exception::Error)
   end
 
   context 'when container is browser by default' do
 
-    context 'watirproc is watirproc defining collection' do
+    context 'package is package defining collection' do
 
       before :each do
-        # watirproc is definition of watir collection
-        # watirproc when instantiated must respond to :each
+        # package is definition of watir collection
+        # package when instantiated must respond to :each
         # test sample:
         # we have 3 text_fields with class that begins with street
-        watirproc = lambda { text_fields(class: /^street/) }
+        package = lambda { text_fields(class: /^street/) }
 
-        @cbs = Domkey::View::PageObjectCollection.new watirproc
+        @cbs = Domkey::View::PageObjectCollection.new package
       end
 
       it 'count or size' do
@@ -63,7 +63,7 @@ describe Domkey::View::PageObjectCollection do
 
     end
 
-    context 'watirproc is hash' do
+    context 'package is hash' do
 
       before :all do
         # would we do that? give me all text_fields :street and all text_fields :city ? in one collection?
@@ -74,10 +74,10 @@ describe Domkey::View::PageObjectCollection do
         Domkey.browser.text_fields(class: /^city/).count.should == 4
 
         # when I define my keyed collection
-        watirproc = {street: lambda { text_fields(class: /^street/) },
-                     city:   lambda { text_fields(class: /^city/) }}
+        package = {street: lambda { text_fields(class: /^street/) },
+                   city:   lambda { text_fields(class: /^city/) }}
 
-        @cbs = Domkey::View::PageObjectCollection.new watirproc
+        @cbs = Domkey::View::PageObjectCollection.new package
       end
 
       it 'count' do
@@ -115,11 +115,11 @@ describe Domkey::View::PageObjectCollection do
 
     end
 
-    context 'watirproc is pageobjectcollection' do
+    context 'package is pageobjectcollection' do
 
       it 'initialize' do
-        watirproc            = lambda { text_fields(class: /^street/) }
-        pageobjectcollection = Domkey::View::PageObjectCollection.new watirproc
+        package              = lambda { text_fields(class: /^street/) }
+        pageobjectcollection = Domkey::View::PageObjectCollection.new package
 
         @cbs = Domkey::View::PageObjectCollection.new pageobjectcollection
       end

data/spec/page_object_decorators_spec.rb

@@ -1,32 +1,29 @@
 require 'spec_helper'
 
-# domain specific page objects composed from regular page object
-# PageObject is a type of object that responds to set and value.
-# it is the Role it plays
-# DateSelector is a type of decoration for domain specific pageobject
-module Domkey
 
-  module View
+describe 'PageObject Decorators' do
 
-    #example of specialized domain specific pageobject.
-    # behavior of set and value
-    class DateSelectorPageObject < PageObject
+  # domain specific page objects composed from regular page object
+  # PageObject is a type of object that responds to set and value.
+  # it is the Role it plays
+  # DateSelector is a type of decoration for domain specific pageobject
 
-      def set value
-        watirproc.each_pair { |k, po| po.set(value.send(k)) }
-      end
 
-      def value
-        h = {}
-        watirproc.each_pair { |k, po| h[k] = po.value }
-        Date.parse "%s/%s/%s" % [h[:year], h[:month], h[:day]]
-      end
+  #example of specialized domain specific pageobject.
+  # behavior of set and value
+  class DateSelectorPageObject < Domkey::View::PageObject
+
+    def set value
+      package.each_pair { |k, po| po.set(value.send(k)) }
     end
-  end
-end
 
+    def value
+      h = {}
+      package.each_pair { |k, po| h[k] = po.value }
+      Date.parse "%s/%s/%s" % [h[:year], h[:month], h[:day]]
+    end
+  end
 
-module DomkeySpecHelper
 
   class CheckboxTextField
 
@@ -77,27 +74,23 @@ module DomkeySpecHelper
       h = pageobject.value
       Date.parse "%s/%s/%s" % [h[:year], h[:month], h[:day]]
     end
-
   end
 
-end
-
-describe 'PageObject Decorators' do
 
   before :all do
-    Domkey.browser.goto("file://" + __dir__ + "/html/test.html")
+    goto_html("test.html")
   end
 
   context 'DateSelector' do
 
-    it 'as pageobject component wrapped by decorator' do
+    it 'as pageobject component wrapped by composite' do
 
       watir_object = {day:   lambda { text_field(id: 'day_field') },
                       month: lambda { text_field(id: 'month_field') },
                       year:  lambda { text_field(id: 'year_field') }}
 
       foo = Domkey::View::PageObject.new watir_object
-      dmy = DomkeySpecHelper::DateSelector.new foo
+      dmy = DateSelector.new foo
 
       dmy.set Date.today
       dmy.value.should eql Date.today
@@ -110,7 +103,7 @@ describe 'PageObject Decorators' do
                       year:  lambda { text_field(id: 'year_field') }}
 
       #foo = Domkey::Page::PageObject.new watir_object, @container
-      dmy          = Domkey::View::DateSelectorPageObject.new watir_object
+      dmy          = DateSelectorPageObject.new watir_object
 
       dmy.set Date.today
       dmy.value.should eql Date.today
@@ -118,36 +111,32 @@ describe 'PageObject Decorators' do
 
   end
 
-
   context 'CheckboxTextField' do
 
+    it 'as pageobject component wrapped by composite' do
 
-    it 'as pageobject component wrapped by decorator' do
-
-      watir_object = {switch: lambda { checkbox(id: 'feature_checkbox1') },
-                      blurb:  lambda { text_field(id: 'feature_textarea1') }}
-
-      #pageobject as component
-      foo          = Domkey::View::PageObject.new watir_object
-
-      foo.set switch: true, blurb: 'I am a blurb'
-      foo.set switch: false
-      foo.set switch: true
+      pageobject = Domkey::View::PageObject.new switch: -> { checkbox(id: 'feature_checkbox1') },
+                                                blurb:  -> { textarea(id: 'feature_textarea1') }
 
-      # decorator add specific behavior to set and value methods
-      tbcf = DomkeySpecHelper::CheckboxTextField.new foo
+      # turn switch on and enter text in text area
+      pageobject.set switch: true, blurb: 'I am a blurb text after you turn on switch'
+      pageobject.set switch: false # => turn switch off, clear textarea blurb entry
+      pageobject.set switch: true # => turn switch on
 
-      tbcf.set true
-      tbcf.set false
-      tbcf.set 'hhkhkjhj'
+      # wrap with composite and handle specific behavior to set and value
+      cbtf = CheckboxTextField.new(pageobject)
 
+      cbtf.set true
+      cbtf.set false
+      cbtf.set 'Domain Specific Behavior to set value - check checkbox and enter text'
+      cbtf.value.should eql('Domain Specific Behavior to set value - check checkbox and enter text')
     end
 
     context 'building array of CheckboxTextFields in the view' do
 
       it 'algorithm from predictable pattern' do
 
-        #given predictable pattern that singals the presence of pageobjects
+        #given predictable pattern that signals the presence of pageobjects
         divs = Domkey::View::PageObjectCollection.new lambda { divs(:id, /^feature_/) }
 
         features = divs.map do |div|
@@ -156,19 +145,19 @@ describe 'PageObject Decorators' do
           id           = div.element.id.split("_").last
 
           #definiton for each PageObject
-          watir_object = {switch: lambda { checkbox(id: "feature_checkbox#{id}") },
-                          blurb:  lambda { text_field(id: "feature_textarea#{id}") },
-                          label:  lambda { label(for: "feature_checkbox#{id}") }}
+          watir_object = {switch: -> { checkbox(id: "feature_checkbox#{id}") },
+                          blurb:  -> { text_field(id: "feature_textarea#{id}") },
+                          label:  -> { label(for: "feature_checkbox#{id}") }}
 
           pageobject = Domkey::View::PageObject.new watir_object
           #domain specific pageobject
-          DomkeySpecHelper::CheckboxTextField.new(pageobject)
+          CheckboxTextField.new(pageobject)
         end
 
         # array of Domain Specific PageObjects
         features.first.set 'bla'
         features.map { |e| e.value }.should eql ["bla", false]
-        features.map { |e| e.pageobject.element(:label).text }.should eql ["Nude Beach", "Golf Course"]
+        features.map { |e| e.pageobject.element(:label).text }.should eql ["Enable Checkbox for TextArea", "Golf Course"]
         features.find { |e| e.label == 'Golf Course' }.value.should be_false
       end
 
@@ -187,7 +176,7 @@ describe 'PageObject Decorators' do
             pageobject = PageObject.new switch: -> { checkbox(id: "feature_checkbox#{i}") },
                                         blurb:  -> { text_field(id: "feature_textarea#{i}") },
                                         label:  -> { label(for: "feature_checkbox#{i}") }
-            DomkeySpecHelper::CheckboxTextField.new(pageobject)
+            CheckboxTextField.new(pageobject)
           end
         end
 

data/spec/page_object_spec.rb

@@ -6,35 +6,36 @@ require 'spec_helper'
 describe Domkey::View::PageObject do
 
   before :all do
-    Domkey.browser.goto("file://" + __dir__ + "/html/test.html")
+    goto_html("test.html")
   end
 
   context 'exceptions' do
 
-    it 'bad proc for watirproc argument' do
+    it 'bad proc for package argument' do
       expect { Domkey::View::PageObject.new lambda { 'foo' } }.to raise_error(Domkey::Exception::Error)
     end
 
-    it 'bad object for watirproc argument' do
+    it 'bad object for package argument' do
       expect { Domkey::View::PageObject.new(Object.new) }.to raise_error(Domkey::Exception::Error)
     end
   end
 
   context 'when container is browser by default and' do
 
-    it 'watirproc is watirproc' do
-      watirproc = lambda { text_field(id: 'street1') }
-      street    = Domkey::View::PageObject.new watirproc
+    it 'package is package' do
+      package = lambda { text_field(id: 'street1') }
+      street  = Domkey::View::PageObject.new package
 
-      street.watirproc.should be_kind_of(Proc)
+      street.package.should be_kind_of(Proc)
       street.element.should be_kind_of(Watir::TextField) #one default element
 
       # talk to browser
       street.set 'Lamar'
       street.value.should eql 'Lamar'
+      street.options.should be_empty # by default options are empty
     end
 
-    it 'watirproc is pageobject' do
+    it 'package is pageobject' do
       # setup
       watir_object = lambda { text_field(id: 'street1') }
       pageobject   = Domkey::View::PageObject.new watir_object
@@ -42,22 +43,23 @@ describe Domkey::View::PageObject do
       # test
       street       = Domkey::View::PageObject.new pageobject
 
-      street.watirproc.should be_kind_of(Proc)
+      street.package.should be_kind_of(Proc)
       street.element.should be_kind_of(Watir::TextField)
 
 
       # talk to browser
       street.set 'zooom' #sending string here so no hash like in composed object
       street.value.should eql 'zooom'
+      street.options.should be_empty
     end
 
-    it 'watirproc is proc hash where values are watirprocs' do
-      hash      = {street1: lambda { text_field(id: 'street1') }, city: lambda { text_field(id: 'city1') }}
-      watirproc = lambda { hash }
-      address   = Domkey::View::PageObject.new watirproc
+    it 'package is proc hash where values are packages' do
+      hash    = {street1: lambda { text_field(id: 'street1') }, city: lambda { text_field(id: 'city1') }}
+      package = lambda { hash }
+      address = Domkey::View::PageObject.new package
 
-      address.watirproc.should respond_to(:each_pair)
-      address.watirproc.each_pair do |k, v|
+      address.package.should respond_to(:each_pair)
+      address.package.each_pair do |k, v|
         k.should be_kind_of(Symbol)
         v.should be_kind_of(Domkey::View::PageObject) #should respond to set and value
       end
@@ -67,16 +69,17 @@ describe Domkey::View::PageObject do
         v.should be_kind_of(Watir::TextField) #resolve suitecase
       end
 
+      address.options.should eql({:street1=>[], :city=>[]})
     end
 
-    it 'watirproc is hash where values are watirprocs' do
+    it 'package is hash where values are packages' do
 
       hash = {street1: lambda { text_field(id: 'street1') }, city: lambda { text_field(id: 'city1') }}
 
       address = Domkey::View::PageObject.new hash
 
-      address.watirproc.should respond_to(:each_pair)
-      address.watirproc.each_pair do |k, v|
+      address.package.should respond_to(:each_pair)
+      address.package.each_pair do |k, v|
         k.should be_kind_of(Symbol)
         v.should be_kind_of(Domkey::View::PageObject) #should respond to set and value
       end
@@ -120,6 +123,8 @@ describe Domkey::View::PageObject do
       e    = lambda { text_field(class: 'city') }
       city = Domkey::View::PageObject.new e, container
       city.set 'Hellocontainer'
+      city.value.should eql 'Hellocontainer'
+      city.options.should be_empty
 
       #verify
       Domkey.browser.div(:id, 'container').text_field(:class, 'city').value.should == 'Hellocontainer'