RubyGems - page_magic - Versions diffs - 1.2.8 → 2.0.2 - Mend

page_magic 1.2.8 → 2.0.2

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 (101) hide show

checksums.yaml +5 -5
data/.rubocop.yml +23 -4
data/.simplecov +5 -3
data/.zsh_config +6 -0
data/Dockerfile +11 -0
data/Gemfile +13 -13
data/Gemfile.lock +136 -148
data/Makefile +17 -0
data/README.md +26 -5
data/Rakefile +12 -2
data/VERSION +1 -1
data/circle.yml +3 -1
data/lib/active_support/core_ext/object/to_query.rb +84 -0
data/lib/page_magic.rb +31 -24
data/lib/page_magic/class_methods.rb +5 -2
data/lib/page_magic/comparator.rb +37 -0
data/lib/page_magic/comparator/fuzzy.rb +23 -0
data/lib/page_magic/comparator/literal.rb +22 -0
data/lib/page_magic/comparator/null.rb +26 -0
data/lib/page_magic/comparator/parameter_map.rb +52 -0
data/lib/page_magic/driver.rb +3 -0
data/lib/page_magic/drivers.rb +6 -5
data/lib/page_magic/drivers/poltergeist.rb +2 -0
data/lib/page_magic/drivers/rack_test.rb +3 -1
data/lib/page_magic/drivers/selenium.rb +4 -2
data/lib/page_magic/element.rb +35 -15
data/lib/page_magic/element/locators.rb +8 -5
data/lib/page_magic/element/not_found.rb +38 -0
data/lib/page_magic/element/query.rb +21 -20
data/lib/page_magic/element/query/multiple_results.rb +21 -0
data/lib/page_magic/element/query/prefetched_result.rb +26 -0
data/lib/page_magic/element/query/single_result.rb +20 -0
data/lib/page_magic/element/selector.rb +41 -16
data/lib/page_magic/element/selector/methods.rb +18 -0
data/lib/page_magic/element/selector/model.rb +21 -0
data/lib/page_magic/element_context.rb +7 -21
data/lib/page_magic/element_definition_builder.rb +20 -24
data/lib/page_magic/elements.rb +65 -69
data/lib/page_magic/elements/config.rb +103 -0
data/lib/page_magic/elements/inheritance_hooks.rb +15 -0
data/lib/page_magic/elements/types.rb +25 -0
data/lib/page_magic/exceptions.rb +6 -1
data/lib/page_magic/instance_methods.rb +8 -3
data/lib/page_magic/mapping.rb +79 -0
data/lib/page_magic/session.rb +15 -35
data/lib/page_magic/session_methods.rb +3 -1
data/lib/page_magic/transitions.rb +49 -0
data/lib/page_magic/utils/string.rb +18 -0
data/lib/page_magic/utils/url.rb +20 -0
data/lib/page_magic/wait_methods.rb +3 -0
data/lib/page_magic/watcher.rb +12 -17
data/lib/page_magic/watchers.rb +31 -15
data/page_magic.gemspec +15 -11
data/spec/lib/active_support/core_ext/object/to_query_test.rb +78 -0
data/spec/page_magic/class_methods_spec.rb +66 -37
data/spec/page_magic/comparator/fuzzy_spec.rb +44 -0
data/spec/page_magic/comparator/literal_spec.rb +41 -0
data/spec/page_magic/comparator/null_spec.rb +35 -0
data/spec/page_magic/comparator/parameter_map_spec.rb +75 -0
data/spec/page_magic/driver_spec.rb +26 -28
data/spec/page_magic/drivers/poltergeist_spec.rb +6 -7
data/spec/page_magic/drivers/rack_test_spec.rb +6 -9
data/spec/page_magic/drivers/selenium_spec.rb +11 -12
data/spec/page_magic/drivers_spec.rb +38 -29
data/spec/page_magic/element/locators_spec.rb +28 -25
data/spec/page_magic/element/not_found_spec.rb +24 -0
data/spec/page_magic/element/query/multiple_results_spec.rb +14 -0
data/spec/page_magic/element/query/single_result_spec.rb +21 -0
data/spec/page_magic/element/query_spec.rb +26 -45
data/spec/page_magic/element/selector_spec.rb +120 -110
data/spec/page_magic/element_context_spec.rb +47 -87
data/spec/page_magic/element_definition_builder_spec.rb +14 -71
data/spec/page_magic/element_spec.rb +256 -0
data/spec/page_magic/elements/config_spec.rb +203 -0
data/spec/page_magic/elements_spec.rb +90 -134
data/spec/page_magic/instance_methods_spec.rb +65 -63
data/spec/page_magic/mapping_spec.rb +181 -0
data/spec/page_magic/session_methods_spec.rb +29 -25
data/spec/page_magic/session_spec.rb +109 -199
data/spec/page_magic/transitions_spec.rb +43 -0
data/spec/page_magic/utils/string_spec.rb +29 -0
data/spec/page_magic/utils/url_spec.rb +9 -0
data/spec/page_magic/wait_methods_spec.rb +16 -22
data/spec/page_magic/watcher_spec.rb +22 -0
data/spec/page_magic/watchers_spec.rb +58 -62
data/spec/page_magic_spec.rb +37 -29
data/spec/spec_helper.rb +9 -2
data/spec/support/shared_contexts.rb +3 -1
data/spec/support/shared_examples.rb +17 -17
metadata +101 -48
data/lib/page_magic/element/query_builder.rb +0 -48
data/lib/page_magic/element/selector_methods.rb +0 -13
data/lib/page_magic/matcher.rb +0 -121
data/spec/element_spec.rb +0 -249
data/spec/page_magic/element/query_builder_spec.rb +0 -108
data/spec/page_magic/matcher_spec.rb +0 -336
data/spec/support/shared_contexts/files_context.rb +0 -7
data/spec/support/shared_contexts/nested_elements_html_context.rb +0 -16
data/spec/support/shared_contexts/rack_application_context.rb +0 -9
data/spec/support/shared_contexts/webapp_fixture_context.rb +0 -39
data/spec/watcher_spec.rb +0 -61

