howitzer 2.0.3 → 2.3.0

data/spec/unit/lib/email_spec.rb

@@ -1,186 +0,0 @@
-require 'spec_helper'
-require 'howitzer/email'
-require 'howitzer/log'
-require 'howitzer/exceptions'
-
-RSpec.describe Howitzer::Email do
-  let(:recipient) { 'first_tester@gmail.com' }
-  let(:message_subject) { 'test subject' }
-  let(:message) { double(:message) }
-  let(:email_object) { described_class.new(message) }
-
-  describe '.adapter' do
-    it do
-      expect(described_class.adapter)
-        .to eql(Howitzer::MailAdapters.const_get(Howitzer.mail_adapter.to_s.capitalize))
-    end
-  end
-
-  describe '.adapter_name' do
-    it { expect(described_class.adapter_name).to eql Howitzer.mail_adapter.to_sym }
-  end
-
-  describe '.adapter=' do
-    subject { described_class.adapter = name }
-
-    context 'when adapter_name is Symbol or String' do
-      let(:name) { Howitzer.mail_adapter }
-      it { expect(described_class.adapter).to eql Howitzer::MailAdapters.const_get(name.to_s.capitalize) }
-    end
-
-    context 'when adapter_name is not Symbol or String' do
-      let(:name) { nil }
-      it { expect { subject }.to raise_error(Howitzer::NoMailAdapterError) }
-    end
-  end
-
-  describe '.subject' do
-    it do
-      described_class.send(:subject, message_subject)
-      expect(described_class.send(:subject_value)).to eql message_subject
-      expect(described_class.private_methods(true)).to include(:subject_value)
-    end
-    it 'should be protected' do
-      expect { described_class.subject(message_subject) }.to raise_error(NoMethodError)
-    end
-  end
-
-  describe '.wait_time' do
-    subject { Class.new(described_class) }
-    it 'should be protected' do
-      expect { subject.wait_time(10) }.to raise_error(NoMethodError)
-    end
-
-    context 'when specified' do
-      before { subject.send(:wait_time, 10) }
-      it do
-        expect(subject.send(:wait_time_value)).to eql 10
-        expect(subject.private_methods(true)).to include(:wait_time_value)
-      end
-    end
-
-    context 'when missing' do
-      it do
-        expect(subject.send(:wait_time_value)).to eql 60
-      end
-    end
-  end
-
-  describe '.find_by_recipient' do
-    let(:recipient) { 'test@user.com' }
-
-    context 'simple subject without parameters' do
-      before { described_class.class_eval { subject 'Some title' } }
-      it do
-        expect(described_class.adapter).to receive(:find).with(recipient, 'Some title', wait: 60).once
-        described_class.find_by_recipient(recipient)
-      end
-    end
-
-    context 'complex subject with 1 parameter' do
-      subject { described_class.find_by_recipient(recipient, name: 'Vasya') }
-      before { described_class.class_eval { subject 'Some title from :name' } }
-      it do
-        expect(described_class.adapter).to receive(:find).with(recipient, 'Some title from Vasya', wait: 60).once
-        subject
-      end
-    end
-
-    context 'complex subject with 2 parameters' do
-      subject { described_class.find_by_recipient(recipient, foo: 1, bar: 2) }
-      before { described_class.class_eval { subject 'Some title with :foo and :bar' } }
-      it do
-        expect(described_class.adapter).to receive(:find).with(recipient, 'Some title with 1 and 2', wait: 60).once
-        subject
-      end
-    end
-
-    context 'missing subject' do
-      subject { described_class.find_by_recipient(recipient) }
-      before do
-        described_class.instance_eval { undef :subject_value }
-      end
-      it do
-        expect { subject }.to raise_error(Howitzer::NoEmailSubjectError)
-      end
-    end
-
-    context 'nil subject' do
-      subject { described_class.find_by_recipient(recipient) }
-      before { described_class.class_eval { subject nil } }
-      it do
-        expect { subject }.to raise_error(Howitzer::NoEmailSubjectError)
-      end
-    end
-  end
-
-  describe '#new' do
-    context 'when Email instance receive message and add create @message variable that' do
-      it { expect(email_object.instance_variable_get(:@message)).to eql message }
-    end
-  end
-
-  describe '#plain_text_body' do
-    subject { email_object.plain_text_body }
-    it do
-      expect(message).to receive(:plain_text_body).once
-      subject
-    end
-  end
-
-  describe '#html_body' do
-    subject { email_object.html_body }
-    it do
-      expect(message).to receive(:html_body).once
-      subject
-    end
-  end
-
-  describe '#text' do
-    subject { email_object.text }
-    it do
-      expect(message).to receive(:text).once
-      subject
-    end
-  end
-
-  describe '#mail_from' do
-    subject { email_object.mail_from }
-    it do
-      expect(message).to receive(:mail_from).once
-      subject
-    end
-  end
-
-  describe '#recipients' do
-    subject { email_object.recipients }
-    it do
-      expect(message).to receive(:recipients).once
-      subject
-    end
-  end
-
-  describe '#received_time' do
-    subject { email_object.received_time }
-    it do
-      expect(message).to receive(:received_time).once
-      subject
-    end
-  end
-
-  describe '#sender_email' do
-    subject { email_object.sender_email }
-    it do
-      expect(message).to receive(:sender_email).once
-      subject
-    end
-  end
-
-  describe '#mime_part' do
-    subject { email_object.mime_part }
-    it do
-      expect(message).to receive(:mime_part).once
-      subject
-    end
-  end
-end

