page_magic 1.2.7 → 2.0.0

data/spec/page_magic/elements_spec.rb

@@ -1,162 +1,125 @@
-# rubocop:disable Metrics/ModuleLength
-module PageMagic
-  describe Elements do
-    include_context :nested_elements_html
+# frozen_string_literal: true
 
-    let(:page) { double(init: nested_elements_node) }
-
-    subject do
-      Class.new do
-        extend Elements
-        include Element::Locators
-      end
+RSpec.describe PageMagic::Elements do
+  subject do
+    Class.new do
+      extend PageMagic::Elements
+      include PageMagic::Element::Locators
     end
-    let(:instance) do
-      subject.new
+  end
+
+  let(:instance) do
+    subject.new
+  end
+  let(:child_selector) { { id: 'child' } }
+
+  context 'element types' do
+    it 'provides all of the type provided by capybara' do
+      capybara_elements = Capybara::Selector.all.except(*%i[element datalist_input datalist_option id xpath css]).keys
+      expect(described_class::TYPES).to include(*capybara_elements)
     end
+  end
 
-    let(:child_selector) { { id: 'child' } }
+  describe '#element' do
+    it 'converts arguments in to options' do
+      allow(PageMagic::Elements::Config)
+        .to receive(:build)
+        .with([:alias, child_selector, { visible: true }], :text_field)
+        .and_call_original
+      subject.text_fields :alias, child_selector, visible: true
+    end
 
-    describe '#element' do
-      it 'sets the selector and type' do
-        expected_definition = ElementDefinitionBuilder.new(definition_class: Element,
-                                                           type: :text_field,
-                                                           selector: child_selector,
-                                                           options: { multiple_results: false })
-        subject.text_field :alias, child_selector
-        expect(instance.element_by_name(:alias)).to eq(expected_definition)
+    context 'complex elements' do
+      let!(:section_class) do
+        Class.new(PageMagic::Element) do
+          def self.name
+            'PageSection'
+          end
+        end
       end
 
-      context 'options' do
-        it 'puts them on the builder' do
-          options = { my: :options }
-          subject.text_field :alias, child_selector, options
-          expect(instance.element_by_name(:alias).options).to eq(options)
+      context 'using a predefined class' do
+        it 'adds an element using that class section' do
+          subject.element section_class, :page_section, child_selector
+          element_definition_builder = instance.element_by_name(:page_section)
+          expect(element_definition_builder.send(:definition_class)).to be < section_class
         end
       end
+    end
 
-      context 'complex elements' do
-        let!(:section_class) do
-          Class.new(Element) do
-            def self.name
-              'PageSection'
-            end
-          end
+    context 'using a block' do
+      it 'passes the parent element in as the last argument' do
+        expected_element = instance
+        subject.element :page_section, child_selector do |_arg1|
+          extend RSpec::Matchers
+          expect(parent_element).to eq(expected_element)
         end
+        instance.element_by_name(:page_section, :arg1)
+      end
 
-        context 'using a predefined class' do
-          it 'should add an element using that class section' do
-            subject.element section_class, :page_section, child_selector
-            element_definition_builder = instance.element_by_name(:page_section)
-            expect(element_definition_builder.definition_class).to be < section_class
-          end
+      it 'passes args through to the block' do
+        subject.element :page_section, child_selector do |arg|
+          extend RSpec::Matchers
+          expect(arg).to eq(:arg1)
+        end
 
-          context 'with no selector supplied' do
-            it 'defaults the selector to the one on the class' do
-              section_class.selector child_selector
-              subject.element section_class, :alias
-              element_definition_builder = instance.element_by_name(:alias)
-              expect(element_definition_builder.selector).to eq(child_selector)
-            end
-          end
+        instance.element_by_name(:page_section, :arg1)
+      end
+    end
 
-          context 'with no name supplied' do
-            it 'should default to the name of the class if one is not supplied' do
-              subject.element section_class, child_selector
-              element_definition_builder = instance.element_by_name(:page_section)
-              expect(element_definition_builder.definition_class).to be < section_class
-            end
-          end
+    describe 'restrictions' do
+      subject do
+        Class.new.tap do |clazz|
+          clazz.extend(described_class)
         end
       end
 
-      context 'using a block' do
-        it 'passes the parent element in as the last argument' do
-          expected_element = instance
-          subject.element :page_section, child_selector do |_arg1|
-            extend RSpec::Matchers
-            expect(parent_element).to eq(expected_element)
-          end
-          instance.element_by_name(:page_section, :arg1)
-        end
+      it 'does not allow method names that match element names' do
+        expect do
+          subject.class_eval do
+            link(:hello, text: 'world')
 
