page_magic 2.0.6 → 2.0.9

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

data/spec/page_magic/session_methods_spec.rb

@@ -1,40 +0,0 @@
-# frozen_string_literal: true
-
-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
-      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(session_methods.page).to eq(session.current_page)
-    end
-  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(session_methods.url).to eq(session.current_url)
-    end
-  end
-end

data/spec/page_magic/session_spec.rb

@@ -1,164 +0,0 @@
-# frozen_string_literal: true
-
-RSpec.describe PageMagic::Session do
-  subject(:session) { described_class.new(browser, 'http://base.url') }
-
-  let(:page) do
-    Class.new do
-      include PageMagic
-    end
-  end
-
-  let(:browser) do
-    rack_application = Class.new do
-      def self.call(_env)
-        [200, {}, ['ok']]
-      end
-    end
-
-    Capybara::Session.new(:rack_test, rack_application)
-  end
-
-  describe '#current_page' do
-    let(:another_page_class) do
-      Class.new do
-        include PageMagic
-      end
-    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
-
-    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 '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 '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 '#method_missing' do
-    before do
-      page.class_eval do
-        def my_method
-          :called
-        end
-      end
-    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
-
-    context 'when method not on current page' do
-      it 'delegates to the capybara session' do
-        session = described_class.new(browser).visit(page, url: 'http://base.url')
-        expect(session).to have_text('ok')
-      end
-    end
-  end
-
-  describe '#is_a?' do
-    context 'when other is a `Capybara::Session`' do
-      it 'returns true' do
-        expect(described_class.new(browser).is_a?(Capybara::Session)).to eq(true)
-      end
-    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
-
-    context 'when method is not on self' do
-      before do
-        page.class_eval do
-          def my_method
-            :called
-          end
-        end
-      end
-
-      it 'checks the current page' do
-        session = described_class.new(browser)
-        session.visit(page, url: '/')
-        expect(session.respond_to?(:my_method)).to eq(true)
-      end
-    end
-
-    context 'when method not on self or the current page' do
-      it 'checks the capybara session' do
-        session = described_class.new(browser)
-        expect(session).to respond_to(:has_text?)
-      end
-    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
-
-      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
-
-      it 'raises an error when page no page mappings are found' do
-        expect do
-          session.visit(page)
-        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 { on_load_hook_called = true }
-        session.visit(page, url: 'http://base.url')
-        expect(on_load_hook_called).to eq(true)
-      end
-    end
-
-    context 'when a page and `:url` supplied' do
-      it 'uses the url' do
-        session.visit(page, url: 'http://other.url/')
-        expect(session.current_url).to eq('http://other.url/')
-      end
-    end
-
-    context 'when `url` is supplied' do
-      it 'visits that url' do
-        expected_url = 'http://base.url/page'
-        session.visit(expected_url)
-        expect(browser.current_url).to eq(expected_url)
-      end
-    end
-  end
-end