watir-formhandler 2.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: b92e73452df613d4cebbab78ba085259a504b00e
+  data.tar.gz: 078a6861a8b11e88e9c1675c3b7c877d1991b062
+SHA512:
+  metadata.gz: 12d2941e5e8b6f3de215eaa2e5bc8088e6629c7f8dc3c6b452d83aeb1475b4ae94c614b50942f085ba973c10e40491aea575b53262708b759d9956692802b3c5
+  data.tar.gz: 0231e8ffe1c62f472da7626c69ce5821b0a552c1dcd19d7b9353d7a9e2435d1b5b8e194bdeaab8cb5ad8ab2d2367ea45181f273c0c63586ce61b52fc8ac3d2ba

data/lib/watir_formhandler/check_box.rb

@@ -0,0 +1,19 @@
+module Watir
+  require 'watir-webdriver/elements/checkbox'
+  class CheckBox
+
+    # Will click the CheckBox unless the #checked? returns the same value as the given one.
+    # @param [Boolean] value the value to achieve on the CheckBox.
+    # @return [Boolean] the new value of this CheckBox.
+    def set(value)
+      click unless !!value == checked?
+    end
+
+
+    # Returns whether this CheckBox is set or not.
+    # @return [Boolean] is checked?
+    def field_value
+      checked?
+    end
+  end
+end

data/lib/watir_formhandler/container.rb

@@ -0,0 +1,49 @@
+module Watir
+  module Container
+    # Searches for the specified label and returns the form field belonging to it, identified by the
+    # 'for' attribute of the label. Alternatively, you may pass a Watir::Label.
+    # @param [String, Watir::Label] label the label for which to find the form field.
+    # @param [Watir::Element] start_node the node where to start searching for the label.
+    # @param [Boolean] include_groups whether to detect the group of a given label.
+    # @return [Watir::Element] form field of the given label.
+    def field(label, start_node: nil, include_groups: false)
+      start_node ||= self
+      field_label = label.respond_to?(:for) ? label : start_node.label(text: label)
+      determine_field(start_node, field_label, include_groups)
+    end
+
+
+    # Fills in the given value(s) to the passed attribute. It therefore accepts the same parameters
+    # as the #field method.
+    # @param [String, Watir::Label] label the label for which to find the form field.
+    # @param [Watir::Element] start_node the node where to start searching for the label.
+    # @param [String, Boolean, Array] value to be set.
+    # @param [Boolean] include_groups whether to detect the group of a given label.
+    def fill_in(label, value, start_node: nil, include_groups: nil)
+      field(label, start_node: start_node, include_groups: include_groups).set(value)
+    end
+
+
+    # Returns an OptionGroup
+    # @return [OptionGroup] the selected OptionGroup
+    def option_group(*args)
+      selector = args.first.respond_to?(:elements) ? args.first : extract_selector(args)
+      OptionGroup.new(self, selector)
+    end
+    Watir.extend_tag_to_class(:option_group, OptionGroup)
+
+
+
+    private
+    def determine_field(start_node, label, include_groups)
+      if include_groups
+        group_member_count = label.parent.checkboxes.count + label.parent.radios.count
+        return option_group(label.parent) if group_member_count > 1
+      end
+
+      field_id = label.for
+      found_field = start_node.element(id: field_id)
+      found_field ? found_field.to_subtype : nil
+    end
+  end
+end

data/lib/watir_formhandler/element.rb

@@ -0,0 +1,5 @@
+module Watir
+  class Element
+    attr_reader :selector
+  end
+end

data/lib/watir_formhandler/file_field.rb

@@ -0,0 +1,9 @@
+module Watir
+  class FileField
+    # Returns the file name of this FileField as a string.
+    # @return [String] file name.
+    def field_value
+      value || ''
+    end
+  end
+end

data/lib/watir_formhandler/option_group.rb