-        it 'should pass args through to the block' do
-          subject.element :page_section, child_selector do |arg|
-            extend RSpec::Matchers
-            expect(arg).to eq(:arg1)
+            def hello; end
           end
-
-          instance.element_by_name(:page_section, :arg1)
-        end
+        end.to raise_error(PageMagic::InvalidMethodNameException)
       end
 
-      describe 'location' do
-        context 'a prefetched object' do
-          it 'should add a section' do
-            subject.element :page_section, :object
+      it 'does not allow element names that match method names' do
+        expect do
+          subject.class_eval do
+            def hello; end
 
-            element_defintion_builder = instance.element_by_name(:page_section)
-            expect(element_defintion_builder.element).to eq(:object)
+            link(:hello, text: 'world')
           end
-        end
+        end.to raise_error(PageMagic::InvalidElementNameException)
       end
 
-      describe 'restrictions' do
-        subject do
-          Class.new.tap do |clazz|
-            clazz.extend(described_class)
+      it 'does not allow duplicate element names' do
+        expect do
+          subject.class_eval do
+            link(:hello, text: 'world')
+            link(:hello, text: 'world')
           end
-        end
-
-        it 'should not allow method names that match element names' do
-          expect do
-            subject.class_eval do
-              link(:hello, text: 'world')
-
-              def hello
-              end
-            end
-          end.to raise_error(InvalidMethodNameException)
-        end
-
-        it 'should not allow element names that match method names' do
-          expect do
-            subject.class_eval do
-              def hello
-              end
-
-              link(:hello, text: 'world')
-            end
-          end.to raise_error(InvalidElementNameException)
-        end
-
-        it 'should not allow duplicate element names' do
-          expect do
-            subject.class_eval do
-              link(:hello, text: 'world')
-              link(:hello, text: 'world')
-            end
-          end.to raise_error(InvalidElementNameException)
-        end
+        end.to raise_error(PageMagic::InvalidElementNameException)
+      end
 
-        it 'should not evaluate the elements when applying naming checks' do
-          subject.class_eval do
-            link(:link1, :selector) do
-              raise('should not have been evaluated')
-            end
-            link(:link2, :selector)
+      it 'does not evaluate the elements when applying naming checks' do
+        subject.class_eval do
+          link(:link1, :selector) do
+            raise('should not have been evaluated')
           end
+          link(:link2, :selector)
         end
       end
     end
+  end
 
-    describe '#element_definitions' do
-      it 'should return your a copy of the core definition' do
-        subject.text_field :alias, child_selector
-        first = instance.element_by_name(:alias)
-        second = instance.element_by_name(:alias)
-        expect(first).to_not equal(second)
-      end
+  describe '#element_definitions' do
+    it 'returns your a copy of the core definition' do
+      subject.text_field :alias, child_selector
+      first = instance.element_by_name(:alias)
+      second = instance.element_by_name(:alias)
+      expect(first).not_to equal(second)
     end
   end
 end

data/spec/page_magic/instance_methods_spec.rb

@@ -1,88 +1,90 @@
-module PageMagic
-  describe InstanceMethods do
-    include_context :webapp_fixture
+# frozen_string_literal: true
 
-    let(:page_class) do
-      Class.new do
-        include PageMagic
-        url '/page1'
-        link(:next_page, text: 'next page')
-      end
-    end
-
-    subject do
-      page_class.visit(application: rack_app)
+RSpec.describe PageMagic::InstanceMethods do
+  let(:page_class) do
+    Class.new.tap do |klass|
+      klass.include(described_class)
     end
+  end
 
-    it_behaves_like 'session accessor'
-    it_behaves_like 'element watcher'
-    it_behaves_like 'waiter'
-    it_behaves_like 'element locator'
-
-    describe 'execute_on_load' do
-      it 'runs the on_load_hook in the context of self' do
-        instance = subject.current_page
-        page_class.on_load do
-          extend RSpec::Matchers
-          expect(self).to be(instance)
-        end
-
-        subject.execute_on_load
-      end
+  it_behaves_like 'session accessor'
+  it_behaves_like 'element watcher'
+  it_behaves_like 'waiter'
+  it_behaves_like 'element locator'
 
