howitzer 1.0.2 → 1.1.0

data/spec/unit/lib/mailgun/client_spec.rb

@@ -1,26 +1,26 @@
 require 'spec_helper'
 require 'howitzer/mailgun/client'
 
-describe Mailgun::Client do
-  let(:mg_obj) { Mailgun::Client.new("Fake-API-Key") }
-  describe ".new" do
+RSpec.describe Mailgun::Client do
+  let(:mg_obj) { Mailgun::Client.new('Fake-API-Key') }
+  describe '.new' do
     subject { mg_obj }
     it { expect { subject }.not_to raise_error }
   end
 
-  describe "#get" do
+  describe '#get' do
     let(:query_string){ {'skip' => '10', 'limit' => '5'} }
-    subject { mg_obj.get("test.com/bounces", query_string) }
-    context "when simulation of client" do
+    subject { mg_obj.get('test.com/bounces', query_string) }
+    context 'when simulation of client' do
       before do
         expect(RestClient::Resource).to receive(:new).once { Mailgun::UnitClient::new('Fake-API-Key', 'api.mailgun.net', 'v2') }
       end
       it do
-        expect(subject.body).to include("total_count")
-        expect(subject.body).to include("items")
+        expect(subject.body).to include('total_count')
+        expect(subject.body).to include('items')
       end
     end
-    context "when real client" do
+    context 'when real client' do
       let(:resource) { double }
       before do
         allow(resource).to receive('[]'){ resource }

data/spec/unit/lib/mailgun/connector_spec.rb

@@ -1,68 +1,68 @@
 require 'spec_helper'
 require 'howitzer/mailgun/connector'
 
-describe Mailgun::Connector do
+RSpec.describe Mailgun::Connector do
   let(:connector) { Mailgun::Connector.instance }
   let(:domain_name) { 'test@domain.com' }
-  describe "#client" do
+  describe '#client' do
     subject { connector.client }
-    context "when api_key is default" do
-      context "when client is not initialized" do
-        it { expect(subject).to be_an_instance_of Mailgun::Client }
+    context 'when api_key is default' do
+      context 'when client is not initialized' do
+        it { is_expected.to be_an_instance_of Mailgun::Client }
       end
-      context "when client is already initialized" do
+      context 'when client is already initialized' do
         it do
           object_id = connector.client.object_id
           expect(subject.object_id).to eq(object_id)
         end
       end
     end
-    context "when api_key is custom" do
-      let(:key) { "some api key" }
+    context 'when api_key is custom' do
+      let(:key) { 'some api key' }
       subject { connector.client(key) }
-      it { expect(subject).to be_an_instance_of Mailgun::Client }
+      it { is_expected.to be_an_instance_of Mailgun::Client }
     end
-    context "when api_key is nil" do
+    context 'when api_key is nil' do
       let(:key) { nil }
       subject { connector.client(key) }
       it do
-        expect(log).to receive(:error).with(Howitzer::InvalidApiKeyError, "Api key can not be blank").once.and_call_original
+        expect(log).to receive(:error).with(Howitzer::InvalidApiKeyError, 'Api key can not be blank').once.and_call_original
         expect { subject }.to raise_error(Howitzer::InvalidApiKeyError)
       end
     end
-    context "when api_key is blank string" do
-      let(:key) { "" }
+    context 'when api_key is blank string' do
+      let(:key) { '' }
       subject { connector.client(key) }
       it do
-        expect(log).to receive(:error).with(Howitzer::InvalidApiKeyError, "Api key can not be blank").once.and_call_original
+        expect(log).to receive(:error).with(Howitzer::InvalidApiKeyError, 'Api key can not be blank').once.and_call_original
         expect { subject }.to raise_error(Howitzer::InvalidApiKeyError)
       end
     end
   end
   describe '#domain' do
     subject { connector.domain }
-    context "when domain is not set" do
+    context 'when domain is not set' do
       before { connector.instance_variable_set(:@domain, nil)}
       it do
         expect(connector).to receive(:change_domain).once{ domain_name }