data/spec/unit/lib/howitzer_spec.rb

@@ -1,40 +0,0 @@
-require 'spec_helper'
-require 'howitzer'
-
-RSpec.describe 'Howitzer' do
-  describe '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
-  describe '.app_uri' do
-    before do
-      allow(Howitzer).to receive(:app_base_auth_login) { app_base_auth_login_setting }
-      allow(Howitzer).to receive(:app_base_auth_pass) { app_base_auth_pass_setting }
-      allow(Howitzer).to receive(:app_protocol) { app_protocol_setting }
-      allow(Howitzer).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(Howitzer.app_uri.site).to eq('http://alex:pa$$w0rd@redmine.strongqa.com') }
-      it { expect(Howitzer.app_uri.origin).to eq('http://redmine.strongqa.com') }
-    end
-    context 'when login and password blank' do
-      let(:app_base_auth_login_setting) { nil }
-      let(:app_base_auth_pass_setting) { nil }
-      it { expect(Howitzer.app_uri.site).to eq('http://redmine.strongqa.com') }
-    end
-  end
-  describe '.mailgun_idle_timeout' do
-    subject { Howitzer.mailgun_idle_timeout }
-    before do
-      expect_any_instance_of(Object).to receive(:puts).with(
-        "WARNING! 'mailgun_idle_timeout' setting is deprecated. Please replace with 'mail_wait_time' setting."
-      )
-    end
-    it { is_expected.to be_nil }
-  end
-end

data/spec/unit/lib/init_spec.rb

@@ -1,2 +0,0 @@
-require 'spec_helper'
-require 'capybara/dsl'

data/spec/unit/lib/log_spec.rb

