howitzer 2.0.1 → 2.0.2

data/lib/howitzer/web/page.rb

@@ -22,6 +22,7 @@ module Howitzer
       include SectionDsl
       include PageValidator
       include ::RSpec::Matchers
+      include RSpec::Wait
 
       # This Ruby callback makes all inherited classes as singleton classes.
 

data/lib/howitzer/web/page_dsl.rb

@@ -5,6 +5,7 @@ module Howitzer
       # This class is for private usage only
       class PageScope
         include RSpec::Matchers
+        include RSpec::Wait
 
         def initialize(page_klass, &block)
           self.page_klass = page_klass
@@ -38,7 +39,7 @@ module Howitzer
         # @see #method_missing
 
         def respond_to_missing?(name, include_private = false)
-          !(name =~ /\A(?:be|have)_/) || super
+          name !~ /\A(?:be|have)_/ || super
         end
 
         private

data/lib/howitzer/web/page_validator.rb

@@ -21,7 +21,6 @@ module Howitzer
 
       def check_validations_are_defined!
         return if self.class.validations.present?
-
         raise Howitzer::NoValidationError, "No any page validation was found for '#{self.class.name}' page"
       end
 
@@ -34,6 +33,7 @@ module Howitzer
         #   For :element_presence must be one of element names described for page
         # @param additional_value [Object, nil] any value required to pass for a labmda selector
         # @raise  [Howitzer::UnknownValidationError] if unknown validation type
+        # @raise  [Howitzer::UndefinedElementError] if :element_presence validations refers to undefined element name
         # @example
         #   class ArticleListPage < Howitzer::Web::Page
         #     validate :title, /\ADemo web application - Listing Articles\z/
@@ -81,6 +81,10 @@ module Howitzer
         def validate_element(element_name, value = nil)
           validations[:element_presence] =
             lambda do |web_page, sync|
+              if element_name.present? && !private_method_defined?("#{element_name}_element")
+                raise(Howitzer::UndefinedElementError, ':element_presence validation refers to ' \
+                     "undefined '#{element_name}' element on '#{name}' page.")
+              end
               if sync
                 web_page.instance.public_send(*["has_#{element_name}_element?", value].compact)
               else

data/spec/spec_helper.rb

@@ -68,6 +68,5 @@ Dir[File.join(__dir__, 'support', '**', '*.rb')].each { |f| require f }
 
 RSpec.configure do |config|
   config.include Howitzer::GeneratorHelper
-  config.disable_monkey_patching = true
-  config.around(:each, &:run)
+  config.disable_monkey_patching!
 end

data/spec/support/shared_examples/capybara_methods_proxy.rb

@@ -47,10 +47,10 @@ RSpec.shared_examples :capybara_methods_proxy do
       let(:switch_to) { double }
       let(:driver_name) { 'selenium' }
       it do
-        expect(session).to receive(:driver).ordered { driver }
-        expect(driver).to receive(:browser).ordered { browser }
-        expect(browser).to receive(:switch_to).ordered { switch_to }
-        expect(switch_to).to receive(:alert).ordered { alert }
+        expect(session).to receive(:driver).ordered.and_return(driver)
+        expect(driver).to receive(:browser).ordered.and_return(browser)
+        expect(browser).to receive(:switch_to).ordered.and_return(switch_to)
+        expect(switch_to).to receive(:alert).ordered.and_return(alert)
         expect(alert).to receive(:accept).once
         subject
       end
@@ -64,10 +64,10 @@ RSpec.shared_examples :capybara_methods_proxy do
       let(:switch_to) { double }
       let(:driver_name) { 'selenium' }
       it do
-        expect(session).to receive(:driver).ordered { driver }
-        expect(driver).to receive(:browser).ordered { browser }
-        expect(browser).to receive(:switch_to).ordered { switch_to }
-        expect(switch_to).to receive(:alert).ordered { alert }
+        expect(session).to receive(:driver).ordered.and_return(driver)
+        expect(driver).to receive(:browser).ordered.and_return(browser)
+        expect(browser).to receive(:switch_to).ordered.and_return(switch_to)
+        expect(switch_to).to receive(:alert).ordered.and_return(alert)
         expect(alert).to receive(:dismiss).once
         subject
       end

