howitzer 1.1.1 → 2.0.0

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

@@ -0,0 +1,163 @@
+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) }
+
+    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' }
+        ).ordered.once { events }
+        allow(Howitzer::MailgunApi::Connector.instance.client).to receive(:get_url).with(
+          'https://si.api.mailgun.net/v3/domains/mg.strongqa.com/messages/1234567890'
+        ).ordered.once { 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' }
+        ).at_least(:twice).ordered { 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

@@ -0,0 +1,58 @@
+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 { 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('[]') { resource }
+        allow(resource).to receive(:get).and_raise(StandardError, '401 Unauthorized: Forbidden')
+        allow(RestClient::Resource).to receive(:new) { 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) { response_raw }
+        allow(Howitzer::MailgunApi::Response).to receive(:new).with(response_raw) { 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) { 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

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

@@ -0,0 +1,28 @@
+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/utils/string_extensions_spec.rb

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

@@ -0,0 +1,41 @@
+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) }
+    before { allow(klass_object).to receive(:capybara_context) { kontext } }
+
+    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

@@ -0,0 +1,17 @@
+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_context
+        Capybara.current_session
+      end
+    end
+  end
+  let(:klass_object) { klass.new }
+
+  include_examples :element_dsl
+  include_examples :capybara_context_holder
+end

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

@@ -0,0 +1,99 @@
+require 'spec_helper'
+require 'howitzer/web/page'
+
+RSpec.describe Howitzer::Web::IframeDsl do
+  let(:fb_page_class) do
+    Class.new(Howitzer::Web::Page) do
+      section :navbar, :xpath, './body' do
+        element :like_button, '#foo_id'
+      end
+    end
+  end
+
+  let(:web_page_class) do
+    Class.new(Howitzer::Web::Page)
+  end
+
+  before do
+    allow_any_instance_of(fb_page_class).to receive(:check_validations_are_defined!)
+    allow_any_instance_of(web_page_class).to receive(:check_validations_are_defined!)
+    stub_const('FbPage', fb_page_class)
+  end
+
+  describe '.iframe' do
+    context 'when selector is integer' do
+      subject do
+        web_page_class.class_eval do
+          iframe :fb, 1
+        end
+        web_page_class
+      end
+
+      it 'should create public :fb_iframe instance method' do
+        expect(subject.instance.public_methods(false)).to include(:fb_iframe)
+      end
+      it 'should create public :has_fb_iframe? instance method' do
+        expect(subject.instance.public_methods(false)).to include(:has_fb_iframe?)
+      end
+      it 'should create public :has_no_fb_iframe? instance method' do
+        expect(subject.instance.public_methods(false)).to include(:has_no_fb_iframe?)
+      end
+      it 'should be protected class method' do
+        expect { subject.iframe :bar }.to raise_error(NoMethodError)
+        expect(subject.protected_methods(true)).to include(:iframe)
+      end
+    end
+  end
+
+  include_examples :capybara_context_holder
+
+  describe 'dynamic_methods' do
+    let(:web_page_object) { web_page_class.instance }
+    let(:kontext) { double(:kontext) }
+    before do
+      allow(Capybara).to receive(:current_session) { kontext }
+    end
+    after { subject }
+
+    describe '#name_iframe' do
+      let(:block) { proc {} }
+      subject { web_page_object.send(:fb_iframe, &block) }
+      context 'when integer selector' do
+        before { web_page_class.class_eval { iframe :fb, 1 } }
+        it do
+          expect(kontext).to receive(:within_frame).with(1) { |&block| block.call }
+          expect(block).to receive(:call).with(fb_page_class.instance)
+        end
+      end
+      context 'when string selector' do
+        before { web_page_class.class_eval { iframe :fb, 'loko' } }
+        it do
+          expect(kontext).to receive(:within_frame).with('loko') { |&block| block.call }
+          expect(block).to receive(:call).with(fb_page_class.instance)
+        end
+      end
+    end
+    describe '#has_name_iframe?' do
+      subject { web_page_object.has_fb_iframe? }
+      context 'when integer selector' do
+        before { web_page_class.class_eval { iframe :fb, 1 } }
+        it { expect(kontext).to receive(:has_selector?).with('iframe:nth-of-type(2)') }
+      end
+      context 'when string selector' do
+        before { web_page_class.class_eval { iframe :fb, 'loko' } }
+        it { expect(kontext).to receive(:has_selector?).with(:frame, 'loko') }
+      end
+    end
+    describe '#has_no_name_iframe?' do
+      subject { web_page_object.has_no_fb_iframe? }
+      context 'when integer selector' do
+        before { web_page_class.class_eval { iframe :fb, 1 } }
+        it { expect(kontext).to receive(:has_no_selector?).with('iframe:nth-of-type(2)') }
+      end
+      context 'when string selector' do
+        before { web_page_class.class_eval { iframe :fb, 'loko' } }
+        it { expect(kontext).to receive(:has_no_selector?).with(:frame, 'loko') }
+      end
+    end
+  end
+end