symbiont 0.3.0 → 0.4.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 05110d9c5eeb8d6971262bff19bad09cc4ed6086
-  data.tar.gz: 589f9bbbf1eb5d49a919486bf7a31b89b952d4ab
+  metadata.gz: cd18724d4d14d9283a706ab94d792c729abdb1c9
+  data.tar.gz: 8f7e64b7080775f04027710b2e01d87599bb5861
 SHA512:
-  metadata.gz: 298a058116b50448144fd72a1101951ffbe85fd6b57a246de08be66aad13b309905a0f61552632a24a2f20b476c5dc40ca933fc88fd75d217fe7420a719c82d1
-  data.tar.gz: ef93ec40a82704bd0e00b3e8d85c566ba725f2e8ce39db1d1670903c9abf8387e6f4cacadd25cea103c556f82b4a7f2a6e4d6b2bb92b12c5e9fe05c656dca9a5
+  metadata.gz: 0481286fe56b0e66938637a42d68ee64e9207ba210788aa3e488e8632f44fcdca78598f2288f296836d69d76e5e0f008d21ae8a49a4c555d1453c1291468b49a
+  data.tar.gz: 4f4ce214003961b53b594eb6e1e09540a6e70f4b92281e2a93e3e398d1323f7a7b0ae1cdc87119a5bdbbb463d9ece9e7f47a443f9fabb5297bdde166f26e66ef

data/lib/symbiont/accessor.rb

@@ -1,5 +1,7 @@
 module Symbiont
   module Accessor
+    # @param element [Symbol] name of Watir-based object
+    # @param locator [Hash] locators for referencing the element
     def reference_element(element, locator)
       driver.send(element, locator)
     end

data/lib/symbiont/assertions.rb

@@ -18,7 +18,7 @@ module Symbiont
       @title = title
     end
     
-    def url
+    def asserted_url
       @url
     end
 
@@ -26,7 +26,7 @@ module Symbiont
       @url_match
     end
 
-    def page_title
+    def asserted_title
       @title
     end
   end

data/lib/symbiont/elements.rb

@@ -10,6 +10,14 @@ module Symbiont
     @elements
   end
 
+  def self.settable
+    @settable ||= [:text_field]
+  end
+
+  def self.settable?(element)
+    settable.include? element.to_sym
+  end
+
   module Element
     # Iterates through Watir factory methods. Each method is defined
     # as a method that can be called on a page class. This is what
@@ -19,22 +27,53 @@ module Symbiont
         identifier, locator = parse_signature(signature)
         context = context_from_signature(locator, &block)
         define_element_accessor(identifier, locator, element, &context)
+        define_set_accessor(identifier, locator, element, &context) if Symbiont.settable?(element)
       end
     end
 
     private
 
-    # @param identifier [String] friendly name of element definition
-    # @param locator [Array] locators for referencing the element
-    # @param element [String] name of Watir-based object
+    # Defines an accessor method for an element that allows the friendly
+    # name of the element to be proxied to a Watir element object that
+    # corresponds to the element type.
+    #
+    # @param identifier [Symbol] friendly name of element definition
+    # @param locator [Hash] locators for referencing the element
+    # @param element [Symbol] name of Watir-based object
     # @param block [Proc] a context block
     #
     # @example
-    #   enable, {:id => 'enableForm'}, checkbox
+    # This element definition:
+    #   text_field :weight, id: 'wt', index: 0
+    #
+    # passed in like this:
+    #   :weight, {:id => 'wt', :index => 0}, :text_field
+    #
+    # This allows access like this:
+    #   @page.weight.set '200'
+    #
+    # Access could also be done this way:
+    #   @page.weight(id: 'wt').set '200'
+    #
+    # The second approach would lead to the *values variable having
+    # an array like this: [{:id => 'wt'}].
+    #
+    # A third approach would be to utilize one element definition
+    # within the context of another. Consider the following element
+    # definitions:
+    #   article :practice, id: 'practice'
+    #
+    #   a :page_link do |text|
+    #     practice.a(text: text)
+    #   end
+    #
+    # These could be utilized as such:
+    #   on_view(Practice).page_link('Click Me').click
+    #
+    # This approach would lead to the *values variable having
+    # an array like this: ["Click Me"].
     def define_element_accessor(identifier, locator, element, &block)
       define_method "#{identifier}".to_sym do |*values|
