howitzer 1.1.1 → 2.0.0

data/spec/support/generator_helper.rb

@@ -1,20 +1,21 @@
 require 'fileutils'
 require_relative '../../generators/base_generator'
 
-module GeneratorHelper
-  def file_tree_info(root)
-    Dir["#{root}/**/*"].sort_by{|name| name.sub(root, '') }.map do |name|
-      hash = {name: name.sub(root, ''), is_directory: File.directory?(name)}
-      hash[:size] = File.stat(name).size unless hash[:is_directory]
-      hash
+module Howitzer
+  module GeneratorHelper
+    def file_tree_info(root)
+      Dir["#{root}/**/.*", "#{root}/**/*"].sort_by { |name| name.sub(root, '') }.map do |name|
+        hash = { name: name.sub(root, ''), is_directory: File.directory?(name) }
+        hash[:size] = File.stat(name).size unless hash[:is_directory]
+        hash
+      end
     end
-  end
 
-  def template_file_size(root_directory, file)
-    File.size(File.join(generators_path, root_directory, 'templates', file))
+    def template_file_size(root_directory, file)
+      File.size(File.join(generators_path, root_directory, 'templates', file))
+    end
   end
 end
-
 Howitzer::BaseGenerator.logger = StringIO.new
 Howitzer::BaseGenerator.destination = Dir.mktmpdir
-Dir[File.join(generators_path, '**', '*_generator.rb')].each{ |f| require f }
+Dir[File.join(generators_path, '**', '*_generator.rb')].each { |f| require f }

data/spec/support/logger_helper.rb

@@ -1,12 +1,13 @@
-module LoggerHelper
-  def read_file(file)
-    path = File.expand_path(file, __FILE__)
-    IO.read(path)
-  end
+module Howitzer
+  module LoggerHelper
+    def read_file(file)
+      path = File.expand_path(file, __FILE__)
+      IO.read(path)
+    end
 
-  def clear_file(file)
-    path = File.expand_path(file, __FILE__)
-    File.open(path, "w"){ }
+    def clear_file(file)
+      path = File.expand_path(file, __FILE__)
+      File.open(path, 'w') {}
+    end
   end
 end
-

data/spec/support/mailgun_unit_client.rb

@@ -1,60 +1,68 @@
-require "time"
-require "json"
+require 'time'
+require 'json'
 require 'howitzer/exceptions'
 
-module Mailgun
-  class UnitClient
+module Howitzer
+  module MailgunApi
+    class UnitClient
+      attr_reader :url, :options, :block, :body, :code
 
-    attr_reader :url, :options, :block, :body, :code
-
-    def initialize(url, options={}, backwards_compatibility=nil, &block)
-      @url = url
-      @block = block
-      @options = options
-      @body = nil
-      @code = nil
-    end
+      def initialize(url, options = {}, _backwards_compatibility = nil, &block)
+        @url = url
+        @block = block
+        @options = options
+        @body = nil
+        @code = nil
+      end
 
-    def [](resource_path, &new_block)
-      case
-        when block_given? then self.class.new(resource_path, options, &new_block)
-        when block        then self.class.new(resource_path, options, &block)
+      def [](resource_path, &new_block)
+        if block_given? then self.class.new(resource_path, options, &new_block)
+        elsif block then self.class.new(resource_path, options, &block)
         else
           self.class.new(resource_path, options)
+        end
       end
-    end
-
-    def get(options, query_string = nil)
-      begin
-        if query_string
 
-          response = response_generator("bounces")
-        else
-          response = response_generator("bounces")
-        end
-        Response.new(response)
-      rescue Exception => e
-        log.error Howitzer::CommunicationError.new(e), e.response
+      def get(_options, _query_string = nil)
+        Response.new(response_generator('bounces'))
+      rescue StandardError => e
+        raise Howitzer::CommunicationError.new(e), e.response
       end
-    end
 
-    private
+      private
 
-    def response_generator(resource_endpoint)
-      case resource_endpoint
-        when "messages"
+      def response_generator(resource_endpoint)
+        case resource_endpoint
+        when 'messages'
           t = Time.now
-          id = "<#{t.to_i}.#{rand(99999999)}.5817@example.com>"
-          @body = JSON.generate({"message" => "Queued. Thank you.", "id" => id})
-        when "bounces"
-          @body = 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"}})
-        when "lists"
-          @body = JSON.generate({"member" => {"vars" => {"age" => 26}, "name" => "Foo Bar", "subscribed" => false, "address" => "bar@example.com"}, "message" => "Mailing list member has been updated"})
-        when "campaigns"
-          @body = JSON.generate({"message" => "Campaign has been deleted", "id" => "ABC123"})
+          id = "<#{t.to_i}.#{rand(99_999_999)}.5817@example.com>"
+          @body = JSON.generate('message' => 'Queued. Thank you.', 'id' => id)
+        when 'bounces'
+          @body = 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'
+            }
+          )
+        when 'lists'
+          @body = JSON.generate(
+            'member' => {
+              'vars' => { 'age' => 26 },
+              'name' => 'Foo Bar',
+              'subscribed' => false,
+              'address' => 'bar@example.com'
+            },
+            'message' => 'Mailing list member has been updated'
+          )
+        when 'campaigns'
+          @body = JSON.generate('message' => 'Campaign has been deleted', 'id' => 'ABC123')
+        end
+        self
       end
