page_magic 1.2.8 → 2.0.2

data/spec/element_spec.rb

@@ -1,249 +0,0 @@
-# rubocop:disable Metrics/ModuleLength
-module PageMagic
-  describe Element do
-    include_context :webapp_fixture
-
-    let(:page_class) do
-      Class.new do
-        include PageMagic
-        url '/elements'
-      end
-    end
-
-    let(:session) { page_class.visit(application: rack_app) }
-
-    let(:page) { session.current_page }
-
-    let(:described_class) do
-      Class.new(Element).tap { |clazz| clazz.parent_element(page) }
-    end
-
-    subject do
-      described_class.new(:page_element)
-    end
-
-    it_behaves_like 'session accessor'
-    it_behaves_like 'element watcher'
-    it_behaves_like 'waiter'
-    it_behaves_like 'element locator'
-
-    describe '.after_events' do
-      subject do
-        Class.new(described_class)
-      end
-
-      context 'hook set' do
-        it 'returns that hook' do
-          hook = proc {}
-          subject.after_events(&hook)
-          expect(subject.after_events).to eq([described_class::DEFAULT_HOOK, hook])
-        end
-      end
-      context 'hook not registered' do
-        it 'returns the default hook' do
-          expect(subject.after_events).to eq([described_class::DEFAULT_HOOK])
-        end
-      end
-    end
-
-    describe '.before_events' do
-      subject do
-        Class.new(described_class)
-      end
-
-      context 'hook set' do
-        it 'returns that hook' do
-          hook = proc {}
-          subject.before_events(&hook)
-          expect(subject.before_events).to eq([described_class::DEFAULT_HOOK, hook])
-        end
-      end
-      context 'hook not registered' do
-        it 'returns the default hook' do
-          expect(subject.before_events).to eq([described_class::DEFAULT_HOOK])
-        end
-      end
-    end
-
-    describe '.inherited' do
-      it 'copies before hooks' do
-        before_hook = proc {}
-        described_class.before_events(&before_hook)
-        sub_class = Class.new(described_class)
-        expect(sub_class.before_events).to include(before_hook)
-      end
-
-      it 'copies after hooks' do
-        after_hook = proc {}
-        described_class.after_events(&after_hook)
-        sub_class = Class.new(described_class)
-        expect(sub_class.after_events).to include(after_hook)
-      end
-
-      it 'lets sub classes defined their own elements' do
-        custom_element = Class.new(described_class) do
-          text_field :form_field, id: 'field_id'
-
-          def self.name
-            'Form'
-          end
-        end
-
-        page_class.class_eval do
-          element custom_element, css: '.form'
-        end
-
-        expect(page.form.form_field).to be_visible
-      end
-    end
-
-    describe '.watch' do
-      let(:described_class) { Class.new(Element) }
-      it 'adds a before hook with the watcher in it' do
-        described_class.watch(:object_id)
-        instance = described_class.new(:element)
-
-        watcher_block = instance.before_events.last
-        instance.instance_exec(&watcher_block)
-        expect(instance.watchers.first.last).to eq(instance.object_id)
-      end
-    end
-
-    describe 'EVENT_TYPES' do
-      context 'methods created' do
-        it 'creates methods for each of the event types' do
-          missing = described_class::EVENT_TYPES.find_all { |event| !subject.respond_to?(event) }
-          expect(missing).to be_empty
-        end
-
-        context 'method called' do
-          let(:browser_element) { instance_double(Capybara::Node::Element) }
-          subject do
-            described_class.new(browser_element)
-          end
-          it 'calls the browser_element passing on all args' do
-            expect(browser_element).to receive(:select).with(:args)
-            subject.select :args
-          end
-        end
-
-        context 'Capybara element does not respond to the method' do
-          it 'raises an error' do
-            expected_message = (described_class::EVENT_NOT_SUPPORTED_MSG % 'click')
-            expect { subject.click }.to raise_error(NotSupportedException, expected_message)
-          end
-        end
-      end
-    end
-
-    describe 'hooks' do
-      subject do
-        Class.new(described_class) do
-          before_events do
-            call_in_before_events
-          end
-        end.new(double('button', click: true))
-      end
-      context 'method called in before_events' do
-        it 'calls methods on the page element' do
-          expect(subject).to receive(:call_in_before_events)
-          subject.click
-        end
-      end
-
-      context 'method called in after_events' do
-        subject do
-          Class.new(described_class) do
-            after_events do
-              call_in_after_events
-            end
-          end.new(double('button', click: true))
-        end
-
-        it 'calls methods on the page element' do
-          expect(subject).to receive(:call_in_after_events)
-          subject.click
-        end
-      end
-    end
-
-    describe '#initialize' do
-      it 'sets the parent element' do
-        instance = described_class.new(:element)
-        expect(instance.parent_element).to eq(page)
-      end
-
-      context 'inherited items' do
-        let(:described_class) do
-          Class.new(Element)
-        end
-
-        it 'copies the event hooks from the class' do
-          before_hook = proc {}
-          after_hook = proc {}
-          described_class.before_events(&before_hook)
-          described_class.after_events(&after_hook)
-
-          instance = described_class.new(:element)
-
-          expect(instance.before_events).to include(before_hook)
-          expect(instance.after_events).to include(after_hook)
-        end
-      end
-    end
-
-    describe '#method_missing' do
-      before do
-        page_class.class_eval do
-          element :form_by_css, css: '.form' do
-            def parent_method
-              :parent_method_called
-            end
-            link(:link_in_form, text: 'link in a form')
-          end
-        end
-      end
-
-      it 'can delegate to capybara' do
-        expect(page.form_by_css).to be_visible
-      end
-
-      context 'no element definition and not a capybara method' do
-        it 'calls method on parent element' do
-          expect(page.form_by_css.link_in_form.parent_method).to eq(:parent_method_called)
-        end
-
-        context 'method not found on parent' do
-          it 'throws and exception' do
-            expect { page.form_by_css.link_in_a_form.bobbins }.to raise_exception ElementMissingException
-          end
-        end
-      end
-    end
-
-    describe '#respond_to?' do
-      subject do
-        Class.new(described_class) do
-          element :sub_element, css: '.sub-element'
-        end.new(double(element_method: ''))
-      end
-      it 'checks for methods on self' do
-        expect(subject.respond_to?(:session)).to eq(true)
-      end
-
-      it 'checks against registered elements' do
-        expect(subject.respond_to?(:sub_element)).to eq(true)
-      end
-
-      it 'checks for the method of the browser_element' do
-        expect(subject.respond_to?(:element_method)).to eq(true)
-      end
-    end
-
-    describe '#session' do
-      it 'should have a handle to the session' do
-        expect(subject.session).to eq(page.session)
-      end
-    end
-  end
-end