-        #puts "*** *values: #{values}"
-
         if block_given?
           instance_exec(*values, &block)
         else
@@ -43,6 +82,44 @@ module Symbiont
       end
     end
 
+    # Defines an accessor method for an element that allows the value of
+    # the element to be set via appending an "=" to the friendly name
+    # (identifier) of the element passed in.
+    #
+    # @param identifier [Symbol] friendly name of element definition
+    # @param locator [Hash] locators for referencing the element
+    # @param element [Symbol] name of Watir-based object
+    # @param block [Proc] a context block
+    #
+    # @example
+    # This element definition:
+    #   text_field :weight, id: 'wt'
+    #
+    # Can be accessed in two ways:
+    #    @page.weight.set '200'
+    #    @page.weight = '200'
+    #
+    # The second approach would lead to the *values variable having
+    # an array like this: ['200']. The first approach would be
+    # handled by define_element_accessor instead.
+    def define_set_accessor(identifier, locator, element, &block)
+      define_method "#{identifier}=".to_sym do |*values|
+        puts "*** *values: #{values}"
+
+        accessor = if block_given?
+          instance_exec(&block)
+        else
+          reference_element(element, locator)
+        end
+
+        if accessor.respond_to?(:set)
+          accessor.set *values
+        else
+          accessor.send_keys *values
+        end
+      end
+    end
+
     # Returns the identifier and locator portions of an element definition.
     #
     # @param signature [Array] full element definition
@@ -56,6 +133,7 @@ module Symbiont
     #
     # @param locator [Array] locators from element definition
     # @param block [Proc] a context block
+    # @return [Proc] the context block or nil if there is no procedure
     def context_from_signature(*locator, &block)
       if block_given?
         block

data/lib/symbiont/pages.rb

@@ -3,8 +3,8 @@ module Symbiont
     include Helpers
 
     def view
-      no_url_is_provided if url.nil?
-      driver.goto(url)
+      no_url_is_provided if asserted_url.nil?
+      driver.goto(asserted_url)
     end
 
     def has_correct_url?
@@ -13,20 +13,115 @@ module Symbiont
     end
 
     def has_correct_title?
-      no_title_is_provided if page_title.nil?
-      !(driver.title.match(page_title)).nil?
+      no_title_is_provided if asserted_title.nil?
+      !(driver.title.match(asserted_title)).nil?
     end
 
-    def url
-      self.class.url
+    def asserted_url
+      self.class.asserted_url
     end
 
     def url_match
       self.class.url_match
     end
 
-    def page_title
-      self.class.page_title
+    def asserted_title
+      self.class.asserted_title
+    end
+
+    def url
+      driver.url
+    end
+
+    def markup
+      driver.html
+    end
+
+    def text
+      driver.text
+    end
+
+    def title
+      driver.title
+    end
+
+    def visit(url)
+      driver.goto(url)
+    end
+
+    def screenshot(file)
+      driver.wd.save_screenshot(file)
     end