-        expect(subject).to eq(domain_name)
+        is_expected.to eq(domain_name)
       end
     end
-    context "when domain is already set" do
+    context 'when domain is already set' do
       before do
         expect(connector).to receive(:change_domain).never
         connector.instance_variable_set(:@domain, domain_name)
       end
-      it { expect(subject).to eql(domain_name) }
+      it { is_expected.to eql(domain_name) }
     end
   end
 
   describe '#change_domain' do
-    context "when default" do
+    context 'when default' do
       before { connector.change_domain }
       it { expect(connector.instance_variable_get(:@domain)).to eq(settings.mailgun_domain)}
     end
-    context "when custom" do
+    context 'when custom' do
       before { connector.change_domain(domain_name) }
       it { expect(connector.instance_variable_get(:@domain)).to eq(domain_name) }
     end

data/spec/unit/lib/mailgun/response_spec.rb

@@ -2,23 +2,23 @@ require 'spec_helper'
 require 'howitzer/mailgun/client'
 require 'howitzer/exceptions'
 
-describe Mailgun::Response do
+RSpec.describe Mailgun::Response do
   let(:body) { {foo: 'bar'}.to_json }
   let(:response) { double(:response, body: body, code: 201)}
-  describe "#body" do
+  describe '#body' do
     subject { Mailgun::Response.new(response).body }
-    it { expect(subject).to eq("{\"foo\":\"bar\"}")}
+    it { is_expected.to eq("{\"foo\":\"bar\"}")}
   end
-  describe "#code" do
+  describe '#code' do
     subject { Mailgun::Response.new(response).code }
-    it { expect(subject).to eq(201)}
+    it { is_expected.to eq(201)}
   end
-  describe "#to_h" do
+  describe '#to_h' do
     subject { Mailgun::Response.new(response).to_h }
-    context "when possible parse body" do
-      it { expect(subject).to eq({"foo"=>"bar"})}
+    context 'when possible parse body' do
+      it { is_expected.to eq({'foo' => 'bar'})}
     end
-    context "when impossible parse body" do
+    context 'when impossible parse body' do
       let(:body) { '123' }
       it do
         expect(log).to receive(:error).with(Howitzer::ParseError, "757: unexpected token at '123'").once.and_call_original

data/spec/unit/lib/settings_spec.rb

@@ -1,17 +1,17 @@
 require 'spec_helper'
 
-describe "Settings" do
-  context "#settings" do
+RSpec.describe 'Settings' do
+  context '#settings' do
     subject { settings }
-    context "when method called two times" do
+    context 'when method called two times' do
       let(:other_settings) { settings }
-      it { expect(subject).to equal(other_settings) }
+      it { is_expected.to equal(other_settings) }
       it { expect(other_settings).to be_a_kind_of(SexySettings::Base) }
     end
   end
-  context "SexySettings configuration" do
+  context 'SexySettings configuration' do
     subject { SexySettings.configuration }
     it { expect(subject.path_to_custom_settings).to include('config/custom.yml') }
     it { expect(subject.path_to_default_settings).to include('config/default.yml') }
   end
-end
+end

data/spec/unit/lib/utils/data_generator/data_storage_spec.rb

@@ -1,79 +1,79 @@
 require 'spec_helper'
 require 'howitzer/utils/data_generator/data_storage'
 
-describe "DataGenerator" do
-  describe "DataStorage" do
+RSpec.describe 'DataGenerator' do
+  describe 'DataStorage' do
     before { DataGenerator::DataStorage.data.clear }
-    describe ".store" do
+    describe '.store' do
       subject { DataGenerator::DataStorage.store(ns, 7, :halt) }
-      context "when namespace specified" do
+      context 'when namespace specified' do
         let(:ns) { :user }
-        it "should return value" do
-          expect(subject).to eql(:halt)
+        it 'should return value' do
+          is_expected.to eql(:halt)
         end
-        it "should store namespace value" do
+        it 'should store namespace value' do
           subject
           expect(DataGenerator::DataStorage.data[:user]).to eql({7 => :halt})
         end
       end