data/spec/support/shared_examples/dynamic_section_methods.rb

@@ -5,7 +5,7 @@ RSpec.shared_examples :dynamic_section_methods do
   describe '#name_section' do
     let(:capybara_element) { double }
     subject { web_page_object.send("#{section_name}_section") }
-    before { expect(session).to receive(:find).with(*finder_args).once { capybara_element } }
+    before { expect(session).to receive(:find).with(*finder_args).once.and_return(capybara_element) }
     it { is_expected.to be_a(section_class) }
   end
   describe '#name_sections' do
@@ -13,7 +13,7 @@ RSpec.shared_examples :dynamic_section_methods do
     let(:capybara_element1) { double }
     let(:capybara_element2) { double }
     before do
-      expect(session).to receive(:all).with(*finder_args).once { [capybara_element1, capybara_element2] }
+      expect(session).to receive(:all).with(*finder_args).once.and_return([capybara_element1, capybara_element2])
     end
     it 'should return collection of sections' do
       res = subject
@@ -24,12 +24,12 @@ RSpec.shared_examples :dynamic_section_methods do
   end
   describe '#has_name_section?' do
     subject { web_page_object.send("has_#{section_name}_section?") }
-    before { expect(session).to receive(:has_selector?).with(*finder_args).once { true } }
+    before { expect(session).to receive(:has_selector?).with(*finder_args).once.and_return(true) }
     it { is_expected.to eq(true) }
   end
   describe '#has_no_name_element?' do
     subject { web_page_object.send("has_no_#{section_name}_section?") }
-    before { expect(session).to receive(:has_no_selector?).with(*finder_args).once { true } }
+    before { expect(session).to receive(:has_no_selector?).with(*finder_args).once.and_return(true) }
     it { is_expected.to eq(true) }
   end
 end

data/spec/support/shared_examples/element_dsl.rb

@@ -75,38 +75,39 @@ RSpec.shared_examples :element_dsl do
     before do
       allow(Capybara).to receive(:current_session) { kontext }
       klass.class_eval do
-        element :foo, :xpath, ->(title, name) { "//a[.='#{title}']/*[@name='#{name}']" }
-        element :bar, '.someclass'
-        element :top_panel, '.top'
+        element :foo, :xpath,
+                ->(title, name) { "//a[.='#{title}']/*[@name='#{name}']" }, text: 'original', match: :first
+        element :bar, '.someclass', text: 'origin', match: :first
+        element :top_panel, '.top', text: 'origin', match: :first
       end
     end
 
     describe '#name_element' do
       context 'when simple selector' do
-        subject { klass_object.send(:bar_element, wait: 10) }
+        subject { klass_object.send(:bar_element, text: 'new', wait: 10) }
         after { subject }
-        it { expect(klass_object.capybara_context).to receive(:find).with('.someclass', wait: 10) }
+        it do
+          expect(klass_object.capybara_context).to receive(:find)
+            .with('.someclass', wait: 10, text: 'new', match: :first)
+        end
       end
       context 'when lambda selector' do
-        subject { klass_object.send(:foo_element, 'Hello', 'super', wait: 10) }
+        subject { klass_object.send(:foo_element, 'Hello', 'super', text: 'new', wait: 10) }
         after { subject }
         it do
-          expect(
-            klass_object.capybara_context
-          ).to receive(:find).with(:xpath, "//a[.='Hello']/*[@name='super']", wait: 10)
+          expect(klass_object.capybara_context).to receive(:find)
+            .with(:xpath, "//a[.='Hello']/*[@name='super']", wait: 10, text: 'new', match: :first)
         end
 
         context 'when several execution with different data' do
           it 'does not cache previous data' do
-            expect(
-              klass_object.capybara_context
-            ).to receive(:find).with(:xpath, "//a[.='Hello']/*[@name='super']", wait: 10).at_least(:once)
-            klass_object.send(:foo_element, 'Hello', 'super', wait: 10)
+            expect(klass_object.capybara_context).to receive(:find)
+              .with(:xpath, "//a[.='Hello']/*[@name='super']", wait: 10, text: 'new', match: :first).at_least(:once)
+            klass_object.send(:foo_element, 'Hello', 'super', text: 'new', wait: 10)
 
