howitzer 1.0.2 → 1.1.0

data/spec/unit/lib/email_spec.rb

@@ -1,18 +1,18 @@
 require 'spec_helper'
-require "howitzer/email"
-require "howitzer/utils/log"
+require 'howitzer/email'
+require 'howitzer/utils/log'
 require 'howitzer/exceptions'
 
-describe "Email" do
+RSpec.describe 'Email' do
   let(:recipient){ 'first_tester@gmail.com' }
   let(:message) do
     {
         'body-plain' => 'test body footer',
-        'stripped-html' => "<p> test body </p> <p> footer </p>",
+        'stripped-html' => '<p> test body </p> <p> footer </p>',
         'stripped-text' => 'test body',
-        'From' => "Strong Tester <tester@gmail.com>",
+        'From' => 'Strong Tester <tester@gmail.com>',
         'To' => recipient,
-        'Received' => "by 10.216.46.75 with HTTP; Sat, 5 Apr 2014 05:10:42 -0700 (PDT)",
+        'Received' => 'by 10.216.46.75 with HTTP; Sat, 5 Apr 2014 05:10:42 -0700 (PDT)',
         'sender' => 'tester@gmail.com',
         'attachments' => []
     }
@@ -43,23 +43,23 @@ describe "Email" do
     let(:mailgun_message){ double(to_h: message) }
     let(:events) { double(to_h: {'items' => [event]}) }
     subject { Email.find(recipient, message_subject) }
-    context "when message is found" do
+    context 'when message is found' do
       let(:event) { {'message' => {'recipients' => [recipient], 'headers' => {'subject' => message_subject} }, 'storage' => {'key' => '1234567890'} } }
       before do
-        allow(Mailgun::Connector.instance.client).to receive(:get).with("mailgun@test.domain/events", event: 'stored').ordered.once {events}
-        allow(Mailgun::Connector.instance.client).to receive(:get).with("domains/mailgun@test.domain/messages/1234567890").ordered.once { mailgun_message }
+        allow(Mailgun::Connector.instance.client).to receive(:get).with('mailgun@test.domain/events', event: 'stored').ordered.once {events}
+        allow(Mailgun::Connector.instance.client).to receive(:get).with('domains/mailgun@test.domain/messages/1234567890').ordered.once { mailgun_message }
       end
       it do
         expect(Email).to receive(:new).with(message).once
         subject
       end
     end
-    context "when message is not found" do
-      let(:event) { {'message' => {'recipients' => ["other@test.com"], 'headers' => {'subject' => message_subject} }, 'storage' => {'key' => '1234567890'} } }
+    context 'when message is not found' do
+      let(:event) { {'message' => {'recipients' => ['other@test.com'], 'headers' => {'subject' => message_subject} }, 'storage' => {'key' => '1234567890'} } }
       before do
         allow(settings).to receive(:timeout_small) { 0.5 }
         allow(settings).to receive(:timeout_short) { 0.05 }
-        allow(Mailgun::Connector.instance.client).to receive(:get).with("mailgun@test.domain/events", event: 'stored').at_least(:twice).ordered {events}
+        allow(Mailgun::Connector.instance.client).to receive(:get).with('mailgun@test.domain/events', event: 'stored').at_least(:twice).ordered {events}
       end
       it do
         expect(log).to receive(:error).with(Howitzer::EmailNotFoundError, "Message with subject '#{message_subject}' for recipient '#{recipient}' was not found.")
@@ -86,17 +86,17 @@ describe "Email" do
 
   describe '#recipients' do
     subject { email_object.recipients }
-    it { expect(subject).to be_a_kind_of Array }
+    it { is_expected.to be_a_kind_of Array }
 
     context 'when one recipient' do
-      it { expect(subject).to include message['To']}
+      it { is_expected.to include message['To']}
     end
 
     context 'when more than one recipient' do
-      let(:second_recipient) { "second_tester@gmail.com" }
+      let(:second_recipient) { 'second_tester@gmail.com' }
       let(:message_with_multiple_recipients) { message.merge({'To' => "#{recipient}, #{second_recipient}"}) }
       let(:email_object) { Email.new(message_with_multiple_recipients) }
-      it { expect(subject).to eql [recipient, second_recipient] }
+      it { is_expected.to eql [recipient, second_recipient] }
     end
   end
 
@@ -114,7 +114,7 @@ describe "Email" do
     context 'when has attachments' do
       let(:files) { [double] }
       before { email_object.instance_variable_set(:@message, 'attachments' => files)}
-      it { expect(subject).to eq(files) }
+      it { is_expected.to eq(files) }
     end
 
     context 'when no attachments' do

data/spec/unit/lib/helpers_spec.rb

@@ -1,620 +1,1003 @@
 require 'spec_helper'
-require "howitzer/helpers"
+require 'howitzer/helpers'
 
-describe "Helpers" do
-  let(:settings) { double("settings")}
+RSpec.describe 'Helpers' do
+  let(:settings) { double('settings')}
+  let(:selenium_driver) { false }
+  let(:selenium_grid_driver) { false }
+  let(:phantomjs_driver) { false }
+  let(:sauce_driver) { false }
+  let(:testingbot_driver) { false }
 
-  describe "#sauce_driver?" do
+  describe '#sauce_driver?' do
     subject { sauce_driver? }
     before { allow(settings).to receive(:driver) { driver_setting } }
-    context "when :sauce" do
+    context 'when :sauce' do
       let(:driver_setting) {:sauce}
-      it{ expect(subject).to be_true }
+      it{ is_expected.to be_truthy }
     end
-    context "when not :sauce" do
+    context 'when not :sauce' do
       let(:driver_setting) {:phantomjs}
-      it{ expect(subject).to be_false }
+      it{ is_expected.to be_falsey }
     end
-    context "when driver specified as String" do
-      let(:driver_setting) {"sauce"}
-      it{ expect(subject).to be_true }
+    context 'when driver specified as String' do
+      let(:driver_setting) { 'sauce' }
+      it{ is_expected.to be true }
     end
-    context "when driver is not specified" do
+    context 'when driver is not specified' do
       let(:driver_setting) { nil }
       it do
-        expect(log).to receive(:error).with(Howitzer::DriverNotSpecifiedError, "Please check your settings").once.and_call_original
+        expect(log).to receive(:error).with(Howitzer::DriverNotSpecifiedError, 'Please check your settings').once.and_call_original
         expect { subject }.to raise_error(Howitzer::DriverNotSpecifiedError)
       end
     end
   end
 
-  describe "#testingbot_driver?" do
+  describe '#testingbot_driver?' do
     subject { testingbot_driver? }
     before { allow(settings).to receive(:driver) { driver_setting } }
-    context "when :testingbot" do
+    context 'when :testingbot' do
       let(:driver_setting) {:testingbot}
-      it{ expect(subject).to be_true }
+      it{ is_expected.to be_truthy }
     end
-    context "when not :testingbot" do
+    context 'when not :testingbot' do
       let(:driver_setting) {:phantomjs}
-      it{ expect(subject).to be_false }
+      it{ is_expected.to be_falsey }
     end
-    context "when driver specified as String" do
-      let(:driver_setting) {"testingbot"}
-      it{ expect(subject).to be_true }
+    context 'when driver specified as String' do
+      let(:driver_setting) { 'testingbot' }
+      it{ is_expected.to be_truthy }
     end
-    context "when driver is not specified" do
+    context 'when driver is not specified' do
       let(:driver_setting) { nil }
       it do
-        expect(log).to receive(:error).with(Howitzer::DriverNotSpecifiedError, "Please check your settings").once.and_call_original
+        expect(log).to receive(:error).with(Howitzer::DriverNotSpecifiedError, 'Please check your settings').once.and_call_original
         expect { subject }.to raise_error(Howitzer::DriverNotSpecifiedError)
       end
     end
   end
 
-  describe "#phantomjs_driver?" do
+  describe '#phantomjs_driver?' do
     subject { phantomjs_driver? }
     before { allow(settings).to receive(:driver) { driver_setting } }
-    context "when :phantomjs" do
+    context 'when :phantomjs' do
       let(:driver_setting) {:phantomjs}
-      it{ expect(subject).to be_true }
+      it{ is_expected.to be_truthy }
     end
-    context "when not :phantomjs" do
+    context 'when not :phantomjs' do
       let(:driver_setting) {:selenium}
-      it{ expect(subject).to be_false }
+      it{ is_expected.to be_falsey }
     end
-    context "when driver specified as String" do
-      let(:driver_setting) {"phantomjs"}
-      it{ expect(subject).to be_true }
+    context 'when :selenium_grid' do
+      let(:driver_setting) {:selenium_grid}
+      it{ is_expected.to be_falsey }
     end
