kameleon 0.0.5 → 0.0.6

data/lib/kameleon/dsl/act.rb

@@ -4,41 +4,92 @@ module Kameleon
 
       def click(*links)
         links.each do |link|
-          session.click_on(link)
+          case link.class.name
+            when 'String'
+              session.click_on(link)
+            when 'Hash'
+              link.each_pair do |what, locator|
+                case what
+                  when :image
+                    session.find(:xpath, "//img[@alt=\"#{locator}\"").click
+                  when :and_accept
+                    if session.driver.is_a?(Capybara::Selenium::Driver)
+                      #! js hack - problem with selenium native alerts usage
+                      #! it switch to allert but no reaction on accept or dismiss
+                      session.evaluate_script("window.alert = function(msg) { return true; }")
+                      session.evaluate_script("window.confirm = function(msg) { return true; }")
+                    end
+                    click(locator)
+                  # session.driver.browser.switch_to.alert.accept if session.driver.is_a?(Capybara::Selenium::Driver)
+                  when :and_dismiss
+                    if session.driver.is_a?(Capybara::Selenium::Driver)
+                      session.evaluate_script("window.alert = function(msg) { return true; }")
+                      session.evaluate_script("window.confirm = function(msg) { return false; }")
+                    end
+                    click(locator)
+                  # session.driver.browser.switch_to.alert.dismiss if session.driver.is_a?(Capybara::Selenium::Driver)
+                  else
+                    raise("User do not know how to click #{what} - you need to teach him how")
+                end
+              end
+          end
         end
       end
 
-      def fill_in(fields)
-        fields.each_pair do |value, selector|
+      def fill_in(locators)
+        fill(locators) if can_fill?(locators)
+      end
+
+      private
+
+      def fill(locators)
+        locators.each_pair do |value, selector|
           case value
-            when :check
+            when :check, :choose, :uncheck
               one_or_all(selector).each do |locator|
-                session.check locator
+                session.send(value, locator)
               end
-            when :uncheck
-              one_or_all(selector).each do |locator|
-                session.uncheck locator
+            when :select, :unselect
+              selector.each_pair do |select_value, select_locator|
+                one_or_all(select_locator).each do |locator|
+                  session.send(value, select_value, :from => locator)
+                end
+              end
+            when :attach
+              selector.each_pair do |file_path, locator|
+                session.attach_file(locator, get_full_test_asset_path(file_path))
               end
             else
-              session.fill_in selector, :with => value
+              one_or_all(selector).each do |locator|
+                session.fill_in(locator, :with => value)
+              end
           end
         end
       end
 
-#      def click(link_text, options={:within => DEFAULT_AREA})
-#  yield if block_given?
-#  rspec_world.within(options[:within]) do
-#    begin
-#      rspec_world.click_on(self_or_translation_for(link_text))
-#    rescue Capybara::ElementNotFound => e
-#      attr_value, attr_type = within_value_and_type(options[:within])
-#      xpath = attr_type ? "//*[@#{attr_type}='#{attr_value}']//*[*='%s']/*" : "//*[#{attr_type}]//*[*='%s']/*"
-#      rspec_world.find(:xpath, xpath % self_or_translation_for(link_text)).click
-#    end
-#  end
-#end
+      def can_fill?(locators)
+        locators.values.each do |loc|
+          locators = loc.respond_to?(:values) ? loc.values : loc
+          one_or_all(locators).each do |locator|
+            return false if unmodifiable?(locator)
+          end
+        end
+      end
 
+      def get_full_test_asset_path(file_path)
+        if File.file?(file_path)
+          file_path
+        elsif File.file?(default_files_path.join(file_path))
+          default_files_path.join(file_path)
+        else
+          raise "Sorry but we didn't found that file in: #{file_path}, neither #{default_files_path.join(file_path)}"
+        end
+      end
 
+      def unmodifiable?(locator)
+        field = session.find_field(locator)
+        field[:readonly] || field[:disabled]
+      end
     end
   end
-end
+end

data/lib/kameleon/dsl/see.rb

@@ -9,28 +9,67 @@ module Kameleon
             session.should rspec_world.have_content(options)
           when 'Array'
             options.each do |content_part|
-              session.should rspec_world.have_content(content_part)
+              see(content_part)
             end
           when 'Hash'
             options.each_pair do |value, locator|