data/spec/page_magic/element/query_builder_spec.rb

@@ -1,108 +0,0 @@
-module PageMagic
-  class Element
-    describe QueryBuilder do
-      it 'has a predefined query for each element type' do
-        missing = PageMagic::Elements::TYPES.dup.delete_if { |type| type.to_s.end_with?('s') }.find_all do |type|
-          described_class.constants.include?(type)
-        end
-        expect(missing).to be_empty
-      end
-
-      describe '.find' do
-        it 'finds the constant with the given name' do
-          expect(described_class.find(:button)).to be(described_class::BUTTON)
-        end
-
-        context 'constant not found' do
-          it 'returns a default' do
-            expect(described_class.find(:billy)).to be(described_class::ELEMENT)
-          end
-        end
-      end
-
-      describe '#build' do
-        let(:selector) { Selector.new }
-        before do
-          expect(Selector).to receive(:find).with(:css).and_return(selector)
-        end
-        let(:locator) { { css: '.css' } }
-
-        it 'builds a query using the correct selector' do
-          expected = Query.new(locator.values)
-          expect(subject.build(locator)).to eq(expected)
-        end
-
-        it 'adds options to the result' do
-          expected = Query.new(locator.values.concat([:options]))
-          expect(subject.build(locator, :options)).to eq(expected)
-        end
-
-        context 'selector support element type' do
-          subject do
-            described_class.new(:field)
-          end
-
-          it 'passes element type through to the selector' do
-            expect(selector).to receive(:build).with(:field, '.css').and_call_original
-            subject.build(locator)
-          end
-        end
-      end
-    end
-
-    class QueryBuilder
-      describe BUTTON do
-        it 'has an element type' do
-          expect(described_class.type).to eq(:button)
-        end
-      end
-
-      describe ELEMENT do
-        it ' does not has an element type' do
-          expect(described_class.type).to be_nil
-        end
-      end
-
-      describe LINK do
-        it 'has an element type' do
-          expect(described_class.type).to eq(:link)
-        end
-      end
-
-      describe TEXT_FIELD do
-        it 'has an element type' do
-          expect(described_class.type).to eq(:field)
-        end
-
-        it 'the same as all form field types' do
-          expect(described_class).to eq(CHECKBOX).and eq(SELECT_LIST).and eq(RADIO).and eq(TEXTAREA)
-        end
-      end
-    end
-
-    context 'integration' do
-      include_context :webapp_fixture
-      let(:capybara_session) { Capybara::Session.new(:rack_test, rack_app).tap { |s| s.visit('/elements') } }
-
-      it 'finds fields' do
-        query = QueryBuilder.find(:text_field).build(name: 'field_name')
-        expect(query.execute(capybara_session).tag_name).to eq('input')
-      end
-
-      it 'finds buttons' do
-        query = QueryBuilder.find(:button).build(text: 'a button')
-        expect(query.execute(capybara_session).tag_name).to eq('button')
-      end
-
-      it 'finds links' do
-        query = QueryBuilder.find(:link).build(text: 'a link')
-        expect(query.execute(capybara_session).tag_name).to eq('a')
-      end
-
-      it 'finds elements' do
-        query = QueryBuilder.find(:element).build(name: 'field_name')
-        expect(query.execute(capybara_session).tag_name).to eq('input')
-      end
-    end
-  end
-end