-    context "when driver is not specified" do
+    context 'when driver specified as String' do
+      let(:driver_setting) { 'phantomjs' }
+      it{ is_expected.to be_truthy }
+    end
+    context 'when driver is not specified' do
       let(:driver_setting) { nil }
       it do
-        expect(log).to receive(:error).with(Howitzer::DriverNotSpecifiedError, "Please check your settings").once.and_call_original
+        expect(log).to receive(:error).with(Howitzer::DriverNotSpecifiedError, 'Please check your settings').once.and_call_original
         expect { subject }.to raise_error(Howitzer::DriverNotSpecifiedError)
       end
     end
   end
 
-  describe "#selenium_driver?" do
+  describe '#selenium_driver?' do
     subject { selenium_driver? }
     before { allow(settings).to receive(:driver) { driver_setting } }
-    context "when :selenium" do
+    context 'when :selenium' do
       let(:driver_setting) {:selenium}
-      it{ expect(subject).to be_true }
+      it{ is_expected.to be_truthy }
+    end
+    context 'when :selenium_grid' do
+      let(:driver_setting) {:selenium_grid}
+      it{ is_expected.to be_falsey }
     end
-    context "when not :selenium" do
+    context 'when not :selenium' do
       let(:driver_setting) {:phantomjs}
-      it{ expect(subject).to be_false }
+      it{ is_expected.to be_falsey }
     end
-    context "when driver specified as String" do
-      let(:driver_setting) {"selenium"}
-      it{ expect(subject).to be_true }
+    context 'when driver specified as String' do
+      let(:driver_setting) { 'selenium' }
+      it{ is_expected.to be_truthy }
     end
-    context "when driver is not specified" do
+    context 'when driver is not specified' do
       let(:driver_setting) { nil }
       it do
-        expect(log).to receive(:error).with(Howitzer::DriverNotSpecifiedError, "Please check your settings").once.and_call_original
+        expect(log).to receive(:error).with(Howitzer::DriverNotSpecifiedError, 'Please check your settings').once.and_call_original
         expect { subject }.to raise_error(Howitzer::DriverNotSpecifiedError)
       end
     end
   end
 
-  describe "#ie_browser?" do
+  describe '#selenium_grid_driver?' do
+    subject { selenium_grid_driver? }
+    before { allow(settings).to receive(:driver) { driver_setting } }
+    context 'when :selenium_grid' do
+      let(:driver_setting) {:selenium_grid}
+      it{ is_expected.to be_truthy }
+    end
+    context 'when :selenium' do
+      let(:driver_setting) {:selenium}
+      it{ is_expected.to be_falsey }
+    end
+    context 'when not :selenium' do
+      let(:driver_setting) {:phantomjs}
+      it{ is_expected.to be_falsey }
+    end
+    context 'when driver specified as String' do
+      let(:driver_setting) { 'selenium_grid' }
+      it{ is_expected.to be_truthy }
+    end
+    context 'when driver is not specified' do
+      let(:driver_setting) { nil }
+      it do
+        expect(log).to receive(:error).with(Howitzer::DriverNotSpecifiedError, 'Please check your settings').once.and_call_original
+        expect { subject }.to raise_error(Howitzer::DriverNotSpecifiedError)
+      end
+    end
+  end
+
+  describe '#ie_browser?' do
     subject { ie_browser? }
-    before { allow(self).to receive(:sauce_driver?) {sauce_driver} }
-    before { allow(self).to receive(:testingbot_driver?) {testingbot_driver} }
-    context "when sauce_driver? is TRUE" do
+    before { allow(self).to receive(:sauce_driver?) { sauce_driver } }
+    before { allow(self).to receive(:testingbot_driver?) { testingbot_driver } }
+    before { allow(self).to receive(:selenium_grid_driver?) { selenium_grid_driver } }
+    context 'when sauce_driver? is TRUE' do
       let(:sauce_driver) { true }
-      let(:testingbot_driver) { false }
-      context "settings.sl_browser_name = :ie" do
+      context 'settings.sl_browser_name = :ie' do
         before { allow(settings).to receive(:sl_browser_name) { :ie } }
-        it { expect(subject).to be_true }
+        it { is_expected.to be_truthy }
       end
-      context "settings.sl_browser_name = :iexplore" do
+      context 'settings.sl_browser_name = :iexplore' do
         before { allow(settings).to receive(:sl_browser_name) { :iexplore } }
-        it { expect(subject).to be_true }
+        it { is_expected.to be_truthy }
       end
-      context "settings.sl_browser_name = :chrome" do
+      context 'settings.sl_browser_name = :chrome' do
         before { allow(settings).to receive(:sl_browser_name) { :chrome } }
-        it { expect(subject).to be_false }
+        it { is_expected.to be_falsey }
       end
-      context "settings.sl_browser_name is not specified" do
+      context 'settings.sl_browser_name is not specified' do
         before { allow(settings).to receive(:sl_browser_name) { nil } }
         it do
-          expect(log).to receive(:error).with(Howitzer::SlBrowserNotSpecifiedError, "Please check your settings").once.and_call_original
+          expect(log).to receive(:error).with(Howitzer::SlBrowserNotSpecifiedError, 'Please check your settings').once.and_call_original
           expect { subject }.to raise_error(Howitzer::SlBrowserNotSpecifiedError)
         end
       end
     end
-    context "when sauce_driver? is FALSE" do
-      let(:sauce_driver) { false }
-      let(:testingbot_driver) { false }
+    context 'when sauce_driver? is FALSE' do
       before { allow(self).to receive(:selenium_driver?){ selenium_driver} }
-      context "when selenium_driver? is TRUE" do
+      context 'when selenium_driver? is TRUE' do
         let(:selenium_driver) { true }
-        context "settings.sel_browser = :ie" do
+        context 'settings.sel_browser = :ie' do
+          before { allow(settings).to receive(:sel_browser) { :ie } }
+          it { is_expected.to be_truthy }
+        end
+        context 'settings.sel_browser = :iexplore' do
+          before { allow(settings).to receive(:sel_browser) { :iexplore } }
+          it { is_expected.to be_truthy }
+        end
+        context 'settings.sel_browser = :chrome' do
+          before { allow(settings).to receive(:sel_browser) { :chrome } }
+          it { is_expected.to be_falsey }
+        end
+        context 'settings.sel_browser is not specified' do
+          before { allow(settings).to receive(:sel_browser) { nil } }
+          it do
+            expect(log).to receive(:error).with(Howitzer::SelBrowserNotSpecifiedError, 'Please check your settings').once.and_call_original
+            expect { subject }.to raise_error(Howitzer::SelBrowserNotSpecifiedError)
+          end
+        end
+      end
+      context 'when selenium_driver? is FALSE' do
+        it { is_expected.to be_falsey }
+      end
+      context 'when selenium_grid_driver? is TRUE' do
+        let(:selenium_grid_driver) { true }
+        context 'settings.sel_browser = :ie' do
           before { allow(settings).to receive(:sel_browser) { :ie } }
-          it { expect(subject).to be_true }
+          it { is_expected.to be_truthy }
         end
-        context "settings.sel_browser = :iexplore" do
+        context 'settings.sel_browser = :iexplore' do
           before { allow(settings).to receive(:sel_browser) { :iexplore } }
-          it { expect(subject).to be_true }
+          it { is_expected.to be_truthy }
         end
-        context "settings.sel_browser = :chrome" do
+        context 'settings.sel_browser = :chrome' do
           before { allow(settings).to receive(:sel_browser) { :chrome } }
-          it { expect(subject).to be_false }
+          it { is_expected.to be_falsey }
         end
-        context "settings.sel_browser is not specified" do
+        context 'settings.sel_browser is not specified' do
           before { allow(settings).to receive(:sel_browser) { nil } }
           it do
-            expect(log).to receive(:error).with(Howitzer::SelBrowserNotSpecifiedError, "Please check your settings").once.and_call_original
+            expect(log).to receive(:error).with(Howitzer::SelBrowserNotSpecifiedError, 'Please check your settings').once.and_call_original
             expect { subject }.to raise_error(Howitzer::SelBrowserNotSpecifiedError)
           end
         end
       end
-      context "when selenium_driver? is FALSE" do
-        let(:selenium_driver) { false }
-        it { expect(subject).to be_false }
+      context 'when selenium_grid_driver? is FALSE' do
+        it { is_expected.to be_falsey }
       end
     end
-    context "when testingbot_driver? is TRUE" do
+    context 'when testingbot_driver? is TRUE' do
       let(:testingbot_driver) { true }
