howitzer 2.1.1 → 2.4.0

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

@@ -1,158 +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
-  before do
-    allow(Howitzer).to receive(:mail_adapter) { 'mailgun' }
-    Howitzer::Email.adapter = 'mailgun'
-  end
-  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) { JSON.generate(message) }
-    let(:events) { JSON.generate('items' => [event]) }
-    before do
-      FakeWeb.register_uri(:any, 'https://api:mailgun_account_private_key@api.mailgun.net/v3/'\
-                                        'mailgun@test.domain/events?event=stored', body: events.to_s)
-      FakeWeb.register_uri(:any, 'https://api:mailgun_account_private_key@si.api.mailgun.net/v3/'\
-                                  'domains/mg.strongqa.com/messages/1234567890', body: mailgun_message.to_s)
-    end
-    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
-      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
-      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 were found.')
-      end
-    end
-  end
-end

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

@@ -1,130 +0,0 @@
-require 'spec_helper'
-require 'howitzer/email'
-require 'howitzer/log'
-require 'howitzer/exceptions'
-RSpec.describe 'Mailtrap Email Adapter' do
-  before do
-    allow(Howitzer).to receive(:mail_adapter) { 'mailtrap' }
-    Howitzer::Email.adapter = 'mailtrap'
-    allow(Howitzer).to receive(:mailtrap_inbox_id) { 777_777 }
-    allow(Howitzer).to receive(:mailtrap_api_token) { 'fake_api_token' }
-    base_url = 'https://mailtrap.io/api/v1/inboxes/777777/messages'
-    stub_const('Howitzer::MailtrapApi::Client::BASE_URL', base_url.gsub('/messages', ''))
-    FakeWeb.register_uri(:get, "#{base_url}/475265146/attachments", body: attachment.to_s)
-    FakeWeb.register_uri(:get, "#{base_url}/32/attachments", body: '[]')
-    FakeWeb.register_uri(:get, "#{base_url}?search=#{recipient}", body: "[#{message.to_s.gsub('=>', ':')}]")
-  end
-  let(:recipient) { 'test@mail.com' }
-  let(:mail_subject) { 'Confirmation instructions' }
-  let(:message) do
-    {
-      'id' => 475_265_146,
-      'inbox_id' => 777_777,
-      'subject' => 'Confirmation instructions',
-      'sent_at' => '2017-07-18T08:55:49.389Z',
-      'from_email' => 'noreply@test.com',
-      'from_name' => '',
-      'to_email' => 'test@mail.com',
-      'to_name' => '',
-      'html_body' => '<p> Test Email! </p>',
-      'text_body' => 'Test Email!',
-      'created_at' => '2017-07-18T14:14:31.641Z'
-    }
-  end
-  let(:attachment) do
-    '[{
-    "id": 1737,
-    "message_id": 475265146,
-    "filename": "Photos.png",
-    "attachment_type": "attachment",
-    "content_type": "image/png",
-    "download_path": "/api/v1/inboxes/777777/messages/475265146/attachments/45120545/download"
-     }]'
-  end
-  let(:email_object) { Howitzer::Email.adapter.new(message) }
-  describe '.find' do
-    subject { Howitzer::MailAdapters::Mailtrap.find(recipient, 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 '#{recipient}' was not found."
-        )
-      end
-    end
-  end
-
-  describe '#plain_text_body' do
-    it { expect(email_object.plain_text_body).to eql message['text_body'] }
-  end
-
-  describe '#html_body' do
-    it { expect(email_object.html_body).to eql message['html_body'] }
-  end
-
-  describe '#text' do
-    it { expect(email_object.text).to eql message['text_body'] }
-  end
-
-  describe '#mail_from' do
-    it { expect(email_object.mail_from).to eql message['from_email'] }
-  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_email'] }
-    end
-
-    context 'when more than one recipient' do
-      let(:second_recipient) { 'second_tester@gmail.com' }
-      let(:message_with_multiple_recipients) { message.merge('to_email' => "#{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 Time.parse(message['created_at']).to_s }
-  end
-
-  describe '#sender_email' do
-    it { expect(email_object.sender_email).to eql message['from_email'] }
-  end
-
-  describe '#mime_part' do
-    context 'when has attachments' do
-      it { expect(email_object.mime_part).not_to be_empty }
-    end
-
-    context 'when no attachments' do
-      let(:another_message) { message.merge('id' => 32) }
-      let(:email_object) { Howitzer::Email.adapter.new(another_message) }
-      it { expect(email_object.mime_part).to be_empty }
-    end
-  end
-
-  describe '#mime_part!' do
-    context 'when has attachments' do
-      it { expect(email_object.mime_part!).not_to be_empty }
-    end
-
-    context 'when no attachments' do
-      let(:another_message) { message.merge('id' => 32) }
-      let(:email_object) { Howitzer::Email.adapter.new(another_message) }
-      it do
-        expect { email_object.mime_part! }.to raise_error(Howitzer::NoAttachmentsError, 'No attachments were found.')
-      end
-    end
-  end
-end

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

@@ -1,80 +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') }
-  let(:bounce_msg) do
-    JSON.generate(
-      'total_count' => 1,
-      'items' => {
-        'created_at' => 'Fri, 21 Oct 2011 11:02:55 GMT',
-        'code' => 550,
-        'address' => 'baz@example.com',
-        'error' => 'Message was not accepted -- invalid mailbox. Local mailbox baz@example.com is" +
-                           " unavailable: user not found'
-      }
-    )
-  end
-  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' => 'baz@example.com',
-      'Received' => 'by 10.216.46.75 with HTTP; Sat, 5 Apr 2014 05:10:42 -0700 (PDT)',
-      'sender' => 'tester@gmail.com',
-      'attachments' => []
-    }
-  end
-  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
-        FakeWeb.register_uri(:get, 'https://api:Fake-API-Key@api.mailgun.net/v3/test.com/'\
-                                          'bounces?skip=10&limit=5', body: bounce_msg.to_s)
-      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 }
-    before do
-      FakeWeb.register_uri(:any, 'https://api:Fake-API-Key@ci.api.mailgan.com/'\
-                                        'domains/test_domain/messages/asdfasdf', body: JSON.generate(message))
-    end
-    subject { mg_obj.get_url('https://ci.api.mailgan.com/domains/test_domain/messages/asdfasdf') }
-    context 'when success request' do
-      it { expect(subject.to_h).to eq(message) }
-    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

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

@@ -1,28 +0,0 @@
-require 'spec_helper'
-require 'howitzer/mailgun_api/client'
-require 'howitzer/exceptions'
-
-RSpec.describe Howitzer::MailgunApi::Response do
-  let(:body) { { foo: 'bar' }.to_json }
-  let(:response) { double(:response, body: body, code: 201) }
-  describe '#body' do
-    subject { described_class.new(response).body }
-    it { is_expected.to eq('{"foo":"bar"}') }
-  end
-  describe '#code' do
-    subject { described_class.new(response).code }
-    it { is_expected.to eq(201) }
-  end
-  describe '#to_h' do
-    subject { described_class.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': '123' :123" }
-      it do
-        expect { subject }.to raise_error(Howitzer::ParseError)
-      end
-    end
-  end
-end

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

@@ -1,67 +0,0 @@
-require 'spec_helper'
-require 'howitzer/mailtrap_api/client'
-
-RSpec.describe Howitzer::MailtrapApi::Client do
-  let(:mailtrap_obj) { described_class.new }
-  let(:recipient) { 'test@mail.com' }
-  let(:mail_subject) { 'Confirmation instructions' }
-  let(:message) do
-    '[{"id": 475265146,
-      "inbox_id": 777777,
-      "subject": "Confirmation instructions",
-      "sent_at": "2017-07-18T08:55:49.389Z",
-      "from_email": "noreply@test.com",
-      "from_name": "",
-      "to_email": "test@mail.com",
-      "to_name": "",
-      "html_body": "<p> Test Email! </p>"}]'
-  end
-  let(:attachment) do
-    '[{
-    "id": 1737,
-    "message_id": 475265146,
-    "filename": "Photos.png",
-    "attachment_type": "attachment",
-    "content_type": "image/png"
-     }]'
-  end
-  before do
-    allow(Howitzer).to receive(:mailtrap_inbox_id) { 777_777 }
-    allow(Howitzer).to receive(:mailtrap_api_token) { 'fake_api_token' }
-    stub_const('Howitzer::MailtrapApi::Client::BASE_URL', 'https://mailtrap.io/api/v1/inboxes/777777')
-  end
-
-  describe '.new' do
-    subject { mailtrap_obj }
-    it { expect { subject }.not_to raise_error }
-  end
-
-  describe '#find_message' do
-    before do
-      FakeWeb.register_uri(:get, "https://mailtrap.io/api/v1/inboxes/#{Howitzer.mailtrap_inbox_id}/"\
-                                        "messages?search=#{recipient}", body: message.to_s)
-    end
-    subject { described_class.new.find_message(recipient, mail_subject) }
-    it do
-      expect(subject['to_email']).to eql(recipient)
-      expect(subject['subject']).to eql(mail_subject)
-    end
-  end
-
-  describe '#find_attachements' do
-    before do
-      FakeWeb.register_uri(:get, "https://mailtrap.io/api/v1/inboxes/#{Howitzer.mailtrap_inbox_id}/"\
-                                 "messages?search=#{recipient}", body: message.to_s)
-      FakeWeb.register_uri(:get, "https://mailtrap.io/api/v1/inboxes/#{Howitzer.mailtrap_inbox_id}/"\
-                                  'messages/475265146/attachments', body: attachment.to_s)
-    end
-    let(:found_message) { described_class.new.find_message(recipient, mail_subject) }
-    subject { described_class.new.find_attachments(found_message) }
-    it do
-      subject.each do |attachment|
-        expect(attachment['message_id']).to eql found_message['id']
-        expect(attachment['filename'].to_s).not_to be_empty
-      end
-    end
-  end
-end

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

