page_magic 2.0.0.alpha1 → 2.0.0

data/spec/page_magic/element/query/multiple_results_spec.rb

@@ -0,0 +1,14 @@
+# frozen_string_literal: true
+
+RSpec.describe PageMagic::Element::Query::MultipleResults do
+  describe '#find' do
+    context 'when multiple results found' do
+      it 'returns an array' do
+        element = PageMagic::Element.load('<a></a><a></a>')
+        subject = described_class.new('a')
+        result = subject.execute(element)
+        expect(result.size).to eq(2)
+      end
+    end
+  end
+end

data/spec/page_magic/element/query/single_result_spec.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+RSpec.describe PageMagic::Element::Query::SingleResult do
+  describe '#find' do
+    context 'when more than one result is returned' do
+      it 'raises an error' do
+        element = PageMagic::Element.load('<a></a><a></a>')
+        query = described_class.new('a')
+        expected_message = 'Ambiguous match, found 2 elements matching visible css "a"'
+        expect { query.execute(element) }.to raise_error PageMagic::AmbiguousQueryException, expected_message
+      end
+    end
+
+    it 'returns the result of the capybara query' do
+      element = PageMagic::Element.load('<a>link</a>')
+      query = described_class.new('a')
+      result = query.execute(element)
+      expect(result.text).to eq('link')
+    end
+  end
+end

data/spec/page_magic/element/query_spec.rb

@@ -1,58 +1,37 @@
 # frozen_string_literal: true
 
-module PageMagic
-  class Element
-    describe Query do
-      include_context :webapp_fixture
-
-      let(:page) do
-        elements_page = Class.new do
-          include PageMagic
-          url '/elements'
-        end
-        elements_page.visit(application: rack_app).current_page
-      end
-
-      describe '#execute' do
-        context 'no results found' do
-          subject do
-            QueryBuilder.find(:link).build({ css: 'wrong' })
-          end
-
-          it 'raises an error' do
-            expected_message = 'Unable to find css "wrong"'
-            expect { subject.execute(page.browser) }.to raise_exception(ElementMissingException, expected_message)
-          end
-        end
-
-        context 'to many results returned' do
-          subject do
-            QueryBuilder.find(:link).build({ css: 'a' })
-          end
+RSpec.describe PageMagic::Element::Query do
+  describe '#execute' do
+    it 'calls find' do
+      subject = described_class.new
+      allow(subject).to receive(:find)
+
+      subject.execute(:capybara_element)
+      expect(subject).to have_received(:find).with(:capybara_element)
+    end
 
-          it 'raises an error' do
-            expected_message = 'Ambiguous match, found 2 elements matching visible css "a"'
-            expect { subject.execute(page.browser) }.to raise_error AmbiguousQueryException, expected_message
-          end
-        end
+    context 'when a formatter supplied' do
+      it 'uses it' do
+        subject = described_class.new
+        allow(subject).to receive(:find) { |_r, &formatter| formatter.call(:result) }
 
-        context 'multiple results found' do
-          subject do
-            QueryBuilder.find(:link).build({ css: 'a' }, {}, multiple_results: true)
-          end
+        result = subject.execute(:capybara_element) { |capybara_result| "formatter_called_on_#{capybara_result}" }
+        expect(result).to eq('formatter_called_on_result')
+      end
+    end
 
-          it 'returns an array' do
-            result = subject.execute(page.browser)
-            expect(result).to be_a(Array)
-            expect(result.size).to eq(2)
+    context 'when no results are found' do
+      subject(:query_class) do
+        Class.new(described_class) do
+          def find(element)
+            element.find('missing')
           end
         end
+      end
 
-        it 'returns the result of the capybara query' do
-          query = QueryBuilder.find(:link).build({ id: 'form_link' })
-          result = query.execute(page.browser)
-          expect(result.text).to eq('link in a form')
-        end
+      it 'Returns `NotFound`' do
+        element = PageMagic::Element.load('<html></html>')
+        expect(query_class.new.execute(element)).to be_a(PageMagic::Element::NotFound)
       end
     end
   end

data/spec/page_magic/element/selector_spec.rb

@@ -1,157 +1,165 @@
 # frozen_string_literal: true
 
-module PageMagic
-  class Element
-    describe Selector do
-      describe '.find' do
-        it 'returns the constant with the given name' do
-          expect(Selector.find(:css)).to be(described_class::CSS)
-        end
+RSpec.describe PageMagic::Element::Selector do
+  describe '.find' do
+    it 'returns the constant with the given name' do
+      expect(described_class.find(:css)).to be(described_class::CSS)
+    end
 