data/spec/page_magic/matcher_spec.rb

@@ -1,336 +0,0 @@
-# rubocop:disable Metrics/ModuleLength
-module PageMagic
-  describe Matcher do
-    describe '#initialize' do
-      context 'no componentes specified' do
-        it 'raises an exeception' do
-          expect { described_class.new }.to raise_exception(MatcherInvalidException)
-        end
-      end
-    end
-    describe '#can_compute_uri?' do
-      context 'regex in path' do
-        it 'returns false' do
-          expect(described_class.new(//).can_compute_uri?).to eq(false)
-        end
-      end
-
-      context 'regex in parameters' do
-        it 'returns false' do
-          expect(described_class.new(parameters: { param: // }).can_compute_uri?).to eq(false)
-        end
-      end
-
-      context 'regexp in fragment' do
-        it 'returns false' do
-          expect(described_class.new(fragment: //).can_compute_uri?).to eq(false)
-        end
-      end
-
-      context 'regexp not present' do
-        it 'returns true' do
-          expect(described_class.new('/').can_compute_uri?).to eq(true)
-        end
-      end
-    end
-
-    describe 'compare' do
-      subject { described_class.new('/') }
-      context 'param 1 not nil' do
-        context 'param 2 not nil' do
-          context 'literal to fuzzy' do
-            it 'returns -1' do
-              expect(subject.instance_eval { compare('/', //) }).to eq(-1)
-            end
-          end
-
-          context 'literal to literal' do
-            it 'returns 0' do
-              expect(subject.instance_eval { compare('/', '/') }).to eq(0)
-            end
-          end
-
-          context 'fuzzy to fuzzy' do
-            it 'returns 0' do
-              expect(subject.instance_eval { compare(//, //) }).to eq(0)
-            end
-          end
-
-          context 'fuzzy to literal' do
-            it 'returns 1' do
-              expect(subject.instance_eval { compare(//, '/') }).to eq(1)
-            end
-          end
-        end
-
-        context 'param2 is nil' do
-          it 'returns -1' do
-            expect(subject.instance_eval { compare('/', nil) }).to eq(-1)
-          end
-        end
-      end
-
-      context 'param1 is nil' do
-        context 'param2 not nil' do
-          it 'returns 1' do
-            expect(subject.instance_eval { compare(nil, '/') }).to eq(1)
-          end
-        end
-
-        context 'param2 nil' do
-          it 'returns 0' do
-            expect(subject.instance_eval { compare(nil, nil) }).to eq(0)
-          end
-        end
-      end
-    end
-
-    describe 'compute_uri' do
-      context 'path present' do
-        it 'returns a uri' do
-          expect(described_class.new('/').compute_uri).to eq('/')
-        end
-      end
-
-      context 'params present' do
-        context '1 param' do
-          it 'returns a uri' do
-            expect(described_class.new(parameters: { a: 1 }).compute_uri).to eq('?a=1')
-          end
-        end
-
-        context 'more than 1 param' 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 'fragment present' 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 'path requirement exists' do
-        context 'path is 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 'path is 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 'query string requirement exists' 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 'parameter requirement is a regexp' do
-          subject do
-            described_class.new(parameters: { foo: /b[a]r/ })
-          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 'fragment requirement exists' do
-        context '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 '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
-
-    describe '<=>' do
-      let(:literal_path_matcher) { '/' }
-      let(:fuzzy_path_matcher) { // }
-      let(:literal_parameter_matchers) { { param: 'value' } }
-      let(:fuzzy_parameter_matchers) { { param: // } }
-
-      let(:literal_fragment_matcher) { 'fragment' }
-      let(:fuzzy_fragment_matcher) { // }
-
-      context 'path' do
-        context 'path is of same class as path on other' do
-          subject(:a) { described_class.new('/a') }
-          subject(:b) { described_class.new('/b') }
-          it 'returns self and other as equivalent' do
-            expect(a <=> b).to eq(0)
-          end
-        end
-
-        context 'path on other is fuzzy' do
-          subject(:a) { described_class.new(literal_path_matcher) }
-          subject(:b) { described_class.new(fuzzy_path_matcher) }
-          it 'returns other as lesser' do
-            expect(a <=> b).to eq(-1)
-          end
-        end
-      end
-
-      context 'parameters' do
-        context 'parameters on self and other contain literal values' do
-          subject(:a) do
-            described_class.new(literal_path_matcher,
-                                parameters: literal_parameter_matchers)
-          end
-          subject(:b) do
-            described_class.new(literal_path_matcher,
-                                parameters: literal_parameter_matchers)
-          end
-          it 'returns self and other as equivalent' do
-            expect(a <=> b).to eq(0)
-          end
-        end
-
-        context 'parameters on self literal values and other has fuzzy values' do
-          subject(:a) do
-            described_class.new(literal_path_matcher,
-                                parameters: literal_parameter_matchers)
-          end
-          subject(:b) do
-            described_class.new(literal_path_matcher,
-                                parameters: fuzzy_parameter_matchers)
-          end
-          it 'returns other as lesser' do
-            expect(a <=> b).to eq(-1)
-          end
-        end
-        context 'parameters on self fuzzy values and other has literal values' do
-          subject(:a) do
-            described_class.new(literal_path_matcher,
-                                parameters: fuzzy_parameter_matchers)
-          end
-
-          subject(:b) do
-            described_class.new(literal_path_matcher,
-                                parameters: literal_parameter_matchers)
-          end
-
-          it 'returns other as greater' do
-            expect(a <=> b).to eq(1)
-          end
-        end
-      end
-
-      context 'fragment' do
-        context 'fragment is of same class as path on other' do
-          subject(:a) do
-            described_class.new(literal_path_matcher,
-                                parameters: literal_parameter_matchers,
-                                fragment: literal_fragment_matcher)
-          end
-
-          subject(:b) do
-            described_class.new(literal_path_matcher,
-                                parameters: literal_parameter_matchers,
-                                fragment: literal_fragment_matcher)
-          end
-
-          it 'returns self and other as equivalent' do
-            expect(a <=> b).to eq(0)
-          end
-        end
-
-        context 'fragment is literal on self and fuzzy on other' do
-          subject(:a) do
-            described_class.new(literal_path_matcher,
-                                parameters: literal_parameter_matchers,
-                                fragment: literal_fragment_matcher)
-          end
-
-          subject(:b) do
-            described_class.new(literal_path_matcher,
-                                parameters: literal_parameter_matchers,
-                                fragment: fuzzy_fragment_matcher)
-          end
-
-          it 'returns other as lesser' do
-            expect(a <=> b).to eq(-1)
-          end
-        end
-
-        context 'fragment is fuzzy on self and literal on other' do
-          subject(:a) do
-            described_class.new(literal_path_matcher,
-                                parameters: literal_parameter_matchers,
-                                fragment: fuzzy_fragment_matcher)
-          end
-
-          subject(:b) do
-            described_class.new(literal_path_matcher,
-                                parameters: literal_parameter_matchers,
-                                fragment: literal_fragment_matcher)
-          end
-          it 'returns other as lesser' do
-            expect(a <=> b).to eq(1)
-          end
-        end
-      end
-    end
-  end
-end