howitzer 1.1.1 → 2.0.0

data/spec/unit/lib/email_spec.rb

@@ -1,142 +1,155 @@
 require 'spec_helper'
 require 'howitzer/email'
-require 'howitzer/utils/log'
+require 'howitzer/log'
 require 'howitzer/exceptions'
 
-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-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' => []
-    }
+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
-  let(:message_subject){ 'test subject' }
-  let(:mail_address){ double }
-  let(:email_object){ Email.new(message) }
-  before do
-    stub_const('Email::SUBJECT', message_subject)
+
+  describe '.adapter_name' do
+    it { expect(described_class.adapter_name).to eql Howitzer.mail_adapter.to_sym }
   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}
+  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 '.find_by_recipient' do
-    let(:recipient) { 'test@user.com' }
-    subject { Email.find_by_recipient(recipient) }
+  describe '.subject' do
     it do
-      expect(Email).to receive(:find).with(recipient, message_subject).once
-      subject
+      described_class.send(:subject, message_subject)
+      expect(described_class.instance_variable_get(:@subject)).to eql message_subject
+    end
+    it 'should be protected' do
+      expect { described_class.subject(message_subject) }.to raise_error(NoMethodError)
     end
   end
 
-  describe '.find' 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
-      let(:url) { 'https://mailgun.com/domains/mailgun@test.domain/messages/1234567890' }
-      let(:event) do
-        {
-          'message' => {
-            'recipients' => [recipient],
-            'headers' => {
-              'subject' => message_subject
-            }
-          },
-          'storage' => {
-            'url' => url
-          }
-        }
-      end
-      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_url).with(url).ordered.once { mailgun_message }
-      end
+  describe '.find_by_recipient' do
+    let(:recipient) { 'test@user.com' }
+
+    context 'simple subject without parameters' do
+      subject { described_class.find_by_recipient(recipient) }
+      before { described_class.class_eval { subject 'Some title' } }
       it do
-        expect(Email).to receive(:new).with(message).once
+        expect(described_class.adapter).to receive(:find).with(recipient, 'Some title').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'} } }
-      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}
+
+    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').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(log).to receive(:error).with(Howitzer::EmailNotFoundError, "Message with subject '#{message_subject}' for recipient '#{recipient}' was not found.")
+        expect(described_class.adapter).to receive(:find).with(recipient, 'Some title with 1 and 2').once
         subject
       end
     end
+
+    context 'missing 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
-    it { expect(email_object.plain_text_body).to eql message['body-plain'] }
+    subject { email_object.plain_text_body }
+    it do
+      expect(message).to receive(:plain_text_body).once
+      subject
+    end
   end
 
   describe '#html_body' do
-    it { expect(email_object.html_body).to eql message['stripped-html'] }
+    subject { email_object.html_body }
+    it do
+      expect(message).to receive(:html_body).once
+      subject
+    end
   end
 
   describe '#text' do
-    it { expect(email_object.text).to eql message['stripped-text'] }
+    subject { email_object.text }
+    it do
+      expect(message).to receive(:text).once
+      subject
+    end
   end
 
   describe '#mail_from' do
-    it { expect(email_object.mail_from).to eql message['From'] }
+    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 { 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) { Email.new(message_with_multiple_recipients) }
-      it { is_expected.to eql [recipient, second_recipient] }
+    it do
+      expect(message).to receive(:recipients).once
+      subject
     end
   end
 
   describe '#received_time' do
-    it { expect(email_object.received_time).to eql message['Received'][27..63] }
+    subject { email_object.received_time }
+    it do
+      expect(message).to receive(:received_time).once
+      subject
+    end
   end
 
   describe '#sender_email' do
-    it { expect(email_object.sender_email).to eql message['sender'] }
-  end
-
-  describe '#get_mime_part' do
-    subject { email_object.get_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) }
+    subject { email_object.sender_email }
+    it do
+      expect(message).to receive(:sender_email).once
+      subject
     end
+  end
 
-    context 'when no attachments' do
-      let(:error) { Howitzer::NoAttachmentsError }
-      let(:error_message) { 'No attachments where found.' }
-      it do
-        expect(log).to receive(:error).with(error, error_message).once
-        subject
-      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.rb

@@ -0,0 +1,31 @@
+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
+end

data/spec/unit/lib/init_spec.rb

@@ -1,3 +1,2 @@
 require 'spec_helper'
-require 'howitzer/utils/data_generator/gen.rb'
 require 'capybara/dsl'

data/spec/unit/lib/log_spec.rb

@@ -0,0 +1,122 @@
+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

@@ -0,0 +1,62 @@
+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) }
+    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