data/spec/page_magic/element/query_spec.rb CHANGED Viewed

@@ -1,56 +1,37 @@
-module PageMagic
-  class Element
-    describe Query do
-      include_context :webapp_fixture
+# frozen_string_literal: true
-      let(:page) do
-        elements_page = Class.new do
-          include PageMagic
-          url '/elements'
-        end
-        elements_page.visit(application: rack_app).current_page
-      end
-      describe '#execute' do
-        context 'no results found' do
-          subject do
-            QueryBuilder.find(:link).build(css: 'wrong')
-          end
+RSpec.describe PageMagic::Element::Query do
+  describe '#execute' do
+    it 'calls find' do
+      subject = described_class.new
+      allow(subject).to receive(:find)
-          it 'raises an error' do
-            expected_message = 'Unable to find css "wrong"'
-            expect { subject.execute(page.browser) }.to raise_exception(ElementMissingException, expected_message)
-          end
-        end
-        context 'to many results returned' do
-          subject do
-            QueryBuilder.find(:link).build(css: 'a')
-          end
+      subject.execute(:capybara_element)
+      expect(subject).to have_received(:find).with(:capybara_element)
+    end
-          it 'raises an error' do
-            expected_message = 'Ambiguous match, found 2 elements matching css "a"'
-            expect { subject.execute(page.browser) }.to raise_error AmbiguousQueryException, expected_message
-          end
-        end
+    context 'when a formatter supplied' do
+      it 'uses it' do
+        subject = described_class.new
+        allow(subject).to receive(:find) { |_r, &formatter| formatter.call(:result) }
-        context 'multiple results found' do
-          subject do
-            QueryBuilder.find(:link).build({ css: 'a' }, {}, multiple_results: true)
-          end
+        result = subject.execute(:capybara_element) { |capybara_result| "formatter_called_on_#{capybara_result}" }
+        expect(result).to eq('formatter_called_on_result')
+      end
+    end
-          it 'returns an array' do
-            result = subject.execute(page.browser)
-            expect(result).to be_a(Array)
-            expect(result.size).to eq(2)
+    context 'when no results are found' do
+      subject(:query_class) do
+        Class.new(described_class) do
+          def find(element)
+            element.find('missing')
           end
         end
+      end
-        it 'returns the result of the capybara query' do
-          query = QueryBuilder.find(:link).build(id: 'form_link')
-          result = query.execute(page.browser)
-          expect(result.text).to eq('link in a form')
-        end
+      it 'Returns `NotFound`' do
+        element = PageMagic::Element.load('<html></html>')
+        expect(query_class.new.execute(element)).to be_a(PageMagic::Element::NotFound)
       end
     end
   end

data/spec/page_magic/element/selector_spec.rb CHANGED Viewed

