flights_gui_henry_tests_ds 0.0.16

data/features/support/lib/helpers/render.rb

@@ -0,0 +1,135 @@
+# -*- encoding : utf-8 -*-
+#validaciones js and css de shop flights
+def get_render(url,type)
+  begin
+    get = HTTParty.get("#{url}#{type}")
+  rescue
+    true.should be_true
+  end  
+  return get
+end
+def validate_render(url,type)
+  data = get_render(url,type)
+  if data.code == 200
+    respond = Hpricot.parse(data.body)
+    respond.inner_text.should_not match("FreeMarker template error!")
+  else
+    true.should be_true
+  end  
+end
+def escala_to_i(escala)  
+  return 0 if escala.to_s =~ /(solo vuelo directo)|(Sin escalas)|(Sem escalas)|(Soamente v.o directo)|(Vuelo Directo)/i
+  return escala.to_s.gsub(/\D/,'').to_i
+end
+def validar_fechas(ticket,search)
+  if search.type.downcase !~ /multiple/
+    (ticket.ida.fecha == search.date_from).should be_true
+    if search.type.downcase =~ /roundtrip/
+      (ticket.vuelta.fecha == search.date_to).should be_true
+    end  
+  else
+    (search.dates.split(',').include?(ticket.ida.fecha.to_s)).should be_true
+    (search.dates.split(',').include?(ticket.vuelta.fecha.to_s)).should be_true
+  end  
+end
+#redefinicion del metodo que valida las ciudades en cada cluster
+#se agrega la validacion del nombre de las ciudades origen/destino
+def validar_destinos(ticket,search,html)
+  if search.type !~ /multipledestinations/
+    ((!search.from_city.airports.include?(ticket.ida.origen_iata))and(!search.to_city.airports.include?(ticket.ida.destino_iata))).should_not be_true
+    if search.type == 'roundtrip'  
+      ((!search.to_city.airports.include?(ticket.vuelta.origen_iata))and(!search.from_city.airports.include?(ticket.vuelta.destino_iata))).should_not be_true
+    end
+  else
+    i = 0
+    (html/"div.sub-cluster.multiple").each do |tramo|
+      #(tramo/"li.city-departure").inner_text.gsub(/,/,'').strip.downcase.no_accents.downcase.should match("#{@search.from_cities[i].name}")
+      i += 1 
+    end
+  end
+end
+#validar que el boton de seleccionar sea correcto
+def validar_button(doc)
+  ((doc/"a[@class='buy btn-buy flights-button']/span").empty? or !(doc/"a[@class='buy btn-buy flights-button']/span").inner_text.strip.downcase.match(/seleccionar|selecionar/)).should_not be_true
+end
+def other_page(page)
+  if BROWSER.li(:class => "page", :index => page).present? or BROWSER.li(:class,'next enabled').present?
+    if BROWSER.li(:class,'next enabled').present?
+      BROWSER.li(:class,'next enabled').click
+    else
+      BROWSER.li(:class => "page", :index => page).click
+    end  
+    wait_action()
+    return nil
+  else
+    BROWSER.li(:class => "page", :index => 0).click if BROWSER.li(:class => "page", :index => 0).present?
+    wait_action()
+    return true
+  end
+end
+def wait_action()
+  Watir::Wait.until(timeout = 120){(!BROWSER.div(:class => "results-update").present?)}
+end
+#validar que se muestren correctamente los precios si la sesion expiro
+def validate_prices_session_expired(ticket)
+  !ticket.tarifas['adicional'].nil?
+end
+#validar que se muestren correctamente los precios si la sesion no expiro
+def validate_prices_without_session_expired(ticket)
+  ticket.tarifas['adicional'].nil?
+end
+#validaciones del popup de mas detalles
+def mostrar_mas_detalles_nr(search)
+  #TODO que cargue el pop up
+  if search.type !~ /multipledestinations/
+    BROWSER.div(:class=>'cluster',:index=>0).div(:class,"sub-cluster outbound").li(:class=>'stops',:index=> 0).links[0].click
+    Watir::Wait.until(timeout = 120){BROWSER.div(:id,'popup-detail').present?}
+    if BROWSER.div(:id,'popup-detail').present?
+      link_reglas_y_restricciones_nr(BROWSER.div(:id,'popup-detail'))
+      html_ida = BROWSER.div(:id,'popup-detail').html
+      BROWSER.div(:id,'popup-detail').span(:class,'popup-close-button popup-close').click
+      if search.type =~ /ida y vuelta/
+        BROWSER.div(:class=>'cluster',:index=>0).div(:class,"sub-cluster inbound").li(:class=>'stops',:index=> 0).links[0].click
+        Watir::Wait.until(timeout = 120){BROWSER.div(:id,'popup-detail').present?}
+        if BROWSER.div(:id,'popup-detail').present?
+          link_reglas_y_restricciones_nr(BROWSER.div(:id,'popup-detail'))
+          validar_mas_detalle_nr(html_ida,BROWSER.div(:id,'popup-detail').html)
+          BROWSER.div(:id,'popup-detail').span(:class,'popup-close-button popup-close').click
+        end
+      end
+    end 
+  else
+    BROWSER.div(:class=>'cluster',:index=>0).li(:class=>'stops',:index=> 0).links[0].click
+    Watir::Wait.until(timeout = 120){BROWSER.div(:id,'popup-detail').present?}
+    if BROWSER.div(:id,'popup-detail').present?
+      link_reglas_y_restricciones_nr(BROWSER.div(:id,'popup-detail'))
+      validar_mas_detalle_nr(BROWSER.html)
+      BROWSER.div(:id,'popup-detail').span(:class,'popup-close-button popup-close').click
+    end
+  end
+end
+def link_reglas_y_restricciones_nr(elemento)
+  elemento.link(:class,'show-rules').click
+  sleep(1)
+  elemento.div(:class,'rules').should visible
+end
+def validar_mas_detalle_nr(html_ida,html_vuelta = nil)
+  ida = Hpricot.parse(html_ida)
+  vuelta = Hpricot.parse(html_vuelta) if html_vuelta
+  (ida/"div.segment li.itinerary span.date").select{|li| li.inner_text.empty?}.should is_empty
+  (ida/"div.rules/div.text").inner_text.empty?.should_not be_true
+  if html_vuelta
+    (vuelta/"div.segment li.itinerary span.date").select{|li| li.inner_text.empty?}.should is_empty
+    (vuelta/"div.rules/div.text").inner_text.empty?.should_not be_true
+  end
+  begin
+    ((ida/"span.location").first.inner_text.match(/(.+)\((...)\)/)[2] == search.from_city.code).should be_true
+    ((ida/"span.location").last.inner_text.match(/(.+)\((...)\)/)[2] == search.to_city.code).should be_true
+    if html_vuelta
+      ((vuelta/"span.location").first.inner_text.match(/(.+)\((...)\)/)[2] == search.to_city.code).should be_true
+      ((vuelta/"span.location").last.inner_text.match(/(.+)\((...)\)/)[2] == search.from_city.code).should be_true
+    end
+  rescue
+    true.should be_true
+  end
+end