@@ -1,77 +0,0 @@
-require 'spec_helper'
-require 'howitzer/utils/string_extensions'
-
-RSpec.describe Howitzer::Utils::StringExtensions do
-  String.send(:include, Howitzer::Utils::StringExtensions)
-
-  let(:page_name) { 'my' }
-  let(:page_object) { double }
-  before { stub_const('MyPage', page_object) }
-  describe '#open' do
-    subject { page_name.open(:exit) }
-    before do
-      expect(page_object).to receive(:open).with(:exit).once
-    end
-    it { is_expected.to be_nil }
-  end
-  describe '#given' do
-    subject { page_name.given }
-    before do
-      allow(page_name).to receive(:as_page_class) { page_object }
-      expect(page_object).to receive(:given).once
-    end
-    it { is_expected.to be_nil }
-  end
-  describe '#displayed?' do
-    subject { page_name.displayed? }
-    before do
-      allow(page_name).to receive(:as_page_class) { page_object }
-      expect(page_object).to receive(:displayed?).once
-    end
-    it { is_expected.to be_nil }
-  end
-  describe '#as_page_class' do
-    subject { page_name.as_page_class }
-    context 'when 1 word' do
-      it { is_expected.to eql(page_object) }
-    end
-    context 'when more 1 word' do
-      let(:page_name) { 'my  super mega' }
-      before { stub_const('MySuperMegaPage', page_object) }
-      it { is_expected.to eql(page_object) }
-    end
-    context 'when plural word' do
-      let(:page_name) { 'user notifications' }
-      before { stub_const('UserNotificationsPage', page_object) }
-      it { is_expected.to eql(page_object) }
-    end
-  end
-  describe '#as_email_class' do
-    subject { email_name.as_email_class }
-    let(:my_email) { double }
-    context 'when 1 word' do
-      let(:email_name) { 'my' }
-      before { stub_const('MyEmail', my_email) }
-      it { is_expected.to eql(my_email) }
-    end
-    context 'when more 1 word' do
-      let(:email_name) { 'my  super mega' }
-      before { stub_const('MySuperMegaEmail', my_email) }
-      it { is_expected.to eql(my_email) }
-    end
-    context 'when plural word' do
-      let(:email_name) { 'email notifications' }
-      before { stub_const('EmailNotificationsEmail', my_email) }
-      it { is_expected.to eql(my_email) }
-    end
-  end
-  describe '#on' do
-    let(:block) { -> {} }
-    subject { page_name.on(&block) }
-    before do
-      allow(page_name).to receive(:as_page_class) { page_object }
-      expect(page_object).to receive(:on).once
-    end
-    it { is_expected.to be_nil }
-  end
-end