@@ -1,155 +1,165 @@
-module PageMagic
-  class Element
-    describe Selector do
-      describe '.find' do
-        it 'returns the constant with the given name' do
-          expect(Selector.find(:css)).to be(described_class::CSS)
-        end
-        context 'selector not found' do
-          it 'raises an exception' do
-            expect { Selector.find(:invalid) }.to raise_exception(UnsupportedCriteriaException)
-          end
-        end
-      end
-      describe '#build' do
-        it 'puts the locator and element type in to the result' do
-          expect(subject.build(:field, :locator)).to eq([:locator])
-        end
+# frozen_string_literal: true
-        context 'exact is set to true' do
-          subject do
-            described_class.new(exact: true)
-          end
+RSpec.describe PageMagic::Element::Selector do
+  describe '.find' do
+    it 'returns the constant with the given name' do
+      expect(described_class.find(:css)).to be(described_class::CSS)
+    end
-          it 'includes the requirement for the match to be exact' do
-            expect(subject.build(:field, :locator)).to include(exact: true)
-          end
-        end
+    context 'when selector not found' do
+      it 'raises an exception' do
+        expect { described_class.find(:invalid) }.to raise_exception(PageMagic::UnsupportedCriteriaException)
+      end
+    end
+  end
-        context 'supports_type flag set to true in constructor' do
-          subject do
-            described_class.new(supports_type: true)
-          end
-          it 'includes the element type in the result' do
-            expect(subject.build(:field, :locator)).to eq([:field, :locator])
-          end
-        end
+  describe '#build' do
+    it 'puts the locator and element type in to the result' do
+      expect(described_class.new.build(:field, :locator)).to have_attributes(
+        args: [:locator]
+      )
+    end
-        context 'formatter supplied to constructor' do
-          subject do
-            described_class.new do |param|
-              "formatted_#{param}".to_sym
-            end
-          end
-          it 'uses the formatter' do
-            expect(subject.build(:field, :locator)).to eq([:formatted_locator])
-          end
-        end
+    context 'when exact matching is required' do
+      it 'is added to options' do
+        expect(described_class.new(exact: true).build(:field, :locator)).to have_attributes(
+          options: { exact: true }
+        )
+      end
+    end
-        context 'name supplied to constructor' do
-          subject do
-            described_class.new(:css)
-          end
+    context 'when supports_type true' do
+      it 'includes the element type' do
+        expect(described_class.new(supports_type: true).build(:field, :locator)).to have_attributes(
+          args: %i[field locator]
+        )
+      end
+    end
-          it 'is added to the result' do
-            expect(subject.build(:field, :locator)).to eq([:css, :locator])
-          end
+    # TODO: - new class?
+    context 'when selector formatter is provided' do
+      subject(:selector) do
+        described_class.new do |param|
+          "formatted_#{param}".to_sym
         end
       end
-      describe '#initialize' do
-        it 'sets exact to false by default' do
-          expect(subject.exact).to eq(false)
-        end
+      it 'uses the formatter' do
+        expect(selector.build(:field, :locator)).to have_attributes(
+          args: [:formatted_locator]
+        )
       end
     end
-    class Selector
-      shared_examples 'named selector' do |options|
-        it 'adds name to the result' do
-          expected = [described_class.name, :locator, options].compact
-          expect(described_class.build(:element_type, :locator)).to eq(expected)
-        end
+    context 'when type supplied' do
+      it 'is added to the result' do
+        expect(described_class.new(:css).build(:field, :locator)).to have_attributes(
+          args: %i[css locator]
+        )
       end
+    end
+  end
-      shared_examples 'anonymous selector' do
-        it 'does not have a name' do
-          expect(described_class.name).to eq(nil)
-        end
+  describe '#initialize' do
+    context 'when exact' do
+      it 'sets the option' do
+        subject = described_class.new(exact: true).build(:element_type, {})
+        expect(subject.options).to eq({ exact: true })
       end
+    end
+  end
-      shared_examples 'element type selector' do
-        it 'adds the element type to the result' do
-          expect(described_class.supports_type).to eq(true)
-        end
+  describe 'predefined selectors' do
+    shared_examples 'a selector' do |named: false, **options|
+      def selector_name
+        self.class.metadata[:parent_example_group][:description].to_sym
       end
-      shared_examples 'non element type selector' do
-        it 'adds the element type to the result' do
-          expect(described_class.supports_type).to eq(false)
-        end
+      subject do
+        described_class.find(selector_name).build(:element_type, :locator)
       end
-      describe NAME do
-        it_behaves_like 'anonymous selector'
-        it_behaves_like 'non element type selector'
+      it 'contains the selector args' do
+        name_arg = named && (named == true ? selector_name : named)
-        it 'formats locators' do
-          button_name = 'my_button'
-          expect(described_class.build(:button, button_name)).to eq(["*[name='#{button_name}']"])
-        end
+        expected_args = [name_arg, :locator].compact
+        expect(subject.args).to eq(expected_args)
       end
