page_magic 1.0.0.alpha13 → 1.0.0.alpha17

data/spec/page_magic/elements_spec.rb

@@ -1,202 +1,205 @@
-describe PageMagic::Elements do
-  let(:page_elements) do
-    Class.new do
-      extend(PageMagic::Elements)
+# rubocop:disable Metrics/ModuleLength
+module PageMagic
+  describe Elements do
+    let(:page_elements) do
+      Class.new.tap do |clazz|
+        clazz.extend(described_class)
+      end
     end
-  end
-
-  let(:selector) { {id: 'id'} }
-  let(:browser_element) { double('browser_element', find: :browser_element) }
-  let(:parent_page_element) do
-    double('parent_page_element', browser_element: browser_element)
-  end
 
-  describe 'adding elements' do
+    let(:selector) { { id: 'id' } }
+    let(:browser_element) { double('browser_element', find: :browser_element) }
+    let(:parent_page_element) do
+      double('parent_page_element', browser_element: browser_element)
+    end
 
-    context 'using a selector' do
-      it 'should add an element' do
-        expected_element = PageMagic::Element.new(:name, parent_page_element, type: :text_field, selector: selector)
-        page_elements.text_field :name, selector
-        page_elements.element_definitions[:name].call(parent_page_element).should == expected_element
+    describe 'adding elements' do
+      context 'using a selector' do
+        it 'should add an element' do
+          expected_element = Element.new(:name, parent_page_element, type: :text_field, selector: selector)
+          page_elements.text_field :name, selector
+          expect(page_elements.element_definitions[:name].call(parent_page_element)).to eq(expected_element)
+        end
       end
-    end
 
-    it 'uses the supplied name' do
-      page_elements.text_field :alias, selector
-      expect(page_elements.elements(parent_page_element).first.name).to eq(:alias)
-    end
+      it 'uses the supplied name' do
+        page_elements.text_field :alias, selector
+        expect(page_elements.elements(parent_page_element).first.name).to eq(:alias)
+      end
 
-    context 'complex elements' do
-      let!(:section_class) do
-        Class.new(PageMagic::Element) do
-          def ==(other)
-            other.name == name &&
+      context 'complex elements' do
+        let!(:section_class) do
+          Class.new(Element) do
+            def ==(other)
+              other.name == name &&
                 other.browser_element == browser_element
+            end
           end
         end
-      end
 
-      context 'using a predefined class' do
+        context 'using a predefined class' do
+          it 'should add an element using that class section' do
+            expected_section = section_class.new(:page_section, parent_page_element, type: :section, selector: selector)
 
-        it 'should add an element using that class section' do
-          expected_section = section_class.new(:page_section, parent_page_element, type: :section, selector: selector)
-
-          page_elements.section section_class, :page_section, selector
-          page_elements.elements(parent_page_element).first.should == expected_section
-        end
+            page_elements.element section_class, :page_section, selector
+            expect(page_elements.elements(parent_page_element).first).to eq(expected_section)
+          end
 
-        context 'with no selector supplied' do
-          it 'defaults the selector to the one on the class' do
-            section_class.selector selector
-            page_elements.section section_class, :alias
-            expect(page_elements.elements(parent_page_element).first.selector).to eq(selector)
+          context 'with no selector supplied' do
+            it 'defaults the selector to the one on the class' do
+              section_class.selector selector
+              page_elements.element section_class, :alias
+              expect(page_elements.elements(parent_page_element).first.selector).to eq(selector)
+            end
           end
-        end
 
-        context 'with no name supplied' do
-          it 'should default to the name of the class if one is not supplied' do
-            section_class.stub(:name).and_return('PageSection')
-            page_elements.section section_class, selector
-            page_elements.elements(parent_page_element).first.name.should == :page_section
+          context 'with no name supplied' do
+            it 'should default to the name of the class if one is not supplied' do
+              allow(section_class).to receive(:name).and_return('PageSection')
+              page_elements.element section_class, selector
+              expect(page_elements.elements(parent_page_element).first.name).to eq(:page_section)
+            end
           end
         end
       end