-      let(:sauce_driver) { false }
       before { allow(settings).to receive(:testingbot_driver?) { testingbot_driver } }
-      context "settings.sel_browser = :ie" do
+      context 'settings.sel_browser = :ie' do
         before do
           allow(settings).to receive(:tb_browser_name) { :ie }
           allow(settings).to receive(:tb_browser_version) { 9 }
         end
-        it { expect(subject).to be_true }
+        it { is_expected.to be_truthy }
       end
-      context "settings.tb_browser_name = :iexplore" do
+      context 'settings.tb_browser_name = :iexplore' do
         before do
           allow(settings).to receive(:tb_browser_name) { :iexplore }
           allow(settings).to receive(:tb_browser_version) { 9 }
         end
-        it { expect(subject).to be_true }
+        it { is_expected.to be_truthy }
       end
-      context "settings.tb_browser_name = :firefox" do
+      context 'settings.tb_browser_name = :firefox' do
         before do
           allow(settings).to receive(:tb_browser_name) { :firefox }
           allow(settings).to receive(:tb_browser_version) { 8 }
         end
-        it { expect(subject).to be_false }
+        it { is_expected.to be_falsey }
       end
-      context "settings.tb_browser_name is not specified" do
+      context 'settings.tb_browser_name is not specified' do
         before { allow(settings).to receive(:tb_browser_name) { nil } }
         it do
-          expect(log).to receive(:error).with(Howitzer::TbBrowserNotSpecifiedError, "Please check your settings").once.and_call_original
+          expect(log).to receive(:error).with(Howitzer::TbBrowserNotSpecifiedError, 'Please check your settings').once.and_call_original
           expect { subject }.to raise_error(Howitzer::TbBrowserNotSpecifiedError)
         end
       end
     end
-    context "when testingbot_driver? is FALSE" do
+    context 'when testingbot_driver? is FALSE' do
       before { allow(self).to receive(:sauce_driver?) { sauce_driver } }
-      context "when sauce_driver? is TRUE" do
-        let(:testingbot_driver) { false }
+      context 'when sauce_driver? is TRUE' do
         let(:sauce_driver) { true }
-        context "settings.sl_browser_name = :ie" do
+        context 'settings.sl_browser_name = :ie' do
           before { allow(settings).to receive(:sl_browser_name) { :ie } }
-          it { expect(subject).to be_true }
+          it { is_expected.to be_truthy }
         end
-        context "settings.sl_browser_name = :iexplore" do
+        context 'settings.sl_browser_name = :iexplore' do
           before { allow(settings).to receive(:sl_browser_name) { :iexplore } }
-          it { expect(subject).to be_true }
+          it { is_expected.to be_truthy }
         end
-        context "settings.sl_browser_name = :chrome" do
+        context 'settings.sl_browser_name = :chrome' do
           before { allow(settings).to receive(:sl_browser_name) { :chrome } }
-          it { expect(subject).to be_false }
+          it { is_expected.to be_falsey }
         end
-        context "settings.sl_browser_name is not specified" do
+        context 'settings.sl_browser_name is not specified' do
           before { allow(settings).to receive(:sl_browser_name) { nil } }
           it do
-            expect(log).to receive(:error).with(Howitzer::SlBrowserNotSpecifiedError, "Please check your settings").once.and_call_original
+            expect(log).to receive(:error).with(Howitzer::SlBrowserNotSpecifiedError, 'Please check your settings').once.and_call_original
             expect { subject }.to raise_error(Howitzer::SlBrowserNotSpecifiedError)
           end
         end
       end
     end
-    context "when selenium_driver? is TRUE" do
-      let(:sauce_driver) { false }
-      let(:testingbot_driver) { false }
+    context 'when selenium_driver? is TRUE' do
       before { allow(self).to receive(:selenium_driver?) { selenium_driver } }
-      context "when selenium_driver? is TRUE" do
+      context 'when selenium_driver? is TRUE' do
         let(:selenium_driver) { true }
-        context "settings.sel_browser = :ie" do
+        context 'settings.sel_browser = :ie' do
           before { allow(settings).to receive(:sel_browser) { :ie } }
-          it { expect(subject).to be_true }
+          it { is_expected.to be_truthy }
         end
-        context "settings.sel_browser = :iexplore" do
+        context 'settings.sel_browser = :iexplore' do
           before { allow(settings).to receive(:sel_browser) { :iexplore } }
-          it { expect(subject).to be_true }
+          it { is_expected.to be_truthy }
         end
-        context "settings.sel_browser = :chrome" do
+        context 'settings.sel_browser = :chrome' do
           before { allow(settings).to receive(:sel_browser) { :chrome } }
-          it { expect(subject).to be_false }
+          it { is_expected.to be_falsey }
         end
-        context "settings.sel_browser is not specified" do
+        context 'settings.sel_browser is not specified' do
           before { allow(settings).to receive(:sel_browser) { nil } }
           it do
-            expect(log).to receive(:error).with(Howitzer::SelBrowserNotSpecifiedError, "Please check your settings").once.and_call_original
+            expect(log).to receive(:error).with(Howitzer::SelBrowserNotSpecifiedError, 'Please check your settings').once.and_call_original
             expect { subject }.to raise_error(Howitzer::SelBrowserNotSpecifiedError)
           end
         end
       end
     end
-    context "when selenium_driver? is FALSE" do
+    context 'when selenium_driver? is FALSE' do
       before { allow(self).to receive(:selenium_driver?) { false } }
-      context "when testingbot_driver? is TRUE" do
+      context 'when testingbot_driver? is TRUE' do
         let(:testingbot_driver) { true }
-        let(:sauce_driver) { false }
         before { allow(settings).to receive(:testingbot_driver?) { testingbot_driver } }
-        context "settings.sl_browser_name = :ie" do
+        context 'settings.sl_browser_name = :ie' do
           before do
             allow(settings).to receive(:tb_browser_name) { :ie }
             allow(settings).to receive(:tb_browser_version) { 9 }
           end
-          it { expect(subject).to be_true }
+          it { is_expected.to be_truthy }
         end
-        context "settings.tb_browser_name = :iexplore" do
+        context 'settings.tb_browser_name = :iexplore' do
           before do
             allow(settings).to receive(:tb_browser_name) { :iexplore }
             allow(settings).to receive(:tb_browser_version) { 9 }
           end
-          it { expect(subject).to be_true }
+          it { is_expected.to be_truthy }
         end
-        context "settings.tb_browser_name = :firefox" do
+        context 'settings.tb_browser_name = :firefox' do
           before do
             allow(settings).to receive(:tb_browser_name) { :firefox }
             allow(settings).to receive(:tb_browser_version) { 8 }
           end
-          it { expect(subject).to be_false }
+          it { is_expected.to be_falsey }
         end
-        context "settings.tb_browser_name is not specified" do
+        context 'settings.tb_browser_name is not specified' do
           before { allow(settings).to receive(:tb_browser_name) { nil } }
           it do
-            expect(log).to receive(:error).with(Howitzer::TbBrowserNotSpecifiedError, "Please check your settings").once.and_call_original
+            expect(log).to receive(:error).with(Howitzer::TbBrowserNotSpecifiedError, 'Please check your settings').once.and_call_original
             expect { subject }.to raise_error(Howitzer::TbBrowserNotSpecifiedError)
           end
         end
       end
     end
   end
-  describe "#ff_browser?" do
+
+  describe '#ff_browser?' do
     subject { ff_browser? }
-    before { allow(self).to receive(:sauce_driver?){ sauce_driver} }
-    before { allow(self).to receive(:testingbot_driver?){ testingbot_driver} }
-    context "when sauce_driver? is TRUE" do
+    before { allow(self).to receive(:sauce_driver?){ sauce_driver } }
+    before { allow(self).to receive(:testingbot_driver?){ testingbot_driver } }
+    before { allow(self).to receive(:selenium_grid_driver?){ selenium_grid_driver } }
+    context 'when sauce_driver? is TRUE' do
       let(:sauce_driver) { true }
-      let(:testingbot_driver) { false }
-      context "settings.sl_browser_name = :ff" do
+      context 'settings.sl_browser_name = :ff' do
         before { allow(settings).to receive(:sl_browser_name) { :ff } }
-        it { expect(subject).to be_true }
+        it { is_expected.to be_truthy }
       end
-      context "settings.sl_browser_name = :firefox" do
+      context 'settings.sl_browser_name = :firefox' do
         before { allow(settings).to receive(:sl_browser_name) { :firefox } }
-        it { expect(subject).to be_true }
+        it { is_expected.to be_truthy }
       end
