unobtainium 0.8.1 → 0.9.0

data/spec/drivers_appium_spec.rb

@@ -0,0 +1,244 @@
+require 'spec_helper'
+require_relative '../lib/unobtainium/drivers/appium'
+
+class SeleniumMock
+  def test
+    return "selenium"
+  end
+
+  def selenium_only
+    return "selenium"
+  end
+end
+
+class AppiumMock
+  def test
+    return "appium"
+  end
+
+  def appium_only
+    return "appium"
+  end
+
+  def start_driver
+    return SeleniumMock.new
+  end
+end
+
+describe ::Unobtainium::Drivers::Appium do
+  let(:tester) { ::Unobtainium::Drivers::Appium }
+
+  context "#matches?" do
+    it "matches all known aliases" do
+      aliases = [:ios, :iphone, :ipad, :android]
+      aliases.each do |name|
+        expect(tester.matches?(name)).to be_truthy
+      end
+    end
+
+    it "does not match unknown names" do
+      unknown = [:foo, :bar, :appium, :phantomjs, :headless]
+      unknown.each do |name|
+        expect(tester.matches?(name)).to be_falsey
+      end
+    end
+  end
+
+  context ::Unobtainium::Drivers::Appium::DriverProxy do
+    let(:appium_driver) { AppiumMock.new }
+
+    it "prefers appium if compatibility is not desired" do
+      proxy = ::Unobtainium::Drivers::Appium::DriverProxy.new(appium_driver, false)
+
+      expect(proxy.respond_to?(:test)).to be_truthy
+      expect(proxy.respond_to?(:selenium_only)).to be_truthy
+      expect(proxy.respond_to?(:appium_only)).to be_truthy
+
+      expect(proxy.test).to eql "appium"
+      expect(proxy.selenium_only).to eql "selenium"
+      expect(proxy.appium_only).to eql "appium"
+    end
+
+    it "prefers selenium if compatibility is desired" do
+      proxy = ::Unobtainium::Drivers::Appium::DriverProxy.new(appium_driver, true)
+
+      expect(proxy.respond_to?(:test)).to be_truthy
+      expect(proxy.respond_to?(:selenium_only)).to be_truthy
+      expect(proxy.respond_to?(:appium_only)).to be_truthy
+
+      expect(proxy.test).to eql "selenium"
+      expect(proxy.selenium_only).to eql "selenium"
+      expect(proxy.appium_only).to eql "appium"
+    end
+
+    it "fails if an undefined method is called" do
+      proxy = ::Unobtainium::Drivers::Appium::DriverProxy.new(appium_driver, true)
+      expect(proxy.respond_to?(:undefined_method)).to be_falsy
+      expect { proxy.undefined_method }.to raise_error(NoMethodError)
+
+      proxy = ::Unobtainium::Drivers::Appium::DriverProxy.new(appium_driver, false)
+      expect(proxy.respond_to?(:undefined_method)).to be_falsy
+      expect { proxy.undefined_method }.to raise_error(NoMethodError)
+    end
+  end
+
+  context "#ensure_preconditions" do
+    it "will succeed because development dependencies include requirements" do
+      expect { tester.ensure_preconditions(:label, nil) }.not_to raise_error
+    end
+
+    it "would fail if requirements were not met" do
+      allow_any_instance_of(Object).to receive(:require).and_raise(LoadError)
+      expect { tester.ensure_preconditions(:label, nil) }.to raise_error(LoadError)
+    end
+  end
+
+  context "#resolve_options" do
+    it "normalizes labels" do
+      ::Unobtainium::Drivers::Appium::LABELS.each do |normalized, aliases|
+        ([normalized] + aliases).each do |label|
+          returned_label, _ = tester.resolve_options(label, nil)
+          expect(returned_label).to eql normalized
+        end
+      end
+    end
+
+    context "capabilities merging" do
+      let(:caps1) { { foo: 42 } }
+      let(:caps2) { { foo: 123 } }
+      let(:caps3) { { foo: "bar" } }
+
+      it "creates :caps from :desired_capabilities" do
+        _, resolved = tester.resolve_options(:ios, desired_capabilities: caps1)
+
+        expect(resolved[:caps]).not_to be_nil
+        expect(resolved[:caps][:foo]).to eql 42
+        expect(resolved[:desired_capabilites]).to be_nil
+      end
+
+      it "creates :caps from 'desired_capabilities'" do
+        _, resolved = tester.resolve_options(:ios, 'desired_capabilities' => caps1)
+
+        expect(resolved[:caps]).not_to be_nil
+        expect(resolved[:caps][:foo]).to eql 42
+        expect(resolved['desired_capabilities']).to be_nil
+      end
+
+      it "merges :caps with :desired_capabilities" do
+        opts = {
+          desired_capabilities: caps1,
+          caps: caps2
+        }
+        _, resolved = tester.resolve_options(:ios, opts)
+
+        expect(resolved[:caps]).not_to be_nil
+        expect(resolved[:caps][:foo]).to eql 123
+        expect(resolved[:desired_capabilities]).to be_nil
+      end
+
+      it "merges :caps with 'desired_capabilities'" do
+        opts = {
+          'desired_capabilities' => caps1,
+          caps: caps2,
+        }
+        _, resolved = tester.resolve_options(:ios, opts)
+
+        expect(resolved[:caps]).not_to be_nil
+        expect(resolved[:caps][:foo]).to eql 123
+        expect(resolved['desired_capabilities']).to be_nil
+      end
+
+      it "merges :caps with :desired_capabilities and 'desired_capabilities'" do
+        opts = {
+          'desired_capabilities' => caps1,
+          desired_capabilites: caps2,
+          caps: caps3,
+        }
+        _, resolved = tester.resolve_options(:ios, opts)
+
+        expect(resolved[:caps]).not_to be_nil
+        expect(resolved[:caps][:foo]).to eql 'bar'
+        expect(resolved[:desired_capabilities]).to be_nil
+        expect(resolved['desired_capabilities']).to be_nil
+      end
+    end
+
+    it "adds a normalized platform name" do
+      _, resolved = tester.resolve_options(:iphone, nil)
+
+      expect(resolved['caps.platformName']).to eql 'ios'
+    end
+
+    context "appium URL" do
+      it "uses 'url' when nothing else is given" do
+        _, resolved = tester.resolve_options(:iphone, url: 'test')
+        expect(resolved['url']).to eql 'test'
+        expect(resolved['appium_lib.server_url']).to eql 'test'
+      end
+
+      it "prefers 'appium_lib.server_url' to 'url'" do
+        opts = {
+          url: 'test1',
+          appium_lib: {
+            server_url: 'test2',
+          },
+        }
+        _, resolved = tester.resolve_options(:iphone, opts)
+        expect(resolved['url']).to eql 'test1'
+        expect(resolved['appium_lib.server_url']).to eql 'test2'
+      end
+
+      it "does not set anything if nothing is given" do
+        _, resolved = tester.resolve_options(:iphone, nil)
+        expect(resolved['url']).to be_nil
+        expect(resolved['appium_lib.server_url']).to be_nil
+      end
+    end
+
+    context "browser matching" do
+      it "does nothing if no browser is requested" do
+        _, resolved = tester.resolve_options(:iphone, nil)
+        expect(resolved['caps.browserName']).to be_nil
+      end
+
+      it "does nothing if no browser match is found" do
+        _, resolved = tester.resolve_options(:iphone, browser: :chrome)
+        expect(resolved['caps.browserName']).to be_nil
+
+        _, resolved = tester.resolve_options(:iphone, browser: :safari)
+        expect(resolved['caps.browserName']).to be_nil
+      end
+
+      it "supplements browserName for chrome on android" do
+        _, resolved = tester.resolve_options(:android, browser: :chrome)
+        expect(resolved['caps.browserName']).to eql 'Chrome'
+      end
+
+      it "raises instead of overwriting explicit options" do
+        opts = {
+          browser: :chrome,
+          caps: {
+            platformName: :android,
+            browserName: 'Something Else',
+          }
+        }
+        expect { tester.resolve_options(:android, opts) }.to \
+          raise_error(ArgumentError)
+      end
+
+      it "silently ignores identical options" do
+        opts = {
+          browser: :chrome,
+          caps: {
+            platformName: :android,
+            browserName: 'Chrome',
+          }
+        }
+        resolved = nil
+        expect { _, resolved = tester.resolve_options(:android, opts) }.not_to \
+          raise_error
+        expect(resolved['caps.browserName']).to eql 'Chrome'
+      end
+    end
+  end
+end

