RubyGems - domkey - Versions diffs - 0.1.0 - Mend

domkey 0.1.0

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (26) hide show

checksums.yaml +7 -0
data/.gitignore +17 -0
data/.rspec +2 -0
data/.travis.yml +3 -0
data/Gemfile +4 -0
data/LICENSE.txt +22 -0
data/README.md +37 -0
data/Rakefile +11 -0
data/domkey.gemspec +30 -0
data/lib/domkey.rb +18 -0
data/lib/domkey/browser_session.rb +14 -0
data/lib/domkey/exception.rb +6 -0
data/lib/domkey/version.rb +3 -0
data/lib/domkey/view.rb +39 -0
data/lib/domkey/view/page_object.rb +120 -0
data/lib/domkey/view/page_object_collection.rb +78 -0
data/spec/browser_spec.rb +23 -0
data/spec/html/test.html +53 -0
data/spec/page_object_collection_spec.rb +130 -0
data/spec/page_object_decorators_spec.rb +211 -0
data/spec/page_object_spec.rb +130 -0
data/spec/page_spec.rb +90 -0
data/spec/spec_helper.rb +14 -0
data/spec/view_dom_spec.rb +57 -0
data/spec/view_doms_spec.rb +49 -0
metadata +149 -0

data/spec/html/test.html ADDED

@@ -0,0 +1,53 @@
+<!DOCTYPE html>
+<html>
+<head>
+    <title>TestView</title>
+</head>
+<body>
+<div class='pageobject'>
+    <p>pageobject with many elements</p>
+    <input type='text' id="street1" class="street1"/>
+    <input type='text' id="city1" class="city" value="id city class city"/>
+</div>
+<div class='pageobject' id="container">
+    <input type='text' id="street2" class="street1"/>
+    <input type='text' id="city2" class="city" value="class city but div id container"/>
+</div>
+<br/>
+<div id='feature_1' class='pageobject'>
+    <label for='feature_checkbox1'>Nude Beach</label>
+    <input id="feature_checkbox1" type="checkbox" class="check" onclick="featureEnabler('feature_checkbox1','feature_textarea1');"/><br/>
+    <textarea id='feature_textarea1' readonly disabled>CheckboxTextField 1</textarea>
+</div>
+<div id='feature_2' class='pageobject'>
+    <label for='feature_checkbox2'>Golf Course</label>
+    <input id='feature_checkbox2' type='checkbox' class="check" onclick="featureEnabler('feature_checkbox2','feature_textarea2');"/><br/>
+    <textarea id='feature_textarea2' readonly disabled>CheckboxTextField 2</textarea>
+</div>
+<script type="text/javascript">
+    function featureEnabler(cbe, txte) {
+        var cb = document.getElementById(cbe);
+        var txt = document.getElementById(txte);
+        if (cb.checked == true) {
+            txt.readOnly = "";
+            txt.disabled = "";
+        } else {
+            txt.readOnly = 'readonly';
+            txt.disabled = 'disabled';
+        }
+    }
+</script>
+<div>
+    <p>DateSelector</p>
+    <input type='text' id="month_field" class="street1"/>
+    <input type='text' id="day_field" class="city"/>
+    <input type='text' id="year_field" class="city"/>
+</div>
+</body>
+</html>

data/spec/page_object_collection_spec.rb ADDED

