RubyGems - page_magic - Versions diffs - 2.0.0.alpha1 → 2.0.0 - Mend

page_magic 2.0.0.alpha1 → 2.0.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 (90) hide show

checksums.yaml +4 -4
data/.rubocop.yml +5 -2
data/.zsh_config +5 -5
data/Dockerfile +2 -1
data/Gemfile +2 -1
data/Gemfile.lock +9 -5
data/Makefile +7 -3
data/README.md +16 -4
data/VERSION +1 -1
data/lib/active_support/core_ext/object/to_query.rb +6 -6
data/lib/page_magic.rb +15 -16
data/lib/page_magic/class_methods.rb +1 -1
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/drivers.rb +2 -2
data/lib/page_magic/element.rb +19 -8
data/lib/page_magic/element/locators.rb +4 -4
data/lib/page_magic/element/not_found.rb +38 -0
data/lib/page_magic/element/query.rb +19 -27
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 +38 -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 +5 -21
data/lib/page_magic/element_definition_builder.rb +17 -24
data/lib/page_magic/elements.rb +62 -102
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 +3 -0
data/lib/page_magic/instance_methods.rb +2 -2
data/lib/page_magic/mapping.rb +79 -0
data/lib/page_magic/session.rb +10 -32
data/lib/page_magic/session_methods.rb +1 -1
data/lib/page_magic/transitions.rb +49 -0
data/lib/page_magic/utils/string.rb +4 -0
data/lib/page_magic/utils/url.rb +20 -0
data/lib/page_magic/watcher.rb +10 -17
data/lib/page_magic/watchers.rb +28 -15
data/spec/page_magic/class_methods_spec.rb +64 -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 +25 -29
data/spec/page_magic/drivers/poltergeist_spec.rb +4 -7
data/spec/page_magic/drivers/rack_test_spec.rb +4 -9
data/spec/page_magic/drivers/selenium_spec.rb +9 -12
data/spec/page_magic/drivers_spec.rb +36 -29
data/spec/page_magic/element/locators_spec.rb +26 -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 -47
data/spec/page_magic/element/selector_spec.rb +118 -110
data/spec/page_magic/element_context_spec.rb +46 -88
data/spec/page_magic/element_definition_builder_spec.rb +12 -71
data/spec/page_magic/element_spec.rb +256 -0
data/spec/page_magic/elements/config_spec.rb +200 -0
data/spec/page_magic/elements_spec.rb +87 -138
data/spec/page_magic/instance_methods_spec.rb +63 -63
data/spec/page_magic/mapping_spec.rb +181 -0
data/spec/page_magic/session_methods_spec.rb +27 -25
data/spec/page_magic/session_spec.rb +109 -198
data/spec/page_magic/transitions_spec.rb +43 -0
data/spec/page_magic/utils/string_spec.rb +20 -27
data/spec/page_magic/utils/url_spec.rb +9 -0
data/spec/page_magic/wait_methods_spec.rb +14 -22
data/spec/page_magic/watcher_spec.rb +22 -0
data/spec/page_magic/watchers_spec.rb +56 -62
data/spec/page_magic_spec.rb +27 -24
data/spec/spec_helper.rb +7 -3
data/spec/support/shared_examples.rb +15 -17
metadata +48 -15
data/lib/page_magic/element/query_builder.rb +0 -61
data/lib/page_magic/element/selector_methods.rb +0 -16
data/lib/page_magic/matcher.rb +0 -130
data/spec/element_spec.rb +0 -251
data/spec/page_magic/element/query_builder_spec.rb +0 -110
data/spec/page_magic/matcher_spec.rb +0 -338
data/spec/support/shared_contexts/files_context.rb +0 -9
data/spec/support/shared_contexts/nested_elements_html_context.rb +0 -18
data/spec/support/shared_contexts/rack_application_context.rb +0 -11
data/spec/support/shared_contexts/webapp_fixture_context.rb +0 -41
data/spec/watcher_spec.rb +0 -64