data/spec/unit/lib/web/base_section_spec.rb

@@ -1,43 +0,0 @@
-require 'spec_helper'
-require 'howitzer/web/section_dsl'
-require 'howitzer/web/base_section'
-
-RSpec.describe Howitzer::Web::BaseSection do
-  describe 'element dsl methods' do
-    let(:parent) { double }
-    let(:capybara_context) { double }
-
-    let(:klass) { Class.new(described_class) }
-    let(:klass_object) { klass.new(parent, capybara_context) }
-    it 'returns correct capybara context' do
-      expect(klass_object.capybara_context).to eq(capybara_context)
-    end
-
-    include_examples :element_dsl
-  end
-  describe 'DSL' do
-    describe '.me' do
-      it { expect { described_class.send(:me, '.foo') }.to raise_error(NoMethodError) }
-    end
-  end
-
-  describe '.default_finder_args' do
-    subject { described_class.default_finder_args }
-    it { is_expected.to be_nil }
-  end
-
-  describe '#parent' do
-    subject { described_class.new(:test, 1).parent }
-    it { is_expected.to eq(:test) }
-  end
-
-  describe '#capybara_context' do
-    subject { described_class.new(1, :test).capybara_context }
-    it { is_expected.to eq(:test) }
-  end
-
-  describe 'includes proxied capybara methods' do
-    let(:reciever) { Class.new(described_class).new(:test, 1) }
-    include_examples :capybara_methods_proxy
-  end
-end

data/spec/unit/lib/web/element_dsl_spec.rb

@@ -1,22 +0,0 @@
-require 'spec_helper'
-require 'howitzer/web/element_dsl'
-
-RSpec.describe Howitzer::Web::ElementDsl do
-  let(:klass) do
-    Class.new do
-      include Howitzer::Web::ElementDsl
-      def capybara_scopes
-        @_scopes ||= [Capybara.current_session]
-      end
-    end
-  end
-  let(:klass_object) { klass.new }
-
-  it 'returns correct capybara context' do
-    allow(Capybara).to receive(:current_session) { 'session' }
-    expect(klass_object.capybara_context).to eq('session')
-  end
-
-  include_examples :element_dsl
-  include_examples :capybara_context_holder
-end