data/spec/drivers_phantom_spec.rb

@@ -0,0 +1,247 @@
+require 'spec_helper'
+require_relative '../lib/unobtainium/drivers/phantom'
+
+class SeleniumMock
+  def test
+    return "selenium"
+  end
+
+  def selenium_only
+    return "selenium"
+  end
+end
+
+class AppiumMock
+  def test
+    return "appium"
+  end
+
+  def appium_only
+    return "appium"
+  end
+
+  def start_driver
+    return SeleniumMock.new
+  end
+end
+
+describe ::Unobtainium::Drivers::Phantom do
+  let(:tester) { ::Unobtainium::Drivers::Phantom }
+
+  context "#matches?" do
+    it "matches all known aliases" do
+      aliases = [:phantomjs, :headless, :phantom]
+      aliases.each do |name|
+        expect(tester.matches?(name)).to be_truthy
+      end
+    end
+
+    it "does not match unknown names" do
+      unknown = [:foo, :bar, :appium, :selenium, :ios]
+      unknown.each do |name|
+        expect(tester.matches?(name)).to be_falsey
+      end
+    end
+  end
+
+  context "#ensure_preconditions" do
+    it "will succeed because development dependencies include requirements" do
+      expect { tester.ensure_preconditions(:label, nil) }.not_to raise_error
+    end
+
+    it "would fail if requirements were not met" do
+      allow_any_instance_of(Object).to receive(:require) do |_, name|
+        if name == 'phantomjs'
+          raise LoadError
+        end
+      end
+      expect { tester.ensure_preconditions(:label, nil) }.to raise_error(LoadError)
+    end
+  end
+
+  context "#resolve_options" do
+    it "normalizes labels" do
+      ::Unobtainium::Drivers::Phantom::LABELS.each do |normalized, aliases|
+        ([normalized] + aliases).each do |label|
+          returned_label, _ = tester.resolve_options(label, nil)
+          expect(returned_label).to eql normalized
+        end
+      end
+    end
+
+    context "phantomjs options" do
+      it "prefers the string if both :phantomjs and 'phantomjs' are given" do
+        opts = {
+          phantomjs: { scheme: 123 },
+          'phantomjs' => { scheme: 42 },
+        }
+
+        resolved = nil
+        expect { _, resolved = tester.resolve_options(:phantomjs, opts) }.not_to \
+          raise_error
+        expect(resolved['phantomjs.scheme']).to eql 42
+      end
+
+      it "uses :url if that is given" do
+        opts = {
+          url: 'http://localhost:1234',
+        }
+
+        _, resolved = tester.resolve_options(:phantomjs, opts)
+        expect(resolved[:phantomjs]).not_to be_nil
+        expect(resolved['phantomjs.scheme']).to eql 'http'
+        expect(resolved['phantomjs.host']).to eql 'localhost'
+        expect(resolved['phantomjs.port']).to eql 1234
+        expect(resolved['url']).to eql 'http://localhost:1234'
+      end
+
+      it "prefers :phantomjs over :url" do
+        opts = {
+          url: 'http://localhost:1234',
+          phantomjs: {
+            port: 8888
+          },
+        }
+
+        _, resolved = tester.resolve_options(:phantomjs, opts)
+        expect(resolved[:phantomjs]).not_to be_nil
+        expect(resolved['phantomjs.scheme']).to eql 'http'
+        expect(resolved['phantomjs.host']).to eql 'localhost'
+        expect(resolved['phantomjs.port']).to eql 8888
+        expect(resolved['url']).to eql 'http://localhost:8888'
+      end
+
+      it "defaults to 'http' and 'localhost' and a free port" do
+        allow(tester).to receive(:scan) { |*_| [9134] }
+        _, resolved = tester.resolve_options(:phantomjs, nil)
+        expect(resolved[:phantomjs]).not_to be_nil
+        expect(resolved['phantomjs.scheme']).to eql 'http'
+        expect(resolved['phantomjs.host']).to eql 'localhost'
+        expect(resolved['phantomjs.port']).to be_nil
+        expect(resolved['phantomjs.generated_port']).to eql 9134
+        expect(resolved['url']).to eql 'http://localhost:9134'
+      end
+
+      it "raises an error when no free port could be found" do
+        allow(tester).to receive(:scan) { |*_| [] }
+        expect { tester.resolve_options(:phantomjs, nil) }.to \
+          raise_error(RuntimeError)
+      end
+    end
+
+    context "driver ID and port" do
+      it "sets a driver ID" do
+        allow(tester).to receive(:scan) { |*_| [9134] }
+        _, resolved = tester.resolve_options(:phantomjs, nil)
+
+        expect(resolved['unobtainium_instance_id']).not_to be_nil
+      end
+
+      it "generates new IDs for new options" do
+        opts = ::Collapsium::UberHash.new(
+          phantomjs: {
+            scheme: 'noodle',
+            port: 1234,
+          }
+        )
+        _, resolved1 = tester.resolve_options(:phantomjs, opts)
+        expect(resolved1['phantomjs.port']).to eql 1234
+
+        opts = opts.deep_dup
+        opts[:phantomjs][:port] = 8888
+        _, resolved2 = tester.resolve_options(:phantomjs, opts)
+
+        # resolved1 must remain untouched by the change
+        expect(resolved1['phantomjs.port']).to eql 1234
+
+        # resolved2 must have the new ID, and the new port
+        expect(resolved1['unobtainium_instance_id']).not_to eql \
+          resolved2['unobtainium_instance_id']
+        expect(resolved2['phantomjs.port']).to eql 8888
+
+        # Urls must differ as well.
+        expect(resolved1[:url]).not_to eql resolved2[:url]
+      end
+
+      it "generates new IDs for changed connection options" do
+        opts = {
+          phantomjs: {
+            scheme: 'noodle',
+            port: 1234,
+          },
+        }
+        _, resolved1 = tester.resolve_options(:phantomjs, opts)
+        expect(resolved1['phantomjs.port']).to eql 1234
+
+        opts = resolved1.deep_dup
+        opts[:phantomjs][:port] = 8888
+        _, resolved2 = tester.resolve_options(:phantomjs, opts)
+
+        # resolved1 must remain untouched by the change
+        expect(resolved1['phantomjs.port']).to eql 1234
+
+        # resolved2 must have the new ID, and the new port
+        expect(resolved1['unobtainium_instance_id']).not_to eql \
+          resolved2['unobtainium_instance_id']
+        expect(resolved2['phantomjs.port']).to eql 8888
+
+        # Urls must differ as well.
+        expect(resolved1[:url]).not_to eql resolved2[:url]
+      end
+
+      it "generates new IDs and port when other options change" do
+        opts = {
+          phantomjs: {
+            scheme: 'noodle',
+            port: 1234,
+          },
+        }
+        _, resolved1 = tester.resolve_options(:phantomjs, opts)
+        expect(resolved1['phantomjs.port']).to eql 1234
+
+        opts = resolved1.deep_dup
+        opts[:foo] = 'something'
+        _, resolved2 = tester.resolve_options(:phantomjs, opts)
+
+        # resolved1 must remain untouched by the change
+        expect(resolved1['phantomjs.port']).to eql 1234
+
+        # resolved2 must have the new ID, and a new port, and also the
+        # extra value.
+        expect(resolved1['unobtainium_instance_id']).not_to eql \
+          resolved2['unobtainium_instance_id']
+        expect(resolved2['phantomjs.port']).not_to eql 1234
+        expect(resolved2[:foo]).to eql 'something'
+
+        # Urls must differ as well.
+        expect(resolved1[:url]).not_to eql resolved2[:url]
+      end
+
+      it "leaves IDs untouched when the port is left undefined" do
+        opts = {
+          phantomjs: {
+            scheme: 'noodle',
+            port: nil,
+          },
+        }
+        _, resolved1 = tester.resolve_options(:phantomjs, opts)
+        expect(resolved1['phantomjs.port']).to be_nil
+
+        opts = resolved1.deep_dup
+        opts[:phantomjs][:port] = nil
+        _, resolved2 = tester.resolve_options(:phantomjs, opts)
+
+        # resolved1 must remain untouched by the change
+        expect(resolved1['phantomjs.port']).to be_nil
+
+        # resolved2 must have the same ID and port
+        expect(resolved1['unobtainium_instance_id']).to eql \
+          resolved2['unobtainium_instance_id']
+        expect(resolved2['phantomjs.port']).to eql resolved1['phantomjs.port']
+
+        # Urls must be the same, too!
+        expect(resolved1[:url]).to eql resolved2[:url]
+      end
+    end
+  end
+end