@@ -0,0 +1,130 @@
+require 'spec_helper'
+describe Domkey::View::PageObjectCollection do
+  before :all do
+    Domkey.browser.goto("file://" + __dir__ + "/html/test.html")
+  end
+  it 'init error' do
+    # TODO. tighter scope what can be a watirproc
+    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
+      before :each do
+        # watirproc is definition of watir collection
+        # watirproc 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/) }
+        @cbs = Domkey::View::PageObjectCollection.new watirproc
+      end
+      it 'count or size' do
+        @cbs.count.should == 3
+      end
+      it 'each returns PageObject' do
+        @cbs.each do |e|
+          e.should be_kind_of(Domkey::View::PageObject)
+        end
+      end
+      it 'by index returns PageObject' do
+        @cbs[0].should be_kind_of(Domkey::View::PageObject)
+        @cbs[1].should be_kind_of(Domkey::View::PageObject)
+      end
+      it 'find_all example' do
+        # find_all of some condition
+        @cbs.find_all { |e| e.value == 'hello pageobject' }.should be_empty
+        @cbs.first.set 'hello pageobject'
+        # find_all returns the one we just set
+        @cbs.find_all { |e| e.value == 'hello pageobject' }.count.should eql(1)
+      end
+      it 'set one and map all example' do
+        # set value to later return
+        @cbs[1].set 'bye bye'
+        # map iterates and harvests value
+        @cbs.map { |e| e.value }.should eql ["hello pageobject", "bye bye", ""]
+      end
+      it 'element reaches to widgetry' do
+        @cbs.element.should be_kind_of(Watir::TextFieldCollection)
+      end
+    end
+    context 'watirproc is hash' do
+      before :all do
+        # would we do that? give me all text_fields :street and all text_fields :city ? in one collection?
+        # it becomes a keyed collection?
+        # secondary usage
+        # given I have city 4 and street 3 textfields
+        Domkey.browser.text_fields(class: /^street/).count.should == 3
+        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/) }}
+        @cbs = Domkey::View::PageObjectCollection.new watirproc
+      end
+      it 'count' do
+        @cbs.count.should == 2
+      end
+      it 'to_a returns array of hashes' do
+        @cbs.to_a.should have(2).items
+      end
+      it 'each returns hash where value is a PageObjectCollection' do
+        @cbs.each do |hash|
+          hash.each_pair { |k, v| v.should be_kind_of(Domkey::View::PageObjectCollection) }
+        end
+      end
+      it 'by index returns hash' do
+        @cbs.to_a[0].should be_kind_of(Hash)
+      end
+      it 'each in key returns PageObject' do
+        collection = @cbs.to_a.find { |e| e[:street] }
+        collection[:street].should be_kind_of(Domkey::View::PageObjectCollection)
+        collection[:street].each { |e| e.should be_kind_of(Domkey::View::PageObject) }
+      end
+      it 'element' do
+        @cbs.element(:street).should be_kind_of(Watir::TextFieldCollection)
+        @cbs.element.should be_kind_of(Hash)
+        @cbs.element.each_pair do |k, v|
+          k.should be_a(Symbol)
+          v.should be_a(Watir::TextFieldCollection)
+        end
+      end
+    end
+    context 'watirproc is pageobjectcollection' do
+      it 'initialize' do
+        watirproc            = lambda { text_fields(class: /^street/) }
+        pageobjectcollection = Domkey::View::PageObjectCollection.new watirproc
+        @cbs = Domkey::View::PageObjectCollection.new pageobjectcollection
+      end
+    end
+  end
+end

data/spec/page_object_decorators_spec.rb ADDED

@@ -0,0 +1,211 @@
+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
+    #example of specialized domain specific pageobject.
+    # behavior of set and value
+    class DateSelectorPageObject < 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
+    end
+  end
+end
+module DomkeySpecHelper
+  class CheckboxTextField
+    attr_reader :pageobject
+    def initialize(pageobject)
+      @pageobject = pageobject
+    end
+    def label
+      pageobject.element(:label).text
+    end
+    def set value
+      return pageobject.set switch: false unless value
+      if value.kind_of? String
+        pageobject.set switch: true, blurb: value
+      else
+        pageobject.set switch: true
+      end
+    end
+    def value
+      if pageobject.element(:switch).set?
+        v = pageobject.element(:blurb).value
+        v == '' ? true : v
+      else
+        false
+      end
+    end
+  end
+  class DateSelector
+    attr_reader :pageobject
+    def initialize(pageobject)
+      @pageobject = pageobject
+    end
+    def set value
+      pageobject.set day: value.day, month: value.month, year: value.year
+    end
+    def value
+      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")
+  end
+  context 'DateSelector' do
+    it 'as pageobject component wrapped by decorator' 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.set Date.today
+      dmy.value.should eql Date.today
+    end
+    it 'inherits from pageobject and overrides set and value' 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::Page::PageObject.new watir_object, @container
+      dmy          = Domkey::View::DateSelectorPageObject.new watir_object
+      dmy.set Date.today
+      dmy.value.should eql Date.today
+    end
+  end
+  context 'CheckboxTextField' 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
+      # decorator add specific behavior to set and value methods
+      tbcf = DomkeySpecHelper::CheckboxTextField.new foo
+      tbcf.set true
+      tbcf.set false
+      tbcf.set 'hhkhkjhj'
+    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
+        divs = Domkey::View::PageObjectCollection.new lambda { divs(:id, /^feature_/) }
+        features = divs.map do |div|
+          #the unique identifier shared by all elements composing a PageObject
+          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}") }}
+          pageobject = Domkey::View::PageObject.new watir_object
+          #domain specific pageobject
+          DomkeySpecHelper::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.find { |e| e.label == 'Golf Course' }.value.should be_false
+      end
+      # example of building Domain Specific PageObject
+      # from a predictable pattern of element collection on the page
+      module CheckboxTextFieldViewFactory
+        include Domkey::View
+        doms(:feature_divs) { divs(:id, /^feature_/) }
+        # returns array of CheckboxTextField pageobjects
+        def features
+          ids = feature_divs.map { |e| e.element.id.split("_").last }
+          ids.map do |i|
+            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)
+          end
+        end
+      end
+      # final client view that gets what the factory for pageobjects
+      class DomainSpecificPageObjectView
+        include CheckboxTextFieldViewFactory
+      end
+      it 'view factory' do
+        view = DomainSpecificPageObjectView.new
+        view.features.should have(2).items
+        view.features.each { |f| f.set true }
+        view.features.each { |f| f.set false }
+        view.features.each { |f| f.set "Hello From Feature View" }
+      end
+    end
+  end
+end

