cornucopia 0.1.12

data/spec/lib/site_prism/element_extensions_spec.rb

@@ -0,0 +1,290 @@
+require "spec_helper"
+require ::File.expand_path("../../../lib/cornucopia/site_prism/element_extensions", File.dirname(__FILE__))
+
+describe "SitePrism element_extensions" do
+  class TestPage < ::SitePrism::Page
+  end
+
+  class TestSection < ::SitePrism::Section
+  end
+
+  [TestSection, TestPage].sample(2).each do |test_class|
+    describe "#{test_class.name}" do
+      let(:pre_name) { Faker::Lorem.word }
+      let(:element_names) { Faker::Lorem.words(rand(3..10)).map(&:to_sym) }
+      let(:class_element_names) { element_names + rand(3..10).times.map(Faker::Lorem.words(rand(2..3).join("-"))) }
+      let(:increment) { rand(2..10) }
+      let(:start_index) { rand(2..10) }
+      let(:options) do
+        Faker::Lorem.words(rand(3..10)).reduce({}) do |hash, option_name|
+          hash[option_name] = Faker::Lorem.word
+          hash
+        end
+      end
+
+      describe "#patterned_elements" do
+        it "works" do
+          expect { test_class.send(:patterned_elements, "\##{pre_name}-%{element_name}", :element_1, :element_2) }.
+              not_to raise_exception
+        end
+
+        it "requires %{element_name} in the pattern" do
+          expect { test_class.send(:patterned_elements, "\##{pre_name}-", :element_1, :element_2) }.to raise_exception
+        end
+
+        it "works for 1 element" do
+          expect(test_class).to receive(:element).with(element_names[0], "\##{pre_name}-#{element_names[0]}")
+
+          test_class.send(:patterned_elements, "\##{pre_name}-%{element_name}", element_names[0])
+        end
+
+        it "calls element once for each element_name" do
+          element_names.each do |element_name|
+            expect(test_class).to receive(:element).with(element_name, "\##{pre_name}-#{element_name}")
+          end
+
+          test_class.send(:patterned_elements, "\##{pre_name}-%{element_name}", *element_names)
+        end
+
+        it "converts -'s to _" do
+          element_names.each do |element_name|
+            expect(test_class).to receive(:element).with(element_name.to_s.gsub("-", "_").to_sym,
+                                                         "\##{pre_name}-#{element_name}")
+          end
+
+          test_class.send(:patterned_elements, "\##{pre_name}-%{element_name}", *element_names)
+        end
+
+        it "calls elements once for each element_name if element_array: true" do
+          element_names.each do |element_name|
+            expect(test_class).to receive(:elements).with(:xpath, element_name, "\##{pre_name}-#{element_name}")
+          end
+
+          test_class.send(:patterned_elements,
+                          "\##{pre_name}-%{element_name}",
+                          *element_names,
+                          find_type:     :xpath,
+                          element_array: true)
+        end
+
+        it "passes in :find_type" do
+          element_names.each do |element_name|
+            expect(test_class).to receive(:element).with(:xpath, element_name, "\##{pre_name}-#{element_name}")
+          end
+
+          test_class.send(:patterned_elements, "\##{pre_name}-%{element_name}", *element_names, find_type: :xpath)
+        end
+
+        it "passes in options" do
+          element_names.each do |element_name|
+            expect(test_class).to receive(:element).with(:xpath, element_name, "\##{pre_name}-#{element_name}", options)
+          end
+
+          test_class.send(:patterned_elements,
+                          "\##{pre_name}-%{element_name}",
+                          *element_names,
+                          find_type:          :xpath,
+                          additional_options: options)
+        end
+      end
+
+      describe "#form_elements" do
+        it "calls once per form item" do
+          element_names.each do |element_name|
+            expect(test_class).to receive(:element).with(element_name, "\##{pre_name}_#{element_name}")
+          end
+
+          test_class.send(:form_elements, pre_name.to_sym, *element_names)
+        end
+
+        it "calls elements once per form item" do
+          element_names.each do |element_name|
+            expect(test_class).to receive(:elements).with(element_name, "\##{pre_name}_#{element_name}")
+          end
+
+          test_class.send(:form_elements, pre_name.to_sym, *element_names, element_array: true)
+        end
+
+        it "ignores other options" do
+          element_names.each do |element_name|
+            expect(test_class).to receive(:elements).with(element_name, "\##{pre_name}_#{element_name}")
+          end
+
+          test_class.send(:form_elements, pre_name.to_sym, *element_names, find_type: :xpath, element_array: true)
+        end
+      end
+
+      describe "#id_elements" do
+        it "calls once per form item" do
+          element_names.each do |element_name|
+            expect(test_class).to receive(:element).with(element_name, "\##{element_name}")
+          end
+
+          test_class.send(:id_elements, *element_names)
+        end
+
+        it "calls elements once per form item" do
+          element_names.each do |element_name|
+            expect(test_class).to receive(:elements).with(element_name, "\##{element_name}")
+          end
+
+          test_class.send(:id_elements, *element_names, element_array: true)
+        end
+
+        it "ignores other options" do
+          element_names.each do |element_name|
+            expect(test_class).to receive(:elements).with(element_name, "\##{element_name}")
+          end
+
+          test_class.send(:id_elements, *element_names, find_type: :xpath, element_array: true)
+        end
+      end
+
+      describe "#class_elements" do
+        it "calls once per form item" do
+          element_names.each do |element_name|
+            expect(test_class).to receive(:element).with(element_name, ".#{element_name}")
+          end
+
+          test_class.send(:class_elements, *element_names)
+        end
+
+        it "calls elements once per form item" do
+          element_names.each do |element_name|
+            expect(test_class).to receive(:elements).with(element_name, ".#{element_name}")
+          end
+
+          test_class.send(:class_elements, *element_names, element_array: true)
+        end
+
+        it "ignores other options" do
+          element_names.each do |element_name|
+            expect(test_class).to receive(:elements).with(element_name, ".#{element_name}")
+          end
+
+          test_class.send(:class_elements, *element_names, find_type: :xpath, element_array: true)
+        end
+      end
+
+      describe "#indexed_elements" do
+        it "works" do
+          expect { test_class.send(:indexed_elements, "\##{pre_name}-%{element_index}", :element_1, :element_2) }.
+              not_to raise_exception
+        end
+
+        it "requires %{element_name} in the pattern" do
+          expect { test_class.send(:indexed_elements, "\##{pre_name}-", :element_1, :element_2) }.to raise_exception
+        end
+
+        it "requires an increment" do
+          expect { test_class.send(:indexed_elements, "\##{pre_name}-", :element_1, :element_2, increment: 0) }.
+              to raise_exception
+        end
+
+        it "works for 1 element" do
+          expect(test_class).to receive(:element).with(element_names[0], "\##{pre_name}-1")
+
+          test_class.send(:indexed_elements, "\##{pre_name}-%{element_index}", element_names[0])
+        end
+
+        it "calls element once for each element_name" do
+          element_names.each_with_index do |element_name, index|
+            expect(test_class).to receive(:element).with(element_name, "\##{pre_name}-#{index + 1}")
+          end
+
+          test_class.send(:indexed_elements, "\##{pre_name}-%{element_index}", *element_names)
+        end
+
+        it "increments the counter" do
+          element_names.each_with_index do |element_name, index|
+            expect(test_class).to receive(:element).with(element_name, "\##{pre_name}-#{(increment * index) + 1}")
+          end
+
+          test_class.send(:indexed_elements, "\##{pre_name}-%{element_index}", *element_names, increment: increment)
+        end
+
+        it "can start anywhere" do
+          element_names.each_with_index do |element_name, index|
+            expect(test_class).to receive(:element).with(element_name, "\##{pre_name}-#{start_index + (increment * index)}")
+          end
+
+          test_class.send(:indexed_elements,
+                          "\##{pre_name}-%{element_index}",
+                          *element_names,
+                          increment:   increment,
+                          start_index: start_index)
+        end
+
+        it "passes in :find_type" do
+          element_names.each_with_index do |element_name, index|
+            expect(test_class).to receive(:element).
+                                      with(:xpath, element_name, "\##{pre_name}-#{start_index + (increment * index)}")
+          end
+
+          test_class.send(:indexed_elements,
+                          "\##{pre_name}-%{element_index}",
+                          *element_names,
+                          increment:   increment,
+                          start_index: start_index,
+                          find_type:   :xpath)
+        end
+
+        it "passes in options" do
+          element_names.each_with_index do |element_name, index|
+            expect(test_class).to receive(:element).
+                                      with(:xpath, element_name, "\##{pre_name}-#{start_index + (increment * index)}", options)
+          end
+
+          test_class.send(:indexed_elements,
+                          "\##{pre_name}-%{element_index}",
+                          *element_names,
+                          increment:          increment,
+                          start_index:        start_index,
+                          find_type:          :xpath,
+                          additional_options: options)
+        end
+
+        it "calls elements if element_array is true" do
+          element_names.each_with_index do |element_name, index|
+            expect(test_class).to receive(:elements).
+                                      with(:xpath, element_name, "\##{pre_name}-#{start_index + (increment * index)}", options)
+          end
+
+          test_class.send(:indexed_elements,
+                          "\##{pre_name}-%{element_index}",
+                          *element_names,
+                          increment:          increment,
+                          start_index:        start_index,
+                          find_type:          :xpath,
+                          additional_options: options,
+                          element_array:      true)
+        end
+
+        it "skips blanks" do
+          skip_pos = rand(1..element_names.length - 2)
+          element_names[0..skip_pos - 1].each_with_index do |element_name, index|
+            expect(test_class).to receive(:elements).
+                                      with(:xpath, element_name, "\##{pre_name}-#{start_index + (increment * index)}", options)
+          end
+          element_names[skip_pos..-1].each_with_index do |element_name, index|
+            expect(test_class).to receive(:elements).
+                                      with(:xpath, element_name, "\##{pre_name}-#{1 + start_index + (increment * (skip_pos + index))}", options)
+          end
+
+          test_array = element_names[0..skip_pos - 1]
+          test_array << :__skip__
+          test_array += element_names[skip_pos..-1]
+
+          test_class.send(:indexed_elements,
+                          "\##{pre_name}-%{element_index}",
+                          *test_array,
+                          increment:          increment,
+                          start_index:        start_index,
+                          find_type:          :xpath,
+                          additional_options: options,
+                          element_array:      true)
+        end
+      end
+    end
+  end
+end

