page_magic 2.0.0.alpha1 → 2.0.0

data/spec/page_magic/element/query_builder_spec.rb

@@ -1,110 +0,0 @@
-# frozen_string_literal: true
-
-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).and eq(FILE_FIELD).and eq(FILLABLE_FIELD).and eq(RADIO_BUTTON)
-        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,338 +0,0 @@
-# frozen_string_literal: true
-
-# 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: /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 '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

data/spec/support/shared_contexts/files_context.rb

@@ -1,9 +0,0 @@
-# frozen_string_literal: true
-
-shared_context :files do
-  require 'tmpdir'
-
-  def scratch_dir
-    @dir ||= Dir.mktmpdir
-  end
-end