-      context "settings.sl_browser_name = :chrome" do
+      context 'settings.sl_browser_name = :chrome' do
         before { allow(settings).to receive(:sl_browser_name) { :chrome } }
-        it { expect(subject).to be_false }
+        it { is_expected.to be_falsey }
       end
-      context "settings.sl_browser_name is not specified" do
+      context 'settings.sl_browser_name is not specified' do
         before { allow(settings).to receive(:sl_browser_name) { nil } }
         it do
-          expect(log).to receive(:error).with(Howitzer::SlBrowserNotSpecifiedError, "Please check your settings").once.and_call_original
+          expect(log).to receive(:error).with(Howitzer::SlBrowserNotSpecifiedError, 'Please check your settings').once.and_call_original
           expect { subject }.to raise_error(Howitzer::SlBrowserNotSpecifiedError)
         end
       end
     end
-    context "when sauce_driver? is FALSE" do
-      let(:testingbot_driver) { false }
-      let(:sauce_driver) { false }
+    context 'when sauce_driver? is FALSE' do
       before { allow(self).to receive(:selenium_driver?){ selenium_driver} }
-      context "when selenium_driver? is TRUE" do
+      context 'when selenium_driver? is TRUE' do
         let(:selenium_driver) { true }
-        context "settings.sel_browser = :ff" do
+        context 'settings.sel_browser = :ff' do
           before { allow(settings).to receive(:sel_browser) { :ff } }
-          it { expect(subject).to be_true }
+          it { is_expected.to be_truthy }
         end
-        context "settings.sel_browser = :firefox" do
+        context 'settings.sel_browser = :firefox' do
           before { allow(settings).to receive(:sel_browser) { :firefox } }
-          it { expect(subject).to be_true }
+          it { is_expected.to be_truthy }
         end
-        context "settings.sel_browser = :chrome" do
+        context 'settings.sel_browser = :chrome' do
           before { allow(settings).to receive(:sel_browser) { :chrome } }
-          it { expect(subject).to be_false }
+          it { is_expected.to be_falsey }
         end
-        context "settings.sel_browser is not specified" do
+        context 'settings.sel_browser is not specified' do
           before { allow(settings).to receive(:sel_browser) { nil } }
           it do
-            expect(log).to receive(:error).with(Howitzer::SelBrowserNotSpecifiedError, "Please check your settings").once.and_call_original
+            expect(log).to receive(:error).with(Howitzer::SelBrowserNotSpecifiedError, 'Please check your settings').once.and_call_original
             expect { subject }.to raise_error(Howitzer::SelBrowserNotSpecifiedError)
           end
         end
       end
-      context "when selenium_driver? is FALSE" do
-        let(:selenium_driver) { false }
-        it { expect(subject).to be_false }
+      context 'when selenium_driver? is FALSE' do
+        it { is_expected.to be_falsey }
       end
     end
-    context "when testingbot_driver? is TRUE" do
+    context 'when testingbot_driver? is TRUE' do
       let(:testingbot_driver) { true }
-      let(:sauce_driver) { false }
       before { allow(settings).to receive(:testingbot_driver?) { testingbot_driver } }
-      context "settings.tb_browser_name = :ff" do
+      context 'settings.tb_browser_name = :ff' do
         before do
           allow(settings).to receive(:tb_browser_name) { :ff }
           allow(settings).to receive(:tb_browser_version) { 8 }
         end
-        it { expect(subject).to be_true }
+        it { is_expected.to be_truthy }
       end
-      context "settings.tb_browser_name = :firefox" do
+      context 'settings.tb_browser_name = :firefox' do
         before do
           allow(settings).to receive(:tb_browser_name) { :firefox }
           allow(settings).to receive(:tb_browser_version) { 8 }
         end
-        it { expect(subject).to be_true }
+        it { is_expected.to be_truthy }
       end
-      context "settings.tb_browser_name = :iexplore" do
+      context 'settings.tb_browser_name = :iexplore' do
         before do
           allow(settings).to receive(:tb_browser_name) { :iexplore }
           allow(settings).to receive(:tb_browser_version) { 9 }
         end
-        it { expect(subject).to be_false }
+        it { is_expected.to be_falsey }
       end
-      context "settings.tb_browser_name is not specified" do
+      context 'settings.tb_browser_name is not specified' do
         before { allow(settings).to receive(:tb_browser_name) { nil } }
         it do
-          expect(log).to receive(:error).with(Howitzer::TbBrowserNotSpecifiedError, "Please check your settings").once.and_call_original
+          expect(log).to receive(:error).with(Howitzer::TbBrowserNotSpecifiedError, 'Please check your settings').once.and_call_original
           expect { subject }.to raise_error(Howitzer::TbBrowserNotSpecifiedError)
         end
       end
     end
-    context "when testingbot_driver? is FALSE" do
+    context 'when testingbot_driver? is FALSE' do
       before { allow(self).to receive(:sauce_driver?) { sauce_driver } }
-      context "when sauce_driver? is TRUE" do
-        let(:testingbot_driver) { false }
+      context 'when sauce_driver? is TRUE' do
         let(:sauce_driver) { true }
-        context "settings.sl_browser_name = :ff" do
+        context 'settings.sl_browser_name = :ff' do
           before { allow(settings).to receive(:sl_browser_name) { :ff } }
-          it { expect(subject).to be_true }
+          it { is_expected.to be_truthy }
         end
-        context "settings.sl_browser_name = :firefox" do
+        context 'settings.sl_browser_name = :firefox' do
           before { allow(settings).to receive(:sl_browser_name) { :firefox } }
-          it { expect(subject).to be_true }
+          it { is_expected.to be_truthy }
         end
-        context "settings.sl_browser_name = :chrome" do
+        context 'settings.sl_browser_name = :chrome' do
           before { allow(settings).to receive(:sl_browser_name) { :chrome } }
-          it { expect(subject).to be_false }
+          it { is_expected.to be_falsey }
         end
-        context "settings.sl_browser_name is not specified" do
+        context 'settings.sl_browser_name is not specified' do
           before { allow(settings).to receive(:sl_browser_name) { nil } }
           it do
-            expect(log).to receive(:error).with(Howitzer::SlBrowserNotSpecifiedError, "Please check your settings").once.and_call_original
+            expect(log).to receive(:error).with(Howitzer::SlBrowserNotSpecifiedError, 'Please check your settings').once.and_call_original
             expect { subject }.to raise_error(Howitzer::SlBrowserNotSpecifiedError)
           end
         end
       end
     end
-    context "when selenium_driver? is TRUE" do
-      let(:sauce_driver) { false }
-      let(:testingbot_driver) { false }
+    context 'when selenium_driver? is TRUE' do
       before { allow(self).to receive(:selenium_driver?) { selenium_driver } }
-      context "when selenium_driver? is TRUE" do
+      context 'when selenium_driver? is TRUE' do
         let(:selenium_driver) { true }
-        context "settings.sel_browser = :ff" do
+        context 'settings.sel_browser = :ff' do
           before { allow(settings).to receive(:sel_browser) { :ff } }
-          it { expect(subject).to be_true }
+          it { is_expected.to be_truthy }
         end
-        context "settings.sel_browser = :firefox" do
+        context 'settings.sel_browser = :firefox' do
           before { allow(settings).to receive(:sel_browser) { :firefox } }
-          it { expect(subject).to be_true }
+          it { is_expected.to be_truthy }
         end
-        context "settings.sel_browser = :chrome" do
+        context 'settings.sel_browser = :chrome' do
           before { allow(settings).to receive(:sel_browser) { :chrome } }
-          it { expect(subject).to be_false }
+          it { is_expected.to be_falsey }
         end
-        context "settings.sel_browser is not specified" do
+        context 'settings.sel_browser is not specified' do
           before { allow(settings).to receive(:sel_browser) { nil } }
           it do
-            expect(log).to receive(:error).with(Howitzer::SelBrowserNotSpecifiedError, "Please check your settings").once.and_call_original
+            expect(log).to receive(:error).with(Howitzer::SelBrowserNotSpecifiedError, 'Please check your settings').once.and_call_original
             expect { subject }.to raise_error(Howitzer::SelBrowserNotSpecifiedError)
           end
         end
       end
     end
-    context "when selenium_driver? is FALSE" do
+    context 'when selenium_driver? is FALSE' do
       before { allow(self).to receive(:selenium_driver?) { false } }
-      context "when testingbot_driver? is TRUE" do
+      context 'when testingbot_driver? is TRUE' do
         let(:testingbot_driver) { true }
-        let(:sauce_driver) { false }
         before { allow(settings).to receive(:testingbot_driver?) { testingbot_driver } }