data/spec/page_magic/session_methods_spec.rb CHANGED Viewed

@@ -1,38 +1,40 @@
 # frozen_string_literal: true
-module PageMagic
-  describe SessionMethods do
-    include_context :webapp_fixture
-    let(:session) { PageMagic.session(application: rack_app, url: '/page1') }
-    subject do
-      OpenStruct.new(session: session).tap do |o|
-        o.extend(described_class)
-      end
+require 'ostruct'
+RSpec.describe PageMagic::SessionMethods do
+  subject(:session_methods) do
+    OpenStruct.new(session: session).tap do |o|
+      o.extend(described_class)
     end
+  end
+  let(:session) do
+    rack_app = instance_double(Proc, call: [200, {}, ['<html><head><title>page1</title></head></html>']])
+    PageMagic.session(application: rack_app, url: '/page1')
+  end
-    describe '#execute_script' do
-      it 'returns the output of Session#execute_script' do
-        expect(session.raw_session).to receive(:execute_script).with(:script).and_return(:result)
-        expect(subject.execute_script(:script)).to eq(:result)
-      end
+  describe '#execute_script' do
+    it 'returns the output of Session#execute_script' do
+      allow(session.raw_session).to receive(:execute_script).with(:script).and_return(:result)
+      expect(session_methods.execute_script(:script)).to eq(:result)
     end
+  end
-    describe '#page' do
-      it 'returns the current page of the session' do
-        expect(subject.page).to eq(session.current_page)
-      end
+  describe '#page' do
+    it 'returns the current page of the session' do
+      expect(session_methods.page).to eq(session.current_page)
     end
+  end
-    describe '#path' do
-      it 'returns the path of the session' do
-        expect(subject.path).to eq(session.current_path)
-      end
+  describe '#path' do
+    it 'returns the path of the session' do
+      expect(session_methods.path).to eq(session.current_path)
     end
+  end
-    describe '#url' do
-      it 'returns the url of the session' do
-        expect(subject.url).to eq(session.current_url)
-      end
+  describe '#url' do
+    it 'returns the url of the session' do
+      expect(session_methods.url).to eq(session.current_url)
     end
   end
 end

data/spec/page_magic/session_spec.rb CHANGED Viewed

@@ -1,253 +1,164 @@
-# rubocop:disable Metrics/ModuleLength
-module PageMagic
-  describe Session do
-    let(:page) do
-      Class.new do
-        include PageMagic
-        url 'http://url.com'
-      end
-    end
-    subject { described_class.new(browser) }
+# frozen_string_literal: true
-    let(:url) { page.url }
-    let(:browser) { double('browser', current_url: "#{url}/somepath", visit: nil, current_path: :current_path) }
+RSpec.describe PageMagic::Session do
+  subject(:session) { described_class.new(browser, 'http://base.url') }
-    describe '#current_page' do
-      let(:another_page_class) do
-        Class.new do
-          include PageMagic
-          url 'http://www.example.com/another_page1'
-        end
-      end
+  let(:page) do
+    Class.new do
+      include PageMagic
+    end
+  end
-      before do
-        subject.define_page_mappings '/another_page1' => another_page_class
-        subject.visit(page, url: url)
+  let(:browser) do
+    rack_application = Class.new do
+      def self.call(_env)
+        [200, {}, ['ok']]
       end
+    end
-      context 'page url has not changed' do
-        it 'returns the original page' do
-          allow(browser).to receive(:current_url).and_return(page.url)
-          expect(subject.current_page).to be_an_instance_of(page)
-        end
-      end
+    Capybara::Session.new(:rack_test, rack_application)
+  end
-      context 'page url has changed' do
-        it 'returns the mapped page object' do
-          allow(browser).to receive(:current_url).and_return(another_page_class.url)
-          expect(subject.current_page).to be_an_instance_of(another_page_class)
-        end
+  describe '#current_page' do
+    let(:another_page_class) do
+      Class.new do
+        include PageMagic
       end
     end