-              case value
-                when :empty
-                  one_or_all(locator).each do |selector|
-                    session.should rspec_world.have_field(selector)
-                    session.find_field(selector).value.should == ""
-                  end
-                when :checked, :selected
-                  one_or_all(locator).each do |selector|
-                    session.should rspec_world.have_checked_field(selector)
-                  end
-                when :unchecked, :unselected
-                  one_or_all(locator).each do |selector|
-                    session.should rspec_world.have_unchecked_field(selector)
-                  end
-                when :link, :links
-                  locator.each_pair do |link_text, url|
-                    session.should rspec_world.have_link(link_text, :href => url)
+              case value.class.name
+                when 'Symbol'
+                  case value
+                    when :button, :buttons
+                      one_or_all(locator).each do |selector|
+                        session.should rspec_world.have_button(selector)
+                      end
+                    when :checked, :unchecked
+                      one_or_all(locator).each do |selector|
+                        session.should rspec_world.send("have_#{value.to_s}_field", selector)
+                      end
+                    when :disabled, :readonly
+                      one_or_all(locator).each do |selector|
+                        see :field => selector
+                        session.find_field(selector)[value].should ==(value.to_s)
+                      end
+                    when :empty
+                      one_or_all(locator).each do |selector|
+                        see :field => selector
+                        session.find_field(selector).value.to_s.should == ''
+                      end
+                    when :error_message_for, :error_messages_for
+                      one_or_all(locator).each do |selector|
+                        session.find(:xpath, '//div[@id="error_explanation"]').should rspec_world.have_content(selector.capitalize)
+                      end
+                    when :field, :fields
+                      one_or_all(locator).each do |selector|
+                        session.should rspec_world.have_field(selector)
+                      end
+                    when :image, :images
+                      one_or_all(locator).each do |selector|
+                        session.should rspec_world.have_xpath("//img[@alt=\"#{selector}\"] | //img[@src=\"#{selector}\"]")
+                      end
+                    when :selected
+                      locator.each_pair do |selected_value, selected_locator|
+                        session.should rspec_world.have_select(selected_locator, :selected => selected_value)
+                      end
+                    when :unselected
+                      locator.each_pair do |selected_value, selected_locator|
+                        session.should rspec_world.have_no_select(selected_locator, :selected => selected_value)
+                      end
+                    when :link, :links
+                      if locator.respond_to?(:each_pair)
+                        locator.each_pair do |link_text, url|
+                          session.should rspec_world.have_link(link_text, :href => url)
+                        end
+                      else
+                        one_or_all(locator).each { |text| session.should rspec_world.have_link(text) }
+                      end
+                    when :ordered
+                      nodes = session.all(:xpath, locator.collect { |n| "//node()[text()= \"#{n}\"]" }.join(' | '))
+                      nodes.map(&:text).should == locator
+                    else
+                      raise("User can not see #{value} - you need to teach him how")
                   end
+                when 'Fixnum'
+                  session.should ::Capybara::RSpecMatchers::HaveMatcher.new(*get_selector(locator), :count => value)
                 else
                   session.should rspec_world.have_field(locator, :with => value)
               end
@@ -51,8 +90,50 @@ module Kameleon
               session.should_not rspec_world.have_content(content_part)
             end
           when 'Hash'
-            options.each_pair do |value, locator|
-              session.should_not rspec_world.have_field(locator, :with => value)
+            options.each_pair do |value, locators|
+              case value
+                when :button, :buttons
+                  one_or_all(locators).each do |selector|
+                    session.should_not rspec_world.have_button(selector)
+                  end
+                when :error_message_for, :error_messages_for
+                  one_or_all(locators).each do |selector|
+                    session.find(:xpath, '//div[@id="error_explanation"]').should_not rspec_world.have_content(selector.capitalize)
+                  end
+                when :image, :images
+                  one_or_all(locators).each do |selector|
+                    session.should_not rspec_world.have_xpath("//img[@alt=\"#{selector}\"] | //img[@src=\"#{selector}\"]")
+                  end
+                when :field, :fields
+                  one_or_all(locators).each do |locator|
+                    session.should_not rspec_world.have_field(locator)
+                  end
+                when :link, :links
+                  if locators.respond_to?(:each_pair)
+                    locators.each_pair do |link_text, url|
+                      session.should_not rspec_world.have_link(link_text, :href => url)
+                    end
+                  else
+                    one_or_all(locators).each { |text| session.should_not rspec_world.have_link(text) }
+                  end
+                when :ordered
+                  nodes = session.all(:xpath, locators.collect { |n| "//node()[text()= \"#{n}\"]" }.join(' | '))
+                  nodes.map(&:text).should_not == locators
+                when :readonly
+                  one_or_all(locators).each do |selector|
+                    see :field => selector
+                    session.find_field(selector)[value].should rspec_world.be_nil
+                  end
+                when :empty
+                  one_or_all(locators).each do |locator|
+                    see :field => locator
+                    session.find_field(locator).value.to_s.should_not == ''
+                  end
+                else
+                  one_or_all(locators).each do |locator|
+                    session.should_not rspec_world.have_field(locator, :with => value)
+                  end
+              end
             end
           else
             raise "Not Implemented Structure #{options} :: #{options.class}"

data/lib/kameleon/session/capybara.rb

@@ -10,6 +10,17 @@ module Kameleon
             current_session
       end
 
+      def refresh_page
+        case session.driver.class.name
+          when 'Capybara::Selenium::Driver', 'Capybara::RackTest::Driver'
+            visit session.driver.browser.current_url
+          when 'Capybara::Culerity::Driver'
+            session.driver.browser.refresh
+          else
+            raise 'unsupported driver'
+        end
+      end
+
       private
 
       def find_or_create_session

data/lib/kameleon/user/abstract.rb

@@ -3,7 +3,6 @@ module Kameleon
     class Abstract
       attr_accessor :options
       attr_accessor :rspec_world