data/spec/page_object_spec.rb ADDED

@@ -0,0 +1,130 @@
+require 'spec_helper'
+# methods each pageobject should have
+# set value options elements
+describe Domkey::View::PageObject do
+  before :all do
+    Domkey.browser.goto("file://" + __dir__ + "/html/test.html")
+  end
+  context 'exceptions' do
+    it 'bad proc for watirproc argument' do
+      expect { Domkey::View::PageObject.new lambda { 'foo' } }.to raise_error(Domkey::Exception::Error)
+    end
+    it 'bad object for watirproc 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
+      street.watirproc.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'
+    end
+    it 'watirproc is pageobject' do
+      # setup
+      watir_object = lambda { text_field(id: 'street1') }
+      pageobject   = Domkey::View::PageObject.new watir_object
+      # test
+      street       = Domkey::View::PageObject.new pageobject
+      street.watirproc.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'
+    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
+      address.watirproc.should respond_to(:each_pair)
+      address.watirproc.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
+      address.element.should respond_to(:each_pair)
+      address.element.each_pair do |k, v|
+        v.should be_kind_of(Watir::TextField) #resolve suitecase
+      end
+    end
+    it 'watirproc is hash where values are watirprocs' 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|
+        k.should be_kind_of(Symbol)
+        v.should be_kind_of(Domkey::View::PageObject) #should respond to set and value
+      end
+      address.element.should respond_to(:each_pair)
+      address.element.each_pair do |k, v|
+        v.should be_kind_of(Watir::TextField) #resolve suitecase
+      end
+      # talk to browser
+      address.element[:street1].set 'helloworld'
+      address.element[:street1].value.should eql 'helloworld'
+      # pageobject.set value
+      # sends values to each element.set value
+      value = {city: 'Berlin', street1: 'Fredrichstrasse'}
+      address.set value
+      ## pageobject.value => returns value from the page
+      # asks each element for its value and aggregates value for entire pageobject
+      expected_value = address.value
+      # compare to value we sent earlier
+      expected_value.should eql(value)
+      # element by element
+      address.element(:city).value.should eql 'Berlin'
+      address.element(:city).set 'Austin'
+      address.element(:city).value.should eql 'Austin'
+    end
+  end
+  context 'when container is pageobject' do
+    it 'pageobject.dom becomes container' do
+      browser   = lambda { Domkey.browser }
+      container = Domkey::View::PageObject.new Proc.new { div(:id, 'container') }, browser
+      e    = lambda { text_field(class: 'city') }
+      city = Domkey::View::PageObject.new e, container
+      city.set 'Hellocontainer'
+      #verify
+      Domkey.browser.div(:id, 'container').text_field(:class, 'city').value.should == 'Hellocontainer'
+    end
+  end
+end