@@ -0,0 +1,91 @@
+module Watir
+
+  # The OptionGroup represents the parent node of any grouped checkboxes or radio buttons. Its
+  # purpose is to provide a way to select different options in a more natural way, like the user
+  # would do it: instead of going through all checkboxes one by one and setting them to 'true',
+  # OptionGroup allows to specify the option names that are desired to be opted in.
+  # @example
+  #   group = browser.option
+  class OptionGroup < HTMLElement
+    # Allows selector to be an HTMLElement, in which case the internal element will be set to this
+    # HTMLElement node.
+    def initialize(parent, selector)
+      stripped_selector = selector.respond_to?(:selector) ? selector.selector : selector
+      super parent, stripped_selector
+
+      @element = selector if selector.respond_to?(:selector)
+    end
+
+
+    # Returns the names of all available options.
+    # @return [Array<String>] names of all options.
+    def option_names
+      self.labels.map{ |label| label.text.strip }
+    end
+
+
+    # Returns the fields of all available options.
+    # @return [Array<Element>] fields of all options.
+    def option_fields
+      self.checkboxes.to_a + self.radios.to_a
+    end
+
+
+    # Returns all available options fields and their respective label as a Hash.
+    # @return [Hash<label => field>] hash with all labels and fields.
+    def options
+      option_hash = {}
+      my_labels = option_names
+      my_inputs = option_fields
+
+      my_labels.count.times do |index|
+        option_hash[my_labels[index]] = my_inputs[index]
+      end
+      option_hash
+    end
+
+
+    # Selects the given option(s) and deselects all other ones. This can not be done with
+    # radio buttons, however, as they cannot be deselected.
+    # @param [String, Array<String>] wanted_options to be selected.
+    # @example Passing a single String
+    #   group.set('Checkbox1')  #=> selects 'Checkbox1'
+    # @example Passing several options
+    #   group.set('Checkbox1', 'Checkbox2') #=> selects 'Checkbox1' and 'Checkbox2'
+    # @example Passing several options as Array
+    #   group.set(['Checkbox1', 'Radio1'])  #=> selects 'Checkbox1' and 'Radio1'
+    def set(*wanted_options)
+      options_to_select = [*wanted_options].flatten
+      options_to_deselect = option_names - options_to_select
+
+      @options = options
+      select(options_to_select, true)
+      select(options_to_deselect, false)
+      @options = nil
+    end
+
+
+    # Returns the selected options of this OptionGroup.
+    # @return [Array<String>] the selected options.
+    def selected_options
+      selected = []
+      my_labels = option_names
+      inputs.each_with_index do |field, index|
+        selected << my_labels[index] if field.checked?
+      end
+      selected
+    end
+
+
+    # @see #selected_options
+    def field_value
+      selected_options
+    end
+
+
+    private
+    def select(options_to_select, value_to_set)
+      options_to_select.each{ |option| @options[option].set(value_to_set) }
+    end
+  end # OptionGroup
+end # Watir

data/lib/watir_formhandler/radio.rb

@@ -0,0 +1,18 @@
+module Watir
+  require 'watir-webdriver/elements/radio'
+  class Radio
+    # Clicks this Radio unless #checked? returns the same value as the given one.
+    # @param [Boolean] value to be set.
+    # @return nil
+    def set(value)
+      click unless checked? || !value
+    end
+
+
+    # Returns whether this CheckBox is set or not.
+    # @return [Boolean] is checked?
+    def field_value
+      checked?
+    end
+  end
+end

data/lib/watir_formhandler/select.rb

@@ -0,0 +1,34 @@
+module Watir
+  require 'watir-webdriver/elements/select'
+  class Select
+    # Selects the given option(s) of this Select. If this Select has the 'multiple' attribute, it
+    # accept an array, otherwise it will call the internal '#select' method.
+    # @param [String, Array<String>] values the values to be selected.
+    # @return [String, Array<String>] the selected values.
+    def set(*values)
+      if multiple?
+        select_multiple(*values)
+      else
+        select(values.first)
+      end
+    end
+
+
+    # Selects the given options of this Select.
+    # @param [Array<String>] values to be selected.
+    # @return [Array<String>] the selected values.
+    def select_multiple(*values)
+      clear
+      values.flatten.each{ |value| select(value) }
+    end
+
+
+    # Selected option(s) of this Select.
+    # @return [String, Array<String>] if only one option is selected, return it as string,
+    # otherwise, return it as an array of strings.
+    def field_value
+      opts = selected_options
+      opts.count == 1 ? opts.first.text : opts.map(&:text)
+    end
+  end
+end

data/lib/watir_formhandler/text_area.rb

@@ -0,0 +1,10 @@
+module Watir
+  class TextArea
+    # Returns the text currently set in this TextField
+    # @return [String] the current text in the field. If the field is not set at all, it will return
+    # and empty string.
+    def field_value
+      value || ''
+    end
+  end
+end

data/lib/watir_formhandler/text_field.rb

@@ -0,0 +1,10 @@
+module Watir
+  class TextField
+    # Returns the text currently set in this TextField
+    # @return [String] the current text in the field. If the field is not set at all, it will return
+    # and empty string.
+    def field_value
+      value || ''
+    end
+  end
+end