-            expect(
-              klass_object.capybara_context
-            ).to receive(:find).with(:xpath, "//a[.='Bye']/*[@name='puper']", wait: 15).at_least(:once)
-            klass_object.send(:foo_element, 'Bye', 'puper', wait: 15)
+            expect(klass_object.capybara_context).to receive(:find)
+              .with(:xpath, "//a[.='Bye']/*[@name='puper']", wait: 15, text: 'new', match: :first).at_least(:once)
+            klass_object.send(:foo_element, 'Bye', 'puper', text: 'new', wait: 15)
           end
         end
       end
@@ -114,32 +115,36 @@ RSpec.shared_examples :element_dsl do
     describe '#name_elements' do
       after { subject }
       context 'when simple selector' do
-        subject { klass_object.send(:bar_elements, wait: 10) }
-        it { expect(klass_object.capybara_context).to receive(:all).with('.someclass', wait: 10) }
+        subject { klass_object.send(:bar_elements, text: 'new', wait: 10) }
+        it do
+          expect(klass_object.capybara_context).to receive(:all)
+            .with('.someclass', wait: 10, text: 'new', match: :first)
+        end
       end
       context 'when lambda selector' do
-        subject { klass_object.send(:foo_elements, 'Hello', 'super', wait: 10) }
+        subject { klass_object.send(:foo_elements, 'Hello', 'super', text: 'new', wait: 10) }
         it do
           expect(
             klass_object.capybara_context
-          ).to receive(:all).with(:xpath, "//a[.='Hello']/*[@name='super']", wait: 10)
+          ).to receive(:all).with(:xpath, "//a[.='Hello']/*[@name='super']", wait: 10, text: 'new', match: :first)
         end
       end
     end
     describe '#wait_for_name_element' do
       context 'when simple selector' do
-        subject { klass_object.send(:wait_for_bar_element, wait: 10) }
+        subject { klass_object.send(:wait_for_bar_element, text: 'new', wait: 10) }
         it do
-          expect(klass_object.capybara_context).to receive(:find).with('.someclass', wait: 10)
+          expect(klass_object.capybara_context).to receive(:find)
+            .with('.someclass', wait: 10, text: 'new', match: :first)
           is_expected.to eq(nil)
         end
       end
       context 'when lambda selector' do
-        subject { klass_object.send(:wait_for_foo_element, 'Hello', 'super', wait: 10) }
+        subject { klass_object.send(:wait_for_foo_element, 'Hello', 'super', text: 'new', wait: 10) }
         it do
           expect(
             klass_object.capybara_context
-          ).to receive(:find).with(:xpath, "//a[.='Hello']/*[@name='super']", wait: 10)
+          ).to receive(:find).with(:xpath, "//a[.='Hello']/*[@name='super']", wait: 10, text: 'new', match: :first)
           is_expected.to eq(nil)
         end
       end
@@ -151,29 +156,30 @@ RSpec.shared_examples :element_dsl do
         context 'when simple selector' do
           subject do
             klass_object.instance_eval do
-              within_bar_element(wait: 10) do
-                foo_element('Hello', 'super', wait: 10)
+              within_bar_element(wait: 5, text: 'new') do
+                foo_element('Hello', 'super', wait: 10, text: 'new')
               end
             end
           end
           it do
-            expect(klass_object.capybara_context).to receive(:find).with('.someclass', wait: 10) { within_scope }
-            expect(within_scope).to receive(:find).with(:xpath, "//a[.='Hello']/*[@name='super']", wait: 10)
+            expect(klass_object.capybara_context).to receive(:find)
+              .with('.someclass', wait: 5, text: 'new', match: :first) { within_scope }
+            expect(within_scope).to receive(:find)
+              .with(:xpath, "//a[.='Hello']/*[@name='super']", wait: 10, text: 'new', match: :first)
           end
         end
         context 'when lambda selector' do
           subject do
             klass_object.instance_eval do