-    end
 
-    context 'using a block' do
-      context 'browser_element' do
-        before :each do
-          @browser = double('browser')
-          @element = double('element')
-          @parent_page_element = double('parent_page_element')
-          @parent_page_element.stub(:browser_element).and_return(@browser)
-          @browser.should_receive(:find).with(:css, :selector).and_return(@element)
-        end
+      context 'using a block' do
+        context 'browser_element' do
+          before :each do
+            @browser = double('browser')
+            @element = double('element')
+            @parent_page_element = double('parent_page_element')
+            allow(@parent_page_element).to receive(:browser_element).and_return(@browser)
+            expect(@browser).to receive(:find).with(:selector).and_return(@element)
+          end
 
-        it 'should be assigned when selector is passed to section method' do
-          element = @element
+          it 'should be assigned when selector is passed to section method' do
+            element = @element
 
-          page_elements.section :page_section, css: :selector do
-            browser_element.should == element
+            page_elements.element :page_section, css: :selector do
+              extend RSpec::Matchers
+              expect(browser_element).to eq(element)
+            end
+
+            page_elements.element_definitions[:page_section].call(@parent_page_element)
           end
 
-          page_elements.element_definitions[:page_section].call(@parent_page_element)
-        end
+          it 'should be assigned when selector is defined in the block passed to the section method' do
+            element = @element
 
-        it 'should be assigned when selector is defined in the block passed to the section method' do
-          element = @element
+            page_elements.element :page_section do
+              selector css: :selector
+              extend RSpec::Matchers
+              expect(browser_element).to eq(element)
+            end
 
-          page_elements.section :page_section do
-            selector css: :selector
-            browser_element.should == element
+            page_elements.elements(@parent_page_element, nil)
           end
-
-          page_elements.elements(@parent_page_element, nil)
         end
-      end
 
-      it 'should pass args through to the block' do
-        page_elements.section :page_section, css: '.blah' do |arg|
-          arg[:passed_through] = true
-        end
+        it 'should pass args through to the block' do
+          page_elements.element :page_section, css: '.blah' do |arg|
+            arg[:passed_through] = true
+          end
 
-        arg = {}
-        browser = double('browser', find: :browser_element)
-        parent_page_element = double('parent_browser_element', browser_element: browser)
-        page_elements.elements(parent_page_element, arg)
-        arg[:passed_through].should be_true
-      end
+          arg = {}
+          browser = double('browser', find: :browser_element)
+          parent_page_element = double('parent_browser_element', browser_element: browser)
+          page_elements.elements(parent_page_element, arg)
+          expect(arg[:passed_through]).to eq(true)
+        end
 
-      it 'should return your a copy of the core definition' do
-        page_elements.element :page_section, selector
-        first = page_elements.element_definitions[:page_section].call(parent_page_element)
-        second = page_elements.element_definitions[:page_section].call(parent_page_element)
-        first.should_not equal(second)
+        it 'should return your a copy of the core definition' do
+          page_elements.element :page_section, selector
+          first = page_elements.element_definitions[:page_section].call(parent_page_element)
+          second = page_elements.element_definitions[:page_section].call(parent_page_element)
+          expect(first).to_not equal(second)
+        end
       end
-    end
 
-    describe 'location' do
-      context 'a prefetched object' do
-        it 'should add a section' do
-          expected_section = PageMagic::Element.new(:page_section, parent_page_element, type: :element, browser_element: :object)
-          page_elements.element :page_section, :object
-          expected_section.should == page_elements.elements(parent_page_element).first
+      describe 'location' do
+        context 'a prefetched object' do
+          it 'should add a section' do
+            expected_section = Element.new(:page_section, parent_page_element, type: :element, browser_element: :object)
+            page_elements.element :page_section, :object
+            expect(expected_section).to eq(page_elements.elements(parent_page_element).first)
+          end
         end
       end