-    describe '#current_path' do
-      it "returns the browser's current path" do
-        expect(subject.current_path).to eq(browser.current_path)
-      end
+    it 'returns the current page' do
+      session.visit(page, url: 'http://base.url')
+      expect(session.current_page).to be_an_instance_of(page)
     end
-    describe '#current_url' do
-      it "returns the browser's current url" do
-        expect(subject.current_url).to eq(browser.current_url)
+    context 'when the page url has changed' do
+      it 'returns the mapped page object' do
+        session.define_page_mappings '/another_page1' => another_page_class
+        browser.visit('/another_page1')
+        expect(session.current_page).to be_an_instance_of(another_page_class)
       end
     end
+  end
-    describe '#define_page_mappings' do
-      context 'mapping includes a literal' do
-        it 'creates a matcher to contain the specification' do
-          subject.define_page_mappings path: :page
-          expect(subject.transitions).to eq(Matcher.new(:path) => :page)
-        end
-      end
+  describe '#current_path' do
+    it "returns the browser's current path" do
+      browser.visit('/url')
+      expect(session.current_path).to eq(browser.current_path)
+    end
+  end
-      context 'mapping is a matcher' do
-        it 'leaves it intact' do
-          expected_matcher = Matcher.new(:page)
-          subject.define_page_mappings expected_matcher => :page
-          expect(subject.transitions.key(:page)).to be(expected_matcher)
-        end
-      end
+  describe '#current_url' do
+    it "returns the browser's current url" do
+      browser.visit('/url')
+      expect(session.current_url).to eq(session.current_url)
     end
+  end
-    describe '#execute_script' do
-      it 'calls the execute script method on the capybara session' do
-        expect(browser).to receive(:execute_script).with(:script).and_return(:result)
-        expect(subject.execute_script(:script)).to be(:result)
+  describe '#define_page_mappings' do
+    context 'when the mapping includes a literal' do
+      it 'creates a matcher to contain the specification' do
+        session.define_page_mappings path: :page
+        expect(session.transitions.to_h).to include(PageMagic::Mapping.new(:path) => :page)
       end
+    end
-      context 'Capybara session does not support #execute_script' do
-        let(:browser) { Capybara::Driver::Base.new }
-        it 'raises an error' do
-          expected_message = described_class::UNSUPPORTED_OPERATION_MSG
-          expect { subject.execute_script(:script) }.to raise_error(NotSupportedException, expected_message)
-        end
+    context 'when the mapping is a matcher' do
+      it 'leaves it intact' do
+        expected_matcher = PageMagic::Mapping.new(:page)
+        session.define_page_mappings expected_matcher => :page
+        expect(session.transitions.key(:page)).to be(expected_matcher)
       end
     end
+  end
-    describe '#find_mapped_page' do
-      subject do
-        described_class.new(nil)
-      end
+  describe '#execute_script' do
+    it 'calls the execute script method on the capybara session' do
+      allow(browser).to receive(:execute_script).with(:script).and_return(:result)
+      expect(session.execute_script(:script)).to be(:result)
+    end
-      context 'match found' do
-        it 'returns the page class' do
-          subject.define_page_mappings '/page' => :mapped_page_using_string
-          expect(subject.instance_eval { find_mapped_page('/page') }).to be(:mapped_page_using_string)
-        end
+    context 'when the Capybara session does not support #execute_script' do
+      let(:browser) { Capybara::Driver::Base.new }
-        context 'more than one match is found' do
-          it 'returns the most specific match' do
-            subject.define_page_mappings %r{/page} => :mapped_page_using_regex, '/page' => :mapped_page_using_string
-            expect(subject.instance_eval { find_mapped_page('/page') }).to eq(:mapped_page_using_string)
-          end
-        end
+      it 'raises an error' do
+        expected_message = described_class::UNSUPPORTED_OPERATION_MSG
+        expect { session.execute_script(:script) }.to raise_error(PageMagic::NotSupportedException, expected_message)
       end