-      describe XPATH do
-        it_behaves_like 'named selector'
-        it_behaves_like 'non element type selector'
+      it 'contains the options' do
+        expect(subject.options).to eq(options)
       end
+    end
-      describe ID do
-        it_behaves_like 'named selector'
-        it_behaves_like 'non element type selector'
-      end
+    let(:capybara_element) do
+      html_source = <<~HTML_SOURCE
+        <a href='#'>a link</a>
-      describe LABEL do
-        it_behaves_like 'named selector', exact: true
-        it_behaves_like 'non element type selector'
-      end
-      describe TEXT do
-        it_behaves_like 'anonymous selector'
-        it_behaves_like 'element type selector'
+          <div id='form' class="form">
+            <a id='form_link' href='/page2'>link in a form</a>
+            <label>enter text
+              <input id='field_id' name='field_name' class='input_class' type='text' value='filled in'/>
+            </label>
+            <button id='form_button' type='submit' value='a button'/>
+          </form>
+      HTML_SOURCE
+      PageMagic::Element.load(html_source)
+    end
+    describe 'label' do
+      it_behaves_like 'a selector', named: :field, exact: true
+      it 'finds elements by label' do
+        selector = described_class.find(:label).build(:text_field, 'enter text')
+        query = PageMagic::Element::Query::SingleResult.new(*selector.args)
+        expect(query.execute(capybara_element)[:name]).to eq('field_name')
       end
     end
-    context 'integration' do
-      include_context :webapp_fixture
-      let(:capybara_session) { Capybara::Session.new(:rack_test, rack_app).tap { |s| s.visit('/elements') } }
+    describe 'name' do
+      it 'formats locators' do
+        name = 'my_button'
+        expect(described_class::NAME.build(:element_type, name)).to have_attributes(
+          args: ["*[name='#{name}']"],
+          options: {}
+        )
+      end
       it 'finds elements by name' do
-        query = QueryBuilder.find(:text_field).build(name: 'field_name')
-        expect(query.execute(capybara_session)[:name]).to eq('field_name')
+        selector = described_class.find(:name).build(:text_field, 'field_name')
+        query = PageMagic::Element::Query::SingleResult.new(*selector.args)
+        expect(query.execute(capybara_element)[:name]).to eq('field_name')
       end
+    end
+    describe 'xpath' do
+      it_behaves_like 'a selector', named: true
       it 'finds elements by xpath' do
-        query = QueryBuilder.find(:element).build(xpath: '//div/label/input')
-        expect(query.execute(capybara_session)[:name]).to eq('field_name')
+        selector = described_class.find(:xpath).build(:element, '//div/label/input')
+        query = PageMagic::Element::Query::SingleResult.new(*selector.args)
+        expect(query.execute(capybara_element)[:name]).to eq('field_name')
       end
+    end
+    describe 'id' do
+      it_behaves_like 'a selector', named: true
       it 'finds elements by id' do
-        query = QueryBuilder.find(:text_field).build(id: 'field_id')
-        expect(query.execute(capybara_session)[:name]).to eq('field_name')
+        selector = described_class.find(:id).build(:text_field, 'field_id')
+        query = PageMagic::Element::Query::SingleResult.new(*selector.args)
+        expect(query.execute(capybara_element)[:name]).to eq('field_name')
       end
+    end
-      it 'finds elements by label' do
-        query = QueryBuilder.find(:text_field).build(label: 'enter text')
-        expect(query.execute(capybara_session)[:name]).to eq('field_name')
-      end
+    describe 'text' do
+      it_behaves_like 'a selector', named: :element_type
       it 'finds elements by text' do
-        query = QueryBuilder.find(:link).build(text: 'a link')
-        expect(query.execute(capybara_session).text).to eq('a link')
+        selector = described_class.find(:text).build(:link, 'a link')
+        query = PageMagic::Element::Query::SingleResult.new(*selector.args)
+        expect(query.execute(capybara_element).text).to eq('a link')
       end
     end
   end

data/spec/page_magic/element_context_spec.rb CHANGED Viewed

