page_magic 2.0.0.alpha1 → 2.0.0

data/spec/page_magic/comparator/literal_spec.rb

@@ -0,0 +1,41 @@
+RSpec.describe PageMagic::Comparator::Literal do
+  describe 'match?' do
+    context 'when parameter is the same' do
+      it 'returns true' do
+        expect(described_class.new('/')).to be_match('/')
+      end
+    end
+
+    context 'when it parameter is not the same' do
+      it 'returns false' do
+        expect(described_class.new('/')).not_to be_match('foo')
+      end
+    end
+  end
+
+  describe '#fuzzy?' do
+    it 'returns false' do
+      expect(described_class.new('value')).not_to be_fuzzy
+    end
+  end
+
+  describe '#<=>' do
+    context 'when other is `Null`' do
+      it 'is greater' do
+        expect(described_class.new('/') <=> PageMagic::Comparator::Null.new).to be 1
+      end
+    end
+
+    context 'when other is `Fuzzy`' do
+      it 'is greater' do
+        expect(described_class.new('/') <=> PageMagic::Comparator::Fuzzy.new(//)).to be 1
+      end
+    end
+
+    context 'when other is `Literal`' do
+      it 'is equal' do
+        expect(described_class.new('/') <=> described_class.new('/')).to be 0
+      end
+    end
+  end
+end

data/spec/page_magic/comparator/null_spec.rb

@@ -0,0 +1,35 @@
+RSpec.describe PageMagic::Comparator::Null do
+  describe '#fuzzy?' do
+    context 'when one value is fuzzy' do
+      it 'returns true' do
+        expect(described_class.new).not_to be_fuzzy
+      end
+    end
+  end
+
+  describe 'match?' do
+    it 'returns false' do
+      expect(described_class.new).to be_match(true)
+    end
+  end
+
+  describe '#<=>' do
+    context 'when other is `Null`' do
+      it 'is equal' do
+        expect(described_class.new <=> described_class.new).to be 0
+      end
+    end
+
+    context 'when other is `Fuzzy`' do
+      it 'is greater' do
+        expect(described_class.new <=> PageMagic::Comparator::Fuzzy.new(//)).to be 1
+      end
+    end
+
+    context 'when other is `Literal`' do
+      it 'is greater' do
+        expect(described_class.new <=> PageMagic::Comparator::Literal.new('/')).to be 1
+      end
+    end
+  end
+end

data/spec/page_magic/comparator/parameter_map_spec.rb

@@ -0,0 +1,75 @@
+RSpec.describe PageMagic::Comparator::ParameterMap do
+  describe '#fuzzy?' do
+    context 'when one value is fuzzy' do
+      it 'returns true' do
+        map = described_class.new({ param1: //, param2: '' })
+        expect(map).to be_fuzzy
+      end
+    end
+
+    context 'when all values are literal' do
+      it 'returns true' do
+        map = described_class.new({ param1: '', param2: '' })
+        expect(map).not_to be_fuzzy
+      end
+    end
+  end
+
+  describe '#match?' do
+    context 'when param has compatible params' do
+      it 'returns true' do
+        expect(described_class.new({ param: '1' })).to be_match(param: '1')
+      end
+    end
+
+    context 'when it does not have compatible params' do
+      it 'returns false' do
+        expect(described_class.new({ param: '1' })).not_to be_match(param: '2')
+      end
+    end
+
+    context 'when it does not meet all of the requirements' do
+      it 'returns false' do
+        expect(described_class.new({ param: '1', another_param: '2' })).not_to be_match(param: '1')
+      end
+    end
+  end
+
+  describe '#<=>' do
+    context 'when other is empty' do
+      context 'and self is empty' do
+        it 'is equal' do
+          expect(described_class.new({}) <=> described_class.new({})).to be 0
+        end
+      end
+
+      context 'self is not empty' do
+        it 'is greater' do
+          expect(described_class.new({ param: 1 }) <=> described_class.new({})).to be 1
+        end
+      end
+    end
+
+    context 'when other contains matchers' do
+      context 'when other has the same number' do
+        context 'and matchers are of the same type' do
+          it 'is equal' do
+            expect(described_class.new({ param: // }) <=> described_class.new({ param: // })).to be 0
+          end
+        end
+
+        context 'and has less literal matchers' do
+          it 'is lesser' do
+            expect(described_class.new({ param: '' }) <=> described_class.new({ param: // })).to be 1
+          end
+        end
+      end
+
+      context 'when other has the less' do
+        it 'is lesser' do
+          expect(described_class.new({ param: // }) <=> described_class.new({})).to be 1
+        end
+      end
+    end
+  end
+end

data/spec/page_magic/driver_spec.rb

@@ -1,43 +1,39 @@
 # frozen_string_literal: true
 
-require 'page_magic/driver'
-
-module PageMagic
-  describe Driver do
-    subject do
-      described_class.new :custom_browser
+RSpec.describe PageMagic::Driver do
+  describe '#build' do
+    it 'returns the result of the block passed to the driver class constructor' do
+      subject = described_class.new(:custom_browser) do
+        :driver
+      end
+      expect(subject.build(:rack_app, browser: :custom_browser, options: {})).to eq(:driver)
     end
 
-    describe '#build' do
-      it 'returns the result of the block passed to the driver class constructor' do
-        subject = described_class.new(:custom_browser) do
-          :driver
-        end
-        expect(subject.build(:rack_app, browser: :custom_browser, options: :options)).to eq(:driver)
+    it 'passes rack app to the handler' do
+      subject = described_class.new(:custom_browser) do |app, options, browser|
+        expect(app).to eq(:rack_app)
+        expect(options).to eq(:options)
+        expect(browser).to eq(:browser)
       end
 
-      it 'passes rack app to the handler' do
-        subject = described_class.new(:custom_browser) do |app, options, browser|
-          expect(app).to eq(:rack_app)
-          expect(options).to eq(:options)
-          expect(browser).to eq(:browser)
-        end
+      subject.build(:rack_app, options: :options, browser: :browser)
+    end
+  end
 
-        subject.build(:rack_app, options: :options, browser: :browser)
-      end
+  describe '#supports?' do
+    subject do
+      described_class.new :custom_browser
     end
 
-    describe '#supports?' do
-      context 'browser is in supported browsers' do
-        it 'returns true' do
-          expect(subject.support?(:custom_browser)).to eq(true)
-        end
+    context 'browser is in supported browsers' do
+      it 'returns true' do
+        expect(subject.support?(:custom_browser)).to eq(true)
       end
+    end
 
-      context 'browser is not in supported browsers' do
-        it 'returns false' do
-          expect(subject.support?(:unsupported_browser)).to eq(false)
-        end
+    context 'browser is not in supported browsers' do
+      it 'returns false' do
+        expect(subject.support?(:unsupported_browser)).to eq(false)
       end
     end
   end

data/spec/page_magic/drivers/poltergeist_spec.rb

@@ -1,11 +1,8 @@
 # frozen_string_literal: true
 
-require 'page_magic/drivers/poltergeist'
-module PageMagic
-  describe Drivers::Poltergeist do
-    it "is capybara's poltergeist driver" do
-      driver = described_class.build(:app, browser: :poltergeist, options: {})
-      expect(driver).to be_a(Capybara::Poltergeist::Driver)
-    end
+RSpec.describe PageMagic::Drivers::Poltergeist do
+  it "is capybara's poltergeist driver" do
+    driver = described_class.build(:app, browser: :poltergeist, options: {})
+    expect(driver).to be_a(Capybara::Poltergeist::Driver)
   end
 end

data/spec/page_magic/drivers/rack_test_spec.rb

@@ -1,13 +1,8 @@
 # frozen_string_literal: true
 
-require 'page_magic/drivers/rack_test'
-module PageMagic
-  class Drivers
-    describe RackTest do
-      it "is capybara's rack test driver" do
-        driver = described_class.build(:app, browser: :rack_test, options: {})
-        expect(driver).to be_a(Capybara::RackTest::Driver)
-      end
-    end
+RSpec.describe PageMagic::Drivers::RackTest do
+  it "is capybara's rack test driver" do
+    driver = described_class.build(:app, browser: :rack_test, options: {})
+    expect(driver).to be_a(Capybara::RackTest::Driver)
   end
 end

data/spec/page_magic/drivers/selenium_spec.rb

@@ -1,18 +1,15 @@
 # frozen_string_literal: true
 
-require 'page_magic/drivers/selenium'
-module PageMagic
-  describe Drivers::Selenium do
-    subject do
-      described_class.build(:app, browser: :selenium, options: {})
-    end
+RSpec.describe PageMagic::Drivers::Selenium do
+  subject do
+    described_class.build(:app, browser: :selenium, options: {})
+  end
 
-    it 'is selenium' do
-      expect(subject).to be_a(Capybara::Selenium::Driver)
-    end
+  it 'is selenium' do
+    expect(subject).to be_a(Capybara::Selenium::Driver)
+  end
 
-    it 'sets the browser option' do
-      expect(subject.options[:browser]).to be(:selenium)
-    end
+  it 'sets the browser option' do
+    expect(subject.options[:browser]).to be(:selenium)
   end
 end

data/spec/page_magic/drivers_spec.rb

@@ -1,41 +1,48 @@
 # frozen_string_literal: true
 
-require 'page_magic/drivers'
-module PageMagic
-  describe Drivers do
-    subject { described_class.new }
-    let(:expected_driver) { Driver.new(:browser_driver) }
-
-    describe '#find' do
-      it 'returns the registered driver' do
-        subject.register expected_driver
-        expect(subject.find(:browser_driver)).to eq(expected_driver)
-      end
+RSpec.describe PageMagic::Drivers do
+  describe '#find' do
+    it 'returns the registered driver' do
+      drivers = described_class.new
+      expected_driver = PageMagic::Driver.new(:browser_driver)
+
+      drivers.register expected_driver
+      expect(drivers.find(:browser_driver)).to eq(expected_driver)
     end
+  end
 
-    describe '#load' do
-      include_context :files
-      it 'loads the drivers in the specified path' do
-        class_definition = <<-RUBY
-          class CustomDriver;
-            def self.support? browser
-              true
-            end
+  describe '#load' do
+    require 'tmpdir'
+
+    def scratch_dir
+      @scratch_dir ||= Dir.mktmpdir
+    end
+
+    let(:class_definition) do
+      <<-RUBY
+        class CustomDriver;
+          def self.support?(_browser)
+            true
           end
-        RUBY
+        end
+      RUBY
+    end
 
-        File.write("#{scratch_dir}/custom_driver.rb", class_definition)
+    it 'loads the drivers in the specified path' do
+      File.write("#{scratch_dir}/custom_driver.rb", class_definition)
 
-        subject.load(scratch_dir)
-        expect(subject.find(:custom_browser)).to be(::CustomDriver)
-      end
+      drivers = described_class.new
+      drivers.load(scratch_dir)
+      expect(drivers.find(:custom_browser)).to be(::CustomDriver)
     end
+  end
 
-    describe '#register' do
-      it 'stores the driver' do
-        subject.register expected_driver
-        expect(subject.all).to eq([expected_driver])
-      end
+  describe '#register' do
+    it 'stores the driver' do
+      drivers = described_class.new
+      expected_driver = PageMagic::Driver.new(:browser_driver)
+      drivers.register expected_driver
+      expect(drivers.all).to eq([expected_driver])
     end
   end
 end

data/spec/page_magic/element/locators_spec.rb

@@ -1,34 +1,35 @@
 # frozen_string_literal: true
 
-module PageMagic
-  class Element
-    describe Locators do
-      subject(:element_clazz) do
-        Class.new do
-          extend(Elements)
-          include(Locators)
-        end
-      end
-      subject { element_clazz.new }
+RSpec.describe PageMagic::Element::Locators do
+  subject { element_clazz.new }
 
-      describe '#element_by_name' do
-        it 'returns the required element' do
-          selector = { id: 'child' }
-          element_clazz.element :child1, selector
-          element_clazz.element :child2, id: 'child 2'
+  let(:element_clazz) do
+    Class.new do
+      extend(PageMagic::Elements)
+      include(PageMagic::Element::Locators)
+    end
+  end
 
-          expected_builder = ElementDefinitionBuilder.new(definition_class: Element, type: :element, selector: selector)
+  describe '#element_by_name' do
+    it 'returns the required element' do
+      selector = { id: 'child' }
+      element_clazz.element :child1, selector
+      element_clazz.element :child2, id: 'child 2'
 
-          expect(subject.element_by_name(:child1)).to eq(expected_builder)
-        end
+      child_1_builder = PageMagic::ElementDefinitionBuilder.new(
+        definition_class: PageMagic::Element,
+        selector: PageMagic::Element::Selector.find(:id).build(:element, 'child')
+      )
+
+      expect(subject.element_by_name(:child1)).to eq(child_1_builder)
+    end
 
-        context 'element not found' do
-          it 'raises an error' do
-            expected_message = (described_class::ELEMENT_NOT_DEFINED_MSG % :child)
-            command = proc { subject.element_by_name(:child) }
-            expect(&command).to raise_exception ElementMissingException, expected_message
-          end
-        end
+    context 'element not found' do
+      it 'raises an error' do
+        expected_message = (described_class::ELEMENT_NOT_DEFINED_MSG % :child)
+        expect do
+          subject.element_by_name(:child)
+        end.to raise_exception PageMagic::ElementMissingException, expected_message
       end
     end
   end

data/spec/page_magic/element/not_found_spec.rb

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+describe PageMagic::Element::NotFound do
+  describe '#method_missing' do
+    it 'raises an error' do
+      subject = described_class.new(Exception.new('message'))
+      expect { subject.any_missing_method }.to raise_exception(PageMagic::ElementMissingException, 'message')
+    end
+  end
+
+  describe '#visible?' do
+    it 'returns false' do
+      subject = described_class.new(Exception.new('message'))
+      expect(subject.visible?).to eq(false)
+    end
+  end
+
+  describe '#present?' do
+    it 'returns false' do
+      subject = described_class.new(Exception.new('message'))
+      expect(subject.present?).to eq(false)
+    end
+  end
+end