data/features/support/lib/price.rb

@@ -0,0 +1,66 @@
+# -*- encoding : utf-8 -*-
+#clase que representa un precio, con su moneda y valor correspondiente
+#se le pasa una string que contiene al precio(moneda y valor juntos)
+class Price 
+  
+  include Comparable
+
+  attr_accessor :value, :currency
+
+  def initialize(precio, costos=nil, item=nil)
+    @currency = (precio.empty?) ? '$' : (precio.gsub(/\-|\.|\d/,'').upstrip == 'BSF' ? "Bs.F." : precio.gsub(/\-|\.|\d| /,'').upstrip )
+    @value = (precio.empty?) ?  0  :  precio.match(/([^\s]+)\s+([^\s]+)/i)[2].strip.gsub(/\./,'').to_i
+  end
+  
+  def moneda
+    self.currency
+  end
+  
+  def valor
+    self.value
+  end
+
+  def set_valor(value)
+    @value = value
+  end
+  
+  #metodo que pregunta si el precio es en dolares
+  def dolar?
+    self.currency =~ /(U\$S)|(U\$D)|(USD)|(US\$)|(\$US)/
+  end
+  
+  #metodos de comparacion 
+  def <=>(other)
+    ( (self.dolar? and other.dolar?) or self.same_moneda?(other) ) ? ( self.value <=> other.value ) : ( self.to_dolar.value <=> other.to_dolar.value)
+  end
+  
+  #informa si la diferencia es mayor a un rango determinado
+  def diff(other,range)
+    ( (self.dolar? and other.dolar?) or self.same_moneda?(other) ) ? ( self.value <=> other.value ) : ( self.to_dolar.value <=> other.to_dolar.value )
+  end
+  
+  #devuelve un string del precio 
+  def to_s
+    "#{self.currency}#{self.value}"
+  end
+  
+  def +(other)
+    ( self.same_moneda?(other) )? ( Precio.new("#{self.currency} #{self.value + other.value}",true) ) : ( Precio.new("U$S #{self.to_dolar.value + other.to_dolar.value}",true) )
+  end
+  def -(other)
+    ( self.same_moneda?(other) )? ( Precio.new("#{self.currency} #{self.value - other.value}","change") ) : ( Precio.new("U$S #{self.to_dolar.value - other.to_dolar.value}","change") )
+  end
+  
+  def same_moneda?(other)
+    self.currency == other.currency or ver_moneda_en_base(other.currency) or (MainData.site =~ /ECUADOR/)
+  end
+  
+  def zero?
+    self.value == 0
+  end
+  
+  def empty?
+    self.zero?
+  end 
+  
+end

