page_magic 2.0.3 → 2.0.9

data/spec/page_magic/elements/config_spec.rb

@@ -1,203 +0,0 @@
-# frozen_string_literal: true
-
-RSpec.describe PageMagic::Elements::Config do
-  describe '.build' do
-    it 'sets of the type' do
-      options = described_class.build([], :field)
-      expect(options.type).to eq(:field)
-    end
-
-    it 'sets the options' do
-      user_options = { option: 1 }
-      options = described_class.build([{ id: 'child' }, user_options], :field)
-      expect(options.options).to eq(user_options)
-    end
-
-    describe 'name' do
-      context 'when supplied' do
-        it 'sets it' do
-          options = described_class.build([:name], :field)
-          expect(options.name).to eq(:name)
-        end
-
-        context 'when an element class supplied' do
-          it 'uses the supplied name' do
-            element_class = Class.new(PageMagic::Element) do
-              selector({ css: 'class' })
-              def self.name
-                'PageSection'
-              end
-            end
-
-            options = described_class.build([:supplied_name, element_class], :field)
-            expect(options.name).to eq(:supplied_name)
-          end
-        end
-      end
-
-      context 'when not supplied' do
-        context 'when an element class supplied' do
-          it 'uses the name of the class' do
-            element_class = Class.new(PageMagic::Element) do
-              selector({ css: 'class' })
-              def self.name
-                'PageSection'
-              end
-            end
-
-            options = described_class.build([element_class], :field)
-            expect(options.name).to eq(:page_section)
-          end
-        end
-      end
-    end
-
-    describe 'selector' do
-      context 'when selector supplied' do
-        it 'sets the selector' do
-          options = described_class.build([{ id: 'child' }], :field)
-          expect(options.selector).to eq(PageMagic::Element::Selector.find(:id).build(:field, 'child'))
-        end
-
-        context 'when is empty hash' do
-          it 'raises an error' do
-            options = described_class.build([{}], :field)
-            expect { options.selector }.to raise_exception(PageMagic::InvalidConfigurationException,
-                                                           described_class::INVALID_SELECTOR_MSG)
-          end
-        end
-
-        context 'when defined on both class and as parameter' do
-          it 'uses the supplied selector' do
-            options = described_class.build([{ css: 'supplied_selector' }], :field)
-            options.definition_class = Class.new(PageMagic::Element) do
-              selector css: 'class_selector'
-            end
-            expect(options.selector).to eq(PageMagic::Element::Selector.find(:css).build(:field, 'supplied_selector'))
-          end
-        end
-
-        context 'when page_element class supplied' do
-          it 'uses the selector on the class' do
-            expected_selector = { css: 'class' }
-            element_class = Class.new(PageMagic::Element) do
-              selector({ css: 'class' })
-              def self.name
-                'PageSection'
-              end
-            end
-            options = described_class.build([element_class, expected_selector], :field)
-
-            expect(options.selector).to eq(PageMagic::Element::Selector.find(:css).build(:field, 'class'))
-          end
-        end
-      end
-
-      context 'when no selector supplied' do
-        context 'when page_element class supplied' do
-          it 'uses the selector on the class' do
-            element_class = Class.new(PageMagic::Element) do
-              selector({ css: 'class' })
-
-              def self.name
-                'PageSection'
-              end
-            end
-            options = described_class.build([element_class], :field)
-
-            expect(options.selector).to eq(PageMagic::Element::Selector.find(:css).build(:field, 'class'))
-          end
-        end
-      end
-
-      context 'when no selector on class or page_element' do
-        context 'when dynamically assigned element definition block' do
-          it 'uses it' do
-            options = described_class.build([], :field)
-
-            options.definition_class = Class.new(PageMagic::Element) do
-              selector({ css: 'class' })
-            end
-
-            expect(options.selector).to eq(PageMagic::Element::Selector.find(:css).build(:field, 'class'))
-          end
-        end
-
-        context 'when not dynamically assigned' do
-          it 'raises and exception' do
-            options = described_class.build([], :field)
-            options.definition_class = Class.new(PageMagic::Element)
-            expect { options.selector }.to raise_exception(PageMagic::InvalidConfigurationException,
-                                                           described_class::INVALID_SELECTOR_MSG)
-          end
-        end
-      end
-    end
-
-    it 'sets prefetched options' do
-      options = described_class.build(%i[page_section prefetched_element], :field)
-      expect(options.element).to eq(:prefetched_element)
-    end
-
-    context 'complex elements' do
-      let!(:element_class) do
-        Class.new(PageMagic::Element) do
-          def self.name
-            'PageSection'
-          end
-        end
-      end
-    end
-  end
-
-  describe '.validate!' do
-    let(:options) do
-      {
-        type: :type,
-        selector: { css: 'css' },
-        element: :object,
-        element_class: Class.new(PageMagic::Element)
-      }
-    end
-
-    context 'when type nil' do
-      it 'raise an error' do
-        subject = described_class.new(options.except(:type))
-        expect { subject.validate! }.to raise_exception(PageMagic::InvalidConfigurationException,
-                                                        described_class::TYPE_REQUIRED_MESSAGE)
-      end
-    end
-
-    describe '`element_class`' do
-      context 'when nil' do
-        it 'raise and error' do
-          subject = described_class.new(options.except(:element_class))
-          expect { subject.validate! }.to raise_exception(PageMagic::InvalidConfigurationException,
-                                                          described_class::INVALID_ELEMENT_CLASS_MSG)
-        end
-      end
-
-      context 'not a type of `PageMagic::Element`' do
-        it 'raise and error' do
-          subject = described_class.new(options.update(element_class: Object))
-          expect { subject.validate! }.to raise_exception(PageMagic::InvalidConfigurationException,
-                                                          described_class::INVALID_ELEMENT_CLASS_MSG)
-        end
-      end
-    end
-  end
-
-  describe '#selector' do
-    it 'returns a selector' do
-      input_options = {
-        type: :type,
-        selector: { css: 'css' },
-        options: { a: :b },
-        element: :object,
-        element_class: Class.new(PageMagic::Element)
-      }
-      options = described_class.new(input_options)
-      expect(options.selector).to eq(PageMagic::Element::Selector.find(:css).build(:type, 'css', options: { a: :b }))
-    end
-  end
-end