data/spec/lib/site_prism/page_application_spec.rb

@@ -0,0 +1,81 @@
+require "spec_helper"
+require ::File.expand_path("../../../lib/cornucopia/site_prism/page_application", File.dirname(__FILE__))
+
+describe Cornucopia::SitePrism::PageApplication do
+  class SimpleTestApplicationClass < Cornucopia::SitePrism::PageApplication
+  end
+
+  class TestApplicationClass < Cornucopia::SitePrism::PageApplication
+    def pages_module
+      TestModule
+    end
+  end
+
+  class Object
+    def method_missing(method_sym, *arguments, &block)
+      if method_sym == :___stupid_missing_message
+        "Missing message"
+      else
+        super
+      end
+    end
+
+    def respond_to?(method_sym, include_private = false)
+      if method_sym == :___stupid_missing_message
+        true
+      else
+        super
+      end
+    end
+  end
+
+  module TestModule
+    class TestClassPage < ::SitePrism::Page
+      set_url "https://www.google.com"
+    end
+
+    module SubTestModule
+      class TestClassPage < ::SitePrism::Page
+        set_url "https://www.facebook.com"
+      end
+    end
+  end
+
+  it "returns a memoized instance of the derived class" do
+    class_instance = TestApplicationClass.current_instance
+    expect(class_instance.object_id).to be == TestApplicationClass.current_instance.object_id
+    expect(class_instance).to be_a(TestApplicationClass)
+  end
+
+  it "should return #pages_module" do
+    expect(TestApplicationClass.pages_module).to be == TestModule
+  end
+
+  it "does not recognize non instance or class functions that are not pages" do
+    expect { TestApplicationClass.send(Faker::Lorem.word) }.to raise_error(NoMethodError)
+  end
+
+  it "does return a simple page object" do
+    expect(TestApplicationClass.test_class_page).to be_a(TestModule::TestClassPage)
+  end
+
+  it "does return a sub_module page object" do
+    expect(TestApplicationClass.sub_test_module__test_class_page).to be_a(TestModule::SubTestModule::TestClassPage)
+  end
+
+  it "has a default #page_module" do
+    expect(SimpleTestApplicationClass.pages_module).to be == Object
+  end
+
+  it "calls respond_to? of the parent" do
+    expect(SimpleTestApplicationClass.respond_to?(:yaml_tag)).to be_truthy
+  end
+
+  it "calls respond_to? of the instance" do
+    expect(SimpleTestApplicationClass.respond_to?(:to_yaml)).to be_truthy
+  end
+
+  it "calls method_missing of the instance" do
+    expect(TestApplicationClass.___stupid_missing_message).to be == "Missing message"
+  end
+end

