howitzer 1.1.1 → 2.0.0

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

@@ -1,36 +0,0 @@
-require 'spec_helper'
-require 'howitzer/mailgun/client'
-
-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
-    let(:query_string){ {'skip' => '10', 'limit' => '5'} }
-    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')
-      end
-    end
-    context 'when real client' do
-      let(:resource) { double }
-      before do
-        allow(resource).to receive('[]'){ resource }
-        allow(resource).to receive(:get).and_raise(StandardError, '401 Unauthorized: Forbidden')
-        allow(RestClient::Resource).to receive(:new) { resource }
-      end
-      it do
-        expect(log).to receive(:error).with(Howitzer::CommunicationError, '401 Unauthorized: Forbidden').once.and_call_original
-        expect { subject }.to raise_error(Howitzer::CommunicationError)
-      end
-    end
-  end
-end

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

@@ -1,70 +0,0 @@
-require 'spec_helper'
-require 'howitzer/mailgun/connector'
-
-RSpec.describe Mailgun::Connector do
-  let(:connector) { Mailgun::Connector.instance }
-  let(:domain_name) { 'test@domain.com' }
-  describe '#client' do
-    subject { connector.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
-        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' }
-      subject { connector.client(key) }
-      it { is_expected.to be_an_instance_of Mailgun::Client }
-    end
-    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 { subject }.to raise_error(Howitzer::InvalidApiKeyError)
-      end
-    end
-    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 { subject }.to raise_error(Howitzer::InvalidApiKeyError)
-      end
-    end
-  end
-  describe '#domain' do
-    subject { connector.domain }
-    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 }
-        is_expected.to eq(domain_name)
-      end
-    end
-    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 { is_expected.to eql(domain_name) }
-    end
-  end
-
-  describe '#change_domain' 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
-      before { connector.change_domain(domain_name) }
-      it { expect(connector.instance_variable_get(:@domain)).to eq(domain_name) }
-    end
-  end
-end

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

@@ -1,28 +0,0 @@
-require 'spec_helper'
-require 'howitzer/mailgun/client'
-require 'howitzer/exceptions'
-
-RSpec.describe Mailgun::Response do
-  let(:body) { {foo: 'bar'}.to_json }
-  let(:response) { double(:response, body: body, code: 201)}
-  describe '#body' do
-    subject { Mailgun::Response.new(response).body }
-    it { is_expected.to eq("{\"foo\":\"bar\"}")}
-  end
-  describe '#code' do
-    subject { Mailgun::Response.new(response).code }
-    it { is_expected.to eq(201)}
-  end
-  describe '#to_h' do
-    subject { Mailgun::Response.new(response).to_h }
-    context 'when possible parse body' do
-      it { is_expected.to eq({'foo' => 'bar'})}
-    end
-    context 'when impossible parse body' do
-      let(:body) { "123" }
-      it do
-        expect { subject }.to raise_error(Howitzer::ParseError)
-      end
-    end
-  end
-end

data/spec/unit/lib/settings_spec.rb

