page_object_wrapper 0.0.6 → 1.0.0

data/Rakefile

@@ -1 +0,0 @@
-require "bundler/gem_tasks"

data/lib/page_object_wrapper/Distribution.rb

@@ -1,43 +0,0 @@
-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

@@ -1,31 +0,0 @@
-# -*- 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

@@ -1,13 +0,0 @@
-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/Form.rb

@@ -1,116 +0,0 @@
-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('Error clicking submitter', "SUBMITTER: WATIR_ELEMENT=#{@submit_element.watir_element}, 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.select{|e| e.respond_to?(:set)}.each{|field|
-			field.watir_element.when_present.set(field.default)
-		}
-	end
-end
-

data/lib/page_object_wrapper/Submitter.rb

@@ -1,8 +0,0 @@
-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/page_object_wrapper.gemspec

@@ -1,22 +0,0 @@
-# -*- encoding: utf-8 -*-
-lib = File.expand_path('../lib', __FILE__)
-$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
-require 'page_object_wrapper/version'
-
-Gem::Specification.new do |gem|
-  gem.name          = "page_object_wrapper"
-  gem.version       = PageObjectWrapper::VERSION
-  gem.authors       = ["Evgeniy Khatko"]
-  gem.email         = ["evgeniy.khatko@gmail.com"]
-  gem.description   = %q{Wraps watir-webdriver with convenient testing interface, based on PageObjects automation testing pattern. Simplifies resulting automated test understanding.}
-  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","lib/page_object_wrapper"]
-end

data/spec/example_spec.rb

@@ -1,42 +0,0 @@
-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

@@ -1,176 +0,0 @@
-# -*- 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