page_magic 2.0.0.alpha1 → 2.0.0

data/spec/page_magic/utils/string_spec.rb

@@ -1,35 +1,28 @@
 # frozen_string_literal: true
 
-require 'page_magic/utils/string'
-module PageMagic
-  module Utils
-    describe String do
-      describe '.classify' do
-        context 'parameter is symbol' do
-          it 'returns a string' do
-            expect(described_class.classify(:Symbol)).to eq('Symbol')
-          end
-        end
+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 'parameter is string' do
-          it 'returns a string' do
-            expect(described_class.classify(:String)).to eq('String')
-          end
-        end
+    context 'when parameter is string' do
+      it 'returns a string' do
+        expect(described_class.classify(:String)).to eq('String')
+      end
+    end
 
-        context 'single word' do
-          context 'first letter is lower case' do
-            it 'converts the first letter to uppercase' do
-              expect(described_class.classify(:symbol)).to eq('Symbol')
-            end
-          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 'snakecase' do
-          it 'removes underscores and capitalises each word' do
-            expect(described_class.classify(:snake_case)).to eq('SnakeCase')
-          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

data/spec/page_magic/utils/url_spec.rb

@@ -0,0 +1,9 @@
+# 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,42 +1,34 @@
 # frozen_string_literal: true
 
-module PageMagic
-  describe WaitMethods do
-    subject do
-      Object.new.tap do |o|
-        o.extend(described_class)
-      end
-    end
+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 { subject.wait_until(**default_options) { true } }.to_not raise_exception
+      expect { wait_until(**default_options) { true } }.not_to raise_exception
     end
 
-    it 'should keep trying for a specified period' do
-      start_time = Time.now
-
-      expect { subject.wait_until(**default_options) { false } }.to raise_exception TimeoutException
-
+    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 'timeout_after specified' do
+    context 'when `timeout_after` specified' do
       it 'throws an exception if when the prescribed action does not happen in time' do
-        expect { subject.wait_until(**default_options) { false } }.to raise_error TimeoutException
+        expect { wait_until(**default_options) { false } }.to raise_error PageMagic::TimeoutException
       end
     end
 
-    context 'retry time specified' do
+    context 'when retry time specified' do
       it 'retries at the given interval' do
         count = 0
-        expect do
-          subject.wait_until(timeout_after: default_options[:timeout_after] * 2, retry_every: 0.1) do
-            count += 1
-          end
-        end.to raise_exception TimeoutException
-        expect(count).to eq(2)
+        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

data/spec/page_magic/watcher_spec.rb

@@ -0,0 +1,22 @@
+# 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,86 +1,80 @@
 # frozen_string_literal: true
 
-module PageMagic
-  describe Watchers do
-    let(:element) { OpenStruct.new(text: :current_value) }
+require 'ostruct'
+RSpec.describe PageMagic::Watchers do
+  include described_class
+  let(:element) { OpenStruct.new(text: :current_value) }
 
-    subject do
-      Object.new.tap do |o|
-        o.extend(described_class)
-        allow(o).to receive(:my_watcher).and_return(element)
+  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
 
-    describe '#changed?' do
-      before do
-        subject.watch(:my_watcher, :text)
-      end
-
-      context 'watched element has changed' do
-        it 'returns true' do
-          element.text = :new_value
-          expect(subject.changed?(:my_watcher)).to eq(true)
-        end
-      end
-
-      context 'watched element has not changed' do
-        it 'returns false' do
-          expect(subject.changed?(:my_watcher)).to eq(false)
-        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
-        subject.watch(:my_watcher, :text)
-        expect(subject.watcher(:my_watcher).last).to eq(:current_value)
-      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 'element name/ method name supplied' do
-        it 'stores the watch instruction' do
-          subject.watch(:object_id)
-          expect(subject.watcher(:object_id)).to eq(Watcher.new(:object_id))
-        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 'element name and attribute supplied' do
-        it 'stores the watch instruction' do
-          subject.watch(:my_watcher, :text)
-          expect(subject.watcher(:my_watcher)).to eq(Watcher.new(:my_watcher, :text))
-        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 'block supplied' do
-        it 'stores the watch instruction' do
-          block = proc {}
-          subject.watch(:my_watcher, &block)
-          expect(subject.watcher(:my_watcher)).to eq(Watcher.new(:my_watcher, &block))
-        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 'watcher with the same name added' do
-        it 'replaces the watcher' do
-          subject.watch(:object_id)
-          original_watcher = subject.watchers.first
-          subject.watch(:object_id)
-          expect(subject.watchers.size).to eq(1)
-          expect(subject.watchers.first).to_not be(original_watcher)
-        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 'watcher defined on element that does not exist' do
-        it 'raises an error' do
-          expected_message = described_class::ELEMENT_MISSING_MSG % :missing
-          expect { subject.watch(:missing, :text) }.to raise_exception(ElementMissingException, expected_message)
-        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
-        subject.watch(:my_watcher, :text)
-        expect(subject.watcher(:my_watcher)).to eq(Watcher.new(:my_watcher, :text))
-      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