-      context "when namespace empty" do
+      context 'when namespace empty' do
         let(:ns) { nil }
-        it { expect {subject}.to raise_error(RuntimeError, "Data storage namespace can not be empty") }
+        it { expect {subject}.to raise_error(RuntimeError, 'Data storage namespace can not be empty') }
       end
     end
-    describe ".extract" do
+    describe '.extract' do
       subject { DataGenerator::DataStorage.extract(ns, key) }
       before { DataGenerator::DataStorage.data[:user] = {7 => :exit} }
-      describe "when namespace specified" do
+      describe 'when namespace specified' do
         let(:ns) { :user }
-        context "and namespace key found" do
+        context 'and namespace key found' do
           let(:key) { 7 }
-          it { expect(subject).to eql(:exit) }
+          it { is_expected.to eql(:exit) }
         end
-        context "and namespace key not found" do
+        context 'and namespace key not found' do
           let(:key) { 5 }
-          it { expect(subject).to be_nil }
+          it { is_expected.to be_nil }
         end
-        context "but namespace key not specified" do
+        context 'but namespace key not specified' do
           let(:key) { nil }
-          it { expect(subject).to eql({ 7 => :exit }) }
+          it { is_expected.to eql({ 7 => :exit }) }
         end
       end
-      context "when namespace not found" do
+      context 'when namespace not found' do
         let(:ns) { :guest }
         let(:key) { 11 }
-        it { expect(subject).to be_nil }
+        it { is_expected.to be_nil }
       end
-      context "when namespace not specified" do
+      context 'when namespace not specified' do
         let(:ns) { nil }
         let(:key) { nil }
-        it { expect {subject}.to raise_error(RuntimeError, "Data storage namespace can not be empty") }
+        it { expect {subject}.to raise_error(RuntimeError, 'Data storage namespace can not be empty') }
       end
     end
-    describe ".clear_ns" do
+    describe '.clear_ns' do
       subject { DataGenerator::DataStorage.clear_ns(:user) }
       before { DataGenerator::DataStorage.data[:user]= {7 => :exit}}
-      it "should return empty hash" do
+      it 'should return empty hash' do
         subject
         adata = DataGenerator::DataStorage.instance_variable_get(:@data)
         expect(adata[:user]).to eql({})
       end
     end
-    describe ".clear_all_ns" do
+    describe '.clear_all_ns' do
       before do
         DataGenerator::DataStorage.store('sauce', :status, false)
-        DataGenerator::DataStorage.store(:foo, "foo", "some value1")
-        DataGenerator::DataStorage.store(:bar, "bar", "some value2")
-        DataGenerator::DataStorage.store(:baz, "baz", "some value3")
+        DataGenerator::DataStorage.store(:foo, 'foo', 'some value1')
+        DataGenerator::DataStorage.store(:bar, 'bar', 'some value2')
+        DataGenerator::DataStorage.store(:baz, 'baz', 'some value3')
       end
-      context "when default argument" do
+      context 'when default argument' do
         before { DataGenerator::DataStorage.clear_all_ns }
-        it { expect(DataGenerator::DataStorage.data).to eq({"sauce"=>{:status=>false}, :foo=>{}, :bar=>{}, :baz=>{}}) }
+        it { expect(DataGenerator::DataStorage.data).to eq({'sauce' =>{:status=>false}, :foo=>{}, :bar=>{}, :baz=>{}}) }
       end
-      context "when custom argument" do
+      context 'when custom argument' do
         let(:exception_list) { [:foo, :bar] }
         before { DataGenerator::DataStorage.clear_all_ns(exception_list) }
-        it { expect(DataGenerator::DataStorage.data).to eq({"sauce"=>{}, :foo=>{"foo"=>"some value1"}, :bar=>{"bar"=>"some value2"}, :baz=>{}}) }
+        it { expect(DataGenerator::DataStorage.data).to eq({'sauce' =>{}, :foo=>{'foo' => 'some value1'}, :bar=>{'bar' => 'some value2'}, :baz=>{}}) }
       end
     end
   end

