page_object_wrapper 0.0.1 → 0.0.2

data/lib/page_object_wrapper/Distribution.rb

@@ -0,0 +1,43 @@
+class Distribution
+	attr_accessor :total_object_number
+	# distribution types
+	RANDOM=0 #(default)
+	SEQUENTAL=1
+	def initialize(dist_hash) # {status_name => status_probability (in percents)}
+		@distribution=dist_hash
+		@type=RANDOM
+		@sequental_increment=1
+		@sequental_index=@sequental_increment
+		# check for consistency
+		raise "Distribution init error > summ of percents must be 100" if @distribution.values.inject{|sum,x| sum + x }!=100
+ 	end
+
+	def type(type,total_object_number=nil)
+		raise "Unknown type: #{type}. Possible types are Distribution::RANDOM, Distribution::SEQUENTAL" if not (type==RANDOM or type==SEQUENTAL)
+		@type=type
+		if @type==SEQUENTAL
+			raise "SEQUENTAL type requires the total number of objects that will be generated (>0)" if (total_object_number==nil or total_object_number==0)
+			@sequental_increment=(100/total_object_number).floor
+			@sequental_index=@sequental_increment
+		end
+	end
+
+	def generate
+		r=(@type==RANDOM)? rand(100) : @sequental_index
+		@sequental_index=(@sequental_index<100)? @sequental_index+@sequental_increment : @sequental_increment
+		dist_ary=@distribution.values
+		dist_ary_normalized=[]
+		dist_ary_normalized << dist_ary.first
+		for i in 1..dist_ary.length-1
+			dist_ary_normalized[i]=dist_ary_normalized[i-1]+dist_ary[i]
+		end
+		ind=(dist_ary_normalized << r).sort!.index(r)
+		return @distribution.keys[ind]
+	end
+end
+
+#d=Distribution.new('new'=>10,'old'=>30,'very_old'=>60)
+#d.type(Distribution::SEQUENTAL,10)
+#10.times do
+#	puts d.generate
+#end

data/lib/page_object_wrapper/DynamicClass.rb

@@ -0,0 +1,31 @@
+# -*- encoding : utf-8 -*-
+require 'Exceptions'
+class DynamicClass
+
+	def metaclass
+		class << self
+			self
+		end
+	end
+
+	@@objects=[]
+	def initialize(xml_hash)
+		raise DynamicClassError.new('parameter is not a hash','new',xml_hash) if not xml_hash.is_a?(Hash)
+		xml_hash.each_pair {|attr, value|
+      metaclass.send :attr_accessor, attr
+      send "#{attr}=".to_sym, value
+    }
+		@@objects << self
+	end
+
+	def self.find(attr,value)
+		ind=@@objects.collect(&attr.to_sym).index(value)
+		@@objects[ind]
+	end
+	def self.each
+		@@objects.each{|object|
+			yield object
+		}
+	end
+end
+

data/lib/page_object_wrapper/Editable.rb

@@ -0,0 +1,13 @@
+class Editable
+	attr_accessor :watir_element, :label, :default, :required
+	def initialize(watir_element,label,default,required)
+		@watir_element = watir_element
+		@label=label.to_sym
+		@default=default
+		@required=required
+	end
+
+	def required?
+		required
+	end
+end

data/lib/page_object_wrapper/Exceptions.rb

@@ -0,0 +1,22 @@
+class PageError < StandardError 
+	attr_accessor :page_url, :page_name
+	def initialize(msg,page_name,page_url)
+		@page_url=page_url
+		@page_name=page_name
+		super "PROBLEM: #{(msg.nil?)? '??' : msg}, PAGE: #{page_name}, URL: #{page_url}"
+	end
+
+end
+
+class ParameterError < StandardError
+	attr_accessor :method, :params
+	def initialize(msg,method,*params)
+		@method=method
+		@params=params
+		super "PROBLEM: #{(msg.nil?)? '??' : msg}, METHOD: #{method}, PARAMS: #{params.join('; ').to_s}"
+	end
+end
+
+class TableError < ParameterError; end
+class FormError < ParameterError; end
+class DynamicClassError < ParameterError; end