-      it 'returns self' do
-        expect(subject.execute_on_load).to be(subject.current_page)
+  describe 'execute_on_load' do
+    let(:page_class) do
+      Class.new.tap do |klass|
+        klass.extend(PageMagic::ClassMethods)
+        klass.include(described_class)
+        klass.include RSpec::Matchers
       end
     end
 
-    describe '#respond_to?' do
-      it 'checks self' do
-        expect(subject.respond_to?(:visit)).to eq(true)
+    it 'runs the on_load_hook in the context of self' do
+      instance = page_class.new
+      page_class.on_load do
+        expect(self).to be(instance)
       end
 
-      it 'checks element definitions' do
-        expect(subject.respond_to?(:next_page)).to eq(true)
-      end
+      instance.execute_on_load
     end
 
-    describe 'session' do
-      it 'gives access to the page magic object wrapping the user session' do
-        expect(subject.session.raw_session).to be_a(Capybara::Session)
-      end
+    it 'returns self' do
+      instance = page_class.new
+      expect(instance.execute_on_load).to be(instance)
     end
+  end
 
-    describe 'text' do
-      it 'returns the text on the page' do
-        expect(subject.text).to eq('next page')
-      end
+  describe '#respond_to?' do
+    it 'checks element definitions' do
+      instance = page_class.new
+      allow(instance).to receive(:contains_element?).and_return(true)
+      expect(instance).to respond_to(:next_page)
     end
+  end
 
-    describe 'text_on_page?' do
-      it 'returns true if the text is present' do
-        expect(subject.text_on_page?('next page')).to eq(true)
-      end
+  describe '#text' do
+    it 'returns the text on the page' do
+      session = PageMagic::Session.new(instance_double(Capybara::Session, text: 'text'))
+      instance = page_class.new(session)
+      expect(instance.text).to eq('text')
+    end
+  end
 
-      it 'returns false if the text is not present' do
-        expect(subject.text_on_page?('not on page')).to eq(false)
-      end
+  describe '#text_on_page?' do
+    it 'returns true if the text is present' do
+      session = PageMagic::Session.new(instance_double(Capybara::Session, text: 'text'))
+      instance = page_class.new(session)
+
+      expect(instance.text_on_page?('text')).to eq(true)
     end
 
-    describe 'title' do
-      it 'returns the title' do
-        expect(subject.title).to eq('page1')
-      end
+    it 'returns false if the text is not present' do
+      session = PageMagic::Session.new(instance_double(Capybara::Session, text: 'text'))
+      instance = page_class.new(session)
+
+      expect(instance.text_on_page?('not on page')).to eq(false)
     end
+  end
 
-    describe '#visit' do
-      it 'goes to the class define url' do
-        expect(subject.session.current_path).to eq('/page1')
-      end
+  describe 'title' do
+    it 'returns the title' do
+      session = PageMagic::Session.new(instance_double(Capybara::Session, title: 'page1'))
+      instance = page_class.new(session)
+
+      expect(instance.title).to eq('page1')
     end
+  end
 
-    describe 'method_missing' do
-      it 'gives access to the elements defined on your page classes' do
-        expect(subject.next_page.tag_name).to eq('a')
-      end
+  describe 'method_missing' do
+    let(:spy_element_context) { spy }
+
+    it 'gives access to element definitions' do
+      instance = page_class.new
+      allow(PageMagic::ElementContext).to receive(:new).with(instance).and_return(spy_element_context)
+      instance.next_page(:arg1, :arg2)
+      expect(spy_element_context).to have_received(:next_page).with(:arg1, :arg2)
     end
   end
 end

data/spec/page_magic/mapping_spec.rb