data/spec/unit/lib/utils/data_generator/gen_spec.rb

@@ -1,18 +1,18 @@
 require 'spec_helper'
 require 'howitzer/utils/data_generator/gen'
 
-describe "DataGenerator" do
-  describe "Gen" do
-    describe ".user" do
+RSpec.describe 'DataGenerator' do
+  describe 'Gen' do
+    describe '.user' do
       subject { DataGenerator::Gen.user(params) }
       before do
         allow(settings).to receive(:def_test_pass) { 'test_pass' }
         allow(settings).to receive(:mailgun_domain) { 'mail.com' }
         allow(DataGenerator::Gen).to receive(:serial) { '012345678abcde' }
       end
-      context "when params specified" do
+      context 'when params specified' do
         let(:params) { { login: 'alex', password: 'pa$$w0rd', mailbox: 'member@test.com' } }
-        it { expect(subject).to be_an_instance_of DataGenerator::Gen::User }
+        it { is_expected.to be_an_instance_of DataGenerator::Gen::User }
         it { expect(subject.email).to eql 'u012345678abcde@mail.com' }
         it do
           email_nm = subject.instance_variable_get(:@email_name)
@@ -24,9 +24,9 @@ describe "DataGenerator" do
         it { expect(subject.first_name).to eql 'FirstName012345678abcde' }
         it { expect(subject.last_name).to eql 'LastName012345678abcde' }
       end
-      context "with empty params" do
+      context 'with empty params' do
         let(:params) { {} }
-        it { expect(subject).to be_an_instance_of DataGenerator::Gen::User }
+        it { is_expected.to be_an_instance_of DataGenerator::Gen::User }
         it { expect(subject.email).to eql 'u012345678abcde@mail.com' }
         it do
           email_nm = subject.instance_variable_get(:@email_name)
@@ -39,40 +39,40 @@ describe "DataGenerator" do
         it { expect(subject.last_name).to eql 'LastName012345678abcde' }
       end
     end
-    describe ".given_user_by_number" do
+    describe '.given_user_by_number' do
       subject { DataGenerator::Gen.given_user_by_number(7) }
-      before { stub_const("DataGenerator::DataStorage", double) }
-      context "when namespace key found" do
+      before { stub_const('DataGenerator::DataStorage', double) }
+      context 'when namespace key found' do
         before { expect(DataGenerator::DataStorage).to receive(:extract).with('user', 7) { :namespace_value } }
-        it { expect(subject).to eql(:namespace_value) }
+        it { is_expected.to eql(:namespace_value) }
       end
-      context "when namespace key not found" do
+      context 'when namespace key not found' do
         let(:dat) { :data_store }
         before do
           allow(DataGenerator::Gen).to receive(:user) { dat }
           expect(DataGenerator::DataStorage).to receive(:extract).with('user', 7) { nil }
           allow(DataGenerator::DataStorage).to receive(:store).with('user', 7, dat)
         end
-        it { expect(subject).to eql :data_store }
+        it { is_expected.to eql :data_store }
       end
     end
-    describe ".serial" do
+    describe '.serial' do
       subject { DataGenerator::Gen.serial }
       let(:ser) { 1 }
-      context "received value should conform to template" do
+      context 'received value should conform to template' do
         let(:ser) { subject }
         it { expect(ser).to match /\d{9}\w{5}/ }
       end
-      context "received values should be different" do
-        it { expect(subject).to_not eql ser }
+      context 'received values should be different' do
+        it { is_expected.to_not eql ser }
       end
     end
-    describe "User" do
-      describe "#initialize" do
+    describe 'User' do
+      describe '#initialize' do
         subject { DataGenerator::Gen::User.new(params) }
         let(:params) { { email: 'alex.petrenko@mail.com', login: 'alex', password: 'pa$$w0rd',
                          first_name: 'Alexey', last_name: 'Petrenko', mailbox: 'member@test.com' } }