data/features/support/lib/process_manager.rb

@@ -0,0 +1,104 @@
+#encoding: utf-8
+
+class ProcessManager
+
+  #Crea un árbol de procesos, donde el PID recibido es el nodo raíz
+  def self.process_tree(pid)
+  	tree = process_info(pid)
+  	tree[:childs] = []
+  	process_childs(pid).each do |child_pid|
+  		tree[:childs].push(self.process_tree(child_pid))
+  	end
+  	tree
+  end
+
+  #Recibe un PID y devuelve un array con los PID de sus hijos 
+  def self.process_childs(pid)
+  	`ps -fea | grep #{pid} | grep -v grep | awk '$2!=#{pid} && $8!~/awk/ && $3==#{pid}{print $2}'`.split("\n")
+  end
+
+  #Devuelve un array con la información de los hijos
+  def self.process_childs_info(pid)
+  	process_childs(pid).collect do |child_pid|
+  		process_info(child_pid)
+  	end
+  end
+
+  #Devuelve un hash con la información del proceso
+  def self.process_info(pid)
+  	{ 
+  		:user => process_user(pid),
+  	  :pid => pid,
+  	  :parent => process_parent(pid),
+  	  :status => process_status(pid),
+  	  :cmd => process_cmd(pid)
+  	}
+  end
+
+  #Devuelve el usuario del proceso
+  def self.process_user(pid)
+  	`ps -fea | grep #{pid} | awk '$2==#{pid}{print $1}'`.split("\n")[0]
+	end
+
+  #Devuelve el padre del proceso
+  def self.process_parent(pid)
+  	`ps -fea | grep #{pid} | awk '$2==#{pid}{print $3}'`.split("\n")[0]
+	end
+
+  #Devuelve el estado del proceso
+  def self.process_status(pid)
+  	`ps aux | grep #{pid} | awk '$2==#{pid}{print $8}'`.split("\n")[0]
+	end
+
+  #Devuelve el comando del proceso
+	def self.process_cmd(pid)
+		`ps -fea | grep #{pid} | awk '$2==#{pid}{print $8}'`.split("\n")[0]
+	end
+
+  #Mata al proceso que recibe, si existe
+	def self.kill_process(pid)
+    begin
+      Process.kill('INT', pid)
+      #Proceso matado
+      true
+    rescue Errno::EPERM
+      #Permiso insuficiente para matar al proceso
+      begin 
+        `kill -9 #{pid.to_i}` 
+        true
+      rescue
+        false
+      end
+    rescue Errno::ESRCH
+      #El proceso no existía
+      true
+    end
+	end
+
+  #Recibe un árbol de procesos y los mata a todos, incluyendo al nodo principal
+  def self.kill_tree(tree)
+    tree[:childs].each do |child|
+      kill_tree(child)
+    end
+    kill_process(tree[:pid].to_i) 
+  end
+
+  #Recibe un PID y mata todo el árbol de procesos a partir de él, sin matar al nodo principal
+  def self.kill_all_childs(pid)
+    tree = process_tree(pid)
+    tree[:childs].each do |child|
+      kill_tree(child)
+    end
+  end
+
+  #Se asegura que no queden procesos chrome zombies
+  def self.chrome_zombies_collector
+    zombies_parent = `ps -fea | grep defunct | grep chrome | grep -v grep | grep -v chromedriver | awk '{print $3}'`.split("\n")
+    zombies_parent.each do |parent|
+      parent_info = process_info(parent)
+      ##Parent == 1, si se volvió huerfano
+      kill_process(parent.to_i) if parent_info[:parent] == '1' and parent_info[:cmd] and parent_info[:cmd].match(/chrome/)
+    end
+  end
+
+end