-        context 'selector not found' do
-          it 'raises an exception' do
-            expect { Selector.find(:invalid) }.to raise_exception(UnsupportedCriteriaException)
-          end
-        end
+    context 'when selector not found' do
+      it 'raises an exception' do
+        expect { described_class.find(:invalid) }.to raise_exception(PageMagic::UnsupportedCriteriaException)
       end
+    end
+  end
 
-      describe '#build' do
-        it 'puts the locator and element type in to the result' do
-          expect(subject.build(:field, :locator)).to eq([:locator])
-        end
-
-        context 'exact is set to true' do
-          subject do
-            described_class.new(exact: true)
-          end
-
-          it 'includes the requirement for the match to be exact' do
-            expect(subject.build(:field, :locator)).to include(exact: true)
-          end
-        end
-
-        context 'supports_type flag set to true in constructor' do
-          subject do
-            described_class.new(supports_type: true)
-          end
-          it 'includes the element type in the result' do
-            expect(subject.build(:field, :locator)).to eq(%i[field locator])
-          end
-        end
+  describe '#build' do
+    it 'puts the locator and element type in to the result' do
+      expect(described_class.new.build(:field, :locator)).to have_attributes(
+        args: [:locator]
+      )
+    end
 
-        context 'formatter supplied to constructor' do
-          subject do
-            described_class.new do |param|
-              "formatted_#{param}".to_sym
-            end
-          end
-          it 'uses the formatter' do
-            expect(subject.build(:field, :locator)).to eq([:formatted_locator])
-          end
-        end
+    context 'when exact matching is required' do
+      it 'is added to options' do
+        expect(described_class.new(exact: true).build(:field, :locator)).to have_attributes(
+          options: { exact: true }
+        )
+      end
+    end
 
-        context 'name supplied to constructor' do
-          subject do
-            described_class.new(:css)
-          end
+    context 'when supports_type true' do
+      it 'includes the element type' do
+        expect(described_class.new(supports_type: true).build(:field, :locator)).to have_attributes(
+          args: %i[field locator]
+        )
+      end
+    end
 
-          it 'is added to the result' do
-            expect(subject.build(:field, :locator)).to eq(%i[css locator])
-          end
+    # TODO: - new class?
+    context 'when selector formatter is provided' do
+      subject(:selector) do
+        described_class.new do |param|
+          "formatted_#{param}".to_sym
         end
       end
 
-      describe '#initialize' do
-        it 'sets exact to false by default' do
-          expect(subject.exact).to eq(false)
-        end
+      it 'uses the formatter' do
+        expect(selector.build(:field, :locator)).to have_attributes(
+          args: [:formatted_locator]
+        )
       end
     end
 
-    class Selector
-      shared_examples 'named selector' do |options|
-        it 'adds name to the result' do
-          expected = [described_class.name, :locator, options].compact
-          expect(described_class.build(:element_type, :locator)).to eq(expected)
-        end
+    context 'when type supplied' do
+      it 'is added to the result' do
+        expect(described_class.new(:css).build(:field, :locator)).to have_attributes(
+          args: %i[css locator]
+        )
       end
+    end
+  end
 
-      shared_examples 'anonymous selector' do
-        it 'does not have a name' do
-          expect(described_class.name).to eq(nil)
-        end
+  describe '#initialize' do
+    context 'when exact' do
+      it 'sets the option' do
+        subject = described_class.new(exact: true).build(:element_type, {})
+        expect(subject.options).to eq({ exact: true })
       end
+    end
+  end
 
-      shared_examples 'element type selector' do
-        it 'adds the element type to the result' do
-          expect(described_class.supports_type).to eq(true)
-        end
+  describe 'predefined selectors' do
+    shared_examples 'a selector' do |named: false, **options|
+      def selector_name
+        self.class.metadata[:parent_example_group][:description].to_sym
       end
 
-      shared_examples 'non element type selector' do
-        it 'adds the element type to the result' do
-          expect(described_class.supports_type).to eq(false)
-        end
+      subject do
+        described_class.find(selector_name).build(:element_type, :locator)
       end
 
-      describe NAME do
-        it_behaves_like 'anonymous selector'
-        it_behaves_like 'non element type selector'
+      it 'contains the selector args' do
+        name_arg = named && (named == true ? selector_name : named)
 
-        it 'formats locators' do
-          button_name = 'my_button'
-          expect(described_class.build(:button, button_name)).to eq(["*[name='#{button_name}']"])
-        end
+        expected_args = [name_arg, :locator].compact
+        expect(subject.args).to eq(expected_args)
       end
 
