RubyGems - domkey - Versions diffs - 0.1.0 - Mend

domkey 0.1.0

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

@@ -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