+
+    def run_script(script, *args)
+      driver.execute_script(script, *args)
+    end
+
+    def get_cookie(name)
+      for cookie in driver.cookies.to_a
+        if cookie[:name] == name
+          return cookie[:value]
+        end
+      end
+      nil
+    end
+
+    def clear_cookies
+      driver.cookies.clear
+    end
+
+    def refresh
+      driver.refresh
+    end
+
+    # @param block [Proc] the code that generates the alert
+    # @return [String] the message contained in the alert message box
+    def will_alert(&block)
+      yield
+      value = nil
+      if driver.alert.exists?
+        value = driver.alert.text
+        driver.alert.ok
+      end
+      value
+    end
+
+    # @param response [Boolean] true to accept the confirmation, false to cancel it
+    # @param block [Proc] the code that generates the confirmation
+    # @return [String] the message contained in the confirmation message box
+    def will_confirm(response, &block)
+      yield
+      value = nil
+      if driver.alert.exists?
+        value = driver.alert.text
+        response ? driver.alert.ok : driver.alert.close
+      end
+      value
+    end
+
+    # @param response [String] the value to be used in the prompt
+    # @param block [Proc] the code that generates the prompt
+    # @return [Hash] :message for the prompt message, :default_value for
+    # the value that the prompt had before the response was applied
+    def will_prompt(response, &block)
+      cmd = "window.prompt = function(text, value) {window.__lastWatirPrompt = {message: text, default_value: value}; return '#{response}';}"
+      driver.wd.execute_script(cmd)
+      yield
+      result = driver.wd.execute_script('return window.__lastWatirPrompt')
+      result && result.dup.each_key { |k| result[k.to_sym] = result.delete(k) }
+      result
+    end
+
+    alias_method :current_url, :url
+    alias_method :page_url, :url
+    alias_method :html, :markup
+    alias_method :page_text, :text
+    alias_method :page_title, :title
+    alias_method :navigate_to, :visit
+    alias_method :goto, :visit
+    alias_method :save_screenshot, :screenshot
+    alias_method :execute_script, :run_script
+    alias_method :remove_cookies, :clear_cookies
+    alias_method :refresh_page, :refresh
   end
 end

data/lib/symbiont/version.rb

@@ -1,3 +1,3 @@
 module Symbiont
-  VERSION = '0.3.0'
+  VERSION = '0.4.0'
 end

data/lib/symbiont.rb

@@ -1,13 +1,11 @@
 require 'watir-webdriver'
 
 require 'symbiont/version'
-require 'symbiont/logging'
 require 'symbiont/errors'
 require 'symbiont/helpers'
 
 require 'colorize'
 
-require 'symbiont/platform'
 require 'symbiont/assertions'
 require 'symbiont/pages'
 require 'symbiont/elements'
@@ -15,8 +13,14 @@ require 'symbiont/accessor'
 require 'symbiont/factory'
 
 module Symbiont
-  include Platform
   
+  # The included callback is used to provide the core functionality of the
+  # library to any class or module that includes the Symbiont library. The
+  # calling class or module is extended with logic that the library makes
+  # available as class methods. Any such class or module becomes a page or
+  # activity definition. The class methods allow assertions and element
+  # defintions to be defined.
+  #
   # @param caller [Class] the class including the framework
   def self.included(caller)
     caller.extend Symbiont::Assertion
@@ -27,6 +31,22 @@ module Symbiont
 
     Symbiont.trace("#{caller.class} #{caller} has attached the Symbiont.")
   end
+
+  def self.trace(message, level = 1)
+    puts '*' * level + " #{message}" if ENV['SYMBIONT_TRACE'] == 'on'
+  end
+
+  # @return [Object] browser driver reference
+  attr_reader :driver
+
+  # @param driver [Object] a tool driver instance
+  def initialize(driver)
+    Symbiont.trace("Dialect attached to driver:\n\t#{driver.inspect}")
+    @driver = driver
+
+    initialize_page if respond_to?(:initialize_page)
+    initialize_activity if respond_to?(:initialize_activity)
+  end
 end
 
 def attach(mod=Symbiont)

data/spec/fixtures/element_definitions.rb

@@ -30,3 +30,26 @@ shared_examples_for 'element generator for' do |elements|
 
   end
 end
+
+shared_examples_for 'element set generator for' do |elements|
+  elements.each do |element|
+    it "will set a value on a specific #{element} with a single locator" do
+      expect(watir_browser).to receive(element).with(id: element).and_return(watir_element)
+      expect(watir_element).to receive(:set).with('value')
+      watir_definition.send "#{element}=", 'value'
+    end
+
+    it "will attempt to send keypresses if a #{element} cannot be set" do
+      expect(watir_browser).to receive(element).with(id: element).and_return(watir_element)
+      allow(watir_element).to receive(:respond_to?).with(:set).and_return(false)
+      expect(watir_element).to receive(:send_keys).with('value')
+      watir_definition.send "#{element}=", 'value'
+    end
+
+    it "will set a value on a specific #{element} with a proc" do
+      expect(watir_browser).to receive(element).with(id: element).and_return(watir_element)
+      expect(watir_element).to receive(:set).with('value')
+      watir_definition.send "#{element}_proc=", 'value'
+    end
+  end
+end