data/spec/page_magic/elements_spec.rb

@@ -1,125 +0,0 @@
-# frozen_string_literal: true
-
-RSpec.describe PageMagic::Elements do
-  subject do
-    Class.new do
-      extend PageMagic::Elements
-      include PageMagic::Element::Locators
-    end
-  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
-
-  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
-
-    context 'complex elements' do
-      let!(:section_class) do
-        Class.new(PageMagic::Element) do
-          def self.name
-            'PageSection'
-          end
-        end
-      end
-
-      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 '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 'passes args through to the block' do
-        subject.element :page_section, child_selector do |arg|
-          extend RSpec::Matchers
-          expect(arg).to eq(:arg1)
-        end
-
-        instance.element_by_name(:page_section, :arg1)
-      end
-    end
-
-    describe 'restrictions' do
-      subject do
-        Class.new.tap do |clazz|
-          clazz.extend(described_class)
-        end
-      end
-
-      it 'does 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(PageMagic::InvalidMethodNameException)
-      end
-
-      it 'does 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(PageMagic::InvalidElementNameException)
-      end
-
-      it 'does 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(PageMagic::InvalidElementNameException)
-      end
-
-      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 '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,90 +0,0 @@
-# frozen_string_literal: true
-
-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
-    let(:page_class) do
-      Class.new.tap do |klass|
-        klass.extend(PageMagic::ClassMethods)
-        klass.include(described_class)
-        klass.include RSpec::Matchers
-      end
-    end
-
-    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
-
-      instance.execute_on_load
-    end
-
-    it 'returns self' do
-      instance = page_class.new
-      expect(instance.execute_on_load).to be(instance)
-    end
-  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' 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
-
-  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
-
-    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 '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
-    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

@@ -1,181 +0,0 @@
-# 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