@@ -1,122 +0,0 @@
-require 'spec_helper'
-require 'howitzer/log'
-include Howitzer::LoggerHelper
-
-RSpec.describe Howitzer::Log do
-  context '.instance' do
-    subject { described_class.instance }
-    let(:other_log) { described_class.instance }
-    it { is_expected.to be_a_kind_of(described_class) }
-    it { is_expected.to equal(other_log) }
-  end
-
-  context '.debug' do
-    it do
-      expect(described_class.instance).to receive(:debug).with('Foo')
-      described_class.debug('Foo')
-    end
-  end
-
-  context '.info' do
-    it do
-      expect(described_class.instance).to receive(:info).with('Foo')
-      described_class.info('Foo')
-    end
-  end
-
-  context '.warn' do
-    it do
-      expect(described_class.instance).to receive(:warn).with('Foo')
-      described_class.warn('Foo')
-    end
-  end
-
-  context '.fatal' do
-    it do
-      expect(described_class.instance).to receive(:fatal).with('Foo')
-      described_class.fatal('Foo')
-    end
-  end
-
-  context '.error' do
-    it do
-      expect(described_class.instance).to receive(:error).with('Foo')
-      described_class.error('Foo')
-    end
-  end
-
-  context '.print_feature_name' do
-    it do
-      expect(described_class.instance).to receive(:print_feature_name).with('Foo')
-      described_class.print_feature_name('Foo')
-    end
-  end
-
-  context '.settings_as_formatted_text' do
-    it do
-      expect(described_class.instance).to receive(:settings_as_formatted_text).with(no_args)
-      described_class.settings_as_formatted_text
-    end
-  end
-
-  context '.print_scenario_name' do
-    it do
-      expect(described_class.instance).to receive(:print_scenario_name).with('Foo')
-      described_class.print_scenario_name('Foo')
-    end
-  end
-
-  describe '#debug' do
-    it do
-      expect(described_class.instance.instance_variable_get(:@logger)).to receive(:debug).with(:foo)
-      described_class.instance.debug :foo
-    end
-  end
-  describe '#info' do
-    it do
-      expect(described_class.instance.instance_variable_get(:@logger)).to receive(:info).with(:foo)
-      described_class.instance.info :foo
-    end
-  end
-  describe '#warn' do
-    it do
-      expect(described_class.instance.instance_variable_get(:@logger)).to receive(:warn).with(:foo)
-      described_class.instance.warn :foo
-    end
-  end
-  describe '#fatal' do
-    it do
-      expect(described_class.instance.instance_variable_get(:@logger)).to receive(:fatal).with(:foo)
-      described_class.instance.fatal :foo
-    end
-  end
-
-  describe '#error' do
-    it do
-      expect(described_class.instance.instance_variable_get(:@logger)).to receive(:error).with(:foo)
-      described_class.instance.error :foo
-    end
-  end
-
-  describe '#print_feature_name' do
-    it do
-      expect(described_class.instance).to receive(:log_without_formatting) { |&arg| arg.call }
-      expect(described_class.instance).to receive(:info).with('*** Feature: FOO ***')
-      described_class.instance.print_feature_name('Foo')
-    end
-  end
-  describe '#settings_as_formatted_text' do
-    it do
-      expect(described_class.instance).to receive(:log_without_formatting) { |&arg| arg.call }
-      expect(described_class.instance).to receive(:info).with(SexySettings::Base.instance.as_formatted_text)
-      described_class.instance.settings_as_formatted_text
-    end
-  end
-  describe '#print_scenario_name' do
-    it do
-      expect(described_class.instance).to receive(:log_without_formatting) { |&arg| arg.call }
-      expect(described_class.instance).to receive(:info).with(' => Scenario: Foo')
-      described_class.instance.print_scenario_name('Foo')
-    end
-  end
-end

data/spec/unit/lib/mail_adapters/abstract_spec.rb

@@ -1,62 +0,0 @@
-require 'spec_helper'
-require 'howitzer/email'
-require 'howitzer/mail_adapters/abstract'
-
-RSpec.describe Howitzer::MailAdapters::Abstract do
-  let(:recipient) { 'first_tester@gmail.com' }
-  let(:message_subject) { 'test subject' }
-  let(:message) { double(:message) }
-  let(:abstract_adapter) { described_class.new(message) }
-  let(:email_object) { Howitzer::Email.adapter.new(message) }
-
-  describe '.find' do
-    subject { described_class.find(recipient, message_subject, _wait: 10) }
-    it { expect { subject }.to raise_error(NotImplementedError) }
-  end
-
-  describe '#new' do
-    context 'when Email instance receive message and add create @message variable that' do
-      it { expect(email_object.instance_variable_get(:@message)).to eql message }
-    end
-  end
-
-  describe '#plain_text_body' do
-    subject { abstract_adapter.plain_text_body }
-    it { expect { subject }.to raise_error(NotImplementedError) }
-  end
-
-  describe '#html_body' do
-    subject { abstract_adapter.html_body }
-    it { expect { subject }.to raise_error(NotImplementedError) }
-  end
-
-  describe '#text' do
-    subject { abstract_adapter.text }
-    it { expect { subject }.to raise_error(NotImplementedError) }
-  end
-
-  describe '#mail_from' do
-    subject { abstract_adapter.mail_from }
-    it { expect { subject }.to raise_error(NotImplementedError) }
-  end
-
-  describe '#recipients' do
-    subject { abstract_adapter.recipients }
-    it { expect { subject }.to raise_error(NotImplementedError) }
-  end
-
-  describe '#received_time' do
-    subject { abstract_adapter.received_time }
-    it { expect { subject }.to raise_error(NotImplementedError) }
-  end
-
-  describe '#sender_email' do
-    subject { abstract_adapter.sender_email }
-    it { expect { subject }.to raise_error(NotImplementedError) }
-  end
-
-  describe '#mime_part' do
-    subject { abstract_adapter.mime_part }
-    it { expect { subject }.to raise_error(NotImplementedError) }
-  end
-end