@@ -0,0 +1,181 @@
+# frozen_string_literal: true
+
+RSpec.describe PageMagic::Mapping do
+  describe '#can_compute_uri?' do
+    context 'when there is a regex in the path' do
+      it 'returns false' do
+        expect(described_class.new(//).can_compute_uri?).to eq(false)
+      end
+    end
+
+    context 'when there is a regex in `parameters`' do
+      it 'returns false' do
+        expect(described_class.new(parameters: { param: // }).can_compute_uri?).to eq(false)
+      end
+    end
+
+    context 'when there is a regexp in `fragment`' do
+      it 'returns false' do
+        expect(described_class.new(fragment: //).can_compute_uri?).to eq(false)
+      end
+    end
+
+    context 'when matching element is a regexp' do
+      it 'returns true' do
+        expect(described_class.new('/').can_compute_uri?).to eq(true)
+      end
+    end
+  end
+
+  describe '<=>' do
+    context 'when other does not have a `path`' do
+      it 'is greater' do
+        expect(described_class.new('/') <=> described_class.new(parameters: {})).to be 1
+      end
+    end
+
+    context 'other has a `path`' do
+      it 'compares them' do
+        expect(described_class.new('/', parameters: { param: 1 }) <=> described_class.new('/')).to be 1
+      end
+
+      context 'other has does not have a fragment' do
+        it 'is lesser' do
+          expect(described_class.new('/', parameters: { param: 1 },
+                                          fragment: '') <=> described_class.new('/', parameters: { param: 1 })).to be 1
+        end
+      end
+
+      context 'other has a fragment' do
+        it 'is compares them' do
+          expect(described_class.new('/', parameters: { param: 1 },
+                                          fragment: '') <=> described_class.new('/', parameters: { param: 1 },
+                                                                                     fragment: //)).to be 1
+        end
+      end
+    end
+  end
+
+  describe 'compute_uri' do
+    context 'when path present' do
+      it 'returns a uri' do
+        expect(described_class.new('/').compute_uri).to eq('/')
+      end
+    end
+
+    context 'when matching on parameters' do
+      context 'when matching on 1 parameter' do
+        it 'returns a uri' do
+          expect(described_class.new(parameters: { a: 1 }).compute_uri).to eq('?a=1')
+        end
+      end
+
+      context 'when matching on more than 1 parameter' do
+        it 'returns a uri' do
+          expect(described_class.new(parameters: { a: 1, b: 2 }).compute_uri).to eq('?a=1&b=2')
+        end
+      end
+    end
+
+    context 'when matching on a fragment' do
+      it 'returns a uri' do
+        expect(described_class.new(fragment: 'fragment').compute_uri).to eq('#fragment')
+      end
+    end
+  end
+
+  describe '#matches?' do
+    let(:matching_url) { 'http://www.example.com/path?foo=bar#fragment' }
+    let(:incompatible_url) { 'http://www.example.com/mismatch?miss=match#mismatch' }
+
+    context 'when matching on path' do
+      context 'when using a literal' do
+        subject do
+          described_class.new('/path')
+        end
+
+        it 'returns true for an exact match' do
+          expect(subject.match?(matching_url)).to eq(true)
+        end
+
+        it 'returns false when not an exact match' do
+          expect(subject.match?(incompatible_url)).to eq(false)
+        end
+      end
+
+      context 'when using a regexp' do
+        subject do
+          described_class.new(/\d/)
+        end
+
+        it 'returns true for a match on the regexp' do
+          expect(subject.match?('3')).to eq(true)
+        end
+
+        it 'returns false when regexp is not a match' do
+          expect(subject.match?('/mismatch')).to eq(false)
+        end
+      end
+    end
+
+    context 'when matching on the query string' do
+      context 'parameter requirement is a literal' do
+        subject do
+          described_class.new(parameters: { foo: 'bar' })
+        end
+
+        it 'returns true for a match' do
+          expect(subject.match?(matching_url)).to eq(true)
+        end
+
+        it 'returns false when regexp is not a match' do
+          expect(subject.match?(incompatible_url)).to eq(false)
+        end
+      end
+
+      context 'when matching on parameters' do
+        subject do
+          described_class.new(parameters: { foo: /bar/ })
+        end
+
+        it 'returns true for a match on the regexp' do
+          expect(subject.match?(matching_url)).to eq(true)
+        end
+
+        it 'returns false when regexp is not a match' do
+          expect(subject.match?(incompatible_url)).to eq(false)
+        end
+      end
+    end
+
+    context 'when matching on the fragment' do
+      context 'when the fragment requirement is a literal' do
+        subject do
+          described_class.new(fragment: 'fragment')
+        end
+
+        it 'returns true for a match' do
+          expect(subject.match?(matching_url)).to eq(true)
+        end
+
+        it 'returns false when regexp is not a match' do
+          expect(subject.match?(incompatible_url)).to eq(false)
+        end
+      end
+
+      context 'when the fragment requirement is a regexp' do
+        subject do
+          described_class.new(fragment: /fragment/)
+        end
+
+        it 'returns true for a match on the regexp' do
+          expect(subject.match?(matching_url)).to eq(true)
+        end
+
+        it 'returns false when regexp is not a match' do
+          expect(subject.match?(incompatible_url)).to eq(false)
+        end
+      end
+    end
+  end
+end