-        it { expect(subject).to be_an_instance_of DataGenerator::Gen::User }
+        it { is_expected.to be_an_instance_of DataGenerator::Gen::User }
         it { expect(subject.email).to eql 'alex.petrenko@mail.com' }
         it do
           email_nm = subject.instance_variable_get(:@email_name)

data/spec/unit/lib/utils/locator_store_spec.rb

@@ -1,80 +1,80 @@
 require 'spec_helper'
 require 'howitzer/utils/locator_store'
 
-describe "Locator store" do
+RSpec.describe 'Locator store' do
   let(:bad_name) { 'name' }
   let(:error) { Howitzer::LocatorNotDefinedError }
 
-  shared_examples "locator methods" do |prefix, web_page|
+  shared_examples 'locator methods' do |prefix, web_page|
     describe "#{prefix}locator" do
-      context "when bad locator given" do
+      context 'when bad locator given' do
         subject { web_page.locator(bad_name) }
         it do
           expect(log).to receive(:error).with(error, bad_name).once.and_call_original
           expect { subject }.to raise_error(error)
         end
       end
-      context "when CSS locator given" do
+      context 'when CSS locator given' do
         before { web_page.add_locator :base_locator, 'base_locator' }
         subject { web_page.locator(:base_locator) }
-        it { expect(subject).to eq('base_locator') }
+        it { is_expected.to eq('base_locator') }
       end
-      context "when XPATH locator given" do
+      context 'when XPATH locator given' do
         before { web_page.add_locator :test_xpath, xpath: "//select[@id='modelOptions']/option[@value='m6']" }
         subject { web_page.locator(:test_xpath) }
-        it { expect(subject).to eq([:xpath, "//select[@id='modelOptions']/option[@value='m6']"]) }
+        it { is_expected.to eq([:xpath, "//select[@id='modelOptions']/option[@value='m6']"]) }
       end
     end
 
     describe "#{prefix}link_locator" do
-      context "when bad locator given" do
+      context 'when bad locator given' do
         subject { web_page.link_locator(bad_name) }
         it { expect {subject}. to raise_error(error) }
       end
-      context "when correct locator given" do
+      context 'when correct locator given' do
         before { web_page.add_link_locator :link_locator, 'link_locator' }
         subject { web_page.link_locator(:link_locator) }
-        it { expect(subject).to eq('link_locator') }
+        it { is_expected.to eq('link_locator') }
       end
     end
 
     describe "#{prefix}field_locator" do
-      context "when bad locator given" do
+      context 'when bad locator given' do
         subject { web_page.field_locator(bad_name) }
         it { expect {subject}. to raise_error(error) }
       end
-      context "when correct locator given" do
+      context 'when correct locator given' do
         before { web_page.add_field_locator :field_locator, 'field_locator' }
         subject { web_page.field_locator(:field_locator) }
-        it { expect(subject).to eq('field_locator') }
+        it { is_expected.to eq('field_locator') }
       end
     end
 
     describe "#{prefix}button_locator" do
-      context "when bad locator given" do
+      context 'when bad locator given' do
         subject { web_page.button_locator(bad_name) }
         it { expect {subject}. to raise_error(error) }
       end
-      context "when correct locator given" do
+      context 'when correct locator given' do
         before { web_page.add_button_locator :button_locator, 'button_locator' }
         subject { web_page.button_locator(:button_locator) }
-        it { expect(subject).to eq('button_locator') }
+        it { is_expected.to eq('button_locator') }
       end
     end
 
     describe "#{prefix}find_element" do
-      context "when existing locator name given" do
-        context "of base type" do
+      context 'when existing locator name given' do
+        context 'of base type' do
           before { web_page.add_locator :test_locator, '.foo' }
           subject { web_page.find_element(name) }
-          context "as string" do
-            let(:name) { "test_locator" }
+          context 'as string' do
+            let(:name) { 'test_locator' }
             it do
               expect(web_page.is_a?(Class) ? web_page : web_page.class).to receive(:find).with('.foo')
               subject
             end
           end