data/spec/symbiont/element_spec.rb

@@ -5,4 +5,5 @@ describe Symbiont::Element do
   include_context :element
 
   provides_an 'element generator for', %w{text_field button}
+  provides_an 'element set generator for', %w{text_field}
 end

data/spec/symbiont/page_spec.rb

@@ -2,15 +2,16 @@ require 'spec_helper'
 
 describe Symbiont::Page do
   include_context :page
+  include_context :element
 
   context 'a page definition being used - url' do
     it 'will establish no default url' do
-      expect(empty_definition.url).to be_nil
+      expect(empty_definition.asserted_url).to be_nil
     end
 
     it 'will establish a page url with the url_is assertion' do
-      expect(watir_definition).to respond_to :url
-      expect(watir_definition.url).to eq('http://localhost:9292')
+      expect(watir_definition).to respond_to :asserted_url
+      expect(watir_definition.asserted_url).to eq('http://localhost:9292')
     end
 
     it 'will not view a page if the url_is assertion has not been set' do
@@ -35,16 +36,119 @@ describe Symbiont::Page do
 
   context 'a page definition being used - title' do
     it 'will establish no default title' do
-      expect(empty_definition.page_title).to be_nil
+      expect(empty_definition.asserted_title).to be_nil
     end
 
     it 'will establish a page title with the title_is assertion' do
-      expect(watir_definition).to respond_to :page_title
-      expect(watir_definition.page_title).to eq('Dialogic')
+      expect(watir_definition).to respond_to :asserted_title
+      expect(watir_definition.asserted_title).to eq('Dialogic')
     end
 
     it 'will not verify a title if the title_is assertion has not been set' do
       expect { empty_definition.has_correct_title? }.to raise_error Symbiont::Errors::NoTitleForDefinition
     end
   end