data/lib/page_object_wrapper/Form.rb

@@ -0,0 +1,116 @@
+require 'Editable'
+require 'Exceptions'
+require 'Submitter'
+class Form < Watir::Form
+	def initialize(current_page,target_page,accessor,*args)
+		super(accessor,extract_selector(args).merge(:tag_name => "form"))
+		@elements=[]
+		@accessor=accessor
+		@current_page=current_page
+		@target_page=target_page
+		@submit_element = nil
+	end
+
+	def editable(type,how_find_hash,label=type,default='Field data',required=false)
+		watir_element = @accessor.send(type.to_sym,how_find_hash)
+		raise FormError.new('Element not found', 'editable', "TYPE=#{type.inspect}, HOW_FIND=#{how_find_hash.inspect}, PAGE=#{@current_page.class.name}") if not element.exists?
+		Form.send :define_method, label do
+			watir_element
+		end
+		@elements << Editable.new(watir_element,label,default,required)
+	end
+
+	def submitter(type,how_find_hash,how_click_method = :click,*click_params)
+		# find submitter
+		@submit_element = Submitter.new(how_click_method,click_params)
+		@submit_element.watir_element = @accessor.send(type.to_sym,how_find_hash)
+		raise FormError.new('Element not found', 'submitter', "TYPE=#{type.inspect}, HOW_FIND=#{how_find_hash.inspect}") if not @submit_element.watir_element.exists?
+	end
+
+	def submit(correct_submission_flag)
+		return_page = (correct_submission_flag==true)? @target_page : @current_page
+		if @submit_element.nil?
+			# submitter is not defined, applying regular form submission
+			super()
+			return return_page.new
+		else
+			# submitter defined, applying its submission method
+			begin
+				@submit_element.watir_element.send(@submit_element.how_click_method.to_sym,*@submit_element.click_params)
+			rescue Exception => e
+				puts "ORIGINAL ERROR: #{e.message}"
+				raise FormError.new('Submitter not clickable', "SUBMITTER: TYPE=#{@submit_element.type}, HOW_FIND=#{@submit_element.how_find_hash}", "CLICK_METHOD: #{@submit_element.how_click_mehtod}, CLICK_PARAMS: #{@submit_element.click_params}")
+			end
+			return return_page.new
+		end
+	end
+
+	def default(label)
+		find_input(label).default
+	end
+
+	def each
+		@elements.each{|e|
+			yield e
+		}
+	end
+
+	def each_required
+		@elements.select{|f| f.required}.each{|e|
+			yield e
+		}
+	end
+
+	def fill_only(data_hash)
+		if data_hash.nil?
+			raise FormError.new('Invalid parameter','fill_only',data_hash)
+		else
+			data_hash.each_key{|label|
+				f=find_input(label)
+				f.watir_element.set(data_hash[label])
+			}
+		end
+		self
+	end
+
+	def fill_all(except_hash=nil)
+		fill_elements(@elements,except_hash)
+		self
+	end
+
+	def fill_required(except_hash=nil)
+		fill_elements(@elements.select{|f| f.required},except_hash)
+		self
+	end
+
+
+private
+	def find_input(label)
+		label = label.to_sym
+		index=@elements.collect(&:label).index(label)
+		raise FormError.new('label not found','find_input',label) if index.nil?
+		@elements[index]
+	end
+	def fill_elements(elements,except_hash)
+		elements = @elements.clone
+		if not except_hash.nil?
+			if not except_hash.has_key?(:except)
+				raise FormError.new('Invalid parameter, must be :except=>"label or [label1,label2,...]"',"fill_elements",elements.inspect,except_hash.inspect)
+			else
+				if except_hash[:except].is_a?(String) or except_hash[:except].is_a?(Symbol)
+					elements.delete(find_input(except_hash[:except]))
+				elsif except_hash[:except].is_a?(Array)
+					except_hash[:except].each{|label|
+						elements.delete(find_input(label))
+					}
+				else
+					raise FormError.new('Invalid parameter',"fill_elements",elements.inspect,except_hash.inspect)
+				end
+			end
+		end
+		elements.each{|field|
+			field.watir_element.when_present.set(field.default)
+		}
+	end
+end
+