@@ -1,17 +0,0 @@
-require 'spec_helper'
-
-RSpec.describe 'Settings' do
-  context '#settings' do
-    subject { settings }
-    context 'when method called two times' do
-      let(:other_settings) { 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
-    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

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

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

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

@@ -1,90 +0,0 @@
-require 'spec_helper'
-require 'howitzer/utils/data_generator/gen'
-
-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
-        let(:params) { { login: 'alex', password: 'pa$$w0rd', mailbox: 'member@test.com' } }
-        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)
-          expect(email_nm).to eql 'u012345678abcde'
-        end
-        it { expect(subject.domain).to eql 'mail.com' }
-        it { expect(subject.login).to eql 'alex' }
-        it { expect(subject.password).to eql 'pa$$w0rd' }
-        it { expect(subject.first_name).to eql 'FirstName012345678abcde' }
-        it { expect(subject.last_name).to eql 'LastName012345678abcde' }
-      end
-      context 'with empty params' do
-        let(:params) { {} }
-        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)
-          expect(email_nm).to eql 'u012345678abcde'
-        end
-        it { expect(subject.domain).to eql 'mail.com' }
-        it { expect(subject.login).to eql 'u012345678abcde' }
-        it { expect(subject.password).to eql 'test_pass' }
-        it { expect(subject.first_name).to eql 'FirstName012345678abcde' }
-        it { expect(subject.last_name).to eql 'LastName012345678abcde' }
-      end
-    end
-    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 { expect(DataGenerator::DataStorage).to receive(:extract).with('user', 7) { :namespace_value } }
-        it { is_expected.to eql(:namespace_value) }
-      end
-      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 { is_expected.to eql :data_store }
-      end
-    end
-    describe '.serial' do
-      subject { DataGenerator::Gen.serial }
-      let(:ser) { 1 }
-      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 { is_expected.to_not eql ser }
-      end
-    end
-    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 { 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)
-          expect(email_nm).to eql 'alex.petrenko'
-        end
-        it { expect(subject.domain).to eql 'mail.com' }
-        it { expect(subject.login).to eql 'alex' }
-        it { expect(subject.password).to eql 'pa$$w0rd' }
-        it { expect(subject.first_name).to eql 'Alexey' }
-        it { expect(subject.last_name).to eql 'Petrenko' }
-        it { expect(subject.full_name).to eql 'Alexey Petrenko' }
-      end
-    end
-  end
-end

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

@@ -1,157 +0,0 @@
-require 'spec_helper'
-require 'howitzer/utils/locator_store'
-
-RSpec.describe 'Locator store' do
-  let(:bad_name) { 'name' }
-  let(:error) { Howitzer::LocatorNotDefinedError }
-
-  shared_examples 'locator methods' do |prefix, web_page|
-    describe "#{prefix}locator" 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
-        before { web_page.add_locator :base_locator, 'base_locator' }
-        subject { web_page.locator(:base_locator) }
-        it { is_expected.to eq('base_locator') }
-      end
-      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 { is_expected.to eq([:xpath, "//select[@id='modelOptions']/option[@value='m6']"]) }
-      end
-    end
-
-    describe "#{prefix}link_locator" 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
-        before { web_page.add_link_locator :link_locator, 'link_locator' }
-        subject { web_page.link_locator(:link_locator) }
-        it { is_expected.to eq('link_locator') }
-      end
-    end
-
-    describe "#{prefix}field_locator" 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
-        before { web_page.add_field_locator :field_locator, 'field_locator' }
-        subject { web_page.field_locator(:field_locator) }
-        it { is_expected.to eq('field_locator') }
-      end
-    end
-
-    describe "#{prefix}button_locator" 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
-        before { web_page.add_button_locator :button_locator, 'button_locator' }
-        subject { web_page.button_locator(: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
-          before { web_page.add_locator :test_locator, '.foo' }
-          subject { web_page.find_element(name) }
-          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
-            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
-        end
-        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
-            expect(web_page.is_a?(Class) ? web_page : web_page.class).to receive(:find_link).with('foo')
-            subject
-          end
-        end
-      end
-      context 'when not existing locator name' do
-        subject { web_page.find_element(: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
-          before { web_page.add_locator :test_locator, '.foo' }
-          subject { web_page.first_element(name) }
-          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
-            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
-        end
-        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
-            expect(web_page.is_a?(Class) ? web_page : web_page.class).to receive(:first).with(:link, 'foo')
-            subject
-          end
-        end
-      end
-      context 'when not existing locator name' do
-        subject { web_page.first_element(:unknown_locator) }
-        it { expect{ subject }.to raise_error(Howitzer::LocatorNotDefinedError, 'unknown_locator') }
-      end
-    end
-    describe "#{prefix}apply" 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
-        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 { is_expected.to eq([:xpath, ".//a[contains(.,'Kiev')]"]) }
-      end
-    end
-  end
-
-  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
-  end
-
-end