+    end
+  end
-      context 'mapping is not found' do
-        it 'returns nil' do
-          expect(subject.instance_eval { find_mapped_page('/fake_page') }).to be(nil)
+  describe '#method_missing' do
+    before do
+      page.class_eval do
+        def my_method
+          :called
         end
       end
     end
-    describe '#matches' do
-      subject do
-        described_class.new(nil)
-      end
-      it 'returns matching page mappings' do
-        subject.define_page_mappings '/page' => :mapped_page_using_string
-        expect(subject.instance_eval { matches('/page') }).to eq([:mapped_page_using_string])
-      end
+    it 'delegates to current page' do
+      session = described_class.new(browser).visit(page, url: 'http://base.url')
+      expect(session.my_method).to be(:called)
+    end
+  end
-      context 'more than one match on path' do
-        it 'orders the results by specificity ' do
-          subject.define_page_mappings %r{/page} => :mapped_page_using_regex, '/page' => :mapped_page_using_string
-          expected_result = %i[mapped_page_using_string mapped_page_using_regex]
-          expect(subject.instance_eval { matches('/page') }).to eq(expected_result)
-        end
-      end
+  describe '#respond_to?' do
+    it 'checks self' do
+      session = described_class.new(browser)
+      expect(session.respond_to?(:current_url)).to eq(true)
     end
-    describe '#method_missing' do
-      it 'should delegate to current page' do
+    context 'when method is not on self' do
+      before do
         page.class_eval do
           def my_method
             :called
           end
         end
-        session = PageMagic::Session.new(browser).visit(page, url: url)
-        expect(session.my_method).to be(:called)
-      end
-    end
-    context '#respond_to?' do
-      subject do
-        PageMagic::Session.new(browser).tap do |s|
-          allow(s).to receive(:current_page).and_return(page.new)
-        end
-      end
-      it 'checks self' do
-        expect(subject.respond_to?(:current_url)).to eq(true)
       end
       it 'checks the current page' do
-        page.class_eval do
-          def my_method; end
-        end
-        expect(subject.respond_to?(:my_method)).to eq(true)
+        session = described_class.new(browser)
+        session.visit(page, url: '/')
+        expect(session.respond_to?(:my_method)).to eq(true)
       end
     end
+  end
-    describe '#url' do
-      let!(:base_url) { "http://example.com" }
-      let!(:path) { 'home' }
-      let!(:expected_url) { "#{base_url}/#{path}" }
-      context 'base_url has a / on the end' do
-        before do
-          base_url << '/'
-        end
-        context 'path has / at the beginning' do
-          it 'produces compound url' do
-            expect(subject.send(:url, base_url, path)).to eq(expected_url)
-          end
-        end
-        context 'path does not have / at the beginning' do
-          it 'produces compound url' do
-            expect(subject.send(:url, base_url, "/#{path}")).to eq(expected_url)
-          end
-        end
-      end
-      context 'current_url does not have a / on the end' do
-        context 'path has / at the beginning' do
-          it 'produces compound url' do
-            expect(subject.send(:url, base_url, "/#{path}")).to eq(expected_url)
-          end
-        end
-        context 'path does not have / at the beginning' do
-          it 'produces compound url' do
-            expect(subject.send(:url, base_url, path)).to eq(expected_url)
-          end
-        end
+  describe '#visit' do
+    context 'when a page is supplied' do
+      it 'sets the current page' do
+        session.define_page_mappings '/page' => page
+        session.visit(page)
+        expect(session.current_page).to be_a(page)
       end