-        context "settings.tb_browser_name = :firefox" do
+        context 'settings.tb_browser_name = :firefox' do
           before do
             allow(settings).to receive(:tb_browser_name) { :firefox }
             allow(settings).to receive(:tb_browser_version) { 8 }
           end
-          it { expect(subject).to be_true }
+          it { is_expected.to be_truthy }
         end
-        context "settings.tb_browser_name = :ff" do
+        context 'settings.tb_browser_name = :ff' do
           before do
             allow(settings).to receive(:tb_browser_name) { :ff }
             allow(settings).to receive(:tb_browser_version) { 8 }
           end
-          it { expect(subject).to be_true }
+          it { is_expected.to be_truthy }
         end
-        context "settings.tb_browser_name = :iexplore" do
+        context 'settings.tb_browser_name = :iexplore' do
           before do
             allow(settings).to receive(:tb_browser_name) { :iexplore }
             allow(settings).to receive(:tb_browser_version) { 9 }
           end
-          it { expect(subject).to be_false }
+          it { is_expected.to be_falsey }
         end
-        context "settings.tb_browser_name is not specified" do
+        context 'settings.tb_browser_name is not specified' do
           before { allow(settings).to receive(:tb_browser_name) { nil } }
           it do
-            expect(log).to receive(:error).with(Howitzer::TbBrowserNotSpecifiedError, "Please check your settings").once.and_call_original
+            expect(log).to receive(:error).with(Howitzer::TbBrowserNotSpecifiedError, 'Please check your settings').once.and_call_original
             expect { subject }.to raise_error(Howitzer::TbBrowserNotSpecifiedError)
           end
         end
       end
-
+      context 'when selenium_grid_driver? is TRUE' do
+        before { allow(self).to receive(:selenium_grid_driver?) { selenium_grid_driver } }
+        context 'when selenium_grid_driver? is TRUE' do
+          let(:selenium_grid_driver) { true }
+          context 'settings.sel_browser = :ff' do
+            before { allow(settings).to receive(:sel_browser) { :ff } }
+            it { is_expected.to be_truthy }
+          end
+          context 'settings.sel_browser = :firefox' do
+            before { allow(settings).to receive(:sel_browser) { :firefox } }
+            it { is_expected.to be_truthy }
+          end
+          context 'settings.sel_browser = :chrome' do
+            before { allow(settings).to receive(:sel_browser) { :chrome } }
+            it { is_expected.to be_falsey }
+          end
+          context 'settings.sel_browser is not specified' do
+            before { allow(settings).to receive(:sel_browser) { nil } }
+            it do
+              expect(log).to receive(:error).with(Howitzer::SelBrowserNotSpecifiedError, 'Please check your settings').once.and_call_original
+              expect { subject }.to raise_error(Howitzer::SelBrowserNotSpecifiedError)
+            end
+          end
+        end
+      end
+      context 'when selenium_grid_driver? is FALSE' do
+        before { allow(self).to receive(:selenium_grid_driver?) { false } }
+        context 'when testingbot_driver? is TRUE' do
+          let(:testingbot_driver) { true }
+          before { allow(settings).to receive(:testingbot_driver?) { testingbot_driver } }
+          context 'settings.tb_browser_name = :firefox' do
+            before do
+              allow(settings).to receive(:tb_browser_name) { :firefox }
+              allow(settings).to receive(:tb_browser_version) { 8 }
+            end
+            it { is_expected.to be_truthy }
+          end
+          context 'settings.tb_browser_name = :ff' do
+            before do
+              allow(settings).to receive(:tb_browser_name) { :ff }
+              allow(settings).to receive(:tb_browser_version) { 8 }
+            end
+            it { is_expected.to be_truthy }
+          end
+          context 'settings.tb_browser_name = :iexplore' do
+            before do
+              allow(settings).to receive(:tb_browser_name) { :iexplore }
+              allow(settings).to receive(:tb_browser_version) { 9 }
+            end
+            it { is_expected.to be_falsey }
+          end
+          context 'settings.tb_browser_name is not specified' do
+            before { allow(settings).to receive(:tb_browser_name) { nil } }
+            it do
+              expect(log).to receive(:error).with(Howitzer::TbBrowserNotSpecifiedError, 'Please check your settings').once.and_call_original
+              expect { subject }.to raise_error(Howitzer::TbBrowserNotSpecifiedError)
+            end
+          end
+        end
+      end
     end
   end
-  describe "#chrome_browser?" do
+
+  describe '#chrome_browser?' do
     subject { chrome_browser? }
-    before { allow(self).to receive(:sauce_driver?){ sauce_driver} }
-    before { allow(self).to receive(:testingbot_driver?){ testingbot_driver} }
-    context "when sauce_driver? is TRUE" do
+    before { allow(self).to receive(:sauce_driver?){ sauce_driver } }
+    before { allow(self).to receive(:testingbot_driver?){ testingbot_driver } }
+    before { allow(self).to receive(:selenium_grid_driver?){ selenium_grid_driver } }
+    context 'when sauce_driver? is TRUE' do
       let(:sauce_driver) { true }
       let(:testingbot_driver) { true }
-      context "settings.sl_browser_name = :chrome" do
+      context 'settings.sl_browser_name = :chrome' do
         before { allow(settings).to receive(:sl_browser_name) { :chrome } }
-        it { expect(subject).to be_true }
+        it { is_expected.to be_truthy }
       end
-      context "settings.sl_browser_name = :firefox" do
+      context 'settings.sl_browser_name = :firefox' do
         before { allow(settings).to receive(:sl_browser_name) { :firefox } }
-        it { expect(subject).to be_false }
+        it { is_expected.to be_falsey }
       end
-      context "settings.sl_browser_name is not specified" do
+      context 'settings.sl_browser_name is not specified' do
         before { allow(settings).to receive(:sl_browser_name) { nil } }
         it do
-          expect(log).to receive(:error).with(Howitzer::SlBrowserNotSpecifiedError, "Please check your settings").once.and_call_original
+          expect(log).to receive(:error).with(Howitzer::SlBrowserNotSpecifiedError, 'Please check your settings').once.and_call_original
           expect { subject }.to raise_error(Howitzer::SlBrowserNotSpecifiedError)
         end
       end
     end
-    context "when sauce_driver? is FALSE" do
-      let(:sauce_driver) { false }
-      let(:testingbot_driver) { false }
+    context 'when sauce_driver? is FALSE' do
       before { allow(self).to receive(:selenium_driver?){ selenium_driver} }
-      context "when selenium_driver? is TRUE" do
+      context 'when selenium_driver? is TRUE' do
         let(:selenium_driver) { true }
-        context "settings.sel_browser = :chrome" do
+        context 'settings.sel_browser = :chrome' do
           before { allow(settings).to receive(:sel_browser) { :chrome } }
-          it { expect(subject).to be_true }
+          it { is_expected.to be_truthy }
         end
-        context "settings.sel_browser = :firefox" do
+        context 'settings.sel_browser = :firefox' do
           before { allow(settings).to receive(:sel_browser) { :firefox } }
-          it { expect(subject).to be_false }
+          it { is_expected.to be_falsey }
         end
-        context "settings.sel_browser is not specified" do
+        context 'settings.sel_browser is not specified' do
           before { allow(settings).to receive(:sel_browser) { nil } }
           it do
-            expect(log).to receive(:error).with(Howitzer::SelBrowserNotSpecifiedError, "Please check your settings").once.and_call_original
+            expect(log).to receive(:error).with(Howitzer::SelBrowserNotSpecifiedError, 'Please check your settings').once.and_call_original
             expect { subject }.to raise_error(Howitzer::SelBrowserNotSpecifiedError)
           end
         end
       end
-      context "when selenium_driver? is FALSE" do
-        let(:selenium_driver) { false }
-        it { expect(subject).to be_false }
+      context 'when selenium_driver? is FALSE' do
+        it { is_expected.to be_falsey }
       end
     end
-    context "when testingbot_driver? is TRUE" do
+    context 'when testingbot_driver? is TRUE' do
       let(:testingbot_driver) { true }
-      let(:sauce_driver) { false }
       before { allow(settings).to receive(:testingbot_driver?) { testingbot_driver } }
-      context "settings.tb_browser_name = :chrome" do
+      context 'settings.tb_browser_name = :chrome' do
         before do
           allow(settings).to receive(:tb_browser_name) { :chrome }
           allow(settings).to receive(:tb_browser_version) { 9 }
         end
-        it { expect(subject).to be_true }
+        it { is_expected.to be_truthy }
       end
-      context "settings.tb_browser_name = :iexplore" do
+      context 'settings.tb_browser_name = :iexplore' do
         before do
           allow(settings).to receive(:tb_browser_name) { :iexplore }
           allow(settings).to receive(:tb_browser_version) { 9 }
         end