+
+  context 'an instance of a page definition' do
+    it 'will be able to get the active url' do
+      watir_browser.should_receive(:url).exactly(3).times.and_return('http://localhost:9292')
+      expect(watir_definition).to respond_to :url
+      expect(watir_definition.current_url).to eq('http://localhost:9292')
+      expect(watir_definition.page_url).to eq('http://localhost:9292')
+      expect(watir_definition.url).to eq('http://localhost:9292')
+    end
+
+    it 'will be able to get the markup of a page' do
+      watir_browser.should_receive(:html).exactly(3).times.and_return('<h1>Page Section</h1>')
+      expect(watir_definition.markup).to eq('<h1>Page Section</h1>')
+      expect(watir_definition.html).to eq('<h1>Page Section</h1>')
+      expect(watir_definition.html).to include('<h1>Page')
+    end
+
+    it 'will be able to get the text of a page' do
+      watir_browser.should_receive(:text).exactly(3).times.and_return('some page text')
+      expect(watir_definition.page_text).to eq('some page text')
+      expect(watir_definition.text).to eq('some page text')
+      expect(watir_definition.text).to include('page text')
+    end
+
+    it 'will be able to get the title of a page' do
+      watir_browser.should_receive(:title).exactly(3).times.and_return('Page Title')
+      expect(watir_definition.page_title).to eq('Page Title')
+      expect(watir_definition.title).to eq('Page Title')
+      expect(watir_definition.title).to include('Title')
+    end
+
+    it 'will navigate to a specific url' do
+      watir_browser.should_receive(:goto).exactly(3).times.with('http://localhost:9292')
+      watir_definition.visit('http://localhost:9292')
+      watir_definition.navigate_to('http://localhost:9292')
+      watir_definition.goto('http://localhost:9292')
+    end
+
+    it 'will be able to get a screenshot of the current page' do
+      watir_browser.should_receive(:wd).twice.and_return(watir_browser)
+      watir_browser.should_receive(:save_screenshot).twice
+      watir_definition.screenshot('testing.png')
+      watir_definition.save_screenshot('testing.png')
+    end
+
+    it 'will run a script against the browser' do
+      watir_browser.should_receive(:execute_script).twice.and_return('input')
+      expect(watir_definition.run_script('return document.activeElement')).to eq('input')
+      expect(watir_definition.execute_script('return document.activeElement')).to eq('input')
+    end
+
+    it 'should run a script, with arguments, against the browser' do
+      watir_browser.should_receive(:execute_script).with('return arguments[0].innerHTML', watir_element).and_return('testing')
+      watir_definition.execute_script('return arguments[0].innerHTML', watir_element).should == 'testing'
+    end
+
+    it 'will be able to get a cookie value' do
+      cookie = [{:name => 'test', :value => 'cookie', :path => '/'}]
+      watir_browser.should_receive(:cookies).and_return(cookie)
+      expect(watir_definition.get_cookie('test')).to eq('cookie')
+    end
+
+    it 'will return nothing if a cookie value is not found' do
+      cookie = [{:name => 'test', :value =>'cookie', :path => '/'}]
+      watir_browser.should_receive(:cookies).and_return(nil)
+      expect(watir_definition.get_cookie('testing')).to be_nil
+    end
+
+    it 'will be able to clear all cookies from the browser' do
+      watir_browser.should_receive(:cookies).twice.and_return(watir_browser)
+      watir_browser.should_receive(:clear).twice
+      watir_definition.remove_cookies
+      watir_definition.clear_cookies
+    end
+
+    it 'will be able to refresh the page' do
+      watir_browser.should_receive(:refresh).twice.and_return(watir_browser)
+      watir_definition.refresh_page
+      watir_definition.refresh
+    end
+
+    it 'will be able to handle JavaScript alert dialogs' do
+      watir_browser.should_receive(:alert).exactly(3).times.and_return(watir_browser)
+      watir_browser.should_receive(:exists?).and_return(true)
+      watir_browser.should_receive(:text)
+      watir_browser.should_receive(:ok)
+      watir_definition.will_alert {}
+    end
+
+    it 'will be able to handle JavaScript confirmation dialogs' do
+      watir_browser.should_receive(:alert).exactly(3).times.and_return(watir_browser)
+      watir_browser.should_receive(:exists?).and_return(true)
+      watir_browser.should_receive(:text)
+      watir_browser.should_receive(:ok)
+      watir_definition.will_confirm(true) {}
+    end
+
+    it 'will be able to handle JavaScript prompt dialogs' do
+      watir_browser.should_receive(:wd).twice.and_return(watir_browser)
+      watir_browser.should_receive(:execute_script).twice
+      watir_definition.will_prompt('Testing') {}
+    end
+  end
 end

data/test/symbiont-script.rb

@@ -15,6 +15,18 @@ class Dialogic
   attach Symbiont
 
   url_is 'http://localhost:9292'
+
+  p          :login_form, id: 'open'
+  text_field :username,   id: 'username'
+  text_field :password,   id: 'password'
+  button     :login,      id: 'login-button'
+
+  def login_as_admin
+    login_form.click
+    username.set 'admin'
+    password.set 'admin'
+    login.click
+  end
 end
 
 class Weight
@@ -37,6 +49,10 @@ class Practice
   url_matches /:\d{4}/
   title_is 'Dialogic - Practice Page'
 
+  button :alert,   id: 'alertButton'
+  button :confirm, id: 'confirmButton'
+  button :prompt,  id: 'promptButton'
+
   link :view_in_frame, id: 'framed_page'
 
   iframe :boxframe, class: 'fancybox-iframe'
@@ -62,9 +78,11 @@ end
 def framed
   @page = Practice.new(@driver)
   @page.view
-  #@page.view_in_frame.click
+  ##@page.view_in_frame.click
   @page.page_link('View Weight Calculator in Frame').click
   @page.weight.set '200'
