kameleon 0.0.9 → 0.2.0.alpha.2

data/lib/kameleon/dsl/act.rb

@@ -1,107 +0,0 @@
-module Kameleon
-  module Dsl
-    module Act
-      include Kameleon::Utils
-
-      def click(*links)
-        links.each do |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(locators)
-        fill(locators) if can_fill?(locators)
-      end
-
-      private
-
-      def fill(locators)
-        locators.each_pair do |value, selector|
-          case value
-            when :check, :choose, :uncheck
-              one_or_all(selector).each do |locator|
-                session.send(value, locator)
-              end
-            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
-              one_or_all(selector).each do |locator|
-                session.fill_in(locator, :with => value)
-              end
-          end
-        end
-      end
-
-      def can_fill?(locators)
-        locators.values.each do |loc|
-          selectors = loc.respond_to?(:values) ? loc.values : loc
-          one_or_all(selectors).each do |selector|
-            return false if unmodifiable?(selector)
-          end
-        end
-      end
-
-      def unmodifiable?(locator)
-        field = session.find_field(locator)
-        case session.driver
-          when Capybara::Selenium::Driver
-            # In driver field attributes - disabled and readonly may be:
-            # 1) string - false or true
-            # 2) nil value
-            return eval(field[:disabled].to_s) || eval(field[:readonly].to_s)
-          when Capybara::RackTest::Driver
-            # In rack field attributes - disabled and readonly may be:
-            # 1) nil value
-            # 2) string - disabled or readonly
-            return field[:disabled] || field[:readonly]
-        end
-      end
-
-      def get_full_test_asset_path(file_path)
-        if File.file?(file_path)
-          file_path
-        elsif File.file?(Helpers.default_path_for_file(file_path))
-          Helpers.default_path_for_file(file_path)
-        else
-          raise "Sorry but we didn't found that file in: #{file_path}, neither #{Helpers.default_path_for_file(file_path)}"
-        end
-      end
-    end
-  end
-end

data/lib/kameleon/dsl/see.rb

@@ -1,155 +0,0 @@
-module Kameleon
-  module Dsl
-    module See
-      def see(*content)
-        options = extract_options(content)
-
-        case options.class.name
-          when 'String'
-            session.should rspec_world.have_content(options)
-          when 'Array'
-            options.each do |content_part|
-              see(content_part)
-            end
-          when 'Hash'
-            options.each_pair do |value, locator|
-              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
-                        case session.driver
-                          when Capybara::Selenium::Driver
-                            session.find_field(selector)[value].should == 'true'
-                          when Capybara::RackTest::Driver
-                            session.find_field(selector)[value].should ==(value.to_s)
-                        end
-                      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
-                      #! we should extend this beyond simply text match (allow to pass full xpath)
-                      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
-            end
-          else
-            raise "Not Implemented Structure #{options} :: #{options.class}"
-        end
-      end
-
-      def not_see(*content)
-        options = extract_options(content)
-
-        case options.class.name
-          when 'String'
-            session.should_not rspec_world.have_content(options)
-          when 'Array'
-            options.each do |content_part|
-              session.should_not rspec_world.have_content(content_part)
-            end
-          when 'Hash'
-            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
-                    case session.driver
-                      when Capybara::Selenium::Driver
-                        session.find_field(selector)[value].should == 'false'
-                      when Capybara::RackTest::Driver
-                        session.find_field(selector)[value].should rspec_world.be_nil
-                    end
-                  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}"
-        end
-      end
-    end
-  end
-end

data/lib/kameleon/session/capybara.rb

@@ -1,33 +0,0 @@
-module Kameleon
-  module Session
-    module Capybara
-      attr_accessor :driver_name
-
-      def set_session
-        @session = ::SessionPool.session(current_driver)
-      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 current_session
-        ::Capybara.current_session
-      end
-
-      def current_driver
-        driver_name ||
-            ::Capybara.current_driver
-      end
-   end
-  end
-end

data/lib/kameleon/session/server.rb

@@ -1,21 +0,0 @@
-require 'singleton'
-module Kameleon
-  module Session
-    class Server
-      include ::Singleton
-      class << self
-        def server(app)
-          @server ||= start_new_server(app)
-        end
-
-        private
-
-        def start_new_server(app)
-          rack_server = ::Capybara::Server.new(app)
-          rack_server.boot
-          rack_server
-        end
-      end
-    end
-  end
-end

data/lib/kameleon/session/session_pool.rb

@@ -1,45 +0,0 @@
-require 'singleton'
-class SessionPool
-  include Singleton
-  class << self
-    attr_writer :nice
-    def session(driver)
-      take_idle(driver) || create(driver)
-    end
-
-    def release_all
-      idle.concat(busy)
-      busy.clear
-    end
-
-    protected
-
-    def idle
-      @idle ||= []
-    end
-
-    def busy
-      @busy ||= []
-    end
-
-    def take_idle(driver)
-      if session = find_idle(driver)
-        session.reset!
-        session.tap do |s|
-          idle.delete(s)
-          busy.push(s)
-        end
-      end
-    end
-
-    def find_idle(driver)
-      idle.detect { |session| session.mode == driver }
-    end
-
-    def create(driver)
-      ::Capybara::Session.new(driver, ::Capybara.app).tap do |session|
-        busy.push(session)
-      end
-    end
-  end
-end

data/lib/kameleon/user/abstract.rb

@@ -1,142 +0,0 @@
-module Kameleon
-  module User
-    class Abstract
-      attr_accessor :options
-      attr_accessor :rspec_world
-
-      include Kameleon::Session::Capybara
-      include Kameleon::Dsl::See
-      include Kameleon::Dsl::Act
-
-      def initialize(rspec_world, options={})
-        @rspec_world = rspec_world
-        @driver_name = options.delete(:driver)
-        @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
-                        elsif args.last == :select_multiple
-                          case driver
-                            when Capybara::Selenium::Driver
-                              raise "So far Unsupported in this driver"
-                            when Capybara::RackTest::Driver
-                              node = find(*args)
-                              native = Nokogiri::HTML.parse(html).xpath(args[1])
-                              base = Capybara::RackTest::Node.new(driver, native)
-                              ::Capybara::Node::Element.new(self,
-                                                            base,
-                                                            node.parent,
-                                                            node.instance_variable_get(:@selector))
-                          end
-                        else
-                          find(*args)
-                        end
-            begin
-              scopes.push(*new_scope)
-              yield
-            ensure
-              scopes.pop
-            end
-          end
-        end
-        yield if block_given?
-        after_initialization
-      end
-
-      def visit(page)
-        session.visit(page)
-      end
-
-      def will(&block)
-        default_selector ?
-            within(*default_selector, &block) :
-            instance_eval(&block)
-      end
-
-      def within(*selector, &block)
-        session.within(*get_selector(selector)) do
-          instance_eval(&block)
-        end
-      end
-
-      def page_areas
-        {}
-      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
-        else
-          opts
-        end
-      end
-
-      def after_initialization
-        # stub, should be implemented in subclass
-      end
-
-      def get_selector(selector)
-        if (selector.is_a?(Array) && selector.size == 1)
-          selector = selector.first
-        end
-        case selector
-          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
-
-      def one_or_all(elements)
-        elements.is_a?(Array) ? elements : [elements]
-      end
-
-    end
-  end
-end