data/lib/page_object_wrapper/Pagination.rb

@@ -0,0 +1,59 @@
+require 'Exceptions'
+
+class Pagination
+
+	def initialize(page_object,pagination_div_args)
+		page_numbers=[]
+		link_pattern=''
+		@pagination_links=[]
+		@page_object=page_object
+		@accessor=@page_object.class.accessor
+		@base_url=@page_object.class.url
+		if @accessor.div(pagination_div_args).exists?
+			raise ArgumentError.new("Cant find ul list inside div #{pagination_div_args.inspect} on page #{@accessor.url}") if not @accessor.div(pagination_div_args).ul.exists?
+			raise ArgumentError.new("Pagination link not found inside div #{pagination_div_args.inspect} on page #{@accessor.url}") if @accessor.div(pagination_div_args).ul.links.to_a.empty?
+			@accessor.div(pagination_div_args).ul.links.each{|l| 
+				if l.text=~/\d/
+					page_numbers << l.text.to_i 
+					@link_pattern=l.href
+				end
+			}
+			page_numbers.collect(&:to_i).sort!
+			for i in page_numbers.first..page_numbers.last do
+				@pagination_links << @link_pattern.gsub(/=\d+/,"="+i.to_s)
+			end
+		else
+			# assuming that page has no pagination links
+			@pagination_links << @base_url
+			@link_pattern=@base_url
+		end
+	end
+
+	def number(n)
+		raise ArgumentError.new("Cant find pagination page number #{n} on Page #{@accessor.url}") if not @pagination_links.include?(@link_pattern.gsub(/=\d+/,"="+(n).to_s))
+		change_page(@pagination_links[n-1])
+	end
+
+	def first
+		change_page(@pagination_links.first)
+	end
+	def last
+		change_page(@pagination_links.last)
+	end
+	def reset
+		change_page(@base_url)
+	end
+	def each
+		@pagination_links.each{|link| 
+			p=change_page(link)
+			yield p
+		}
+	end
+		
+
+private
+	def change_page(link)
+		@page_object.class.url=link
+		@page_object.class.new(true)
+	end
+end

data/lib/page_object_wrapper/Submitter.rb

@@ -0,0 +1,8 @@
+class Submitter
+	attr_accessor :how_click_method, :click_params, :watir_element
+	def initialize(how_click_method=:click,click_params=nil)
+		@how_click_method=how_click_method
+		@click_params=click_params
+		@watir_element = nil
+	end
+end

data/lib/page_object_wrapper/Table.rb

