page_magic 2.0.6 → 2.0.12

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

data/spec/page_magic/transitions_spec.rb

@@ -1,43 +0,0 @@
-# frozen_string_literal: true
-
-RSpec.describe PageMagic::Transitions do
-  describe '#mapped_page' do
-    context 'when a match is match found' do
-      it 'returns the page class' do
-        mappings = described_class.new('/page' => :mapped_page_using_string)
-        expect(mappings.mapped_page('/page')).to be(:mapped_page_using_string)
-      end
-    end
-
-    context 'when more than one match is found' do
-      it 'returns the most specific match' do
-        mappings = described_class.new(%r{/page} => :mapped_page_using_regex, '/page' => :mapped_page_using_string)
-        expect(mappings.mapped_page('/page')).to eq(:mapped_page_using_string)
-      end
-    end
-
-    context 'when a mapping is not found' do
-      it 'returns nil' do
-        mappings = described_class.new({})
-        expect(mappings.mapped_page('/unmapped_page')).to be(nil)
-      end
-    end
-  end
-
-  describe '#url_for' do
-    it 'returns the url for the mapped page' do
-      page = Object.new
-      mappings = described_class.new('/mapping' => page)
-      expect(mappings.url_for(page, base_url: 'http://base.url')).to eq('http://base.url/mapping')
-    end
-
-    context 'when page mapping is a regular expression' do
-      it 'raises an error' do
-        page = Object.new
-        mappings = described_class.new(/mapping/ => page)
-        expect { mappings.url_for(page, base_url: 'http://base.url') }
-          .to raise_exception PageMagic::InvalidURLException, described_class::REGEXP_MAPPING_MSG
-      end
-    end
-  end
-end

data/spec/page_magic/utils/string_spec.rb

@@ -1,29 +0,0 @@
-# frozen_string_literal: true
-
-RSpec.describe PageMagic::Utils::String do
-  describe '.classify' do
-    context 'when parameter is symbol' do
-      it 'returns a string' do
-        expect(described_class.classify(:Symbol)).to eq('Symbol')
-      end
-    end
-
-    context 'when parameter is string' do
-      it 'returns a string' do
-        expect(described_class.classify(:String)).to eq('String')
-      end
-    end
-
-    context 'when the first letter is lower case' do
-      it 'converts the first letter to uppercase' do
-        expect(described_class.classify(:symbol)).to eq('Symbol')
-      end
-    end
-
-    context 'when parameter is in snakecase' do
-      it 'removes underscores and capitalises each word' do
-        expect(described_class.classify(:snake_case)).to eq('SnakeCase')
-      end
-    end
-  end
-end

data/spec/page_magic/utils/url_spec.rb

@@ -1,9 +0,0 @@
-# frozen_string_literal: true
-
-RSpec.describe PageMagic::Utils::URL do
-  describe '#concat' do
-    it 'produces compound url' do
-      expect(described_class.concat('http://base.url/', '/home')).to eq('http://base.url/home')
-    end
-  end
-end

data/spec/page_magic/wait_methods_spec.rb

@@ -1,35 +0,0 @@
-# frozen_string_literal: true
-
-RSpec.describe PageMagic::WaitMethods do
-  include described_class
-
-  describe '#wait_until' do
-    let(:default_options) { { timeout_after: 0.1, retry_every: 0.05 } }
-    let!(:start_time) { Time.now }
-
-    it 'waits until the prescribed thing has happened' do
-      expect { wait_until(**default_options) { true } }.not_to raise_exception
-    end
-
-    it 'keeps trying for a specified period' do
-      wait_until(**default_options) { false }
-    rescue PageMagic::TimeoutException
-      expect(Time.now - default_options[:timeout_after]).to be > start_time
-    end
-
-    context 'when `timeout_after` specified' do
-      it 'throws an exception if when the prescribed action does not happen in time' do
-        expect { wait_until(**default_options) { false } }.to raise_error PageMagic::TimeoutException
-      end
-    end
-
-    context 'when retry time specified' do
-      it 'retries at the given interval' do
-        count = 0
-        expect { wait_until(timeout_after: 0.2, retry_every: 0.1) { count += 1 } }
-          .to raise_exception(PageMagic::TimeoutException)
-          .and change { count }.by(2)
-      end
-    end
-  end
-end