-        it { expect(subject).to be_false }
+        it { is_expected.to be_falsey }
       end
-      context "settings.tb_browser_name is not specified" do
+      context 'settings.tb_browser_name is not specified' do
         before { allow(settings).to receive(:tb_browser_name) { nil } }
         it do
-          expect(log).to receive(:error).with(Howitzer::TbBrowserNotSpecifiedError, "Please check your settings").once.and_call_original
+          expect(log).to receive(:error).with(Howitzer::TbBrowserNotSpecifiedError, 'Please check your settings').once.and_call_original
           expect { subject }.to raise_error(Howitzer::TbBrowserNotSpecifiedError)
         end
       end
     end
-    context "when testingbot_driver? is FALSE" do
+    context 'when testingbot_driver? is FALSE' do
       before { allow(self).to receive(:sauce_driver?) { sauce_driver } }
-      context "when sauce_driver? is TRUE" do
-        let(:testingbot_driver) { false }
+      context 'when sauce_driver? is TRUE' do
         let(:sauce_driver) { true }
-        context "settings.sl_browser_name = :chrome" do
+        context 'settings.sl_browser_name = :chrome' do
           before { allow(settings).to receive(:sl_browser_name) { :chrome } }
-          it { expect(subject).to be_true }
+          it { is_expected.to be_truthy }
         end
-        context "settings.sl_browser_name = :firefox" do
+        context 'settings.sl_browser_name = :firefox' do
           before { allow(settings).to receive(:sl_browser_name) { :firefox } }
-          it { expect(subject).to be_false }
+          it { is_expected.to be_falsey }
         end
-        context "settings.sl_browser_name is not specified" do
+        context 'settings.sl_browser_name is not specified' do
           before { allow(settings).to receive(:sl_browser_name) { nil } }
           it do
-            expect(log).to receive(:error).with(Howitzer::SlBrowserNotSpecifiedError, "Please check your settings").once.and_call_original
+            expect(log).to receive(:error).with(Howitzer::SlBrowserNotSpecifiedError, 'Please check your settings').once.and_call_original
             expect { subject }.to raise_error(Howitzer::SlBrowserNotSpecifiedError)
           end
         end
       end
-
     end
-    context "when selenium_driver? is TRUE" do
-      let(:sauce_driver) { false }
-      let(:testingbot_driver) { false }
+    context 'when selenium_driver? is TRUE' do
       before { allow(self).to receive(:selenium_driver?) { selenium_driver } }
-      context "when selenium_driver? is TRUE" do
+      context 'when selenium_driver? is TRUE' do
         let(:selenium_driver) { true }
-        context "settings.sel_browser = :chrome" do
+        context 'settings.sel_browser = :chrome' do
           before { allow(settings).to receive(:sel_browser) { :chrome } }
-          it { expect(subject).to be_true }
+          it { is_expected.to be_truthy }
         end
-        context "settings.sel_browser = :firefox" do
+        context 'settings.sel_browser = :firefox' do
           before { allow(settings).to receive(:sel_browser) { :firefox } }
-          it { expect(subject).to be_false }
+          it { is_expected.to be_falsey }
         end
-        context "settings.sel_browser is not specified" do
+        context 'settings.sel_browser is not specified' do
           before { allow(settings).to receive(:sel_browser) { nil } }
           it do
-            expect(log).to receive(:error).with(Howitzer::SelBrowserNotSpecifiedError, "Please check your settings").once.and_call_original
+            expect(log).to receive(:error).with(Howitzer::SelBrowserNotSpecifiedError, 'Please check your settings').once.and_call_original
             expect { subject }.to raise_error(Howitzer::SelBrowserNotSpecifiedError)
           end
         end
       end
-
     end
-    context "when selenium_driver? is FALSE" do
-      let(:sauce_driver) { false }
-      let(:testingbot_driver) { false }
+    context 'when selenium_driver? is FALSE' do
       before { allow(self).to receive(:selenium_driver?){ selenium_driver} }
-      context "when selenium_driver? is TRUE" do
+      context 'when selenium_driver? is TRUE' do
         let(:selenium_driver) { true }
-        context "settings.sel_browser = :chrome" do
+        context 'settings.sel_browser = :chrome' do
           before { allow(settings).to receive(:sel_browser) { :chrome } }
-          it { expect(subject).to be_true }
+          it { is_expected.to be_truthy }
+        end
+        context 'settings.sel_browser = :firefox' do
+          before { allow(settings).to receive(:sel_browser) { :firefox } }
+          it { is_expected.to be_falsey }
+        end
+        context 'settings.sel_browser is not specified' do
+          before { allow(settings).to receive(:sel_browser) { nil } }
+          it do
+            expect(log).to receive(:error).with(Howitzer::SelBrowserNotSpecifiedError, 'Please check your settings').once.and_call_original
+            expect { subject }.to raise_error(Howitzer::SelBrowserNotSpecifiedError)
+          end
+        end
+      end
+      context 'when selenium_driver? is FALSE' do
+        it { is_expected.to be_falsey }
+      end
+    end
+  end
+
+  describe '#opera_browser?' do
+    subject { opera_browser? }
+    before { allow(self).to receive(:sauce_driver?){ sauce_driver } }
+    before { allow(self).to receive(:testingbot_driver?){ testingbot_driver } }
+    before { allow(self).to receive(:selenium_grid_driver?){ selenium_grid_driver } }
+    context 'when sauce_driver? is TRUE' do
+      let(:sauce_driver) { true }
+      let(:testingbot_driver) { true }
+      context 'settings.sl_browser_name = :opera' do
+        before { allow(settings).to receive(:sl_browser_name) { :opera } }
+        it { is_expected.to be_truthy }
+      end
+      context 'settings.sl_browser_name = :firefox' do
+        before { allow(settings).to receive(:sl_browser_name) { :firefox } }
+        it { is_expected.to be_falsey }
+      end
+      context 'settings.sl_browser_name is not specified' do
+        before { allow(settings).to receive(:sl_browser_name) { nil } }
+        it do
+          expect(log).to receive(:error).with(Howitzer::SlBrowserNotSpecifiedError, 'Please check your settings').once.and_call_original
+          expect { subject }.to raise_error(Howitzer::SlBrowserNotSpecifiedError)
+        end
+      end
+    end
+    context 'when sauce_driver? is FALSE' do
+      before { allow(self).to receive(:selenium_driver?){ selenium_driver} }
+      context 'when selenium_driver? is TRUE' do
+        let(:selenium_driver) { true }
+        context 'settings.sel_browser = :opera' do
+          before { allow(settings).to receive(:sel_browser) { :opera } }
+          it { is_expected.to be_truthy }
+        end
+        context 'settings.sel_browser = :firefox' do
+          before { allow(settings).to receive(:sel_browser) { :firefox } }
+          it { is_expected.to be_falsey }
+        end
+        context 'settings.sel_browser is not specified' do
+          before { allow(settings).to receive(:sel_browser) { nil } }
+          it do
+            expect(log).to receive(:error).with(Howitzer::SelBrowserNotSpecifiedError, 'Please check your settings').once.and_call_original
+            expect { subject }.to raise_error(Howitzer::SelBrowserNotSpecifiedError)
+          end
+        end
+      end
+      context 'when selenium_driver? is FALSE' do
+        it { is_expected.to be_falsey }
+      end
+    end
+    context 'when testingbot_driver? is TRUE' do
+      let(:testingbot_driver) { true }
+      before { allow(settings).to receive(:testingbot_driver?) { testingbot_driver } }
+      context 'settings.tb_browser_name = :opera' do
+        before do
+          allow(settings).to receive(:tb_browser_name) { :opera }
+          allow(settings).to receive(:tb_browser_version) { 9 }
+        end
+        it { is_expected.to be_truthy }
+      end
+      context 'settings.tb_browser_name = :iexplore' do
+        before do
+          allow(settings).to receive(:tb_browser_name) { :iexplore }
+          allow(settings).to receive(:tb_browser_version) { 9 }
+        end
+        it { is_expected.to be_falsey }
+      end
+      context 'settings.tb_browser_name is not specified' do
+        before { allow(settings).to receive(:tb_browser_name) { nil } }
+        it do
+          expect(log).to receive(:error).with(Howitzer::TbBrowserNotSpecifiedError, 'Please check your settings').once.and_call_original
+          expect { subject }.to raise_error(Howitzer::TbBrowserNotSpecifiedError)
+        end
+      end
+    end
+    context 'when testingbot_driver? is FALSE' do
+      before { allow(self).to receive(:sauce_driver?) { sauce_driver } }
+      context 'when sauce_driver? is TRUE' do
+        let(:sauce_driver) { true }
+        context 'settings.sl_browser_name = :opera' do
+          before { allow(settings).to receive(:sl_browser_name) { :opera } }
+          it { is_expected.to be_truthy }
+        end
+        context 'settings.sl_browser_name = :firefox' do
+          before { allow(settings).to receive(:sl_browser_name) { :firefox } }
+          it { is_expected.to be_falsey }
+        end
+        context 'settings.sl_browser_name is not specified' do
+          before { allow(settings).to receive(:sl_browser_name) { nil } }
+          it do
+            expect(log).to receive(:error).with(Howitzer::SlBrowserNotSpecifiedError, 'Please check your settings').once.and_call_original
+            expect { subject }.to raise_error(Howitzer::SlBrowserNotSpecifiedError)
+          end
+        end
+      end
+    end
+    context 'when selenium_driver? is TRUE' do
+      before { allow(self).to receive(:selenium_driver?) { selenium_driver } }
+      context 'when selenium_driver? is TRUE' do
+        let(:selenium_driver) { true }
+        context 'settings.sel_browser = :opera' do
+          before { allow(settings).to receive(:sel_browser) { :opera } }
+          it { is_expected.to be_truthy }
         end