@@ -2,9 +2,11 @@
 
 require 'page_magic'
 
-describe PageMagic do
-  subject do
-    Class.new { include PageMagic }
+RSpec.describe PageMagic do
+  subject(:page_class) do
+    Class.new.tap do |klass|
+      klass.include(described_class)
+    end
   end
 
   describe '.drivers' do
@@ -17,12 +19,12 @@ describe PageMagic do
 
   describe '.included' do
     it 'gives a method for defining the url' do
-      subject.url :url
-      expect(subject.url).to eq(:url)
+      page_class.url :url
+      expect(page_class.url).to eq(:url)
     end
 
     it 'lets you define elements' do
-      expect(subject).to be_a(PageMagic::Elements)
+      expect(page_class).to be_a(PageMagic::Elements)
     end
   end
 
@@ -38,12 +40,12 @@ describe PageMagic do
       Class.new(parent_page)
     end
 
-    context 'children' do
-      it 'should inherit elements defined on the parent class' do
+    describe 'children' do
+      it 'inherits elements defined on the parent class' do
         expect(child_page.element_definitions).to include(:next)
       end
 
-      it 'should pass on element definitions to their children' do
+      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
@@ -53,40 +55,41 @@ describe PageMagic do
   describe '#mapping' do
     it 'returns a matcher' do
       mapping = described_class.mapping('/', parameters: {}, fragment: '')
-      expect(mapping).to eq(PageMagic::Matcher.new('/', parameters: {}, fragment: ''))
+      expect(mapping).to eq(PageMagic::Mapping.new('/', parameters: {}, fragment: ''))
     end
   end
 
   describe '.session' do
-    include_context :rack_application
+    let(:rack_application) do
+      Class.new do
+        def self.call(_env)
+          [200, {}, ['hello world!!']]
+        end
+      end
+    end
 
     let(:url) { 'http://url.com/' }
-    let(:application) { rack_application.new }
-
-    before do
-      allow_any_instance_of(Capybara::Selenium::Driver).to receive(:visit)
-    end
 
     it "defaults to capybara's default session " do
       Capybara.default_driver = :rack_test
-      expect(subject.new.browser.mode).to eq(:rack_test)
+      expect(page_class.new.browser.mode).to eq(:rack_test)
     end
 
-    context 'specifying the browser' do
+    context 'when `:browser` is specified' do
       it 'loads the correct driver' do
-        session = described_class.session(application: rack_application.new, browser: :firefox, url: :url)
+        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 'specifying a rack application' do
+    context 'when `:rack_application` is specified' do
       it 'configures capybara to run against the app' do
-        session = described_class.session(application: application, url: url)
-        expect(session.raw_session.app).to be(application)
+        session = described_class.session(application: rack_application, url: url)
+        expect(session.raw_session.app).to be(rack_application)
       end
     end
 
-    context 'specifying options' do
+    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)
@@ -95,7 +98,7 @@ describe PageMagic do
       end
     end
 
-    context 'driver for browser not found' do
+    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

data/spec/spec_helper.rb

@@ -1,11 +1,15 @@
 # frozen_string_literal: true
-require 'bundler'
-Bundler.require
-$LOAD_PATH.unshift("#{File.dirname(__FILE__)}/lib")
+
+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_examples.rb

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