data/spec/page_magic/watcher_spec.rb

@@ -1,22 +0,0 @@
-# frozen_string_literal: true
-
-RSpec.describe PageMagic::Watcher do
-  describe '#initialize' do
-    context 'when `check` has not been called yet' do
-      it 'sets `observed_value` to nil' do
-        instance = described_class.new(:custom_watcher, context: self)
-        expect(instance.observed_value).to be_nil
-      end
-    end
-  end
-
-  describe '#check' do
-    it 'assigns last to be the result of calling the block passed to the constructor' do
-      instance = described_class.new(:object_id, context: self) do
-        object_id
-      end
-      instance.check
-      expect(instance.observed_value).to eq(object_id)
-    end
-  end
-end

data/spec/page_magic/watchers_spec.rb

@@ -1,80 +0,0 @@
-# frozen_string_literal: true
-
-require 'ostruct'
-RSpec.describe PageMagic::Watchers do
-  include described_class
-  let(:element) { OpenStruct.new(text: :current_value) }
-
-  describe '#changed?' do
-    context 'when the watched element has changed' do
-      it 'returns true' do
-        watch(:element_watcher, context: element, method: :text)
-        element.text = :new_value
-        expect(changed?(:element_watcher)).to eq(true)
-      end
-    end
-
-    context 'when the watched element has not changed' do
-      it 'returns false' do
-        watch(:element_watcher, context: element, method: :text)
-        expect(changed?(:element_watcher)).to eq(false)
-      end
-    end
-  end
-
-  describe '#watch' do
-    it 'stores the initial value of the watched element' do
-      watch(:element_watcher, context: element, method: :text)
-      expect(watcher(:element_watcher).observed_value).to eq(:current_value)
-    end
-
-    context 'when a method name is supplied' do
-      it 'stores the watch instruction' do
-        watch(:object_id)
-        watcher = watcher(:object_id)
-        expect(watcher.check.observed_value).to eq(object_id)
-      end
-    end
-
-    context 'when a watcher name and a method are supplied' do
-      it 'stores the watch instruction' do
-        watch(:my_watcher, method: :object_id)
-        watcher = watcher(:my_watcher)
-        expect(watcher.check.observed_value).to eq(object_id)
-      end
-    end
-
-    context 'when a block is supplied' do
-      it 'stores the watch instruction' do
-        block = proc { :value }
-        watch(:my_watcher, &block)
-        watcher = watcher(:my_watcher)
-        expect(watcher.check.observed_value).to eq(:value)
-      end
-    end
-
-    context 'when a watcher with the same name is added' do
-      it 'replaces the watcher' do
-        original_watcher = watch(:object_id)
-        expect(watcher(:object_id)).not_to be(original_watcher)
-      end
-    end
-
-    context 'when a watcher defined on a method that does not exist' do
-      it 'raises an error' do
-        expected_message = described_class::ELEMENT_MISSING_MSG % :text
-        expect do
-          watch(:missing, method: :text)
-        end.to raise_exception(PageMagic::ElementMissingException, expected_message)
-      end
-    end
-  end
-
-  describe '#watcher' do
-    it 'returns the watcher with the given name' do
-      watch(:my_watcher, method: :object_id)
-      watcher = watcher(:my_watcher)
-      expect(watcher.check.observed_value).to eq(object_id)
-    end
-  end
-end

data/spec/page_magic_spec.rb