-      attr_accessor :session
 
       include Kameleon::Session::Capybara
       include Kameleon::Dsl::See
@@ -15,6 +14,31 @@ module Kameleon
         @session_name = options.delete(:session_name)
         @options = options
         set_session
+        session.instance_eval do
+          def within(*args)
+            new_scope = if args.size == 1 && Capybara::Node::Base === args.first
+                          args.first
+                        else
+                          if args.last == :select_multiple
+                            node = find(*args)
+                            native = Nokogiri::HTML.parse(all(*args[0..-2]).map(&:native).map(&:to_s).join)
+                            base = Capybara::RackTest::Node.new(driver, native)
+                            ::Capybara::Node::Element.new(self,
+                                                          base,
+                                                          node.parent,
+                                                          node.instance_variable_get(:@selector))
+                          else
+                            find(*args)
+                          end
+                        end
+            begin
+              scopes.push(new_scope)
+              yield
+            ensure
+              scopes.pop
+            end
+          end
+        end
         yield if block_given?
         after_initialization
       end
@@ -25,12 +49,12 @@ module Kameleon
 
       def will(&block)
         default_selector ?
-            within(default_selector, &block) :
+            within(*default_selector, &block) :
             instance_eval(&block)
       end
 
-      def within(selector, &block)
-        session.within(get_selector(selector)) do
+      def within(*selector, &block)
+        session.within(*get_selector(selector)) do
           instance_eval(&block)
         end
       end
@@ -39,12 +63,29 @@ module Kameleon
         {}
       end
 
+      def debug
+        session
+      end
+
+      #! it should be package into raw module
+      def page_element(selector)
+        session.find(*get_selector(selector))
+      end
+
+      def page_elements(selector)
+        session.all(*get_selector(selector))
+      end
+
       private
 
       def load_homepage?
         !options[:skip_page_autoload]
       end
 
+      def session
+        @session
+      end
+
       def extract_options(opts)
         if opts.size == 1
           opts.first
@@ -58,16 +99,47 @@ module Kameleon
       end
 
       def get_selector(selector)
-        selector.is_a?(Symbol) ? page_areas[selector] : selector
+        if (selector.is_a?(Array) && selector.size == 1)
+          selector = selector.first
+        end
+        case selector.class.name
+          when 'Hash'
+            selector.each_pair do |key, value|
+              case key
+                when :row
+                  return [:xpath, "//tr[*='#{value}'][1]"]
+                when :column
+                  position =
+                      session.all(:xpath, "//table//th").index { |n| n.text =~ /#{value}/ }
+                  return [:xpath, "//table//th[#{position + 1}] | //table//td[#{position + 1}]", :select_multiple]
+                else
+                  raise "not supported selectors"
+              end
+            end
+          when 'Symbol'
+            page_areas[selector].is_a?(Array) ?
+                page_areas[selector] :
+                [Capybara.default_selector, page_areas[selector]]
+          when 'Array'
+            selector
+          else
+            [Capybara.default_selector, selector]
+        end
       end
 
       def default_selector
         page_areas[:main]
       end
 
+      #! rails dependency
+      def default_files_path
+        ::Rails.root.join('spec')
+      end
+
       def one_or_all(elements)
         elements.is_a?(Array) ? elements : [elements]
       end
+
     end
   end
-end
+end

data/spec/sample_rack_app/hey.rb

@@ -1,10 +1,17 @@
 class Hey
-
-  def initialize(body)
-    @body = body
+  def initialize(filename = 'default')
+    @body = get_body(filename)
   end
 
   def call(env)
     [200, {"Content-Type" => "text/plain"}, [@body]]
   end
-end
+
+  private
+
+  def get_body(filename)
+    File.open(File.dirname(__FILE__) + "/../dummy/#{filename}").read
+  rescue
+    filename
+  end
+end

data/spec/spec_helper.rb

@@ -1,4 +1,16 @@
 require 'kameleon'
 require 'capybara/dsl'
+require 'capybara/rspec/matchers'
+
+Dir["#{File.expand_path("../", __FILE__)}/support/**/*.rb"].each { |f| require f }
 
 require 'sample_rack_app/hey'
+
+RSpec.configure do |config|
+  config.before(:all) do
+    DeferredGarbageCollection.start
+  end
+  config.after(:all) do
+    DeferredGarbageCollection.reconsider
+  end
+end

data/spec/support/deferred_garbage_collection.rb

@@ -0,0 +1,20 @@
+# https://makandracards.com/makandra/950-speed-up-rspec-by-deferring-garbage-collection
+class DeferredGarbageCollection
+
+  DEFERRED_GC_THRESHOLD = (ENV['DEFER_GC'] || 10.0).to_f
+
+  @@last_gc_run = Time.now
+
+  def self.start
+    GC.disable if DEFERRED_GC_THRESHOLD > 0
+  end
+
+  def self.reconsider
+    if DEFERRED_GC_THRESHOLD > 0 && Time.now - @@last_gc_run >= DEFERRED_GC_THRESHOLD
+      GC.enable
+      GC.start
+      GC.disable
+      @@last_gc_run = Time.now
+    end
+  end
+end