-      describe XPATH do
-        it_behaves_like 'named selector'
-        it_behaves_like 'non element type selector'
+      it 'contains the options' do
+        expect(subject.options).to eq(options)
       end
+    end
 
-      describe ID do
-        it_behaves_like 'named selector'
-        it_behaves_like 'non element type selector'
-      end
+    let(:capybara_element) do
+      html_source = <<~HTML_SOURCE
+        <a href='#'>a link</a>
 
-      describe LABEL do
-        it_behaves_like 'named selector', exact: true
-        it_behaves_like 'non element type selector'
-      end
 
-      describe TEXT do
-        it_behaves_like 'anonymous selector'
-        it_behaves_like 'element type selector'
+          <div id='form' class="form">
+            <a id='form_link' href='/page2'>link in a form</a>
+            <label>enter text
+              <input id='field_id' name='field_name' class='input_class' type='text' value='filled in'/>
+            </label>
+            <button id='form_button' type='submit' value='a button'/>
+          </form>
+      HTML_SOURCE
+      PageMagic::Element.load(html_source)
+    end
+
+    describe 'label' do
+      it_behaves_like 'a selector', named: :field, exact: true
+
+      it 'finds elements by label' do
+        selector = described_class.find(:label).build(:text_field, 'enter text')
+        query = PageMagic::Element::Query::SingleResult.new(*selector.args)
+        expect(query.execute(capybara_element)[:name]).to eq('field_name')
       end
     end
 
-    context 'integration' do
-      include_context :webapp_fixture
-      let(:capybara_session) { Capybara::Session.new(:rack_test, rack_app).tap { |s| s.visit('/elements') } }
+    describe 'name' do
+      it 'formats locators' do
+        name = 'my_button'
+        expect(described_class::NAME.build(:element_type, name)).to have_attributes(
+          args: ["*[name='#{name}']"],
+          options: {}
+        )
+      end
 
       it 'finds elements by name' do
-        query = QueryBuilder.find(:text_field).build({ name: 'field_name' })
-        expect(query.execute(capybara_session)[:name]).to eq('field_name')
+        selector = described_class.find(:name).build(:text_field, 'field_name')
+        query = PageMagic::Element::Query::SingleResult.new(*selector.args)
+        expect(query.execute(capybara_element)[:name]).to eq('field_name')
       end
+    end
+
+    describe 'xpath' do
+      it_behaves_like 'a selector', named: true
 
       it 'finds elements by xpath' do
-        query = QueryBuilder.find(:element).build({ xpath: '//div/label/input' })
-        expect(query.execute(capybara_session)[:name]).to eq('field_name')
+        selector = described_class.find(:xpath).build(:element, '//div/label/input')
+        query = PageMagic::Element::Query::SingleResult.new(*selector.args)
+        expect(query.execute(capybara_element)[:name]).to eq('field_name')
       end
+    end
+
+    describe 'id' do
+      it_behaves_like 'a selector', named: true
 
       it 'finds elements by id' do
-        query = QueryBuilder.find(:text_field).build({ id: 'field_id' })
-        expect(query.execute(capybara_session)[:name]).to eq('field_name')
+        selector = described_class.find(:id).build(:text_field, 'field_id')
+        query = PageMagic::Element::Query::SingleResult.new(*selector.args)
+        expect(query.execute(capybara_element)[:name]).to eq('field_name')
       end
+    end
 
-      it 'finds elements by label' do
-        query = QueryBuilder.find(:text_field).build({ label: 'enter text' })
-        expect(query.execute(capybara_session)[:name]).to eq('field_name')
-      end
+    describe 'text' do
+      it_behaves_like 'a selector', named: :element_type
 
       it 'finds elements by text' do
-        query = QueryBuilder.find(:link).build({ text: 'a link' })
-        expect(query.execute(capybara_session).text).to eq('a link')
+        selector = described_class.find(:text).build(:link, 'a link')
+        query = PageMagic::Element::Query::SingleResult.new(*selector.args)
+        expect(query.execute(capybara_element).text).to eq('a link')
       end
     end
   end

data/spec/page_magic/element_context_spec.rb

@@ -1,113 +1,71 @@
 # frozen_string_literal: true
 
-module PageMagic
-  describe ElementContext do
-    include_context :webapp_fixture
-
-    let!(:elements_page) do
-      Class.new do
-        include PageMagic
-        url '/elements'
-        link(:a_link, text: 'a link')
-        link(:prefetched, Object.new)
-      end
-    end
-
-    let(:page) do
-      elements_page.visit(application: rack_app).current_page
-    end
-
-    subject do
-      described_class.new(page)
+RSpec.describe PageMagic::ElementContext do
+  describe '#method_missing' do
+    let(:element_class) do
+      Class.new(PageMagic::Element)
     end
 