@@ -1,115 +0,0 @@
-# frozen_string_literal: true
-
-require 'page_magic'
-
-RSpec.describe PageMagic do
-  subject(:page_class) do
-    Class.new.tap do |klass|
-      klass.include(described_class)
-    end
-  end
-
-  describe '.drivers' do
-    it 'returns loaded drivers' do
-      expected_drivers = described_class::Drivers.new.tap(&:load)
-
-      expect(described_class.drivers).to eq(expected_drivers)
-    end
-  end
-
-  describe '.included' do
-    it 'gives a method for defining the url' do
-      page_class.url :url
-      expect(page_class.url).to eq(:url)
-    end
-
-    it 'lets you define elements' do
-      expect(page_class).to be_a(PageMagic::Elements)
-    end
-  end
-
-  describe '.inherited' do
-    let(:parent_page) do
-      Class.new do
-        include PageMagic
-        link(:next, text: 'next page')
-      end
-    end
-
-    let(:child_page) do
-      Class.new(parent_page)
-    end
-
-    describe 'children' do
-      it 'inherits elements defined on the parent class' do
-        expect(child_page.element_definitions).to include(:next)
-      end
-
-      it 'passes on element definitions to their children' do
-        grand_child_class = Class.new(child_page)
-        expect(grand_child_class.element_definitions).to include(:next)
-      end
-    end
-  end
-
-  describe '#mapping' do
-    it 'returns a matcher' do
-      mapping = described_class.mapping('/', parameters: {}, fragment: '')
-      expect(mapping).to eq(PageMagic::Mapping.new('/', parameters: {}, fragment: ''))
-    end
-  end
-
-  describe '.session' do
-    let(:rack_application) do
-      Class.new do
-        def self.call(_env)
-          [200, {}, ['hello world!!']]
-        end
-      end
-    end
-
-    let(:url) { 'http://url.com/' }
-
-    it "defaults to capybara's default session " do
-      Capybara.default_driver = :rack_test
-      expect(page_class.new.browser.mode).to eq(:rack_test)
-    end
-
-    context 'when `:browser` is specified' do
-      it 'loads the correct driver' do
-        session = described_class.session(application: rack_application, browser: :firefox, url: :url)
-        expect(session.raw_session.driver).to be_a(Capybara::Selenium::Driver)
-      end
-    end
-
-    context 'when `:rack_application` is specified' do
-      it 'configures capybara to run against the app' do
-        session = described_class.session(application: rack_application, url: url)
-        expect(session.raw_session.app).to be(rack_application)
-      end
-    end
-
-    context 'when `session` is specified' do
-      it 'uses it' do
-        session = described_class.session(session: :custom_session)
-        expect(session.raw_session).to be(:custom_session)
-      end
-    end
-
-    context 'when `:options` is specified' do
-      it 'passes the options to the browser driver' do
-        options = { option: :config }
-        session = described_class.session(options: options, browser: :chrome, url: url)
-
-        expect(session.raw_session.driver.options).to include(options)
-      end
-    end
-
-    context 'when the driver assigned to `:browser` is not found' do
-      it 'raises an error' do
-        expected_exception = described_class::UnsupportedBrowserException
-        expect { described_class.session(browser: :invalid, url: url) }.to raise_exception expected_exception
-      end
-    end
-  end
-end

data/spec/spec_helper.rb

@@ -1,15 +0,0 @@
-# frozen_string_literal: true
-
-this_dir = File.dirname(__FILE__)
-$LOAD_PATH.unshift("#{this_dir}/lib")
-require 'support/shared_contexts'
-require 'support/shared_examples'
-
-require 'simplecov' if ENV['coverage']
-
-require 'page_magic'
-
-Dir["#{this_dir}/../lib/page_magic/drivers/*.rb"].sort.each do |driver|
-  require driver
-end
-Capybara.server = :webrick

data/spec/support/shared_contexts.rb

@@ -1,5 +0,0 @@
-# frozen_string_literal: true
-
-Dir["#{__dir__}/shared_contexts/*.rb"].sort.each do |file|
-  require file
-end

data/spec/support/shared_examples.rb

@@ -1,25 +0,0 @@
-# frozen_string_literal: true
-
-RSpec.shared_examples 'session accessor' do
-  it 'includes session methods' do
-    expect(described_class.included_modules).to include(PageMagic::SessionMethods)
-  end
-end
-
-RSpec.shared_examples 'element watcher' do
-  it 'includes watchers' do
-    expect(described_class.included_modules).to include(PageMagic::Watchers)
-  end
-end
-
-RSpec.shared_examples 'waiter' do
-  it 'includes waiters' do
-    expect(described_class.included_modules).to include(PageMagic::WaitMethods)
-  end
-end
-
-RSpec.shared_examples 'element locator' do
-  it 'includes Locators' do
-    expect(described_class.included_modules).to include(PageMagic::Element::Locators)
-  end
-end