-    end
 
-    describe 'session handle' do
-      it 'should be on instances created from a class' do
-        browser_element = double(:browser_element, find: :browser_element)
-        parent = double('parent', session: :current_session, browser_element: browser_element)
-        page_elements.element  :page_section, selector
+      describe 'session handle' do
+        it 'should be on instances created from a class' do
+          browser_element = double(:browser_element, find: :browser_element)
+          parent = double('parent', session: :current_session, browser_element: browser_element)
+          page_elements.element :page_section, selector
 
-        section = page_elements.element_definitions[:page_section].call(parent)
+          section = page_elements.element_definitions[:page_section].call(parent)
 
-        section.session.should == :current_session
-      end
+          expect(section.session).to eq(:current_session)
+        end
 
-      it 'should be on instances created dynamically using the section method' do
-        browser_element = double('browser_element')
-        browser_element.stub(:find)
-        parent = double('parent', session: :current_session, browser_element: browser_element)
+        it 'should be on instances created dynamically using the section method' do
+          browser_element = double('browser_element')
+          allow(browser_element).to receive(:find)
+          parent = double('parent', session: :current_session, browser_element: browser_element)
 
-        page_elements.section :page_section, css: :selector do
-        end
+          page_elements.element :page_section, css: :selector do
+          end
 
-        section = page_elements.element_definitions[:page_section].call(parent)
-        section.session.should == :current_session
+          section = page_elements.element_definitions[:page_section].call(parent)
+          expect(section.session).to eq(:current_session)
+        end
       end
     end
-  end
 
-  describe 'retrieving element definitions' do
-    it 'should return your a copy of the core definition' do
-      page_elements.text_field :name, selector
-      first = page_elements.element_definitions[:name].call(parent_page_element)
-      second = page_elements.element_definitions[:name].call(parent_page_element)
-      first.should_not equal(second)
+    describe 'retrieving element definitions' do
+      it 'should return your a copy of the core definition' do
+        page_elements.text_field :name, selector
+        first = page_elements.element_definitions[:name].call(parent_page_element)
+        second = page_elements.element_definitions[:name].call(parent_page_element)
+        expect(first).to_not equal(second)
+      end
     end
-  end
 
-  describe 'restrictions' do
-    it 'should not allow method names that match element names' do
-      expect do
-        page_elements.class_eval do
-          link(:hello, text: 'world')
+    describe 'restrictions' do
+      it 'should not allow method names that match element names' do
+        expect do
+          page_elements.class_eval do
+            link(:hello, text: 'world')
 
-          def hello
+            def hello
+            end
           end
-        end
-      end.to raise_error(PageMagic::Elements::InvalidMethodNameException)
-    end
+        end.to raise_error(InvalidMethodNameException)
+      end
 
-    it 'should not allow element names that match method names' do
-      expect do
-        page_elements.class_eval do
-          def hello
+      it 'should not allow element names that match method names' do
+        expect do
+          page_elements.class_eval do
+            def hello
+            end
+
+            link(:hello, text: 'world')
           end
+        end.to raise_error(InvalidElementNameException)
+      end
 
-          link(:hello, text: 'world')
-        end
-      end.to raise_error(PageMagic::Elements::InvalidElementNameException)
-    end
+      it 'should not allow duplicate element names' do
+        expect do
+          page_elements.class_eval do
+            link(:hello, text: 'world')
+            link(:hello, text: 'world')
+          end
+        end.to raise_error(InvalidElementNameException)
+      end
 
-    it 'should not allow duplicate element names' do
-      expect do
+      it 'should not evaluate the elements when applying naming checks' do
         page_elements.class_eval do