data/spec/unit/lib/mail_adapters/mailgun_spec.rb

@@ -1,163 +0,0 @@
-require 'spec_helper'
-require 'howitzer/email'
-require 'howitzer/log'
-require 'howitzer/exceptions'
-require 'howitzer/mailgun_api/connector'
-
-RSpec.describe 'Mailgun Email Adapter' 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-text' => 'test body',
-      '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)',
-      'sender' => 'tester@gmail.com',
-      'attachments' => []
-    }
-  end
-  let(:message_subject) { 'test subject' }
-  let(:mail_address) { double }
-  let(:email_object) { Howitzer::Email.adapter.new(message) }
-
-  before do
-    stub_const('Howitzer::Email::SUBJECT', message_subject)
-  end
-
-  describe '.find' do
-    let(:mailgun_message) { double(to_h: message) }
-    let(:events) { double(to_h: { 'items' => [event] }) }
-    subject { Howitzer::MailAdapters::Mailgun.find(recipient, message_subject, wait: 0.01) }
-
-    context 'when message is found' do
-      let(:event) do
-        {
-          'message' => {
-            'recipients' => [recipient],
-            'headers' => {
-              'subject' => message_subject
-            }
-          },
-          'storage' => {
-            'key' => '1234567890',
-            'url' => 'https://si.api.mailgun.net/v3/domains/mg.strongqa.com/messages/1234567890'
-          }
-        }
-      end
-      before do
-        allow(Howitzer::MailgunApi::Connector.instance.client).to receive(:get).with(
-          'mailgun@test.domain/events',
-          params: { event: 'stored' }
-        ) { events }
-        allow(Howitzer::MailgunApi::Connector.instance.client).to receive(:get_url).with(
-          'https://si.api.mailgun.net/v3/domains/mg.strongqa.com/messages/1234567890'
-        ) { mailgun_message }
-      end
-      it do
-        expect(Howitzer::Email.adapter).to receive(:new).with(message).once
-        subject
-      end
-    end
-
-    context 'when message is not found' do
-      let(:event) do
-        {
-          'message' => {
-            'recipients' => ['other@test.com'],
-            'headers' => {
-              'subject' => message_subject
-            }
-          },
-          'storage' => {
-            'key' => '1234567890',
-            'url' => 'https://si.api.mailgun.net/v3/domains/mg.strongqa.com/messages/1234567890'
-          }
-        }
-      end
-      before do
-        allow(Howitzer::MailgunApi::Connector.instance.client).to receive(:get).with(
-          'mailgun@test.domain/events',
-          params: { event: 'stored' }
-        ) { events }
-      end
-      it do
-        expect { subject }.to raise_error(
-          Howitzer::EmailNotFoundError,
-          "Message with subject '#{message_subject}' for recipient '#{recipient}' was not found."
-        )
-      end
-    end
-  end
-
-  describe '#plain_text_body' do
-    it { expect(email_object.plain_text_body).to eql message['body-plain'] }
-  end
-
-  describe '#html_body' do
-    it { expect(email_object.html_body).to eql message['stripped-html'] }
-  end
-
-  describe '#text' do
-    it { expect(email_object.text).to eql message['stripped-text'] }
-  end
-
-  describe '#mail_from' do
-    it { expect(email_object.mail_from).to eql message['From'] }
-  end
-
-  describe '#recipients' do
-    subject { email_object.recipients }
-    it { is_expected.to be_a_kind_of Array }
-
-    context 'when one recipient' do
-      it { is_expected.to include message['To'] }
-    end
-
-    context 'when more than one recipient' do
-      let(:second_recipient) { 'second_tester@gmail.com' }
-      let(:message_with_multiple_recipients) { message.merge('To' => "#{recipient}, #{second_recipient}") }
-      let(:email_object) { Howitzer::Email.adapter.new(message_with_multiple_recipients) }
-      it { is_expected.to eql [recipient, second_recipient] }
-    end
-  end
-
-  describe '#received_time' do
-    it { expect(email_object.received_time).to eql message['Received'][27..63] }
-  end
-
-  describe '#sender_email' do
-    it { expect(email_object.sender_email).to eql message['sender'] }
-  end
-
-  describe '#mime_part' do
-    subject { email_object.mime_part }
-
-    context 'when has attachments' do
-      let(:files) { [double] }
-      before { email_object.instance_variable_set(:@message, 'attachments' => files) }
-      it { is_expected.to eq(files) }
-    end
-
-    context 'when no attachments' do
-      it { is_expected.to eq([]) }
-    end
-  end
-
-  describe '#mime_part!' do
-    subject { email_object.mime_part! }
-
-    context 'when has attachments' do
-      let(:files) { [double] }
-      before { email_object.instance_variable_set(:@message, 'attachments' => files) }
-      it { is_expected.to eq(files) }
-    end
-
-    context 'when no attachments' do
-      it do
-        expect { subject }.to raise_error(Howitzer::NoAttachmentsError, 'No attachments where found.')
-      end
-    end
-  end
-end

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