+
+  ##on_view(Practice).page_link('View Weight Calculator in Frame').click
 end
 
 def basic
@@ -78,20 +96,58 @@ def basic
 
   @page.should have_correct_url
   @page.should have_correct_title
-end
 
-#basic
+  expect(@page.url).to eq('http://localhost:9292/practice')
+  @page.markup.include?('<strong id="group">Apocalypticists Unite</strong>').should be_true
+  @page.text.include?('LEAST FAVORITE WAY').should be_true
+  expect(@page.title).to eq('Dialogic - Practice Page')
 
-on_view(Weight)
-on(Weight).convert('200')
-on(Weight).calculate.click
+  script = <<-JS
+    return arguments[0].innerHTML
+  JS
 
-on(Weight) do
-  @active.convert('200')
-  @active.calculate.click
+  result = @page.run_script(script, @page.view_in_frame)
+  expect(result).to eq('View Weight Calculator in Frame')
 end
 
-on(Weight) do |page|
-  page.convert('200')
-  page.calculate.click
+def factory
+  on_view(Weight)
+  on(Weight).convert('200')
+  on(Weight).calculate.click
+
+  on(Weight) do
+    @active.convert('200')
+    @active.calculate.click
+  end
+
+  on(Weight) do |page|
+    page.convert('200')
+    page.calculate.click
+  end
 end
+
+#basic
+
+@page = Dialogic.new(@driver)
+@page.view
+@page.login_as_admin
+
+@page = Practice.new(@driver)
+@page.view
+
+response = @page.will_alert { @page.alert.click }
+expect(response).to eq 'Alert Message Received'
+
+response = @page.will_confirm(false) { @page.confirm.click }
+expect(response).to eq 'Confirmation Message Received'
+
+response = @page.will_prompt("magenta") { @page.prompt.click }
+expect(response[:message]).to eq('Favorite Color')
+expect(response[:default_value]).to eq('blue')
+
+@page = Weight.new(@driver)
+@page.view
+
+Watir::Wait.until { @page.weight.exists? }
+
+@page.weight.when_present.set '200'

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: symbiont
 version: !ruby/object:Gem::Version
-  version: 0.3.0
+  version: 0.4.0
 platform: ruby
 authors:
 - Jeff Nyman
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-05-02 00:00:00.000000000 Z
+date: 2014-05-08 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -109,9 +109,7 @@ files:
 - lib/symbiont/errors.rb
 - lib/symbiont/factory.rb
 - lib/symbiont/helpers.rb
-- lib/symbiont/logging.rb
 - lib/symbiont/pages.rb
-- lib/symbiont/platform.rb
 - lib/symbiont/version.rb
 - spec/fixtures/element_definitions.rb
 - spec/fixtures/mock_drivers.rb
@@ -129,7 +127,7 @@ licenses:
 - MIT
 metadata: {}
 post_install_message: "\n    (::) (::) (::) (::) (::) (::) (::) (::) (::) (::) (::)
-  (::)\n\n      Symbiont 0.3.0 has been installed.\n\n    (::) (::) (::) (::) (::)
+  (::)\n\n      Symbiont 0.4.0 has been installed.\n\n    (::) (::) (::) (::) (::)
   (::) (::) (::) (::) (::) (::) (::)\n  "
 rdoc_options: []
 require_paths:

data/lib/symbiont/logging.rb

@@ -1,5 +0,0 @@
-module Symbiont
-  def self.trace(message, level = 1)
-    puts '*' * level + " #{message}" if ENV['SYMBIONT_TRACE'] == 'on'
-  end
-end

data/lib/symbiont/platform.rb

@@ -1,12 +0,0 @@
-module Symbiont
-  module Platform
-    # @return [Object] browser driver reference
-    attr_reader :driver
-
-    # @param driver [Object] a tool driver instance
-    def initialize(driver)
-      Symbiont.trace("Dialect attached to driver:\n\t#{driver.inspect}")
-      @driver = driver
-    end
-  end
-end