data/features/support/lib/services.rb

@@ -0,0 +1,4 @@
+# -*- encoding : utf-8 -*-
+require_relative 'services/results'
+require_relative 'services/landing'
+require_relative 'services/fenix'

data/features/support/lib/services/fenix.rb

@@ -0,0 +1,14 @@
+# -*- encoding : utf-8 -*-
+module Services
+  class Fenix 
+    def self.start_test(id,body={},headers={})
+      respond = HTTParty.post("http://fenix-tools.despegar.it/fenix-tools/start-tests/#{id}",:body=>body,:headers=>headers)
+      puts respond
+      return respond
+    end
+    def self.test_status(id)
+      respond = JSON.parse(HTTParty.get "http://fenix-tools.despegar.it/fenix-tools/tests-status/#{id}")
+      return respond
+    end
+  end  
+end 

data/features/support/lib/services/landing.rb

@@ -0,0 +1,18 @@
+# -*- encoding : utf-8 -*-
+module Services
+
+  class Landing
+
+    attr_accessor :json
+
+    def initialize(html)
+      @json = JSON.parse(get_json(html))
+    end  
+
+    def get_json(html)
+      script=(html/"script").select{|script| script.inner_text.match('jsonData')}.first
+      return script.inner_text.match(/^\"jsonData\" \: (.*),$/)[1]
+    end
+
+  end  
+end 

data/features/support/lib/services/results.rb

@@ -0,0 +1,62 @@
+# -*- encoding : utf-8 -*-
+require 'digest/md5'
+module Services
+
+  class Results
+
+    attr_accessor :json, :json_no_referer
+
+    def initialize(browser,type)
+      @json = eval "get_json_#{type}(browser)"
+      @json_no_referer = eval "get_json_#{type}_no_referer(browser)"
+    end  
+
+    def get_json_roundtrip(url,type="TOTALFARE")
+      begin
+        HTTParty.get(url.gsub(/results/,"data/search") + "/#{type}/ASCENDING/NA/NA/NA/NA/NA?hashForData=#{digest_md5(url)}",:headers => {"referer" => url})
+      rescue Errno::ECONNRESET,Timeout::Error
+        HTTParty.get(url.gsub(/results/,"data/search") + "/#{type}/ASCENDING/NA/NA/NA/NA/NA?hashForData=#{digest_md5(url)}",:headers => {"referer" => url})
+      end
+    end
+    def get_json_oneway(url,type="TOTALFARE")
+      begin
+        HTTParty.get(url.gsub(/results/,"data/search") + "/#{type}/ASCENDING/NA/NA/NA/NA?hashForData=#{digest_md5(url)}",:headers => {"referer" => url})
+      rescue Errno::ECONNRESET,Timeout::Error
+        HTTParty.get(url.gsub(/results/,"data/search") + "/#{type}/ASCENDING/NA/NA/NA/NA?hashForData=#{digest_md5(url)}",:headers => {"referer" => url})
+      end
+    end
+    def get_json_multipledestinations(url,type="TOTALFARE")
+      begin
+        HTTParty.get(url.gsub(/results/,"data/search") + "/#{type}/ASCENDING?hashForData=#{digest_md5(url)}",:headers => {"referer" => url})
+      rescue Errno::ECONNRESET,Timeout::Error
+        HTTParty.get(url.gsub(/results/,"data/search") + "/#{type}/ASCENDING?hashForData=#{digest_md5(url)}",:headers => {"referer" => url})
+      end
+    end
+    def get_json_roundtrip_no_referer(url,type="TOTALFARE")
+      begin
+        HTTParty.get(url.gsub(/results/,"data/search") + "/#{type}/ASCENDING/NA/NA/NA/NA/NA")
+      rescue Errno::ECONNRESET,Timeout::Error
+        HTTParty.get(url.gsub(/results/,"data/search") + "/#{type}/ASCENDING/NA/NA/NA/NA/NA")
+      end
+    end
+    def get_json_oneway_no_referer(url,type="TOTALFARE")
+      begin
+        HTTParty.get(url.gsub(/results/,"data/search") + "/#{type}/ASCENDING/NA/NA/NA/NA")
+      rescue Errno::ECONNRESET,Timeout::Error
+        HTTParty.get(url.gsub(/results/,"data/search") + "/#{type}/ASCENDING/NA/NA/NA/NA")
+      end
+    end
+    def get_json_multipledestinations_no_referer(url,type="TOTALFARE")
+      begin
+        HTTParty.get(url.gsub(/results/,"data/search") + "/#{type}/ASCENDING")
+      rescue Errno::ECONNRESET,Timeout::Error
+        HTTParty.get(url.gsub(/results/,"data/search") + "/#{type}/ASCENDING")
+      end
+    end
+
+    def digest_md5(url)
+      return Digest::MD5.hexdigest(url+"despegar")
+    end  
+  
+  end  
+end  

data/features/support/matchers.rb

@@ -0,0 +1,120 @@
+# -*- encoding : utf-8 -*-
+RSpec::Matchers.define :is_greater_than do |min|
+  match do |actual|
+    actual.to_i > min
+  end
+  failure_message_for_should do |actual|
+    "se esperaba que el valor #{actual} sea mayor a #{min}"
+  end
+  failure_message_for_should_not do |actual|
+    "se esperaba que el valor #{actual} no sea mayor a #{min}"
+  end
+end
+
+RSpec::Matchers.define :is_greater_equal_than do |min|
+  match do |actual|
+    actual.to_i >= min
+  end
+  failure_message_for_should do |actual|
+    "se esperaba que el valor #{actual} sea mayor o igual a #{min}"
+  end
+  failure_message_for_should_not do |actual|
+    "se esperaba que el valor #{actual} no sea mayor o igual a #{min}"
+  end
+end
+
+RSpec::Matchers.define :visible do
+  match do |actual|
+    actual.present?
+  end
+  failure_message_for_should do |actual|
+    "se esperaba que el elemento #{actual} sea visible"
+  end
+  failure_message_for_should_not do |actual|
+    "se esperaba que el elemento #{actual} no sea visible"
+  end
+end
+
+RSpec::Matchers.define :enabled do
+  match do |actual|
+    actual.enabled?
+  end
+  failure_message_for_should do |actual|
+    "se esperaba que el elemento #{actual} estuviera habilitado"
+  end
+  failure_message_for_should_not do |actual|
+    "se esperaba que el elemento #{actual} estuviera deshabilitado"
+  end
+end
+
+RSpec::Matchers.define :visible do |text|
+  match do |actual|
+    actual.present?
+  end
+  failure_message_for_should do |actual|
+    "se esperaba que el elemento #{text} sea visible"
+  end
+  failure_message_for_should_not do |actual|
+    "se esperaba que el elemento #{text} no sea visible"
+  end
+end
+
+RSpec::Matchers.define :match do |text_for_match|
+  match do |actual|
+    actual.match(/#{text_for_match}/)
+  end
+  failure_message_for_should do |actual|
+    "se esperaba que el texto #{actual} contenga a #{text_for_match}"
+  end
+  failure_message_for_should_not do |actual|
+    "se esperaba que el texto #{actual} no contenga a #{text_for_match}"
+  end
+end
+
+RSpec::Matchers.define :match_sensitive do |text_for_match|
+  match do |actual|
+    actual.match(/#{text_for_match}/i)
+  end
+  failure_message_for_should do |actual|
+    "se esperaba que el texto #{actual} contenga a #{text_for_match}"
+  end
+  failure_message_for_should_not do |actual|
+    "se esperaba que el texto #{actual} no contenga a #{text_for_match}"
+  end
+end
+
+RSpec::Matchers.define :equal do |text|
+  match do |actual|
+    actual == text
+  end
+  failure_message_for_should do |actual|
+    "se esperaba que el texto #{actual} sea igual a #{text}"
+  end
+  failure_message_for_should_not do |actual|
+    "se esperaba que el texto #{actual} no sea igual a #{text}"
+  end
+end
+
+RSpec::Matchers.define :include? do |text|
+  match do |actual|
+    actual.include?(text)
+  end
+  failure_message_for_should do |actual|
+    "se esperaba que la coleccion [#{actual.join('-')}] contenga a #{text}"
+  end
+  failure_message_for_should_not do |actual|
+    "se esperaba que la coleccion [#{actual.join('-')}] no contenga a #{text}"
+  end
+end
+
+RSpec::Matchers.define :is_empty do
+  match do |actual|
+    actual.empty?
+  end
+  failure_message_for_should do |actual|
+    "Se esperaba que la coleccion #{actual.join('-')} sea vacia"
+  end
+  failure_message_for_should_not do |actual|
+    "Se esperaba que la coleccion #{actual.join('-')} no sea vacia"
+  end
+end