howitzer 2.2.0 → 2.5.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/gmail_api/client_spec.rb

@@ -1,26 +0,0 @@
-require 'spec_helper'
-require 'howitzer/gmail_api/client'
-
-RSpec.describe Howitzer::GmailApi::Client do
-  let(:gmail_obj) { described_class.new }
-  let(:recipient) { 'test@gmail.com' }
-  let(:mail_subject) { 'Confirmation instructions' }
-
-  describe '.new' do
-    subject { gmail_obj }
-    it { expect { subject }.not_to raise_error }
-  end
-
-  describe '#find_message' do
-    let(:mailbox) { double(Gmail::Mailbox) }
-    before do
-      allow(mailbox).to receive(:emails).with(
-        to: recipient, subject: mail_subject
-      ) { [Gmail::Message.new('INBOX', 30)] }
-      allow(gmail_obj.instance_variable_get(:@client)).to receive(:inbox) { mailbox }
-    end
-    it do
-      expect(gmail_obj.find_message(recipient, mail_subject)).to be_an_instance_of(Gmail::Message)
-    end
-  end
-end

data/spec/unit/lib/howitzer_spec.rb

@@ -1,92 +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
-    context 'when custom host exist' do
-      before do
-        allow(Howitzer).to receive(:test_app_base_auth_login) { app_base_auth_login_setting }
-        allow(Howitzer).to receive(:test_app_base_auth_pass) { app_base_auth_pass_setting }
-        allow(Howitzer).to receive(:test_app_protocol) { app_protocol_setting }
-        allow(Howitzer).to receive(:test_app_host) { app_host_setting }
-      end
-      let(:app_host_setting) { 'test.strongqa.com' }
-      let(:app_protocol_setting) { nil }
-      context 'when login and password present' do
-        let(:app_base_auth_login_setting) { 'user' }
-        let(:app_base_auth_pass_setting) { 'password' }
-        it { expect(Howitzer.app_uri(:test).site).to eq('http://user:password@test.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(:test).site).to eq('http://test.strongqa.com') }
-      end
-    end
-    context 'when configuration settings are not specified for particular application' do
-      it do
-        expect { Howitzer.app_uri(:test).site }.to raise_error(
-          Howitzer::UndefinedSexySettingError,
-          "Undefined 'test_app_base_auth_login' setting. Please add the setting to config/default.yml:\n " \
-            "test_app_base_auth_login: some_value\n"
-        )
-      end
-    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
-  describe '.session_name' do
-    context 'when default' do
-      subject { Howitzer.session_name }
-      it do
-        is_expected.to be_eql('default')
-      end
-    end
-    context 'when set' do
-      subject { Howitzer.session_name = 'another' }
-      it do
-        expect(Capybara).to receive(:session_name=).with('another')
-        is_expected.to be_eql('another')
-      end
-    end
-  end
-  describe 'using_session' do
-    before { Howitzer.session_name = 'default' }
-    it do
-      expect(Capybara).to receive(:using_session).with('another')
-      Howitzer.using_session('another') {}
-      expect(Howitzer.session_name).to be_eql('default')
-    end
-  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/gmail_spec.rb

@@ -1,128 +0,0 @@
-require 'spec_helper'
-require 'howitzer/email'
-require 'howitzer/log'
-require 'howitzer/exceptions'
-RSpec.describe 'Gmail Email Adapter' do
-  before do
-    allow(Howitzer).to receive(:mail_adapter) { 'gmail' }
-    Howitzer::Email.adapter = 'gmail'
-  end
-  let(:email) { 'test@gmail.com' }
-  let(:mail_subject) { 'Confirmation instructions' }
-  let(:message) { double(Gmail::Message) }
-  let(:email_object) { Howitzer::Email.adapter.new(message) }
-  let(:client) { instance_double(Howitzer::GmailApi::Client) }
-  let(:to_msg) { { 'name' => 'test', 'route' => nil, 'mailbox' => 'test', 'host' => 'gmail.com' } }
-  let(:attachment) do
-    '--f403043c3de80c1017055511c33d
-Content-Type: text/plain; charset="US-ASCII"; name="te.txt"
-Content-Disposition: attachment; filename="te.txt"
-Content-Transfer-Encoding: base64
-X-Attachment-Id: f_j5iaurws0'
-  end
-  before do
-    allow_any_instance_of(Howitzer::GmailApi::Client).to receive(:find_message).with(
-      email,
-      mail_subject
-    ) { message }
-    allow_any_instance_of(Howitzer::GmailApi::Client).to receive(:find_message).with(
-      email,
-      'Wrong subject'
-    ) { nil }
-  end
-  describe '.find' do
-    subject { Howitzer::MailAdapters::Gmail.find(email, mail_subject, wait: 0.01) }
-    context 'when message is found' do
-      it do
-        expect(Howitzer::Email.adapter).to receive(:new).with(message).once
-        subject
-      end
-    end
-
-    context 'when message is not found' do
-      let(:mail_subject) { 'Wrong subject' }
-      it do
-        expect { subject }.to raise_error(
-          Howitzer::EmailNotFoundError,
-          "Message with subject '#{mail_subject}' for recipient '#{email}' was not found."
-        )
-      end
-    end
-  end
-
-  describe '#plain_text_body' do
-    before { allow(message).to receive(:body) { Mail::Body.new('test body') } }
-    it { expect(email_object.plain_text_body).to eql 'test body' }
-  end
-
-  describe '#html_body' do
-    before do
-      html_part = <<-HTML
-      Content-Type: text/html;
-        charset=UTF-8
-      Content-Transfer-Encoding: 7bit
-      <p>test body</p>
-      HTML
-      allow(message).to receive(:html_part) { Mail::Part.new(html_part) }
-    end
-    it { expect(email_object.html_body).to include('<p>test body</p>') }
-  end
-
-  describe '#text' do
-    before { allow(message).to receive(:text_part) { Mail::Part.new('test text part') } }
-    it { expect(email_object.text).to include 'test text part' }
-  end
-
-  describe '#mail_from' do
-    before { allow(message).to receive(:from) { [to_msg] } }
-    it { expect(email_object.mail_from).to eql email }
-  end
-
-  describe '#recipients' do
-    context 'when one recipient' do
-      before { allow(message).to receive(:to) { [to_msg] } }
-      it { expect(email_object.recipients).to include email }
-    end
-    context 'when several recipients' do
-      before { allow(message).to receive(:to) { [to_msg, to_msg.merge('mailbox' => 'test2')] } }
-      it { expect(email_object.recipients).to eql [email, 'test2@gmail.com'] }
-    end
-  end
-
-  describe '#received_time' do
-    before { allow(message).to receive(:date) { 'Mon, 24 Jul 2017 18:20:58 +0300' } }
-    it { expect(email_object.received_time).to eql Time.parse('Mon, 24 Jul 2017 18:20:58 +0300').strftime('%F %T') }
-  end
-
-  describe '#sender_email' do
-    before { allow(message).to receive(:from) { [to_msg] } }
-    it { expect(email_object.mail_from).to eql email }
-  end
-
-  describe '#mime_part' do
-    before { allow(message).to receive(:attachments) { Mail::AttachmentsList.new([Mail::Part.new(attachment)]) } }
-    context 'when has attachments'
-    it { expect(email_object.mime_part).not_to be_empty }
-
-    context 'when no attachments' do
-      it do
-        allow(message).to receive(:attachments) { [] }
-        expect(email_object.mime_part).to be_empty
-      end
-    end
-  end
-
-  describe '#mime_part!' do
-    before { allow(message).to receive(:attachments) { Mail::AttachmentsList.new([Mail::Part.new(attachment)]) } }
-    context 'when has attachments' do
-      it { expect(email_object.mime_part!).not_to be_empty }
-    end
-
-    context 'when no attachments' do
-      it do
-        allow(message).to receive(:attachments) { [] }
-        expect { email_object.mime_part! }.to raise_error(Howitzer::NoAttachmentsError, 'No attachments were found.')
-      end
-    end
-  end
-end