data/lib/watir_formhandler/watir.rb

@@ -0,0 +1,13 @@
+module Watir
+  # As the tag_to_class hash is frozen once Watir is done loading its base classes, it cannot be
+  # extended with custom classes. Therefore, extend_tag_to_class unfreezes it, by replacing it with
+  # a duplicate and freezing it again after the addition.
+  #
+  # @param [Symbol] tag the tag to add to the list.
+  # @param [Element] tag_class the element class to return for the given tag.
+  # @return [Hash] the new tag-class hash.
+  def self.extend_tag_to_class(tag, tag_class)
+    @tag_to_class = @tag_to_class.dup.merge(tag => tag_class)
+    @tag_to_class.freeze
+  end
+end

data/lib/watir_formhandler.rb

@@ -0,0 +1,14 @@
+require 'watir'
+require 'watir-webdriver'
+require 'selenium-webdriver'
+
+require 'watir_formhandler/watir'
+require 'watir_formhandler/element'
+require 'watir_formhandler/option_group'
+require 'watir_formhandler/container'
+require 'watir_formhandler/check_box'
+require 'watir_formhandler/select'
+require 'watir_formhandler/radio'
+require 'watir_formhandler/text_field'
+require 'watir_formhandler/text_area'
+require 'watir_formhandler/file_field'

data/spec/check_box_spec.rb

@@ -0,0 +1,56 @@
+require 'spec_helper'
+
+module Watir
+  describe CheckBox do
+    before(:each)   { @checkbox = Watir::CheckBox.new('', id: '') }
+    let(:checkbox)  { @checkbox                                   }
+
+    describe '#set' do
+
+      context 'when given true' do
+        it 'checks it if unchecked' do
+          allow(checkbox).to receive(:checked?).and_return(false)
+          expect(checkbox).to receive(:click)
+          checkbox.set(true)
+        end
+
+        it 'does not check it if checked' do
+          allow(checkbox).to receive(:checked?).and_return(true)
+          expect(checkbox).to_not receive(:click)
+          checkbox.set(true)
+        end
+      end
+
+
+      context 'when given false' do
+        it 'unchecks it if checked' do
+          allow(checkbox).to receive(:checked?).and_return(true)
+          expect(checkbox).to receive(:click)
+          checkbox.set(false)
+        end
+
+        it 'does not uncheck it if unchecked' do
+          allow(checkbox).to receive(:checked?).and_return(false)
+          expect(checkbox).to_not receive(:click)
+          checkbox.set(false)
+        end
+      end #context when given false
+    end # #set
+
+
+    describe '#field_value' do
+      context 'if checked' do
+        it 'returns true' do
+          allow(checkbox).to receive(:checked?).and_return(true)
+          expect(checkbox.field_value).to eq(true)
+        end
+      end
+      context 'if unchecked' do
+        it 'returns false' do
+          allow(checkbox).to receive(:checked?).and_return(false)
+          expect(checkbox.field_value).to eq(false)
+        end
+      end
+    end # #read
+  end
+end

data/spec/container_spec.rb