data/spec/drivers_selenium_spec.rb

@@ -0,0 +1,170 @@
+require 'spec_helper'
+require_relative '../lib/unobtainium/drivers/selenium'
+
+describe ::Unobtainium::Drivers::Selenium do
+  let(:tester) { ::Unobtainium::Drivers::Selenium }
+
+  context "#matches?" do
+    it "matches all known aliases" do
+      aliases = [
+        :firefox, :ff, :internet_explorer, :internetexplorer, :explorer,
+        :ie, :safari, :chrome, :chromium
+      ]
+      aliases.each do |name|
+        expect(tester.matches?(name)).to be_truthy
+      end
+    end
+
+    it "does not match unknown names" do
+      unknown = [:foo, :bar, :appium, :phantomjs, :headless]
+      unknown.each do |name|
+        expect(tester.matches?(name)).to be_falsey
+      end
+    end
+  end
+
+  context "#ensure_preconditions" do
+    it "will succeed because development dependencies include requirements" do
+      expect { tester.ensure_preconditions(:label, nil) }.not_to raise_error
+    end
+
+    it "would fail if requirements were not met" do
+      allow_any_instance_of(Object).to receive(:require).and_raise(LoadError)
+      expect { tester.ensure_preconditions(:label, nil) }.to raise_error(LoadError)
+    end
+  end
+
+  context "#resolve_options" do
+    it "normalizes labels" do
+      ::Unobtainium::Drivers::Selenium::LABELS.each do |normalized, aliases|
+        ([normalized] + aliases).each do |label|
+          returned_label, _ = tester.resolve_options(label, nil)
+          if normalized == :chromium
+            expect(returned_label).to eql :chrome # chromedriver
+          else
+            expect(returned_label).to eql normalized
+          end
+        end
+      end
+    end
+
+    context "capabilities merging" do
+      let(:caps1) { { foo: 42 } }
+      let(:caps2) { { foo: 123 } }
+      let(:caps3) { { foo: "bar" } }
+
+      it "creates :desired_capabilites from :caps" do
+        _, resolved = tester.resolve_options(:chrome, caps: caps1)
+
+        expect(resolved[:desired_capabilities]).not_to be_nil
+        expect(resolved[:desired_capabilities][:foo]).to eql 42
+        expect(resolved[:caps]).to be_nil
+      end
+
+      it "creates :desired_capabilites from 'caps'" do
+        _, resolved = tester.resolve_options(:chrome, 'caps' => caps1)
+
+        expect(resolved[:desired_capabilities]).not_to be_nil
+        expect(resolved[:desired_capabilities][:foo]).to eql 42
+        expect(resolved['caps']).to be_nil
+      end
+
+      it "merges :desired_capabilites with :caps" do
+        opts = {
+          caps: caps1,
+          desired_capabilities: caps2,
+        }
+        _, resolved = tester.resolve_options(:chrome, opts)
+
+        expect(resolved[:desired_capabilities]).not_to be_nil
+        expect(resolved[:desired_capabilities][:foo]).to eql 123
+        expect(resolved[:caps]).to be_nil
+      end
+
+      it "merges :desired_capabilites with 'caps'" do
+        opts = {
+          'caps' => caps1,
+          desired_capabilities: caps2,
+        }
+        _, resolved = tester.resolve_options(:chrome, opts)
+
+        expect(resolved[:desired_capabilities]).not_to be_nil
+        expect(resolved[:desired_capabilities][:foo]).to eql 123
+        expect(resolved['caps']).to be_nil
+      end
+
+      it "merges :desired_capabilites with :caps and 'caps'" do
+        opts = {
+          'caps' => caps1,
+          caps: caps2,
+          desired_capabilities: caps3,
+        }
+        _, resolved = tester.resolve_options(:chrome, opts)
+
+        expect(resolved[:desired_capabilities]).not_to be_nil
+        expect(resolved[:desired_capabilities][:foo]).to eql 'bar'
+        expect(resolved[:caps]).to be_nil
+        expect(resolved['caps']).to be_nil
+      end
+    end
+
+    context ":chromium" do
+      it "supplements a binary when one is found" do
+        # Ensure a test result
+        allow_any_instance_of(Object).to receive(:require) {}
+        allow(File).to receive(:which) { '/path/to/binary' }
+
+        label, resolved = tester.resolve_options(:chromium, nil)
+
+        expect(resolved[:desired_capabilities]["chromeOptions"]["binary"]).to \
+          eql '/path/to/binary'
+        expect(label).to eql :chrome
+      end
+
+      it "returns the label and options unaltered when no binary is found" do
+        # Ensure a test result
+        allow_any_instance_of(Object).to receive(:require) {}
+        allow(File).to receive(:which) { nil }
+
+        label, resolved = tester.resolve_options(:chromium, nil)
+
+        expect(resolved[:desired_capabilities]["chromeOptions"]).to be_nil
+        expect(label).to eql :chromium
+      end
+
+      it "does not overwrite binaries if they are set" do
+        # Ensure a test result
+        allow_any_instance_of(Object).to receive(:require) {}
+        allow(File).to receive(:which) { '/path/to/binary' }
+
+        opts = {
+          desired_capabilities: {
+            chromeOptions: {
+              binary: 'test',
+            },
+          },
+        }
+        label, resolved = tester.resolve_options(:chromium, opts)
+
+        expect(resolved[:desired_capabilities]["chromeOptions"]["binary"]).to \
+          eql 'test'
+        expect(label).to eql :chrome
+      end
+    end
+
+    context "fixing options" do
+      it "symbolies option keys" do
+        opts = {
+          "foo" => "bar",
+          baz: 42,
+        }
+        _, resolved = tester.resolve_options(:chromium, opts)
+
+        expect(resolved["foo"]).to be_nil
+        expect(resolved[:foo]).to eql "bar"
+        expect(resolved["baz"]).to be_nil
+        expect(resolved[:baz]).to eql 42
+      end
+    end
+  end
+end

data/spec/mock_driver.rb

@@ -24,4 +24,27 @@ class MockDriver
     end
   end
 end # class MockDriver
+
+class OptionResolvingMockDriver < MockDriver
+  class << self
+    def matches?(label)
+      label == :option_resolving
+    end
+
+    def resolve_options(label, options)
+      if options
+        opts = options.dup
+      end
+      opts ||= {}
+
+      if opts[:foo] == 123 or opts[:foo].nil?
+        opts[:foo] = 42
+      end
+
+      opts["unobtainium_instance_id"] = 'FIXED'
+
+      return label, opts
+    end
+  end
+end # class OptionResolvingMockDriver
 # rubocop:enable Style/GuardClause

data/spec/spec_helper.rb

@@ -1,6 +1,5 @@
 # Always start SimpleCov
 require 'simplecov'
 SimpleCov.start do
-  add_filter 'unobtainium/drivers'
   add_filter 'spec'
 end