data/spec/lib/util/configuration_spec.rb

@@ -0,0 +1,254 @@
+require "spec_helper"
+require ::File.expand_path("../../../lib/cornucopia/util/configuration", File.dirname(__FILE__))
+
+describe "Cornucopia::Util::Configuration" do
+  it "has a default seed value" do
+    expect(Cornucopia::Util::Configuration.seed).not_to be
+  end
+
+  it "can set the seed value" do
+    begin
+      seed_value = rand(0..999999999999999999999999999)
+
+      Cornucopia::Util::Configuration.seed = seed_value
+
+      expect(Cornucopia::Util::Configuration.seed).to be == seed_value
+    ensure
+      Cornucopia::Util::Configuration.seed = nil
+    end
+  end
+
+  describe "log files" do
+    it "grabs logs by default" do
+      expect(Cornucopia::Util::Configuration.grab_logs).to be_truthy
+    end
+
+    it "can set the seed value" do
+      begin
+        Cornucopia::Util::Configuration.grab_logs = false
+
+        expect(Cornucopia::Util::Configuration.grab_logs).to be_falsey
+      ensure
+        Cornucopia::Util::Configuration.grab_logs = true
+      end
+    end
+
+    it "has no custom files by default" do
+      expect(Cornucopia::Util::Configuration.user_log_files).to be == {}
+    end
+
+    it "can add custom user log files" do
+      begin
+        num_lines   = rand(0..500)
+        some_config = Faker::Lorem.sentence
+
+        Cornucopia::Util::Configuration.add_log_file("test_log_file.log", { num_lines: num_lines, some_config: some_config })
+
+        expect(Cornucopia::Util::Configuration.user_log_files).to be == {
+                                                                      "test_log_file.log" => { num_lines: num_lines, some_config: some_config }
+                                                                  }
+      ensure
+        Cornucopia::Util::Configuration.remove_log_file("test_log_file.log")
+      end
+    end
+
+    it "can remove custom user log files" do
+      begin
+        num_lines   = rand(0..500)
+        some_config = Faker::Lorem.sentence
+
+        Cornucopia::Util::Configuration.add_log_file("test_log_file.log", { num_lines: num_lines, some_config: some_config })
+
+        expect(Cornucopia::Util::Configuration.user_log_files).to be == {
+                                                                      "test_log_file.log" => { num_lines: num_lines, some_config: some_config }
+                                                                  }
+
+        Cornucopia::Util::Configuration.remove_log_file("test_log_file.log")
+
+        expect(Cornucopia::Util::Configuration.user_log_files).to be == {}
+      ensure
+        Cornucopia::Util::Configuration.remove_log_file("test_log_file.log")
+      end
+    end
+
+    it "can change settings for custom user log files" do
+      begin
+        num_lines   = rand(0..500)
+        some_config = Faker::Lorem.sentence
+
+        Cornucopia::Util::Configuration.add_log_file("test_log_file.log", { num_lines: num_lines, some_config: some_config })
+
+        expect(Cornucopia::Util::Configuration.user_log_files).to be == {
+                                                                      "test_log_file.log" => { num_lines: num_lines, some_config: some_config }
+                                                                  }
+
+        num_lines = rand(501..1_000)
+
+        Cornucopia::Util::Configuration.add_log_file("test_log_file.log", { num_lines: num_lines })
+
+        expect(Cornucopia::Util::Configuration.user_log_files).to be == {
+                                                                      "test_log_file.log" => { num_lines: num_lines, some_config: some_config }
+                                                                  }
+      ensure
+        Cornucopia::Util::Configuration.remove_log_file("test_log_file.log")
+      end
+    end
+
+    describe "#num_lines" do
+      it "returns the default number of lines to fetch" do
+        expect(Cornucopia::Util::Configuration.num_lines).to be == 500
+      end
+
+      it "returns the default number of lines to fetch it it isn't set for a fake file" do
+        expect(Cornucopia::Util::Configuration.num_lines("fake_file.log")).to be == 500
+      end
+
+      it "returns the default number of lines to fetch it it isn't set for a file" do
+        begin
+          Cornucopia::Util::Configuration.add_log_file("test_log_file.log", { some_config: "nothing" })
+
+          expect(Cornucopia::Util::Configuration.num_lines("test_log_file.log")).to be == 500
+        ensure
+          Cornucopia::Util::Configuration.remove_log_file("test_log_file.log")
+        end
+      end
+
+      it "returns the number of lines for a specific file" do
+        begin
+          num_lines   = rand(0..500)
+          some_config = Faker::Lorem.sentence
+
+          Cornucopia::Util::Configuration.add_log_file("test_log_file.log", { num_lines: num_lines, some_config: some_config })
+
+          expect(Cornucopia::Util::Configuration.num_lines("test_log_file.log")).to be == num_lines
+        ensure
+          Cornucopia::Util::Configuration.remove_log_file("test_log_file.log")
+        end
+      end
+
+      it "can change the defualt number of lines" do
+        begin
+          new_default = rand(0..10_000_000)
+
+          Cornucopia::Util::Configuration.default_num_lines = new_default
+
+          expect(Cornucopia::Util::Configuration.num_lines).to be == new_default
+          expect(Cornucopia::Util::Configuration.num_lines("fake_file.log")).to be == new_default
+        ensure
+          Cornucopia::Util::Configuration.default_num_lines = 500
+        end
+      end
+    end
+  end
+
+  describe "configured_reports" do
+    [:rspec, :cucumber, :spinach, :capybara_page_diagnostics].each do |report_type|
+      it "has a #{report_type} report" do
+        expect(Cornucopia::Util::Configuration.report_configuration(report_type)).to be
+      end
+    end
+  end
+
+  describe "#print_timeout_min" do
+    it "#can read the default" do
+      expect(Cornucopia::Util::Configuration.print_timeout_min).to be == 10
+    end
+
+    it "#can set the value" do
+      begin
+        rand_value                                        = rand(20..100)
+        Cornucopia::Util::Configuration.print_timeout_min = rand_value
+
+        expect(Cornucopia::Util::Configuration.print_timeout_min).to be == rand_value
+      ensure
+        Cornucopia::Util::Configuration.print_timeout_min = 10
+      end
+    end
+  end
+
+  describe "#selenium_cache_retry_count" do
+    it "#can read the default" do
+      expect(Cornucopia::Util::Configuration.selenium_cache_retry_count).to be == 5
+    end
+
+    it "#can set the value" do
+      begin
+        rand_value                                                 = rand(20..100)
+        Cornucopia::Util::Configuration.selenium_cache_retry_count = rand_value
+
+        expect(Cornucopia::Util::Configuration.selenium_cache_retry_count).to be == rand_value
+      ensure
+        Cornucopia::Util::Configuration.selenium_cache_retry_count = 5
+      end
+    end
+  end
+
+  describe "#analyze_find_exceptions" do
+    it "#can read the default" do
+      expect(Cornucopia::Util::Configuration.analyze_find_exceptions).to be_truthy
+    end
+
+    it "#can set the value" do
+      begin
+        Cornucopia::Util::Configuration.analyze_find_exceptions = false
+
+        expect(Cornucopia::Util::Configuration.analyze_find_exceptions).to be_falsy
+      ensure
+        Cornucopia::Util::Configuration.analyze_find_exceptions = true
+      end
+    end
+  end
+
+  describe "#retry_with_found" do
+    it "#can read the default" do
+      expect(Cornucopia::Util::Configuration.retry_with_found).to be_falsy
+    end
+
+    it "#can set the value" do
+      begin
+        Cornucopia::Util::Configuration.retry_with_found = true
+
+        expect(Cornucopia::Util::Configuration.retry_with_found).to be_truthy
+      ensure
+        Cornucopia::Util::Configuration.retry_with_found = false
+      end
+    end
+  end
+
+  describe "#auto_open_report_after_generation" do
+    after(:each) do
+      Cornucopia::Util::Configuration.class_variable_get(:@@configurations).open_report_settings = { default: false }
+    end
+
+    it "sets the default value if unspecified" do
+      Cornucopia::Util::Configuration.auto_open_report_after_generation(true)
+      expect(Cornucopia::Util::Configuration.class_variable_get(:@@configurations).open_report_settings)
+          .to eq({ default: true })
+    end
+
+    it "sets the value of a specific report" do
+      Cornucopia::Util::Configuration.auto_open_report_after_generation(true, "fred")
+      expect(Cornucopia::Util::Configuration.class_variable_get(:@@configurations).open_report_settings).
+          to eq({ default: false, "fred" => true })
+    end
+  end
+
+  describe "#open_report_after_generation" do
+  end
+
+  # describe "#alternate_retry" do
+  #   it "#can read the default" do
+  #     expect(Cornucopia::Util::Configuration.alternate_retry).to be_falsy
+  #   end
+  #
+  #   it "#can set the value" do
+  #     begin
+  #       Cornucopia::Util::Configuration.alternate_retry = true
+  #
+  #       expect(Cornucopia::Util::Configuration.alternate_retry).to be_truthy
+  #     ensure
+  #       Cornucopia::Util::Configuration.alternate_retry = false
+  #     end
+  #   end
+  # end
+end