-    let!(:session) do
-      double('session', raw_session: double('browser'))
-    end
-
-    describe '#method_missing' do
-      context 'method is a element defintion' do
-        it 'returns the sub page element' do
-          element = described_class.new(page).a_link
-          expect(element.text).to eq('a link')
-        end
-
-        it 'passes arguments through to the element definition' do
-          elements_page.links :pass_through, css: 'a' do |args|
-            args[:passed_through] = true
-          end
-          args = {}
-          described_class.new(page).pass_through(args)
-          expect(args[:passed_through]).to eq(true)
-        end
-
-        it 'does not evaluate any of the other definitions' do
-          elements_page.class_eval do
-            link(:another_link, :selector) do
-              raise('should not have been evaluated')
-            end
-          end
+    context 'when method is a element definition' do
+      it 'returns the sub page element' do
+        element_class.link(:a_link, text: 'a link')
+        element = described_class.new(element_class.load("<a href='#'>a link</a>")).a_link
+        expect(element.text).to eq('a link')
+      end
 
-          described_class.new(page).a_link
-        end
+      it 'passes arguments through to the element definition' do
+        element_class.link(:pass_through, css: 'a') { |args| args[:passed_through] = true }
 
-        context 'more than one match found in the browser' do
-          it 'returns an array of element definitions' do
-            elements_page.links :links, css: 'a'
-            links = described_class.new(page).links
-            expect(links.find_all { |e| e.kind_of?(Element) }.size).to eq(2)
-            expect(links.collect(&:text)).to eq(['a link', 'link in a form'])
-          end
-        end
+        args = {}
+        described_class.new(element_class.load("<a href='#'>a link</a>")).pass_through(args)
+        expect(args[:passed_through]).to eq(true)
       end
 
-      context 'method found on page_element' do
-        it 'calls page_element method' do
-          elements_page.class_eval do
-            def page_method
-              :called
-            end
-          end
+      it 'does not evaluate any of the other definitions' do
+        element_class.link(:a_link, text: 'a link')
+        element_class.link(:another_link, :selector) { raise('should not have been evaluated') }
 
-          expect(described_class.new(page).page_method).to eq(:called)
-        end
+        described_class.new(element_class.load("<a href='#'>a link</a>")).a_link
       end
+    end
 
-      context 'element is prefetched' do
-        it 'does not call find' do
-          expect(subject).not_to receive(:find)
-          described_class.new(page).prefetched
+    context 'when the method is found on page_element' do
+      it 'calls page_element method' do
+        element_class.define_method(:page_method) do
+          :called
         end
-      end
 
-      context 'method not found on page_element or as a element definition' do
-        it 'raises an error' do
-          expect { elements_page.missing_method }.to raise_error(NoMethodError)
-        end
+        expect(described_class.new(element_class.load("<a href='#'>a link</a>")).page_method).to eq(:called)
       end
     end
 
-    describe '#respond_to?' do
-      let(:page_element) do
-        Class.new(Element) do
-          link(:a_link, css: '.link')
-        end
+    context 'when the method is not found on page_element or as a element definition' do
+      it 'raises an error' do
+        expect do
+          described_class.new(PageMagic::Element.load('')).missing_method
+        end.to raise_error(PageMagic::ElementMissingException)
       end
+    end
+  end
 
-      subject do
-        described_class.new(page_element.new(session))
+  describe '#respond_to?' do
+    let(:page_element_class) do
+      Class.new(PageMagic::Element) do
+        link(:a_link, text: 'a link')
       end
+    end
 
-      context 'page_element responds to method name' do
-        it 'returns true' do
-          expect(subject.respond_to?(:a_link)).to eq(true)
-        end
+    context 'when the page_element responds to method name' do
+      it 'returns true' do
+        element = described_class.new(page_element_class.load("<a href='#'>a link</a>"))
+        expect(element).to respond_to(:a_link)
       end
+    end
 
-      context 'method is not on page_element' do
-        it 'calls super' do
-          expect(subject.respond_to?(:methods)).to eq(true)
-        end
+    context 'when the method is not on the page_element' do
+      it 'calls super' do
+        element = described_class.new(page_element_class.load("<a href='#'>a link</a>")).a_link
+        expect(element.text).to respond_to(:methods)
       end
     end
   end