-          context "as symbol" do
+          context 'as symbol' do
             let(:name) { :test_locator }
             it do
               expect(web_page.is_a?(Class) ? web_page : web_page.class).to receive(:find).with('.foo')
@@ -82,7 +82,7 @@ describe "Locator store" do
             end
           end
         end
-        context "when link locator or other" do
+        context 'when link locator or other' do
           before { web_page.add_link_locator :test_link_locator, 'foo' }
           subject { web_page.find_element(:test_link_locator) }
           it do
@@ -91,24 +91,24 @@ describe "Locator store" do
           end
         end
       end
-      context "when not existing locator name" do
+      context 'when not existing locator name' do
         subject { web_page.find_element(:unknown_locator) }
-        it { expect{ subject }.to raise_error(Howitzer::LocatorNotDefinedError, "unknown_locator") }
+        it { expect{ subject }.to raise_error(Howitzer::LocatorNotDefinedError, 'unknown_locator') }
       end
     end
     describe "#{prefix}first_element" do
-      context "when existing locator name given" do
-        context "of base type" do
+      context 'when existing locator name given' do
+        context 'of base type' do
           before { web_page.add_locator :test_locator, '.foo' }
           subject { web_page.first_element(name) }
-          context "as string" do
-            let(:name) { "test_locator" }
+          context 'as string' do
+            let(:name) { 'test_locator' }
             it do
               expect(web_page.is_a?(Class) ? web_page : web_page.class).to receive(:first).with('.foo')
               subject
             end
           end
-          context "as symbol" do
+          context 'as symbol' do
             let(:name) { :test_locator }
             it do
               expect(web_page.is_a?(Class) ? web_page : web_page.class).to receive(:first).with('.foo')
@@ -116,7 +116,7 @@ describe "Locator store" do
             end
           end
         end
-        context "when link locator or other" do
+        context 'when link locator or other' do
           before { web_page.add_link_locator :test_link_locator, 'foo' }
           subject { web_page.first_element(:test_link_locator) }
           it do
@@ -125,33 +125,33 @@ describe "Locator store" do
           end
         end
       end
-      context "when not existing locator name" do
+      context 'when not existing locator name' do
         subject { web_page.first_element(:unknown_locator) }
-        it { expect{ subject }.to raise_error(Howitzer::LocatorNotDefinedError, "unknown_locator") }
+        it { expect{ subject }.to raise_error(Howitzer::LocatorNotDefinedError, 'unknown_locator') }
       end
     end
     describe "#{prefix}apply" do
-      context "when bad locator given" do
+      context 'when bad locator given' do
         before { web_page.add_locator :test_locator,  lambda{|test| test} }
         let(:locator)  { lambda{|test| test}  }
         subject { web_page.apply(locator, 'test') }
         it { expect {subject}.to raise_error(NoMethodError) }
       end
-      context "when correct locator given" do
+      context 'when correct locator given' do
         before { web_page.add_locator :test_locator,  lambda{|location_name| {xpath: ".//a[contains(.,'#{location_name}')]"}} }
         let(:locator) { lambda{|location_name| {xpath: ".//a[contains(.,'#{location_name}')]"}} }
         subject { web_page.apply(locator, 'Kiev') }
-        it { expect(subject).to eq([:xpath, ".//a[contains(.,'Kiev')]"]) }
+        it { is_expected.to eq([:xpath, ".//a[contains(.,'Kiev')]"]) }
       end
     end
   end
 
-  context "Class methods" do
-    it_behaves_like "locator methods", '.', Class.new{ include LocatorStore }
+  context 'Class methods' do
+    it_behaves_like 'locator methods', '.', Class.new{ include LocatorStore }
   end
 
-  context "Instance methods" do
-    it_behaves_like "locator methods", '#', Class.new{ include LocatorStore }.new
+  context 'Instance methods' do
+    it_behaves_like 'locator methods', '#', Class.new{ include LocatorStore }.new
   end
 
 end