kameleon 0.0.9 → 0.2.0.alpha.2

data/lib/kameleon/dsl/context/scope.rb

@@ -0,0 +1,95 @@
+module Kameleon
+  module DSL
+    module Context
+      class Scope
+
+        attr_accessor :params
+
+        def initialize(params)
+          @params = params
+        end
+
+        def selector
+          detect_selector(params)
+        end
+
+        private
+
+        def detect_selector(param)
+          case param
+            when Hash
+              #! add warning when there is more then one element in hash
+              Kameleon::DSL::Context::SpecialSelectors.send(*param.first)
+            when Symbol
+              normalize(defined_areas[param])
+            when String
+              normalize(param)
+            when Array
+              param.size == 1 ?
+                  detect_selector(param.first) :
+                  normalize(param)
+            when nil
+              normalize(default_selector)
+            else
+              raise "type <#{param.class.name}> not implemented"
+          end
+        end
+
+        def normalize(params)
+          case params
+            when String
+              [::Capybara.default_selector, params]
+            when Array
+              if params.empty?
+                normalize(default_selector)
+              elsif params.size == 1
+                [::Capybara.default_selector] + params
+              else
+                params
+              end
+          end
+        end
+
+        def default_selector
+          defined_areas[:default] || [:xpath, "//body"]
+        end
+
+        def defined_areas
+          ::Kameleon::Session.defined_areas
+        end
+      end
+
+      #! extending selectors in capybara way https://github.com/jnicklas/capybara/blob/master/lib/capybara.rb#L76
+      module SpecialSelectors
+        def self.row(param)
+          case param
+            when String
+              [:xpath, "//tr[*='#{param}'][1]"]
+            when Fixnum
+              [:xpath, "//tbody/tr[#{param}]"]
+            else
+              raise "not implemented"
+          end
+        end
+
+        def self.row_and_column(param)
+          value_in_row, value_in_column = *param
+          if value_in_row.is_a?(Fixnum) and value_in_column.is_a?(Fixnum)
+            [:xpath, "//tbody/tr[#{value_in_row}]/td[#{value_in_column}]"]
+          else
+            #! on page there might be more then one table
+            position = Capybara.current_session.all(:xpath, "//table//th").index { |n| n.text =~ /#{value_in_column}/ }
+            [:xpath, "//tr[*='#{value_in_row}'][1]/td[#{position+1}]"]
+          end
+        end
+
+        def self.column(param)
+          raise "not implemented"
+          #            position = session.all(:xpath, "//table//th").index { |n| n.text =~ /#{value}/ }
+          #            return [:xpath, ".//table//th[#{position + 1}] | .//table//td[#{position + 1}]", :select_multiple]
+        end
+      end
+    end
+  end
+end
+

data/lib/kameleon/dsl/utils/debug.rb

@@ -0,0 +1,10 @@
+#! 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
+
+#! js execution

data/lib/kameleon/dsl/verify/absence.rb

@@ -0,0 +1,151 @@
+module Kameleon
+  module DSL
+    module Verify
+      class Absence
+
+        attr_accessor :conditions, :params
+
+        def initialize(*params)
+          @params = params
+          @conditions = []
+
+          parse_conditions
+        end
+
+        private
+
+        def parse_conditions
+          prepare_conditions(params)
+        end
+
+        def prepare_conditions(param)
+          case param
+            when String
+              conditions << Condition.new(:have_no_content, param)
+            when Hash
+              param.each_pair do |type, values|
+                case type
+                  when :link, :links
+                    conditions.concat Link.new(values).conditions
+                  when :image, :images
+                    conditions.concat Image.new(values).conditions
+                  when :field, :fields
+                    conditions.concat Field.new(values).conditions
+                  else
+                    raise "not implemented"
+                end
+              end
+            when Array
+              params.each { |parameter| prepare_conditions(parameter) }
+            else
+              raise "not implemented"
+          end
+        end
+
+        class Condition
+          attr_accessor :method, :params, :block
+
+          def initialize(method, *params, &block)
+            @method = method
+            @params = params
+            @block = block
+          end
+        end
+
+        #! below class need some love - refactoring
+
+        class Link
+          attr_reader :conditions
+
+          def initialize(params)
+            @conditions = []
+            parse_params(params)
+          end
+
+          private
+
+          def parse_params(params)
+            case params
+              when Hash
+                params.each_pair do |text, url|
+                  conditions << Condition.new(:have_no_link, text, :href => url)
+                end
+              when String
+                conditions << Condition.new(:have_no_link, params)
+              when Array
+                params.each { |param| parse_params(param) }
+              else
+                raise 'not implemented'
+            end
+          end
+        end
+
+        class Image
+          attr_reader :conditions
+
+          def initialize(params)
+            @conditions = []
+            parse_params(params)
+          end
+
+          private
+
+          def parse_params(params)
+            case params
+            when String
+              conditions << Condition.new(:have_no_xpath, prepare_xpath(params))
+              when Array
+                params.each { |param| parse_params(param) }
+              else
+                raise 'not implemented'
+            end
+          end
+
+          def prepare_xpath(alt_or_src)
+            "//img[@alt=\"#{alt_or_src}\"] | //img[@src=\"#{alt_or_src}\"]"
+          end
+        end
+
+        class Field
+          attr_reader :conditions
+
+          def initialize(params)
+            @conditions = []
+            parse_params(params)
+          end
+
+          private
+
+          def parse_params(params)
+            case params
+              when Hash
+                params.each_pair do |text, url|
+                  conditions << Condition.new(:have_no_field, text, :href => url)
+                end
+              when String
+                conditions << Condition.new(:have_no_field, params)
+              when Array
+                params.each { |param| parse_params(param) }
+              else
+                raise 'not implemented'
+            end
+          end
+        end
+
+        class Condition
+          attr_accessor :method, :params, :block
+
+          def initialize(method, *params, &block)
+            @method = method
+            @params = params
+            @block = block
+          end
+        end
+
+
+      end
+    end
+  end
+end
+
+#! not_see :button, :buttons ->  have_no_button(selector)

data/lib/kameleon/dsl/verify/presence.rb

@@ -0,0 +1,327 @@
+module Kameleon
+  module DSL
+    module Verify
+      class Presence
+
+        attr_accessor :conditions, :params
+
+        def initialize(*params)
+          @params = params
+          @conditions = []
+
+          parse_conditions
+        end
+
+        private
+
+        def parse_conditions
+          prepare_conditions(params)
+        end
+
+        def prepare_conditions(param)
+          case param
+            when String
+              conditions << Condition.new(:have_content, param)
+            when Hash
+              param.each_pair do |type, values|
+                case type
+                  when :link, :links
+                    conditions.concat Link.new(values).conditions
+                  when :image, :images
+                    conditions.concat Image.new(values).conditions
+                  when :ordered
+                    conditions.concat Sequence.new(values).conditions
+                  when Fixnum
+                    conditions.concat Quantity.new(type, values).conditions
+                  when String
+                    if type == ""
+                      prepare_conditions(:empty => values)
+                    else
+                      conditions.concat TextInput.new(type, values).conditions
+                    end
+                  when :checked, :unchecked, :check, :uncheck
+                    conditions.concat CheckBoxInput.new(type, values).conditions
+                  when :selected, :unselected, :select, :unselect
+                    conditions.concat SelectInput.new(type, values).conditions
+                  when :field, :fields
+                    conditions.concat TextInput.new(nil, values).conditions
+                  when :empty
+                    conditions.concat EmptyInput.new(values).conditions
+                  else
+                    raise "not implemented"
+                end
+              end
+            when Array
+              params.each { |parameter| prepare_conditions(parameter) }
+            else
+              raise "not implemented"
+          end
+        end
+      end
+
+      class Condition
+        attr_accessor :method, :params, :block
+
+        def initialize(method, *params, &block)
+          @method = method
+          @params = params
+          @block = block
+        end
+      end
+
+      #! below class  require some deep refactoring
+
+      class Link
+        attr_reader :conditions
+
+        def initialize(params)
+          @conditions = []
+          parse_params(params)
+        end
+
+        private
+
+        def parse_params(params)
+          case params
+            when Hash
+              params.each_pair do |text, url|
+                conditions << Condition.new(:have_link, text, :href => url)
+              end
+            when String
+              conditions << Condition.new(:have_link, params)
+            when Array
+              params.each { |param| parse_params(param) }
+            else
+              raise 'not implemented'
+          end
+        end
+      end
+
+      class Image
+        attr_reader :conditions
+
+        def initialize(params)
+          @conditions = []
+          parse_params(params)
+        end
+
+        private
+
+        def parse_params(params)
+          case params
+            when String
+              conditions << Condition.new(:have_xpath, prepare_xpath(params))
+            when Array
+              params.each { |param| parse_params(param) }
+            else
+              raise 'not implemented'
+          end
+        end
+
+        def prepare_xpath(alt_or_src)
+          "//img[@alt=\"#{alt_or_src}\"] | //img[@src=\"#{alt_or_src}\"]"
+        end
+      end
+
+      class Quantity
+        attr_reader :conditions
+        attr_reader :quantity
+
+        def initialize(quantity, params)
+          @conditions = []
+          @quantity = quantity
+          parse_params(params)
+        end
+
+        private
+
+        def parse_params(params)
+          if params === Array && params.first == Array
+            params.each { |param| parse_params(param) }
+          else
+            #! refactor
+            selector = prepare_query(params).selector
+            conditions << Condition.new(prepare_method(selector), selector.last, :count => quantity)
+          end
+        end
+
+        def prepare_query(selector)
+          Context::Scope.new(selector)
+        end
+
+        #! refactor - delagate to Context::Scope class
+        def prepare_method(query)
+          query.first == :xpath ?
+              :have_xpath :
+              :have_css
+        end
+      end
+
+      class Sequence
+        attr_reader :params
+
+        def initialize(params)
+          @params = params
+        end
+
+
+        def conditions
+          [condition]
+        end
+
+        private
+
+        def condition
+          Condition.new(nil, params, prepare_xpath) do |elements, xpath_query|
+            texts = page.all(:xpath, xpath_query).map(&:text)
+            texts.should == elements
+          end
+        end
+
+        def prepare_xpath
+          params.collect { |n| "//node()[text()= \"#{n}\"]" }.join(' | ')
+        end
+      end
+
+      class TextInput
+        attr_reader :conditions, :value
+
+        def initialize(value, *params)
+          @value = value
+          @conditions = []
+          parse_params(params)
+        end
+
+        private
+
+        def parse_params(params)
+          case params
+            when String
+              conditions << Condition.new(:have_field, params, :with => value)
+            when Array
+              params.each { |param| parse_params(param) }
+            else
+              raise "not supported"
+          end
+        end
+      end
+
+
+      class EmptyInput
+        attr_reader :conditions
+
+        def initialize(*params)
+          @conditions = []
+          parse_params(params)
+        end
+
+        private
+
+        def parse_params(params)
+          case params
+            when String
+              conditions << condition(params)
+            when Array
+              params.each { |param| parse_params(param) }
+            else
+              raise "not supported"
+          end
+        end
+
+        def condition(params)
+          Condition.new(nil, params) do |element|
+            page.should have_field(element)
+            find_field(element).value.should satisfy do |value|
+              value == nil or value == ""
+            end
+          end
+        end
+      end
+
+      class CheckBoxInput
+        attr_reader :conditions, :value
+
+        def initialize(value, *params)
+          @value = value
+          @conditions = []
+          parse_params(params)
+        end
+
+        private
+
+        def parse_params(params)
+          case params
+            when String
+              conditions << Condition.new(matcher_method, params)
+            when Array
+              params.each { |param| parse_params(param) }
+            else
+              raise "not supported"
+          end
+        end
+
+        def matcher_method
+          case value
+            when :checked, :check
+              :have_checked_field
+            when :unchecked, :uncheck
+              :have_unchecked_field
+            else
+              raise "not supported"
+          end
+        end
+      end
+
+      class SelectInput
+        attr_reader :conditions, :value
+
+        def initialize(value, *params)
+          @value = value
+          @conditions = []
+          parse_params(params)
+        end
+
+        private
+
+        def parse_params(params)
+          case params
+            when Hash
+              params.each_pair do |selected_value, identifier|
+                case identifier
+                  when Array
+                    selected_value.each do |value|
+                      parse_params(value => identifier)
+                    end
+                  when String
+                    conditions << Condition.new(matcher_method, identifier, :selected => selected_value)
+                  else
+                    raise "not supported"
+                end
+              end
+            when Array
+              params.each { |param| parse_params(param) }
+            else
+              raise "not supported"
+          end
+        end
+
+
+        def matcher_method
+          case value
+            when :selected, :select
+              :have_select
+            when :unselected, :unselect
+              :have_no_select
+            else
+              raise "not supported"
+          end
+        end
+      end
+
+    end
+
+  end
+end
+
+#! see :button, :buttons -> have_button(selector)
+#! see field that is :disabled, :readonly