-      self
     end
   end
-
 end

data/spec/support/shared_examples/capybara_context_holder.rb

@@ -0,0 +1,33 @@
+require 'spec_helper'
+
+RSpec.shared_examples :capybara_context_holder do
+  describe '#capybara_context' do
+    let(:web_page_class) do
+      klass = described_class
+      Class.new do
+        include klass
+      end
+    end
+    subject { web_page_class.new.capybara_context }
+    context 'when parent class has the method' do
+      before do
+        web_page_class.class_eval do
+          def capybara_context
+            true
+          end
+        end
+      end
+      it 'should execute parent method' do
+        is_expected.to eq(true)
+      end
+    end
+    context 'when parent class does not have the method' do
+      it 'should raise error' do
+        expect { subject }.to raise_error(
+          NotImplementedError,
+          "Please define 'capybara_context' method for class holder"
+        )
+      end
+    end
+  end
+end

data/spec/support/shared_examples/capybara_methods_proxy.rb

@@ -0,0 +1,94 @@
+require 'spec_helper'
+
+RSpec.shared_examples :capybara_methods_proxy do
+  let(:session) { double(:session) }
+  before do
+    allow(Capybara).to receive(:current_session) { session }
+    allow(Howitzer).to receive(:driver) { driver_name }
+    allow(session).to receive(:current_url) { 'google.com' }
+  end
+
+  describe '#driver' do
+    it 'should proxy #driver method' do
+      expect(session).to receive(:driver).once
+      reciever.driver
+    end
+  end
+
+  describe '#text' do
+    it 'should proxy #text method' do
+      expect(session).to receive(:text).once
+      reciever.text
+    end
+  end
+
+  context 'when capybara session method' do
+    it 'should proxy method' do
+      expect(session).to receive(:visit).once
+      reciever.visit
+    end
+  end
+
+  context 'when capybara modal method' do
+    it 'should proxy method' do
+      expect(session).to receive(:dismiss_prompt).with(:some_text).once
+      reciever.dismiss_prompt(:some_text)
+    end
+  end
+
+  describe '#click_alert_box' do
+    subject { reciever.click_alert_box(flag_value) }
+    context 'when flag true and correct driver specified' do
+      let(:flag_value) { true }
+      let(:page) { double }
+      let(:alert) { double }
+      let(:driver) { double }
+      let(:browser) { double }
+      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(alert).to receive(:accept).once
+        subject
+      end
+    end
+    context 'when flag false and correct driver specified' do
+      let(:flag_value) { false }
+      let(:page) { double }
+      let(:alert) { double }
+      let(:driver) { double }
+      let(:browser) { double }
+      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(alert).to receive(:dismiss).once
+        subject
+      end
+    end
+    context 'when flag true and wrong driver specified' do
+      let(:flag_value) { true }
+      let(:page) { double }
+      let(:driver_name) { 'ff' }
+      it do
+        expect(session).to receive(:evaluate_script).with('window.confirm = function() { return true; }')
+        subject
+      end
+    end
+    context 'when flag false and wrong driver specified' do
+      let(:driver_name) { 'ff' }
+      let(:flag_value) { false }
+      let(:page) { double }
+      it do
+        expect(session).to receive(:evaluate_script).with('window.confirm = function() { return false; }')
+        subject
+      end
+    end
+  end
+end

data/spec/support/shared_examples/dynamic_section_methods.rb

@@ -0,0 +1,35 @@
+require 'spec_helper'
+RSpec.shared_examples :dynamic_section_methods do
+  let(:web_page_object) { web_page_class.new }
+
+  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 } }
+    it { is_expected.to be_a(section_class) }
+  end
+  describe '#name_sections' do
+    subject { web_page_object.send("#{section_name}_sections") }
+    let(:capybara_element1) { double }
+    let(:capybara_element2) { double }
+    before do
+      expect(session).to receive(:all).with(*finder_args).once { [capybara_element1, capybara_element2] }
+    end
+    it 'should return collection of sections' do
+      res = subject
+      expect(res.size).to eq(2)
+      expect(res.first).to be_a(section_class)
+      expect(res.last).to be_a(section_class)
+    end
+  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 } }
+    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 } }
+    it { is_expected.to eq(true) }
+  end
+end