@@ -0,0 +1,50 @@
+require 'Exceptions'
+
+class Table < Watir::Table
+	def initialize(accessor,*args)
+		super(accessor, extract_selector(args).merge(:tag_name => "table"))
+		@cells=[]
+		self.rows.each{|row|
+			row.cells.each{|cell|
+				@cells << cell
+			}
+		}
+	end
+
+	def has_cell?(text)
+		@cells.collect(&:text).include?(text)
+	end
+	def cells
+		@cells
+	end
+	def select(column_name,where_hash)
+		######## TABLE ##############
+		# HEADER r0,c0 r0,c1,...,r0cN
+		# ROW    r1,c0,r1,c1,...,r1cN
+		return_column,find_by_column_name,find_by_column_value=nil
+		begin
+			return_column=Regexp.new(column_name)
+			find_by_column_name=Regexp.new(where_hash[:where].keys.first)
+			find_by_column_value=where_hash[:where].values.first
+		rescue
+			raise TableError.new('invalid parameters, check column names and parameters (must be Table#select(column_name_regexp,:where=>{column_name_regexp=>value_or_:any}))','select',column_name,where_hash) if not find_attrs_valid?(column_name,where_hash)
+		end
+		index=0
+		return_index=nil
+		find_by_index=nil
+		self.rows[0].cells.each{|header_cell|
+			return_index=index if return_column===header_cell.text
+			find_by_index=index if find_by_column_name===header_cell.text
+			index+=1
+		}
+		raise TableError.new("column not found",'select',column_name) if return_index.nil?
+		raise TableError.new("column not found",'select',where_hash) if find_by_index.nil?
+		return self.rows[1].cells[return_index] if find_by_column_value==:any
+		found=nil
+		self.rows.each{|row|
+			found=row.cells[return_index] if row.cells[find_by_index].text==find_by_column_value
+		}
+		raise TableError.new("value #{find_by_column_value} not found in column #{find_by_column_name}",'select',column_name,where_hash) if found.nil?
+		found
+	end
+end

data/lib/page_object_wrapper/version.rb

@@ -1,3 +1,3 @@
 module PageObjectWrapper
-  VERSION = "0.0.1"
+  VERSION = "0.0.2"
 end

data/page_object_wrapper.gemspec

@@ -12,10 +12,11 @@ Gem::Specification.new do |gem|
   gem.summary       = %q{Wraps watir-webdriver with convenient testing interface.}
   gem.homepage      = "https://github.com/evgeniy-khatko/page_object_wrapper"
 	gem.add_dependency "watir-webdriver"
+	gem.add_development_dependency "rspec", ">= 2.0.0"
  
 
   gem.files         = `git ls-files`.split($/)
   gem.executables   = gem.files.grep(%r{^bin/}).map{ |f| File.basename(f) }
   gem.test_files    = gem.files.grep(%r{^(test|spec|features)/})
-  gem.require_paths = ["lib"]
+  gem.require_paths = ["lib","lib/page_object_wrapper"]
 end

data/spec/example_spec.rb

@@ -0,0 +1,42 @@
+require 'spec_helper'
+
+describe "Overall usage" do
+  describe "Test Google for long search query" do
+    let(:precondition){"Open google.com page"}
+    let(:step1){"Enter long search query into the search field"}
+    let(:step2){"Press search button"}
+    let(:expected_result){"The requested URL /... is too large to process"}
+
+    describe "Defining two page objects: GoogleSearchPage, GoogleErrorPage and performing test" do
+      let(:pages_definition){
+        class GoogleSearchPage < PageObjectWrapper::Page
+          attr_accessor :find_form
+          @url="/"
+          expected_element :text_field, :name => 'q' 
+          def initialize visit=false 
+            super visit
+            @find_form = form(GoogleErrorPage, {:action => '/search'}) 
+            @find_form.editable(:text_field, {:name => 'q'}, :seach_what, '@find_form default value', true) 
+          end
+        end
+        
+        class GoogleErrorPage < PageObjectWrapper::Page
+          @url="really does not matter, because navigating to this page done through search query submission"
+          #expected_element :ins, {:text => "That\’s an error."}
+        end
+        {:gsearch_page_class => GoogleSearchPage, :gerror_page => GoogleErrorPage}
+      }
+
+      it "performing test" do
+        puts precondition
+        google_page = pages_definition[:gsearch_page_class].new(true)
+        puts step1
+        long_query = 'q '*1000
+        google_page.find_form.fill_only(:seach_what => long_query)
+        puts step2
+        google_error_page = google_page.find_form.submit(true)
+        google_error_page.should have_text(expected_result)
+      end
+    end
+  end
+end

data/spec/form_spec.rb