@@ -0,0 +1,242 @@
+require 'spec_helper'
+
+module Watir
+  describe Container do
+    before(:all) { @browser = Watir::Browser.new }
+    after(:all)  { @browser.close}
+    let(:browser){ @browser }
+
+    before(:each) { browser.goto(local_url(FORM_PAGE)) }
+
+    describe '#option_group' do
+      context 'using a selector' do
+        it "returns a Watir::OptionGroup for id: 'checkboxset'" do
+          expect(browser.option_group(id: 'checkboxset')).to be_a(Watir::OptionGroup)
+        end
+
+        it "returns a Watir::OptionGroup for class: 'radioset' selector" do
+          expect(browser.option_group(class: 'radioset')).to be_a(Watir::OptionGroup)
+        end
+      end
+
+      context 'using a node' do
+        it 'returns a Watir::OptionGroup for a given Watir::Element' do
+          fieldset = browser.fieldset(id: 'checkboxset')
+          expect(browser.option_group(fieldset).tag_name).to eq('fieldset')
+        end
+      end
+    end # #option_group
+
+
+    describe '#field' do
+      describe 'without a start node' do
+        it 'returns form field of the specified label string' do
+          expect(browser.field('Checkbox').id).to eq('checkbox')
+        end
+
+        it 'returns form field of the given label node' do
+          field_label = browser.label(text: 'Checkbox')
+          expect(browser.field(field_label).id).to eq('checkbox')
+        end
+      end
+
+
+      describe 'with a start node' do
+        context 'specifying the label with a string' do
+          it 'searches the label within given Watir::Element' do
+            field_label = double('label', for: 'checkbox')
+            start_node = double('enter_element', label: field_label)
+
+            expect(start_node).to receive(:label).with(text: 'Checkbox')
+            expect(start_node).to receive(:element).with(id: 'checkbox')
+            browser.field('Checkbox', start_node: start_node)
+          end
+
+          it 'returns form field of the label within Watir::Element' do
+            start_node = browser.element(id: 'main_content')
+            expect(browser.field('Checkbox', start_node: start_node).id).to eq('checkbox')
+          end
+        end
+
+
+        context 'specifying the label with a Watir::Label' do
+          it 'searches the label within given Watir::Element' do
+            field_label = double('label', for: 'checkbox')
+            start_node = double('enter_element')
+
+            expect(start_node).to receive(:element).with(id: 'checkbox')
+            browser.field(field_label, start_node: start_node)
+          end
+
+          it 'returns form field of the label within Watir::Element' do
+            start_node = browser.element(id: 'main_content')
+            field_label = browser.label(text: 'Checkbox')
+            expect(browser.field(field_label, start_node: start_node).id).to eq('checkbox')
+          end
+        end
+      end
+
+
+      describe 'depending on subtype' do
+        context 'if a single field is in the area' do
+          it 'returns a Watir::Checkbox for a checkbox' do
+            expect(browser.field('Checkbox')).to be_a(Watir::CheckBox)
+          end
+
+          it 'returns a Watir::Select for a select' do
+            expect(browser.field('Select')).to be_a(Watir::Select)
+          end
+
+          it 'returns a Watir::TextField for a text field' do
+            expect(browser.field('Text Field')).to be_a(Watir::TextField)
+          end
+
+          it 'returns a Watir::TextArea for a text area' do
+            expect(browser.field('Text Area')).to be_a(Watir::TextArea)
+          end
+
+          it 'returns a Watir::Radio for a radio button' do
+            expect(browser.field('Radio')).to be_a(Watir::Radio)
+          end
+
+          it 'returns a Watir::FileField for a file field' do
+            expect(browser.field('File')).to be_a(Watir::FileField)
+          end
+        end
+
+        context 'if fields are grouped' do
+          it 'returns Watir::OptionGroup for grouped checkboxes' do
+            expect(browser.field('Checkbox1', include_groups: true)).to be_a(Watir::OptionGroup)
+          end
+
+          it 'returns Watir::OptionGroup for grouped radio buttons' do
+            expect(browser.field('Radio1', include_groups: true)).to be_a(Watir::OptionGroup)
+          end
+
+          it 'returns Watir::OptionGroup for grouped chckboxes and radio buttons' do
+            expect(browser.field('Checkbox5', include_groups: true)).to be_a(Watir::OptionGroup)
+          end
+        end
+      end # describe sybtype
+    end # #field
+
+
+    describe '#fill_in' do
+      describe 'without a start node' do
+        it 'fills a Watir::Checkbox' do
+          browser.fill_in('Checkbox', true)
+          expect(browser.checkboxes.first).to be_checked
+        end
+
+        it 'fills a Watir::Radio' do
+          browser.fill_in('Radio', true)
+          expect(browser.radios.first).to be_checked
+        end
+
+        it 'fills a Watir::FileField' do
+          browser.fill_in('File', File.join(HTML_DIR, FORM_PAGE))
+          expect(browser.file_fields.first.value).to eq(FORM_PAGE)
+        end
+
+        it 'fills a Watir::TextField' do
+          browser.fill_in('Text Field', 'test text')
+          expect(browser.text_fields.first.value).to eq('test text')
+        end
+
+        it 'fills a Watir::TextArea' do
+          browser.fill_in('Text Area', 'test text')
+          expect(browser.textareas.first.value).to eq('test text')
+        end
+
+        it 'fills a Watir::Select with single select' do
+          browser.fill_in('Select', 'Test2')
+          expect(browser.selects.first.selected_options.count).to eq(1)
+          expect(browser.selects.first.selected_options.first.text).to eq('Test2')
+        end
+
+        it 'fills a Watir::Select with multiple select' do
+          browser.fill_in('Multi Select', %w(Option2 Option3))
+          multiselect = browser.select(id: 'multiselect')
+          expect(multiselect.selected_options.count).to eq(2)
+          expect(multiselect.selected_options.map(&:text)).to eq(%w(Option2 Option3))
+        end
+
+        it 'fills a Watir::OptionGroup' do
+          browser.fill_in('Checkbox5', %w(Checkbox5 Radio7), include_groups: true)
+          option_group = browser.option_group(id: 'radio_and_checkbox')
+          expect(option_group.selected_options.count).to eq(2)
+          expect(option_group.selected_options).to eq(%w(Checkbox5 Radio7))
+        end
+      end # desribe: without a start node
+
+
+      describe 'with a start node' do
+        let(:start_node){ browser.element(id: 'main_content') }
+
+        it 'fills a Watir::Checkbox from start node' do
+          allow(start_node).to receive(:label).and_return(browser.label(text: 'Checkbox'))
+          expect(start_node).to receive(:label)
+          browser.fill_in('Checkbox', true, start_node: start_node)
+          expect(browser.checkboxes.first).to be_checked
+        end
+
+        it 'fills a Watir::Radio from start node' do
+          allow(start_node).to receive(:label).and_return(browser.label(text: 'Radio'))
+          expect(start_node).to receive(:label)
+          browser.fill_in('Radio', true, start_node: start_node)
+          expect(browser.radios.first).to be_checked
+        end
+
+        it 'fills a Watir::Select  with single select from start node' do
+          allow(start_node).to receive(:label).and_return(browser.label(text: 'Select'))
+          expect(start_node).to receive(:label)
+          browser.fill_in('Select', 'Test2', start_node: start_node)
+          expect(browser.selects.first.selected_options.count).to eq(1)
+          expect(browser.selects.first.selected_options.first.text).to eq('Test2')
+        end
+
+        it 'fills a Watir::Select with multiple select from start node' do
+          allow(start_node).to receive(:label).and_return(browser.label(text: 'Multi Select'))
+          expect(start_node).to receive(:label)
+          browser.fill_in('Multi Select', %w(Option2 Option3), start_node: start_node)
+          multiselect = browser.select(id: 'multiselect')
+          expect(multiselect.selected_options.count).to eq(2)
+          expect(multiselect.selected_options.map(&:text)).to eq(%w(Option2 Option3))
+        end
+
+        it 'fills a Watir::TextField from start node' do
+          allow(start_node).to receive(:label).and_return(browser.label(text: 'Text Field'))
+          expect(start_node).to receive(:label)
+          browser.fill_in('Text Field', 'test text', start_node: start_node)
+          expect(browser.text_fields.first.value).to eq('test text')
+        end
+
+        it 'fills a Watir::TextArea from start node' do
+          allow(start_node).to receive(:label).and_return(browser.label(text: 'Text Area'))
+          expect(start_node).to receive(:label)
+          browser.fill_in('Text Area', 'test text', start_node: start_node)
+          expect(browser.textareas.first.value).to eq('test text')
+        end
+
+        it 'fills a Watir::FileField from start node' do
+          allow(start_node).to receive(:label).and_return(browser.label(text: 'File'))
+          expect(start_node).to receive(:label)
+          browser.fill_in('File', File.join(HTML_DIR, FORM_PAGE), start_node: start_node)
+          expect(browser.file_fields.first.value).to eq(FORM_PAGE)
+        end
+
+        it 'fills a Watir::OptionGroup from start node' do
+          allow(start_node).to receive(:label).and_return(browser.label(text: 'Checkbox5'))
+          expect(start_node).to receive(:label)
+          browser.fill_in(
+            'Checkbox5', %w(Checkbox5 Radio7), include_groups: true, start_node: start_node
+          )
+          option_group = browser.option_group(id: 'radio_and_checkbox')
+          expect(option_group.selected_options.count).to eq(2)
+          expect(option_group.selected_options).to eq(%w(Checkbox5 Radio7))
+        end
+      end # descibe: with a start node
+    end # #fill_in
+  end
+
+end

data/spec/file_field_spec.rb

@@ -0,0 +1,23 @@
+require 'spec_helper'
+
+module Watir
+  describe FileField do
+    describe '#field_value' do
+      subject { FileField.new('', id: '') }
+
+      context 'no path is set' do
+        it 'returns empty string' do
+          allow(subject).to receive(:value).and_return(nil)
+          expect(subject.field_value).to eq('')
+        end
+      end
+
+      context 'a path is set' do
+        it 'returns string with file name' do
+          allow(subject).to receive(:value).and_return('form.html')
+          expect(subject.field_value).to eq('form.html')
+        end
+      end
+    end
+  end
+end