-        context "settings.sel_browser = :firefox" do
+        context 'settings.sel_browser = :firefox' do
           before { allow(settings).to receive(:sel_browser) { :firefox } }
-          it { expect(subject).to be_false }
+          it { is_expected.to be_falsey }
         end
-        context "settings.sel_browser is not specified" do
+        context 'settings.sel_browser is not specified' do
           before { allow(settings).to receive(:sel_browser) { nil } }
           it do
-            expect(log).to receive(:error).with(Howitzer::SelBrowserNotSpecifiedError, "Please check your settings").once.and_call_original
+            expect(log).to receive(:error).with(Howitzer::SelBrowserNotSpecifiedError, 'Please check your settings').once.and_call_original
             expect { subject }.to raise_error(Howitzer::SelBrowserNotSpecifiedError)
           end
         end
       end
-      context "when selenium_driver? is FALSE" do
-        let(:selenium_driver) { false }
-        it { expect(subject).to be_false }
+    end
+    context 'when selenium_driver? is FALSE' do
+      before { allow(self).to receive(:selenium_driver?){ selenium_driver} }
+      context 'when selenium_driver? is TRUE' do
+        let(:selenium_driver) { true }
+        context 'settings.sel_browser = :opera' do
+          before { allow(settings).to receive(:sel_browser) { :opera } }
+          it { is_expected.to be_truthy }
+        end
+        context 'settings.sel_browser = :firefox' do
+          before { allow(settings).to receive(:sel_browser) { :firefox } }
+          it { is_expected.to be_falsey }
+        end
+        context 'settings.sel_browser is not specified' do
+          before { allow(settings).to receive(:sel_browser) { nil } }
+          it do
+            expect(log).to receive(:error).with(Howitzer::SelBrowserNotSpecifiedError, 'Please check your settings').once.and_call_original
+            expect { subject }.to raise_error(Howitzer::SelBrowserNotSpecifiedError)
+          end
+        end
+      end
+      context 'when selenium_driver? is FALSE' do
+        it { is_expected.to be_falsey }
       end
     end
   end
-  describe "#app_url" do
+
+  describe '#safari_browser?' do
+    subject { safari_browser? }
+    before { allow(self).to receive(:sauce_driver?){ sauce_driver } }
+    before { allow(self).to receive(:testingbot_driver?){ testingbot_driver } }
+    before { allow(self).to receive(:selenium_grid_driver?){ selenium_grid_driver } }
+    context 'when sauce_driver? is TRUE' do
+      let(:sauce_driver) { true }
+      let(:testingbot_driver) { true }
+      context 'settings.sl_browser_name = :safari' do
+        before { allow(settings).to receive(:sl_browser_name) { :safari } }
+        it { is_expected.to be_truthy }
+      end
+      context 'settings.sl_browser_name = :firefox' do
+        before { allow(settings).to receive(:sl_browser_name) { :firefox } }
+        it { is_expected.to be_falsey }
+      end
+      context 'settings.sl_browser_name is not specified' do
+        before { allow(settings).to receive(:sl_browser_name) { nil } }
+        it do
+          expect(log).to receive(:error).with(Howitzer::SlBrowserNotSpecifiedError, 'Please check your settings').once.and_call_original
+          expect { subject }.to raise_error(Howitzer::SlBrowserNotSpecifiedError)
+        end
+      end
+    end
+    context 'when sauce_driver? is FALSE' do
+      before { allow(self).to receive(:selenium_driver?){ selenium_driver} }
+      context 'when selenium_driver? is TRUE' do
+        let(:selenium_driver) { true }
+        context 'settings.sel_browser = :safari' do
+          before { allow(settings).to receive(:sel_browser) { :safari } }
+          it { is_expected.to be_truthy }
+        end
+        context 'settings.sel_browser = :firefox' do
+          before { allow(settings).to receive(:sel_browser) { :firefox } }
+          it { is_expected.to be_falsey }
+        end
+        context 'settings.sel_browser is not specified' do
+          before { allow(settings).to receive(:sel_browser) { nil } }
+          it do
+            expect(log).to receive(:error).with(Howitzer::SelBrowserNotSpecifiedError, 'Please check your settings').once.and_call_original
+            expect { subject }.to raise_error(Howitzer::SelBrowserNotSpecifiedError)
+          end
+        end
+      end
+      context 'when selenium_driver? is FALSE' do
+        it { is_expected.to be_falsey }
+      end
+    end
+    context 'when testingbot_driver? is TRUE' do
+      let(:testingbot_driver) { true }
+      before { allow(settings).to receive(:testingbot_driver?) { testingbot_driver } }
+      context 'settings.tb_browser_name = :safari' do
+        before do
+          allow(settings).to receive(:tb_browser_name) { :safari }
+          allow(settings).to receive(:tb_browser_version) { 9 }
+        end
+        it { is_expected.to be_truthy }
+      end
+      context 'settings.tb_browser_name = :iexplore' do
+        before do
+          allow(settings).to receive(:tb_browser_name) { :iexplore }
+          allow(settings).to receive(:tb_browser_version) { 9 }
+        end
+        it { is_expected.to be_falsey }
+      end
+      context 'settings.tb_browser_name is not specified' do
+        before { allow(settings).to receive(:tb_browser_name) { nil } }
+        it do
+          expect(log).to receive(:error).with(Howitzer::TbBrowserNotSpecifiedError, 'Please check your settings').once.and_call_original
+          expect { subject }.to raise_error(Howitzer::TbBrowserNotSpecifiedError)
+        end
+      end
+    end
+    context 'when testingbot_driver? is FALSE' do
+      before { allow(self).to receive(:sauce_driver?) { sauce_driver } }
+      context 'when sauce_driver? is TRUE' do
+        let(:sauce_driver) { true }
+        context 'settings.sl_browser_name = :safari' do
+          before { allow(settings).to receive(:sl_browser_name) { :safari } }
+          it { is_expected.to be_truthy }
+        end
+        context 'settings.sl_browser_name = :firefox' do
+          before { allow(settings).to receive(:sl_browser_name) { :firefox } }
+          it { is_expected.to be_falsey }
+        end
+        context 'settings.sl_browser_name is not specified' do
+          before { allow(settings).to receive(:sl_browser_name) { nil } }
+          it do
+            expect(log).to receive(:error).with(Howitzer::SlBrowserNotSpecifiedError, 'Please check your settings').once.and_call_original
+            expect { subject }.to raise_error(Howitzer::SlBrowserNotSpecifiedError)
+          end
+        end
+      end
+    end
+    context 'when selenium_driver? is TRUE' do
+      before { allow(self).to receive(:selenium_driver?) { selenium_driver } }
+      context 'when selenium_driver? is TRUE' do
+        let(:selenium_driver) { true }
+        context 'settings.sel_browser = :safari' do
+          before { allow(settings).to receive(:sel_browser) { :safari } }
+          it { is_expected.to be_truthy }
+        end
+        context 'settings.sel_browser = :firefox' do
+          before { allow(settings).to receive(:sel_browser) { :firefox } }
+          it { is_expected.to be_falsey }
+        end
+        context 'settings.sel_browser is not specified' do
+          before { allow(settings).to receive(:sel_browser) { nil } }
+          it do
+            expect(log).to receive(:error).with(Howitzer::SelBrowserNotSpecifiedError, 'Please check your settings').once.and_call_original
+            expect { subject }.to raise_error(Howitzer::SelBrowserNotSpecifiedError)
+          end
+        end
+      end
+    end
+    context 'when selenium_driver? is FALSE' do
+      before { allow(self).to receive(:selenium_driver?){ selenium_driver} }
+      context 'when selenium_driver? is TRUE' do
+        let(:selenium_driver) { true }
+        context 'settings.sel_browser = :safari' do
+          before { allow(settings).to receive(:sel_browser) { :safari } }
+          it { is_expected.to be_truthy }
+        end
+        context 'settings.sel_browser = :firefox' do
+          before { allow(settings).to receive(:sel_browser) { :firefox } }
+          it { is_expected.to be_falsey }
+        end
+        context 'settings.sel_browser is not specified' do
+          before { allow(settings).to receive(:sel_browser) { nil } }
+          it do
+            expect(log).to receive(:error).with(Howitzer::SelBrowserNotSpecifiedError, 'Please check your settings').once.and_call_original
+            expect { subject }.to raise_error(Howitzer::SelBrowserNotSpecifiedError)
+          end
+        end
+      end
+      context 'when selenium_driver? is FALSE' do
+        it { is_expected.to be_falsey }
+      end
+    end
+  end
+
+  describe '#app_url' do
     subject { app_url }
     before do
       allow(settings).to receive(:app_base_auth_login) { app_base_auth_login_setting }