@@ -0,0 +1,176 @@
+# -*- encoding : utf-8 -*-
+require 'spec_helper'
+
+describe "Form wrapper" do
+  describe "form definition", :code => 6..30 do
+    let(:page_objects){
+      class GoogleAdvancedSearchPage < PageObjectWrapper::Page
+        attr_accessor :as_form
+        @url="/advanced_search"
+        expected_element :text_field, :name => 'as_q'
+        def initialize visit=false
+          super visit
+          @as_form = form(GoogleResultsPage, {:name => 'f'})
+          @as_form.editable(:text_field, {:name => 'as_q'}, :with_words, 'with_words default value', true)
+          @as_form.editable(:text_field, {:name => 'as_epq'}, :with_phrase, 'with_phrase default value', true)
+          @as_form.editable(:text_field, {:name => 'as_oq'}, :with_any_word, 'with_any_word default value', false)
+          @as_form.submitter(:input, {:type => 'submit'})
+        end
+      end
+      class GoogleResultsPage < PageObjectWrapper::Page
+        @url="/"
+        expected_element :button, :name => 'btnG'
+        def initialize visit=false 
+          super visit
+          @find_form = form(GoogleResultsPage, {:action => '/search'}) 
+          @find_form.editable(:text_field, {:name => 'q'}, :seach_what, '@find_form default value', true) 
+        end
+      end
+      {:gresults_page_class => GoogleResultsPage, :gadv_page_class => GoogleAdvancedSearchPage}
+    }
+
+
+    it "is defined as #form(TargetPage, how_find_hash)", :code => [13,25] do
+      page_objects[:gadv_page_class].new(true).as_form.class.should eq(Form)
+    end
+
+    it "has #editable(:field_type, how_find_hash, :label, default_value, required?) method to set form's fields
+      :field_type sets corresponding watir element type
+      how_find_hash is used to locate corresponding watir element on the page
+      :label is used to reffer to the form field after definition
+      default_value is used to populate fields with default test data
+      required = true | false and indicates if the field is required
+    ", :code =>  14..16 do
+      gadv_page = page_objects[:gadv_page_class].new(true)
+      gadv_page.as_form.with_words.tag_name.should eq('input')
+      gadv_page.as_form.with_words.name.should eq('as_q')
+      gadv_page.as_form.with_words.should be_a(Watir::TextField)
+    end
+
+    it "has #submitter(:field_type, how_find_hash, how_click_mehtod, click_params) method to set form's submitter
+      :field_type sets corresponding watir element type
+      how_find_hash is used to locate corresponding watir element on the page
+      how_click_mehtod is used to tell Waitr the method which should be applied to click the submitter
+      click_params set parameters for the how_click_mehtod
+    ", :code => 17 do
+    end
+  end
+  describe "form usage", :code => 59..84 do
+    let(:page_objects){
+      class GoogleAdvancedSearchPage < PageObjectWrapper::Page
+        attr_accessor :as_form
+        @url="/advanced_search"
+        expected_element :text_field, :name => 'as_q'
+        def initialize visit=false
+          super visit
+          @as_form = form(GoogleSearchPage, {:name => 'f'})
+          @as_form.editable(:text_field, {:name => 'as_q'}, :with_words, 'with_words default value', true)
+          @as_form.editable(:text_field, {:name => 'as_epq'}, :with_phrase, 'with_phrase default value', true)
+          @as_form.editable(:text_field, {:name => 'as_oq'}, :with_any_word, 'with_any_word default value', false)
+          @as_form.submitter(:input, {:type => 'submit'})
+        end
+      end
+      class GoogleSearchPage < PageObjectWrapper::Page
+        attr_accessor :find_form
+        @url="/"
+        expected_element :text_field, :name => 'q' # tells Watir that we expect this element which identifies the page in a uniq way
+        def initialize visit=false 
+          super visit
+          @find_form = form(GoogleSearchPage, {:action => '/search'}) 
+          @find_form.editable(:text_field, {:name => 'q'}, :search_what, '@find_form default value', true)                                   
+        end
+      end
+      {:gsearch_page_class => GoogleSearchPage, :gadv_page_class => GoogleAdvancedSearchPage}
+    }
+    
+    it "has #submit(flag) method which submits form
+      if flag = true than TargetPage instance is returned
+      if flag = false than CurrentPage instance is returned
+      if submitter is defined, than it's used to submit the form, otherwise standart Watir::Form submit is used
+    ", :code => 91..95 do
+      gadv_page = page_objects[:gadv_page_class].new(true)
+      gsearch_page = gadv_page.as_form.submit(true)
+      gsearch_page.should be_a(GoogleSearchPage)
+      gsearch_page_reloaded = gsearch_page.find_form.submit(false)
+      gsearch_page_reloaded.should be_a(GoogleSearchPage)
+    end
+
+    it "field's watir elements can be accessed by labels", :code => 99..100 do
+      gsearch_page = page_objects[:gsearch_page_class].new(true)
+      gsearch_page.find_form.search_what.should be_a(Watir::TextField)
+    end
+
+    it "fields default values set during form definition can be retrieved with #default(:label) method", :code => 104..105 do
+      gsearch_page = page_objects[:gsearch_page_class].new(true)
+      gsearch_page.find_form.default(:search_what).should eq('@find_form default value')
+    end
+
+    it "has #each method which allows navigating between form fields", :code => 110..112 do
+      gadv_page = page_objects[:gadv_page_class].new(true)
+      gadv_page.as_form.each{|form_field|
+        form_field.should be_a(Editable)
+        form_field.watir_element.should be_a(Watir::TextField)
+      }
+    end
+    
+    it "has #each_required method which allows navigating between form required fields", :code => 118..122 do
+      gadv_page = page_objects[:gadv_page_class].new(true)
+      gadv_page.as_form.each_required{|form_field|
+        form_field.should be_a(Editable)
+        form_field.watir_element.should be_a(Watir::TextField)
+        form_field.should be_required
+      }
+    end
+
+    it "has #fill_only(:label => value) method which populated form's :label field with \'value\'
+      method returns form object
+    ", :code => 129..130 do
+      gadv_page = page_objects[:gadv_page_class].new(true)
+      form = gadv_page.as_form.fill_only(:with_words => 'some value')
+      gadv_page.as_form.with_words.value.should eq('some value')
+      form.should be_a(Form)
+    end
+
+    it "has #fill_all(:except => labels_array | label) method which populated all form's fields with default values
+      if except_hash is not nil than provided fields are not populated
+      method returns form object
+    ", :code => 139..142 do
+      gadv_page = page_objects[:gadv_page_class].new(true)
+      form = gadv_page.as_form.fill_all
+      gadv_page.as_form.each{|field|
+        field.watir_element.value.should eq(gadv_page.as_form.default(field.label))
+      }
+      gadv_page = page_objects[:gadv_page_class].new(true)
+      gadv_page.as_form.fill_all(:except => :with_words)
+      gadv_page.as_form.each{|field|
+        if field.label==:with_words
+          field.watir_element.value.should eq ''
+        else
+          field.watir_element.value.should eq(gadv_page.as_form.default(field.label))
+        end
+      }
+      form.should be_a(Form)
+    end
+
+    it "has #fill_required(:except => labels_array | label) method which populated all required form's fields with default values
+      if except_hash is not nil than provided fields are not populated
+      method returns form object
+    ", :code =>  165..172 do
+      gadv_page = page_objects[:gadv_page_class].new(true)
+      form = gadv_page.as_form.fill_required
+      gadv_page.as_form.each_required{|field|
+        field.watir_element.value.should eq(gadv_page.as_form.default(field.label))
+      }
+      gadv_page = page_objects[:gadv_page_class].new(true)
+      gadv_page.as_form.fill_required(:except => :with_words)
+      gadv_page.as_form.each_required{|field|
+        if field.label==:with_words
+          field.watir_element.value.should eq ''
+        else
+          field.watir_element.value.should eq(gadv_page.as_form.default(field.label))
+        end
+      }
+      form.should be_a(Form)
+    end
+  end
+end