-          link(:hello, text: 'world')
-          link(:hello, text: 'world')
-        end
-      end.to raise_error(PageMagic::Elements::InvalidElementNameException)
-    end
-
-    it 'should not evaluate the elements when applying naming checks' do
-      page_elements.class_eval do
-        link(:link1, :selector) do
-          fail('should not have been evaluated')
+          link(:link1, :selector) do
+            fail('should not have been evaluated')
+          end
+          link(:link2, :selector)
         end
-        link(:link2, :selector)
       end
     end
   end

data/spec/page_magic/page_magic_spec.rb

@@ -1,19 +1,62 @@
 describe PageMagic do
-  context '#respond_to?' do
-    subject do
-      page_class = Class.new do
-        include PageMagic
-        element :sub_element, id: 'sub-element'
-      end
-      page_class.new
+  include_context :webapp_fixture
+  subject do
+    described_class = described_class()
+    page_class = Class.new do
+      include described_class
+      url '/page1'
+      link(:next_page, text: 'next page')
     end
+    page_class.new.tap(&:visit)
+  end
 
+  context '#respond_to?' do
     it 'checks self' do
       expect(subject.respond_to?(:visit)).to eq(true)
     end
 
     it 'checks the current page' do
-      expect(subject.respond_to?(:sub_element)).to eq(true)
+      expect(subject.respond_to?(:next_page)).to eq(true)
+    end
+  end
+
+  describe 'visit' do
+    it 'goes to the class define url' do
+      expect(subject.session.current_path).to eq('/page1')
+    end
+  end
+
+  describe 'session' do
+    it 'gives access to the page magic object wrapping the user session' do
+      expect(subject.session.raw_session).to be(Capybara.current_session)
+    end
+  end
+
+  describe 'text_on_page?' do
+    it 'returns true if the text is present' do
+      expect(subject.text_on_page?('next page')).to eq(true)
+    end
+
+    it 'returns false if the text is not present' do
+      expect(subject.text_on_page?('not on page')). to eq(false)
+    end
+  end
+
+  describe 'title' do
+    it 'returns the title' do
+      expect(subject.title).to eq('page1')
+    end
+  end
+
+  describe 'text' do
+    it 'returns the text on the page' do
+      expect(subject.text).to eq('next page')
+    end
+  end
+
+  describe 'method_missing' do
+    it 'gives access to the elements defined on your page classes' do
+      expect(subject.next_page.tag_name).to eq('a')
     end
   end
 end

data/spec/page_magic/session_spec.rb

@@ -1,15 +1,16 @@
+# rubocop:disable Metrics/ModuleLength
 module PageMagic
   describe Session do
     let(:page) do
       Class.new do
         include PageMagic
-        url '/page1'
       end
     end
 
     subject { described_class.new(browser) }
 
-    let(:browser) { double('browser', current_url: 'url', visit: nil, current_path: :current_path) }
+    let(:url) { 'http://url.com' }
+    let(:browser) { double('browser', current_url: url, visit: nil, current_path: :current_path) }
 
     describe '#current_url' do
       it "returns the browser's current url" do
@@ -33,7 +34,7 @@ module PageMagic
 
       before do
         subject.define_page_mappings another_page_class.url => another_page_class
-        subject.visit(page)
+        subject.visit(page, url: url)
       end
 
       context 'page url has not changed' do
@@ -77,64 +78,81 @@ module PageMagic
     end
 
     describe '#visit' do
-
       let(:session) do
-        PageMagic::Session.new(browser)
+        allow(browser).to receive(:visit)
+        PageMagic::Session.new(browser, url)
       end
 
-      context 'page supplied' do
-        context 'url supplied' do
-          it 'uses this url instead of the one defined on the page class' do
-            expect(browser).to receive(:visit).with(:custom_url)
-            session.visit(page, url: :custom_url)
-            expect(session.current_page).to be_a(page)
-          end
+      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 current url and the path in the page mappings' do
+        session.define_page_mappings '/page' => page
+        expect(browser).to receive(:visit).with("#{browser.current_url}/page")
+        session.visit(page)
+      end
+
+      context 'no mappings found' do
+        it 'raises an error' do
+          expect { session.visit(page) }.to raise_exception InvalidURLException, described_class::URL_MISSING_MSG
         end