-              within_foo_element('Hello', 'super', wait: 10) do
-                bar_element(wait: 10)
+              within_foo_element('Hello', 'super', wait: 10, text: 'new') do
+                bar_element(wait: 10, text: 'new')
               end
             end
           end
           it do
-            expect(
-              klass_object.capybara_context
-            ).to receive(:find).with(:xpath, "//a[.='Hello']/*[@name='super']", wait: 10) { within_scope }
-            expect(within_scope).to receive(:find).with('.someclass', wait: 10)
+            expect(klass_object.capybara_context).to receive(:find)
+              .with(:xpath, "//a[.='Hello']/*[@name='super']", wait: 10, text: 'new', match: :first) { within_scope }
+            expect(within_scope).to receive(:find).with('.someclass', wait: 10, text: 'new', match: :first)
           end
         end
       end
@@ -181,47 +187,54 @@ RSpec.shared_examples :element_dsl do
         let(:nested_within_scope) { double }
         subject do
           klass_object.instance_eval do
-            within_top_panel_element(wait: 10) do
-              within_bar_element(wait: 10) do
-                foo_element('Hello', 'super', wait: 10)
+            within_top_panel_element(wait: 10, text: 'new') do
+              within_bar_element(wait: 10, text: 'new') do
+                foo_element('Hello', 'super', wait: 10, text: 'new')
               end
             end
           end
         end
         it do
-          expect(klass_object.capybara_context).to receive(:find).with('.top', wait: 10) { within_scope }
-          expect(within_scope).to receive(:find).with('.someclass', wait: 10) { nested_within_scope }
-          expect(nested_within_scope).to receive(:find).with(:xpath, "//a[.='Hello']/*[@name='super']", wait: 10)
+          expect(klass_object.capybara_context).to receive(:find)
+            .with('.top', wait: 10, text: 'new', match: :first) { within_scope }
+          expect(within_scope).to receive(:find)
+            .with('.someclass', wait: 10, text: 'new', match: :first) { nested_within_scope }
+          expect(nested_within_scope).to receive(:find)
+            .with(:xpath, "//a[.='Hello']/*[@name='super']", wait: 10, text: 'new', match: :first)
         end
       end
     end
     describe '#has_name_element?' do
       after { subject }
       context 'when simple selector' do
-        subject { klass_object.send(:has_bar_element?, wait: 10) }
-        it { expect(klass_object.capybara_context).to receive(:has_selector?).with('.someclass', wait: 10) }
+        subject { klass_object.send(:has_bar_element?, wait: 10, text: 'new') }
+        it do
+          expect(klass_object.capybara_context).to receive(:has_selector?)
+            .with('.someclass', wait: 10, text: 'new', match: :first)
+        end
       end
       context 'when lambda selector' do
-        subject { klass_object.send(:has_foo_element?, 'Hello', 'super', wait: 10) }
+        subject { klass_object.send(:has_foo_element?, 'Hello', 'super', wait: 10, text: 'new') }
         it do
-          expect(
-            klass_object.capybara_context
-          ).to receive(:has_selector?).with(:xpath, "//a[.='Hello']/*[@name='super']", wait: 10)
+          expect(klass_object.capybara_context).to receive(:has_selector?)
+            .with(:xpath, "//a[.='Hello']/*[@name='super']", wait: 10, text: 'new', match: :first)
         end
       end
     end
     describe '#has_no_name_element?' do
       after { subject }
       context 'when simple selector' do
-        subject { klass_object.send(:has_no_bar_element?, wait: 10) }
-        it { expect(klass_object.capybara_context).to receive(:has_no_selector?).with('.someclass', wait: 10) }
+        subject { klass_object.send(:has_no_bar_element?, wait: 10, text: 'new') }
+        it do
+          expect(klass_object.capybara_context).to receive(:has_no_selector?)
+            .with('.someclass', wait: 10, text: 'new', match: :first)
+        end
       end
       context 'when lambda selector' do
-        subject { klass_object.send(:has_no_foo_element?, 'Hello', 'super', wait: 10) }
+        subject { klass_object.send(:has_no_foo_element?, 'Hello', 'super', wait: 10, text: 'new', match: :first) }
         it do