@@ -1,58 +0,0 @@
-require 'spec_helper'
-require 'howitzer/mailgun_api/client'
-
-RSpec.describe Howitzer::MailgunApi::Client do
-  let(:mg_obj) { described_class.new(api_key: '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', params: query_string) }
-    context 'when simulation of client' do
-      before do
-        expect(RestClient::Resource).to receive(:new)
-          .once.and_return(Howitzer::MailgunApi::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('[]').and_return(resource)
-        allow(resource).to receive(:get).and_raise(StandardError, '401 Unauthorized: Forbidden')
-        allow(RestClient::Resource).to receive(:new).and_return(resource)
-      end
-      it do
-        expect { subject }.to raise_error(Howitzer::CommunicationError, '401 Unauthorized: Forbidden')
-      end
-    end
-  end
-
-  describe '#get_url' do
-    let(:response_raw) { double }
-    subject { mg_obj.get_url('https://ci.api.mailgan.com/domains/test_domain/messages/asdfasdf') }
-    context 'when success request' do
-      let(:response_raw) { double }
-      let(:response_real) { double }
-      before do
-        allow(RestClient::Request).to receive(:execute).with(any_args).and_return(response_raw)
-        allow(Howitzer::MailgunApi::Response).to receive(:new).with(response_raw).and_return(response_real)
-      end
-      it { is_expected.to eq(response_real) }
-    end
-    context 'when error happens' do
-      before do
-        allow(RestClient::Resource).to receive(:new).with(any_args).and_return(response_raw)
-        mg_obj
-        allow(RestClient::Request).to receive(:execute).with(any_args).and_raise(StandardError, 'Some message')
-      end
-      it { expect { subject }.to raise_error(Howitzer::CommunicationError, 'Some message') }
-    end
-  end
-end

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

@@ -1,54 +0,0 @@
-require 'spec_helper'
-require 'howitzer/mailgun_api/connector'
-
-RSpec.describe Howitzer::MailgunApi::Connector do
-  let(:connector) { described_class.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 Howitzer::MailgunApi::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 Howitzer::MailgunApi::Client }
-    end
-    context 'when api_key is nil' do
-      let(:key) { nil }
-      subject { connector.client(key) }
-      it do
-        expect { subject }.to raise_error(Howitzer::InvalidApiKeyError, 'Api key can not be blank')
-      end
-    end
-    context 'when api_key is blank string' do
-      let(:key) { '' }
-      subject { connector.client(key) }
-      it do
-        expect { subject }.to raise_error(Howitzer::InvalidApiKeyError, 'Api key can not be blank')
-      end
-    end
-  end
-  describe '#domain' do
-    subject { connector.domain }
-    context 'when default domain' do
-      it do
-        is_expected.to eq(Howitzer.mailgun_domain)
-      end
-    end
-    context 'when domain is already set' do
-      before do
-        connector.domain = domain_name
-      end
-      it { is_expected.to eql(domain_name) }
-    end
-  end
-end