howitzer 2.2.0 → 2.3.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/meta/element_spec.rb

@@ -1,59 +0,0 @@
-require 'spec_helper'
-require 'howitzer/meta/element'
-
-RSpec.describe Howitzer::Meta::Element do
-  let(:context) { double }
-  let(:name) { 'foo' }
-  let(:element) { described_class.new(name, context) }
-
-  describe '.new' do
-    it { expect(element.context).to eq(context) }
-    it { expect(element.name).to eq('foo') }
-  end
-
-  describe '#capybara_elements' do
-    context 'without arguments' do
-      subject { element.capybara_elements }
-      it do
-        expect(context).to receive(:send).with("#{name}_elements")
-        subject
-      end
-    end
-    context 'whith custom arguments' do
-      subject { element.capybara_elements('test', text: 'test', wait: 5) }
-      it do
-        expect(context).to receive(:send).with("#{name}_elements", 'test', text: 'test', wait: 5)
-        subject
-      end
-    end
-  end
-
-  describe '#capybara_element' do
-    subject { element.capybara_element }
-    context 'when element is present' do
-      context 'with default arguments' do
-        it do
-          expect(context).to receive(:send).with("#{name}_element", match: :first, wait: 0)
-          subject
-        end
-      end
-      context 'with custom arguments' do
-        subject { element.capybara_element('test', { text: 'test' }, wait: 5) }
-        it do
-          expect(context).to receive(:send).with("#{name}_element", 'test', text: 'test', match: :first, wait: 5)
-          subject
-        end
-      end
-    end
-    context 'when element is not found' do
-      before do
-        allow(context).to receive(:send).with("#{name}_element", match: :first, wait: 0) do
-          raise Capybara::ElementNotFound
-        end
-      end
-      it { is_expected.to be_nil }
-    end
-  end
-
-  include_examples :meta_highlight_xpath
-end

data/spec/unit/lib/meta/entry_spec.rb

@@ -1,77 +0,0 @@
-require 'spec_helper'
-require 'howitzer/meta/entry'
-
-RSpec.describe Howitzer::Meta::Entry do
-  let(:klass) do
-    Class.new do
-      include Howitzer::Web::ElementDsl
-      def capybara_scopes
-        @capybara_scopes ||= Hash.new { |hash, key| hash[key] = [Capybara.current_session] }
-        @capybara_scopes[Howitzer.session_name]
-      end
-
-      def foo_section; end
-
-      def bar_section; end
-
-      def foo_sections; end
-
-      def bar_sections; end
-
-      def foo_iframe; end
-
-      def bar_iframe; end
-
-      def has_foo_iframe?; end
-
-      def has_bar_iframe?; end
-    end
-  end
-  let(:klass_object) { klass.new }
-
-  before do
-    klass.class_eval do
-      element :foo, :xpath, '//a'
-      element :bar, '#bar'
-    end
-  end
-
-  describe '.new' do
-    let(:context) { klass.new }
-    subject { described_class.new(context) }
-    it { expect(subject.context).to eq(context) }
-  end
-
-  describe '#elements' do
-    subject { described_class.new(klass.new).elements }
-    it { expect(subject.map(&:name)).to contain_exactly('foo', 'bar') }
-    it { expect(subject.count).to eq(2) }
-  end
-
-  describe '#element' do
-    subject { described_class.new(klass.new).element('foo') }
-    it { expect(subject.name).to eq('foo') }
-  end
-
-  describe '#sections' do
-    subject { described_class.new(klass.new).sections }
-    it { expect(subject.map(&:name)).to contain_exactly('foo', 'bar') }
-    it { expect(subject.count).to eq(2) }
-  end
-
-  describe '#section' do
-    subject { described_class.new(klass.new).section('foo') }
-    it { expect(subject.name).to eq('foo') }
-  end
-
-  describe '#iframes' do
-    subject { described_class.new(klass.new).iframes }
-    it { expect(subject.map(&:name)).to contain_exactly('foo', 'bar') }
-    it { expect(subject.count).to eq(2) }
-  end
-
-  describe '#iframe' do
-    subject { described_class.new(klass.new).iframe('foo') }
-    it { expect(subject.name).to eq('foo') }
-  end
-end