data/spec/support/shared_examples/element_dsl.rb

@@ -0,0 +1,119 @@
+require 'spec_helper'
+
+RSpec.shared_examples :element_dsl do
+  describe '.element' do
+    context 'when regular capybara params' do
+      before do
+        klass.class_eval do
+          element :foo, :xpath, '//a'
+        end
+      end
+      it 'should create private :foo_element instance method' do
+        expect(klass_object.private_methods(false)).to include(:foo_element)
+      end
+      it 'should create private :foo_elements instance method' do
+        expect(klass_object.private_methods(false)).to include(:foo_elements)
+      end
+      it 'should create public :has_foo_element? instance method' do
+        expect(klass_object.public_methods(false)).to include(:has_foo_element?)
+      end
+      it 'should create public :has_no_foo_element? instance method' do
+        expect(klass_object.public_methods(false)).to include(:has_no_foo_element?)
+      end
+      it 'should be protected class method' do
+        expect { klass.element :bar }.to raise_error(NoMethodError)
+        expect(klass.protected_methods(true)).to include(:element)
+      end
+    end
+    context 'when 1 param is proc' do
+      before do
+        klass.class_eval do
+          element :foo, :xpath, ->(title) { "//a[.='#{title}']" }
+        end
+      end
+      it 'should create private :foo_element instance method' do
+        expect(klass_object.private_methods(false)).to include(:foo_element)
+      end
+      it 'should create private :foo_elements instance method' do
+        expect(klass_object.private_methods(false)).to include(:foo_elements)
+      end
+      it 'should create public :has_foo_element? instance method' do
+        expect(klass_object.public_methods(false)).to include(:has_foo_element?)
+      end
+      it 'should create public :has_no_foo_element? instance method' do
+        expect(klass_object.public_methods(false)).to include(:has_no_foo_element?)
+      end
+      it 'should be protected class method' do
+        expect { klass.element :bar }.to raise_error(NoMethodError)
+        expect(klass.protected_methods(true)).to include(:element)
+      end
+    end
+    context 'when 2 params are proc' do
+      subject do
+        klass.class_eval do
+          element :foo, -> { puts 1 }, ->(title) { "//a[.='#{title}']" }
+        end
+      end
+      it 'should generate error' do
+        expect { subject.element :bar }.to raise_error(
+          Howitzer::BadElementParamsError,
+          'Using more than 1 proc in arguments is forbidden'
+        )
+      end
+    end
+  end
+
+  describe 'dynamic_methods' do
+    let(:web_page_object) { web_page_class.new }
+    let(:kontext) { double(:kontext) }
+    before do
+      allow(Capybara).to receive(:current_session) { kontext }
+      klass.class_eval do
+        element :foo, :xpath, ->(title) { "//a[.='#{title}']" }
+        element :bar, '.someclass'
+      end
+    end
+    after { subject }
+
+    describe '#name_element' do
+      context 'when simple selector' do
+        subject { klass_object.send(:bar_element) }
+        it { expect(kontext).to receive(:find).with('.someclass') }
+      end
+      context 'when lambda selector' do
+        subject { klass_object.send(:foo_element, 'Hello') }
+        it { expect(kontext).to receive(:find).with(:xpath, "//a[.='Hello']") }
+      end
+    end
+    describe '#name_elements' do
+      context 'when simple selector' do
+        subject { klass_object.send(:bar_elements) }
+        it { expect(kontext).to receive(:all).with('.someclass') }
+      end
+      context 'when lambda selector' do
+        subject { klass_object.send(:foo_elements, 'Hello') }
+        it { expect(kontext).to receive(:all).with(:xpath, "//a[.='Hello']") }
+      end
+    end
+    describe '#has_name_element?' do
+      context 'when simple selector' do
+        subject { klass_object.send(:has_bar_element?) }
+        it { expect(kontext).to receive(:has_selector?).with('.someclass') }
+      end
+      context 'when lambda selector' do
+        subject { klass_object.send(:has_foo_element?, 'Hello') }
+        it { expect(kontext).to receive(:has_selector?).with(:xpath, "//a[.='Hello']") }
+      end
+    end
+    describe '#has_no_name_element?' do
+      context 'when simple selector' do
+        subject { klass_object.send(:has_no_bar_element?) }
+        it { expect(kontext).to receive(:has_no_selector?).with('.someclass') }
+      end
+      context 'when lambda selector' do
+        subject { klass_object.send(:has_no_foo_element?, 'Hello') }
+        it { expect(kontext).to receive(:has_no_selector?).with(:xpath, "//a[.='Hello']") }
+      end
+    end
+  end
+end