-          expect(
-            klass_object.capybara_context
-          ).to receive(:has_no_selector?).with(:xpath, "//a[.='Hello']/*[@name='super']", wait: 10)
+          expect(klass_object.capybara_context).to receive(:has_no_selector?)
+            .with(:xpath, "//a[.='Hello']/*[@name='super']", wait: 10, text: 'new', match: :first)
         end
       end
     end

data/spec/unit/generators/cucumber_generator_spec.rb

@@ -35,7 +35,12 @@ RSpec.describe 'Generators' do
           size: template_file_size('cucumber', 'transformers.rb')
         },
         { name: '/tasks', is_directory: true },
-        { name: '/tasks/cucumber.rake', is_directory: false, size: template_file_size('cucumber', 'cucumber.rake') }
+        { name: '/tasks/cucumber.rake', is_directory: false, size: template_file_size('cucumber', 'cucumber.rake') },
+        {
+          name: '/tasks/cuke_sniffer.rake',
+          is_directory: false,
+          size: template_file_size('cucumber', 'cuke_sniffer.rake')
+        }
       ]
     end
     it { is_expected.to eql(expected_result) }
@@ -47,7 +52,8 @@ RSpec.describe 'Generators' do
       Added 'features/support/hooks.rb' file
       Added 'features/support/transformers.rb' file
       Added 'features/example.feature' file
-      Added 'tasks/cucumber.rake' file\n"
+      Added 'tasks/cucumber.rake' file
+      Added 'tasks/cuke_sniffer.rake' file\n"
       end
       subject { output.string }
       it { is_expected.to eql(expected_output) }

data/spec/unit/lib/cache_spec.rb

@@ -70,7 +70,7 @@ RSpec.describe Howitzer::Cache do
       it { expect(described_class.data).to eq(cloud: { status: false }, foo: {}, bar: {}, baz: {}) }
     end
     context 'when custom argument' do
-      let(:exception_list) { [:foo, :bar] }
+      let(:exception_list) { %i(foo bar) }
       before { described_class.clear_all_ns(exception_list) }
       it do
         expect(described_class.data).to eq(

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

@@ -14,7 +14,7 @@ RSpec.describe Howitzer::MailgunApi::Client do
     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') }
+          .once.and_return(Howitzer::MailgunApi::UnitClient.new('Fake-API-Key', 'api.mailgun.net', 'v2'))
       end
       it do
         expect(subject.body).to include('total_count')
@@ -24,9 +24,9 @@ RSpec.describe Howitzer::MailgunApi::Client do
     context 'when real client' do
       let(:resource) { double }
       before do
-        allow(resource).to receive('[]') { resource }
+        allow(resource).to receive('[]').and_return(resource)
         allow(resource).to receive(:get).and_raise(StandardError, '401 Unauthorized: Forbidden')
-        allow(RestClient::Resource).to receive(:new) { resource }
+        allow(RestClient::Resource).to receive(:new).and_return(resource)
       end
       it do
         expect { subject }.to raise_error(Howitzer::CommunicationError, '401 Unauthorized: Forbidden')
@@ -41,14 +41,14 @@ RSpec.describe Howitzer::MailgunApi::Client 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 }
+        allow(RestClient::Request).to receive(:execute).with(any_args).and_return(response_raw)
+        allow(Howitzer::MailgunApi::Response).to receive(:new).with(response_raw).and_return(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 }
+        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

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

@@ -43,6 +43,19 @@ RSpec.describe Howitzer::Web::IframeDsl do
         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
@@ -57,42 +70,74 @@ RSpec.describe Howitzer::Web::IframeDsl do
 
     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 } }
+      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(1) { |&block| block.call }
+          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 string selector' do
-        before { web_page_class.class_eval { iframe :fb, 'loko' } }
+      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('loko') { |&block| block.call }
+          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? }
-      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)') }
+      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 string selector' do
-        before { web_page_class.class_eval { iframe :fb, 'loko' } }
-        it { expect(kontext).to receive(:has_selector?).with(:frame, 'loko') }
+      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? }
-      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') }
+      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