+      end
 
-        context 'url defined on page_class' do
-          it 'visits the url on defined on the page class' do
-            browser.should_receive(:visit).with(page.url)
-            session.visit(page)
-            expect(session.current_page).to be_a(page)
-          end
+      context 'mapping is a regular expression' do
+        it 'raises an error' do
+          session.define_page_mappings(/mapping/ => page)
+          expect { session.visit(page) }.to raise_exception InvalidURLException, described_class::REGEXP_MAPPING_MSG
+        end
+      end
+
+      context 'url supplied' do
+        it 'visits that url' do
+          expected_url = 'http://url.com/page'
+          expect(browser).to receive(:visit).with(expected_url)
+          session.visit(url: expected_url)
         end
+      end
+    end
+
+    describe '#url' do
+      let!(:base_url) { 'http://example.com' }
+      let!(:path) { 'home' }
+      let!(:expected_url) { "#{base_url}/#{path}" }
 
-        context 'url not specified' do
-          context 'url not specified on page class' do
-            before do
-              page.instance_variable_set(:@url, nil)
-            end
-            it 'uses the current url and the path in the page mappings' do
-              session.define_page_mappings '/page' => page
-              expect(browser).to receive(:visit).with("#{browser.current_url}/page")
-              session.visit(page)
-            end
-
-            context 'no mappings found' do
-              it 'raises an error' do
-                expect { session.visit(page) }.to raise_exception InvalidURLException, described_class::URL_MISSING_MSG
-              end
-            end
-
-            context 'mapping is a regular expression' do
-              it 'raises an error' do
-                session.define_page_mappings %r{mapping} => page
-                expect { session.visit(page) }.to raise_exception InvalidURLException, described_class::REGEXP_MAPPING_MSG
-              end
-            end
+      context 'base_url has a / on the end' do
+        before do
+          base_url << '/'
+        end
+
+        context 'path has / at the beginning' do
+          it 'produces compound url' do
+            expect(subject.url(base_url, path)).to eq(expected_url)
           end
         end
 
-        context 'url supplied' do
-          it 'visits that url' do
-            expected_url = 'http://url.com'
-            expect(browser).to receive(:visit).with(expected_url)
-            session.visit(expected_url)
+        context 'path does not have / at the beginning' do
+          it 'produces compound url' do
+            expect(subject.url(base_url, "/#{path}")).to eq(expected_url)
           end
         end
       end
 
+      context 'current_url does not have a / on the end' do
+        context 'path has / at the beginning' do
+          it 'produces compound url' do
+            expect(subject.url(base_url, "/#{path}")).to eq(expected_url)
+          end
+        end
 
+        context 'path does not have / at the beginning' do
+          it 'produces compound url' do
+            expect(subject.url(base_url, path)).to eq(expected_url)
+          end
+        end
+      end
     end
 
     context '#method_missing' do
@@ -145,15 +163,15 @@ module PageMagic
           end
         end
 
-        session = PageMagic::Session.new(browser).visit(page)
-        session.my_method.should be(:called)
+        session = PageMagic::Session.new(browser).visit(page, url: url)
+        expect(session.my_method).to be(:called)
       end
     end
 
     context '#respond_to?' do
       subject do
         PageMagic::Session.new(browser).tap do |s|
-          s.current_page = page.new
+          allow(s).to receive(:current_page).and_return(page.new)
         end
       end
       it 'checks self' do
@@ -162,11 +180,11 @@ module PageMagic
 
       it 'checks the current page' do
         page.class_eval do
-          def my_method;
+          def my_method
           end
         end
         expect(subject.respond_to?(:my_method)).to eq(true)
       end
     end
   end
-end
+end