@@ -623,123 +1006,124 @@ describe "Helpers" do
       allow(settings).to receive(:app_host) { app_host_setting }
     end
     let(:app_protocol_setting) { nil }
-    let(:app_host_setting) { "redmine.strongqa.com" }
-    context "when login and password present" do
-      let(:app_base_auth_login_setting) { "alex" }
-      let(:app_base_auth_pass_setting) { "pa$$w0rd" }
-      it{ expect(subject).to eq("http://alex:pa$$w0rd@redmine.strongqa.com") }
+    let(:app_host_setting) { 'redmine.strongqa.com' }
+    context 'when login and password present' do
+      let(:app_base_auth_login_setting) { 'alex' }
+      let(:app_base_auth_pass_setting) { 'pa$$w0rd' }
+      it{ is_expected.to eq('http://alex:pa$$w0rd@redmine.strongqa.com') }
     end
-    context "when login and password blank" do
-      let(:app_base_auth_login_setting) { "" }
-      let(:app_base_auth_pass_setting) { "" }
-      it{ expect(subject).to eq("http://redmine.strongqa.com") }
+    context 'when login and password blank' do
+      let(:app_base_auth_login_setting) { '' }
+      let(:app_base_auth_pass_setting) { '' }
+      it{ is_expected.to eq('http://redmine.strongqa.com') }
     end
   end
-  describe "#app_base_url" do
+
+  describe '#app_base_url' do
     subject { app_base_url(prefix) }
     before do
       allow(settings).to receive(:app_protocol) { app_protocol_setting }
       allow(settings).to receive(:app_host) { app_host_setting }
     end
     let(:app_protocol_setting) { nil }
-    let(:app_host_setting) { "redmine.strongqa.com" }
-    context "when login and password present" do
-      let(:prefix) { "alex:pa$$w0rd@" }
-      it{ expect(subject).to eq("http://alex:pa$$w0rd@redmine.strongqa.com") }
+    let(:app_host_setting) { 'redmine.strongqa.com' }
+    context 'when login and password present' do
+      let(:prefix) { 'alex:pa$$w0rd@' }
+      it{ is_expected.to eq('http://alex:pa$$w0rd@redmine.strongqa.com') }
     end
-    context "when login and password blank" do
+    context 'when login and password blank' do
       let(:prefix) { nil }
-      it{ expect(subject).to eq("http://redmine.strongqa.com") }
+      it{ is_expected.to eq('http://redmine.strongqa.com') }
     end
   end
-  describe "#duration" do
-    context "when more than hour" do
-      it{ expect(duration(10000)).to eq("[2h 46m 40s]") }
+
+  describe '#duration' do
+    context 'when more than hour' do
+      it{ expect(duration(10000)).to eq('[2h 46m 40s]') }
     end
-    context "when 1 hour exactly" do
-      it{ expect(duration(3600)).to eq("[1h 0m 0s]") }
+    context 'when 1 hour exactly' do
+      it{ expect(duration(3600)).to eq('[1h 0m 0s]') }
     end
-    context "when 0 hours and more than minute" do
-      it{ expect(duration(2000)).to eq("[33m 20s]") }
+    context 'when 0 hours and more than minute' do
+      it{ expect(duration(2000)).to eq('[33m 20s]') }
     end
-    context "when 1 minute exactly" do
-      it{ expect(duration(60)).to eq("[1m 0s]") }
+    context 'when 1 minute exactly' do
+      it{ expect(duration(60)).to eq('[1m 0s]') }
     end
-    context "when less than minute" do
-      it{ expect(duration(45)).to eq("[0m 45s]") }
+    context 'when less than minute' do
+      it{ expect(duration(45)).to eq('[0m 45s]') }
     end
-    context "when zero" do
-      it{ expect(duration(0)).to eq("[0m 0s]") }
+    context 'when zero' do
+      it{ expect(duration(0)).to eq('[0m 0s]') }
     end
   end
-  describe "#ri" do
+
+  describe '#ri' do
     subject { ri 'boom' }
     it { expect {subject}.to raise_error(RuntimeError, /boom/) }
   end
+
   describe String do
-    let(:page_name) { "my" }
+    let(:page_name) { 'my' }
     let(:page_object) { double }
-    before { stub_const("MyPage", page_object) }
-    describe "#open" do
+    before { stub_const('MyPage', page_object) }
+    describe '#open' do
       subject { page_name.open(:exit) }
       before do
         expect(page_object).to receive(:open).with(:exit).once
       end
-      it { expect(subject).to be_nil }
+      it { is_expected.to be_nil }
     end
-    describe "#given" do
+    describe '#given' do
       subject { page_name.given }
       before do
         allow(page_name).to receive(:as_page_class){ page_object }
         expect(page_object).to receive(:given).once
       end
-      it { expect(subject).to be_nil }
+      it { is_expected.to be_nil }
     end
-    describe "#wait_for_opened" do
+    describe '#wait_for_opened' do
       subject { page_name.wait_for_opened }
       before do
         allow(page_name).to receive(:as_page_class){ page_object }
         expect(page_object).to receive(:wait_for_opened).once
       end
-      it { expect(subject).to be_nil }
+      it { is_expected.to be_nil }
     end
-    describe "#as_page_class" do
+    describe '#as_page_class' do
       subject { page_name.as_page_class }
-      context "when 1 word" do
-        it { expect(subject).to eql(page_object) }
+      context 'when 1 word' do
+        it { is_expected.to eql(page_object) }
       end
-      context "when more 1 word" do
+      context 'when more 1 word' do
         let(:page_name) { 'my  super mega' }
-        before { stub_const("MySuperMegaPage", page_object) }
-        it { expect(subject).to eql(page_object) }
+        before { stub_const('MySuperMegaPage', page_object) }
+        it { is_expected.to eql(page_object) }
       end
-
-      context "when plural word" do
+      context 'when plural word' do
         let(:page_name) { 'user notifications' }
-        before { stub_const("UserNotificationsPage", page_object) }
-        it { expect(subject).to eql(page_object) }
+        before { stub_const('UserNotificationsPage', page_object) }
+        it { is_expected.to eql(page_object) }
       end
     end
-    describe "#as_email_class" do
+    describe '#as_email_class' do
       subject { email_name.as_email_class }
       let(:my_email) { double }
-      context "when 1 word" do
+      context 'when 1 word' do
         let(:email_name) { 'my' }
-        before { stub_const("MyEmail", my_email) }
-        it { expect(subject).to eql(my_email) }
+        before { stub_const('MyEmail', my_email) }
+        it { is_expected.to eql(my_email) }
       end
-
-      context "when more 1 word" do
+      context 'when more 1 word' do
         let(:email_name) { 'my  super mega' }
-        before { stub_const("MySuperMegaEmail", my_email) }
-        it { expect(subject).to eql(my_email) }
+        before { stub_const('MySuperMegaEmail', my_email) }
+        it { is_expected.to eql(my_email) }
       end
-
-      context "when plural word" do
+      context 'when plural word' do
         let(:email_name) { 'email notifications' }
-        before { stub_const("EmailNotificationsEmail", my_email) }
-        it { expect(subject).to eql(my_email) }
+        before { stub_const('EmailNotificationsEmail', my_email) }
+        it { is_expected.to eql(my_email) }
       end
     end
   end
-end
+end