-    end
-    describe '#visit' do
-      let(:session) do
-        allow(browser).to receive(:visit)
-        PageMagic::Session.new(browser, url)
+      it 'uses the base url and the path in the page mappings' do
+        session = described_class.new(browser, 'http://base.url')
+        session.define_page_mappings '/page' => page
+        session.visit(page)
+        expect(session.current_url).to eq('http://base.url/page')
       end
-      context 'page supplied' do
-        it 'sets the current page' do
-          session.define_page_mappings '/page' => page
+      it 'raises an error when page no page mappings are found' do
+        expect do
           session.visit(page)
-          expect(session.current_page).to be_a(page)
-        end
-        it 'uses the base url and the path in the page mappings' do
-          session.define_page_mappings '/page' => page
-          expect(browser).to receive(:visit).with("#{url}/page")
-          session.visit(page)
-        end
-        context 'no mappings found' do
-          it 'raises an error' do
-            expect { session.visit(page) }.to raise_exception InvalidURLException, described_class::URL_MISSING_MSG
-          end
-        end
-        context 'mapping is a regular expression' do
-          it 'raises an error' do
-            session.define_page_mappings(/mapping/ => page)
-            expect { session.visit(page) }.to raise_exception InvalidURLException, described_class::REGEXP_MAPPING_MSG
-          end
-        end
+        end.to raise_exception PageMagic::InvalidURLException, described_class::URL_MISSING_MSG
+      end
-        it 'calls the onload hook' do
-          on_load_hook_called = false
-          page.on_load do
-            on_load_hook_called = true
-          end
-          session.define_page_mappings('/page' => page)
-          session.visit(page)
-          expect(on_load_hook_called).to eq(true)
-        end
+      it 'calls the onload hook' do
+        on_load_hook_called = false
+        page.on_load { on_load_hook_called = true }
+        session.visit(page, url: 'http://base.url')
+        expect(on_load_hook_called).to eq(true)
       end
+    end
-      context 'url supplied' do
-        it 'visits that url' do
-          expected_url = 'http://url.com/page'
-          expect(browser).to receive(:visit).with(expected_url)
-          session.visit(url: expected_url)
-        end
+    context 'when `url` is supplied' do
+      it 'visits that url' do
+        expected_url = 'http://base.url/page'
+        session.visit(url: expected_url)
+        expect(browser.current_url).to eq(expected_url)
       end
     end
   end

data/spec/page_magic/transitions_spec.rb ADDED Viewed

@@ -0,0 +1,43 @@
+# frozen_string_literal: true
+RSpec.describe PageMagic::Transitions do
+  describe '#mapped_page' do
+    context 'when a match is match found' do
+      it 'returns the page class' do
+        mappings = described_class.new('/page' => :mapped_page_using_string)
+        expect(mappings.mapped_page('/page')).to be(:mapped_page_using_string)
+      end
+    end
+    context 'when more than one match is found' do
+      it 'returns the most specific match' do
+        mappings = described_class.new(%r{/page} => :mapped_page_using_regex, '/page' => :mapped_page_using_string)
+        expect(mappings.mapped_page('/page')).to eq(:mapped_page_using_string)
+      end
+    end
+    context 'when a mapping is not found' do
+      it 'returns nil' do
+        mappings = described_class.new({})
+        expect(mappings.mapped_page('/unmapped_page')).to be(nil)
+      end
+    end
+  end
+  describe '#url_for' do
+    it 'returns the url for the mapped page' do
+      page = Object.new
+      mappings = described_class.new('/mapping' => page)
+      expect(mappings.url_for(page, base_url: 'http://base.url')).to eq('http://base.url/mapping')
+    end
+    context 'when page mapping is a regular expression' do
+      it 'raises an error' do
+        page = Object.new
+        mappings = described_class.new(/mapping/ => page)
+        expect { mappings.url_for(page, base_url: 'http://base.url') }
+          .to raise_exception PageMagic::InvalidURLException, described_class::REGEXP_MAPPING_MSG
+      end
+    end
+  end
+end