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

page_magic 2.0.0.alpha1 → 2.0.0

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