howitzer 2.2.0 → 2.3.0

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

@@ -1,66 +0,0 @@
-require 'spec_helper'
-require 'howitzer/meta/iframe'
-
-RSpec.describe Howitzer::Meta::Iframe do
-  let(:context) { double }
-  let(:name) { 'foo' }
-  let(:iframe) { described_class.new(name, context) }
-
-  describe '.new' do
-    it { expect(iframe.context).to eq(context) }
-    it { expect(iframe.name).to eq('foo') }
-  end
-
-  describe '#capybara_elements' do
-    subject { iframe.capybara_elements }
-    it do
-      expect(iframe).to receive(:site_value)
-      expect(context).to receive_message_chain(:capybara_context, :all)
-      subject
-    end
-  end
-
-  describe '#capybara_element' do
-    subject { iframe.capybara_element }
-    context 'when element is present' do
-      context 'with default arguments' do
-        it do
-          expect(iframe).to receive(:site_value)
-          expect(context).to receive_message_chain(:capybara_context, :find)
-          subject
-        end
-      end
-      context 'with custom arguments' do
-        subject { iframe.capybara_element(wait: 5) }
-        it do
-          expect(iframe).to receive(:site_value)
-          expect(context).to receive_message_chain(:capybara_context, :find)
-          subject
-        end
-      end
-    end
-    context 'when element is not found' do
-      before do
-        allow(iframe).to receive(:site_value)
-        allow(context).to receive_message_chain(:capybara_context, :find) { raise Capybara::ElementNotFound }
-      end
-      it { is_expected.to be_nil }
-    end
-  end
-
-  describe '#site_value' do
-    subject { iframe.site_value }
-    context 'when site value is present' do
-      before { iframe.instance_variable_set(:@site_value, 'test') }
-      it { is_expected.to eq('test') }
-    end
-    context 'when site value is blank' do
-      it do
-        expect(context).to receive(:send).with("#{name}_iframe")
-        subject
-      end
-    end
-  end
-
-  include_examples :meta_highlight_xpath
-end

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

@@ -1,43 +0,0 @@
-require 'spec_helper'
-require 'howitzer/meta/section'
-
-RSpec.describe Howitzer::Meta::Section do
-  let(:context) { double }
-  let(:name) { 'foo' }
-  let(:section) { described_class.new(name, context) }
-
-  describe '.new' do
-    it { expect(section.context).to eq(context) }
-    it { expect(section.name).to eq('foo') }
-  end
-
-  describe '#capybara_elements' do
-    subject { section.capybara_elements }
-    let(:capybara_element) { double }
-    it do
-      expect(context).to receive(:send).with("#{name}_sections") { [capybara_element] }
-      expect(capybara_element).to receive(:capybara_context)
-      subject
-    end
-  end
-
-  describe '#capybara_element' do
-    let(:capybara_element) { double }
-    subject { section.capybara_element }
-    context 'when element is present' do
-      it do
-        expect(context).to receive(:send).with("#{name}_sections") { [capybara_element] }
-        expect(capybara_element).to receive(:capybara_context)
-        subject
-      end
-    end
-    context 'when element is not found' do
-      it do
-        expect(context).to receive(:send).with("#{name}_sections") { [] }
-        is_expected.to be_nil
-      end
-    end
-  end
-
-  include_examples :meta_highlight_xpath
-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.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,31 +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
-        @capybara_scopes ||= Hash.new { |hash, key| hash[key] = [Capybara.current_session] }
-        @capybara_scopes[Howitzer.session_name]
-      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
-
-  it 'returns another capybara context' do
-    allow(Capybara).to receive(:current_session) { 'session' }
-    expect(klass_object.capybara_context).to eq('session')
-    Howitzer.session_name = 'session2'
-    allow(Capybara).to receive(:current_session) { 'session2' }
-    expect(klass_object.capybara_context).to eq('session2')
-  end
-
-  include_examples :element_dsl
-  include_examples :capybara_context_holder
-end

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

@@ -1,203 +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(:nested_class) do
-    module Foo
-      Class.new(Howitzer::Web::Page) do
-        section :navbar, :xpath, './body' do
-          element :like_button, '#foo_id'
-        end
-      end
-    end
-  end
-  let(:double_nested_class) do
-    module Foo
-      module Bar
-        Class.new(Howitzer::Web::Page) do
-          section :navbar, :xpath, './body' do
-            element :like_button, '#foo_id'
-          end
-        end
-      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)
-    stub_const('Foo::FbPage', nested_class)
-    stub_const('Foo::Bar::FbHomePage', double_nested_class)
-    allow(Howitzer::Web::Page).to receive(:descendants) { [FbPage, Foo::FbPage, Foo::Bar::FbHomePage] }
-  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
-
-    context 'when class defined explicity' do
-      subject do
-        web_page_class.class_eval do
-          iframe :fb, FbPage, 1
-        end
-        web_page_class
-      end
-      it 'should find page class specified' do
-        expect(subject).to eql(web_page_class)
-      end
-    end
-
-    context 'when frame nested in module' do
-      subject do
-        web_page_class.class_eval do
-          iframe :foo_fb, 1
-        end
-        web_page_class
-      end
-      it 'should find page class nested in module' do
-        expect(subject).to eql(web_page_class)
-      end
-    end
-
-    context 'when frame nested in module nested in module' do
-      subject do
-        web_page_class.class_eval do
-          iframe :foo_bar_fb_home, 1
-        end
-        web_page_class
-      end
-      it 'should find class nested in modules' do
-        expect(subject).to eql(web_page_class)
-      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