howitzer 2.0.3 → 2.3.0

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/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

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

@@ -1,144 +0,0 @@
-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
-
-    context 'when selector is not specified' do
-      subject do
-        web_page_class.class_eval do
-          iframe :fb
-        end
-        web_page_class
-      end
-
-      it 'should raise error' do
-        expect { subject }.to raise_error(ArgumentError, 'iframe selector arguments must be specified')
-      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 {} }
-      context 'when no options' do
-        subject { web_page_object.fb_iframe(&block) }
-        before { web_page_class.class_eval { iframe :fb, 'foo' } }
-        it do
-          expect(kontext).to receive(:within_frame)
-            .with('foo') { |&block| block.call }
-          expect(block).to receive(:call).with(fb_page_class.instance)
-          expect(fb_page_class).to receive(:displayed?).with(no_args)
-        end
-      end
-      context 'when all possible options' do
-        subject { web_page_object.fb_iframe(wait: 10, text: 'new', &block) }
-        before { web_page_class.class_eval { iframe :fb, :xpath, './/foo', match: :first, text: 'origin' } }
-        it do
-          expect(kontext).to receive(:within_frame)
-            .with(:xpath, './/foo', match: :first, wait: 10, text: 'new') { |&block| block.call }
-          expect(block).to receive(:call).with(fb_page_class.instance)
-          expect(fb_page_class).to receive(:displayed?).with(no_args)
-        end
-      end
-    end
-    describe '#has_name_iframe?' do
-      subject { web_page_object.has_fb_iframe?(wait: 1, text: 'new') }
-      context 'when first argument is integer' do
-        before { web_page_class.class_eval { iframe :fb, 1, match: :first, text: 'origin' } }
-        it do
-          expect(kontext).to receive(:has_selector?)
-            .with('iframe:nth-of-type(2)', match: :first, wait: 1, text: 'new')
-        end
-      end
-      context 'when first argument is string' do
-        before { web_page_class.class_eval { iframe :fb, 'loko', match: :first, text: 'origin' } }
-        it { expect(kontext).to receive(:has_selector?).with(:frame, 'loko', match: :first, wait: 1, text: 'new') }
-      end
-      context 'when first argument is hash' do
-        before { web_page_class.class_eval { iframe :fb, name: 'loko', match: :first, text: 'origin' } }
-        it do
-          expect(kontext).to receive(:has_selector?)
-            .with(:frame, name: 'loko', match: :first, wait: 1, text: 'new')
-        end
-      end
-      context 'when first argument is symbol' do
-        before { web_page_class.class_eval { iframe :fb, :xpath, './/foo', match: :first, text: 'origin' } }
-        it { expect(kontext).to receive(:has_selector?).with(:xpath, './/foo', match: :first, wait: 1, text: 'new') }
-      end
-    end
-    describe '#has_no_name_iframe?' do
-      subject { web_page_object.has_no_fb_iframe?(wait: 1, text: 'new') }
-      context 'when first argument is integer' do
-        before { web_page_class.class_eval { iframe :fb, 1, match: :first, text: 'origin' } }
-        it do
-          expect(kontext).to receive(:has_no_selector?)
-            .with('iframe:nth-of-type(2)', match: :first, wait: 1, text: 'new')
-        end
-      end
-      context 'when first argument is string' do
-        before { web_page_class.class_eval { iframe :fb, 'loko', match: :first, text: 'origin' } }
-        it { expect(kontext).to receive(:has_no_selector?).with(:frame, 'loko', match: :first, wait: 1, text: 'new') }
-      end
-      context 'when first argument is hash' do
-        before { web_page_class.class_eval { iframe :fb, name: 'loko', match: :first, text: 'origin' } }
-        it do
-          expect(kontext).to receive(:has_no_selector?).with(:frame, name: 'loko', match: :first, wait: 1, text: 'new')
-        end
-      end
-      context 'when first argument is symbol' do
-        before { web_page_class.class_eval { iframe :fb, :xpath, './/foo', match: :first, text: 'origin' } }
-        it { expect(kontext).to receive(:has_no_selector?).with(:xpath, './/foo', match: :first, wait: 1, text: 'new') }
-      end
-    end
-  end
-end

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

@@ -1,74 +0,0 @@
-require 'spec_helper'
-require 'howitzer/web/page_dsl'
-
-RSpec.describe Howitzer::Web::PageDsl do
-  let(:page) { Class.new { include Howitzer::Web::PageDsl } }
-
-  describe '.on' do
-    subject { page.on { 1 } }
-    before { expect(Howitzer::Web::PageDsl::PageScope).to receive(:new).with(page) }
-    it { is_expected.to be_nil }
-  end
-end
-
-RSpec.describe Howitzer::Web::PageDsl::PageScope do
-  let(:fake_page) { double }
-  let(:page) { Class.new }
-  before { allow(page).to receive(:given) { fake_page } }
-
-  describe '.new' do
-    subject { described_class.new(page) { bar } }
-    before { expect_any_instance_of(described_class).to receive(:bar).with(no_args) { true } }
-    it { is_expected.to be_a(described_class) }
-  end
-
-  describe '#is_expected' do
-    let(:scope) { described_class.new(page) { 1 } }
-    subject { scope.is_expected }
-    before { expect(scope).to receive(:expect).with(fake_page) { true } }
-    it { is_expected.to eq(true) }
-  end
-
-  describe '#method_missing' do
-    context 'when starts with be_' do
-      let(:scope) { described_class.new(page) { 1 } }
-      subject { scope.be_a(described_class) }
-      it { expect(subject.class).to eq(RSpec::Matchers::BuiltIn::BeAKindOf) }
-    end
-
-    context 'when starts with have_' do
-      let(:scope) { described_class.new(page) { 1 } }
-      subject { scope.have_content(described_class) }
-      it { expect(subject.class).to eq(RSpec::Matchers::BuiltIn::Has) }
-    end
-
-    context 'when out' do
-      let(:outer_context) do
-        Class.new do
-          def initialize(klass)
-            @klass = klass
-            @a = 5
-          end
-
-          def scope
-            @klass.new(nil) { 1 }
-          end
-
-          def secret
-            '***'
-          end
-        end
-      end
-      let(:scope) { outer_context.new(described_class).scope }
-      it { expect(scope.out(:@a)).to eq(5) }
-      it { expect(scope.out(:secret)).to eq('***') }
-    end
-
-    context 'when starts other prefix' do
-      let(:scope) { described_class.new(page) { 1 } }
-      subject { scope.foo(1, 2, 3) }
-      before { expect(fake_page).to receive(:foo).with(1, 2, 3) { true } }
-      it { is_expected.to eq(true) }
-    end
-  end
-end