@@ -1,111 +1,71 @@
-module PageMagic
-  describe ElementContext do
-    include_context :webapp_fixture
+# frozen_string_literal: true
-    let!(:elements_page) do
-      Class.new do
-        include PageMagic
-        url '/elements'
-        link(:a_link, text: 'a link')
-        link(:prefetched, Object.new)
-      end
-    end
-    let(:page) do
-      elements_page.visit(application: rack_app).current_page
-    end
-    subject do
-      described_class.new(page)
-    end
-    let!(:session) do
-      double('session', raw_session: double('browser'))
+RSpec.describe PageMagic::ElementContext do
+  describe '#method_missing' do
+    let(:element_class) do
+      Class.new(PageMagic::Element)
     end
-    describe '#method_missing' do
-      context 'method is a element defintion' do
-        it 'returns the sub page element' do
-          element = described_class.new(page).a_link
-          expect(element.text).to eq('a link')
-        end
-        it 'passes arguments through to the element definition' do
-          elements_page.links :pass_through, css: 'a' do |args|
-            args[:passed_through] = true
-          end
-          args = {}
-          described_class.new(page).pass_through(args)
-          expect(args[:passed_through]).to eq(true)
-        end
-        it 'does not evaluate any of the other definitions' do
-          elements_page.class_eval do
-            link(:another_link, :selector) do
-              raise('should not have been evaluated')
-            end
-          end
+    context 'when method is a element definition' do
+      it 'returns the sub page element' do
+        element_class.link(:a_link, text: 'a link')
+        element = described_class.new(element_class.load("<a href='#'>a link</a>")).a_link
+        expect(element.text).to eq('a link')
+      end
-          described_class.new(page).a_link
-        end
+      it 'passes arguments through to the element definition' do
+        element_class.link(:pass_through, css: 'a') { |args| args[:passed_through] = true }
-        context 'more than one match found in the browser' do
-          it 'returns an array of element definitions' do
-            elements_page.links :links, css: 'a'
-            links = described_class.new(page).links
-            expect(links.find_all { |e| e.class == Element }.size).to eq(2)
-            expect(links.collect(&:text)).to eq(['a link', 'link in a form'])
-          end
-        end
+        args = {}
+        described_class.new(element_class.load("<a href='#'>a link</a>")).pass_through(args)
+        expect(args[:passed_through]).to eq(true)
       end
-      context 'method found on page_element' do
-        it 'calls page_element method' do
-          elements_page.class_eval do
-            def page_method
-              :called
-            end
-          end
+      it 'does not evaluate any of the other definitions' do
+        element_class.link(:a_link, text: 'a link')
+        element_class.link(:another_link, :selector) { raise('should not have been evaluated') }
-          expect(described_class.new(page).page_method).to eq(:called)
-        end
+        described_class.new(element_class.load("<a href='#'>a link</a>")).a_link
       end
+    end
-      context 'element is prefetched' do
-        it 'does not call find' do
-          expect(subject).not_to receive(:find)
-          described_class.new(page).prefetched
+    context 'when the method is found on page_element' do
+      it 'calls page_element method' do
+        element_class.define_method(:page_method) do
+          :called
         end
-      end
-      context 'method not found on page_element or as a element definition' do
-        it 'raises an error' do
-          expect { elements_page.missing_method }.to raise_error(NoMethodError)
-        end
+        expect(described_class.new(element_class.load("<a href='#'>a link</a>")).page_method).to eq(:called)
       end
     end
-    describe '#respond_to?' do
-      let(:page_element) do
-        Class.new(Element) do
-          link(:a_link, css: '.link')
-        end
+    context 'when the method is not found on page_element or as a element definition' do
+      it 'raises an error' do
+        expect do
+          described_class.new(PageMagic::Element.load('')).missing_method
+        end.to raise_error(PageMagic::ElementMissingException)
       end
+    end
+  end
-      subject do
-        described_class.new(page_element.new(session))
+  describe '#respond_to?' do
+    let(:page_element_class) do
+      Class.new(PageMagic::Element) do
+        link(:a_link, text: 'a link')
       end
+    end
-      context 'page_element responds to method name' do
-        it 'returns true' do
-          expect(subject.respond_to?(:a_link)).to eq(true)
-        end
+    context 'when the page_element responds to method name' do
+      it 'returns true' do
+        element = described_class.new(page_element_class.load("<a href='#'>a link</a>"))
+        expect(element).to respond_to(:a_link)
       end
+    end
-      context 'method is not on page_element' do
-        it 'calls super' do
-          expect(subject.respond_to?(:methods)).to eq(true)
-        end
+    context 'when the method is not on the page_element' do
+      it 'calls super' do
+        element = described_class.new(page_element_class.load("<a href='#'>a link</a>")).a_link
+        expect(element.text).to respond_to(:methods)
       end
     end
   end