selenium-cucumber 0.1.1 → 1.1.1

data/lib/selenium-cucumber.rb

@@ -1,2 +1,2 @@
-
-Dir[File.dirname(__FILE__) + '/selenium-cucumber/*.rb'].each {|file| require file }
+
+Dir[File.dirname(__FILE__) + '/selenium-cucumber/*.rb'].each { |file| require file }

data/lib/selenium-cucumber/assertion_steps.rb

@@ -1,81 +1,79 @@
 require_relative 'methods/assertion_methods'
 
-
-#Page title checking
+# page title checking
 Then(/^I should see page title as "(.*?)"$/) do |title|
-  	check_title(title)
+  check_title(title)
 end
 
-#Step to check element text
-Then(/^element having (.+) "([^\"]*)" should\s*((?:not)?)\s+have text as "(.*?)"$/) do |type, access_name,present, value |
+# step to check element text
+Then(/^element having (.+) "([^\"]*)" should\s*((?:not)?)\s+have text as "(.*?)"$/) do |type, access_name, present, value |
   validate_locator type
   check_element_text(type, value, access_name, present.empty?)
 end
 
-#Step to check attribute value
+# step to check attribute value
 Then(/^element having (.+) "([^\"]*)" should\s*((?:not)?)\s+have attribute "(.*?)" with value "(.*?)"$/) do |type, access_name, present, attrb, value|
   validate_locator type
   check_element_attribute(type, attrb, value, access_name, present.empty?)
 end
 
-#Step to check element enabled or not
+# step to check element enabled or not
 Then(/^element having (.+) "([^\"]*)" should\s*((?:not)?)\s+be (enabled|disabled)$/) do |type, access_name, present, state|
   validate_locator type
-  flag = state == "enabled"
+  flag = state == 'enabled'
   flag = !flag unless present.empty?
   check_element_enable(type, access_name, flag)
 end
 
-#Step to check element present or not
+# step to check element present or not
 Then(/^element having (.+) "(.*?)" should\s*((?:not)?)\s+be present$/) do |type, access_name, present|
   validate_locator type
   check_element_presence(type, access_name, present.empty?)
 end
 
-#Step to assert checkbox is checked or unchecked
+# step to assert checkbox is checked or unchecked
 Then(/^checkbox having (.+) "(.*?)" should be (checked|unchecked)$/) do |type, access_name, state|
   validate_locator type
-  flag = state == "checked"
+  flag = state == 'checked'
   is_checkbox_checked(type, access_name, flag)
 end
 
-#steps to assert radio button checked or unchecked
+# steps to assert radio button checked or unchecked
 Then(/^radio button having (.+) "(.*?)" should be (selected|unselected)$/) do |type, access_name, state|
   validate_locator type
-  flag = state == "selected"
+  flag = state == 'selected'
   is_radio_button_selected(type, access_name, flag)
 end
 
-#steps to assert option by text from radio button group selected/unselected
+# steps to assert option by text from radio button group selected/unselected
 Then(/^option "(.*?)" by (.+) from radio button group having (.+) "(.*?)" should be (selected|unselected)$/) do |option, attrb, type, access_name, state|
   validate_locator type
-  flag = state == "selected"
+  flag = state == 'selected'
   is_option_from_radio_button_group_selected(type, attrb, option, access_name, flag)
 end
 
-#steps to check link presence
-Then(/^link having text "(.*?)" should\s*((?:not)?)\s+be present$/) do |present,access_name|
-  check_element_presence("link", access_name, present.empty?)
+# steps to check link presence
+Then(/^link having text "(.*?)" should\s*((?:not)?)\s+be present$/) do |present, access_name|
+  check_element_presence('link', access_name, present.empty?)
 end
 
-Then(/^link having partial text "(.*?)" should\s*((?:not)?)\s+be present$/) do |present,access_name|
-  check_element_presence("partial_link_text", access_name, present.empty?)
+Then(/^link having partial text "(.*?)" should\s*((?:not)?)\s+be present$/) do |present, access_name|
+  check_element_presence('partial_link_text', access_name, present.empty?)
 end
 
-#Step to assert javascript pop-up alert text
-
+# step to assert javascript pop-up alert text
 Then(/^I should see alert text as "(.*?)"$/) do |actual_value|
-     check_alert_text(actual_value)
+  check_alert_text(actual_value)
 end
 
-#Step to assert dropdown list
+# step to assert dropdown list
 Then(/^option "(.*?)" by (.+) from dropdown having (.+) "(.*?)" should be (selected|unselected)$/) do |option, by, type, access_name, state|
   validate_locator type
-  flag = state == "selected"
-  is_option_from_dropdown_selected(type,by,option,access_name,state)
+  flag = state == 'selected'
+  is_option_from_dropdown_selected(type, by, option, access_name, state)
 end
 
-#Step to assert difference in images
+# step to assert difference in images
 Then(/^actual image having (.+) "(.*?)" and expected image having (.+) "(.*?)" should be similar$/) do |actual_img_access_type, actual_img_access_name, excp_img_access_type, excp_img_access_name|
   does_images_similar?(actual_img_access_type, actual_img_access_name, excp_img_access_type, excp_img_access_name)
 end

data/lib/selenium-cucumber/click_elements_steps.rb

@@ -1,30 +1,27 @@
 require_relative 'methods/click_elements_methods'
 
 # click on web element
-
 When(/^I click on element having (.+) "(.*?)"$/) do |type, access_name|
   validate_locator type
-  click(type,access_name)
+  click(type, access_name)
 end
 
 Then(/^I forcefully click on element having (.+) "(.*?)"$/) do |type, access_name|
-	validate_locator type
-	click_forcefully(type, access_name)
+  validate_locator type
+  click_forcefully(type, access_name)
 end
 
 # double click on web element
-
 Then(/^I double click on element having (.+) "(.*?)"$/) do |type, access_value|
-  	validate_locator type
-  	double_click(type, access_value)
+  validate_locator type
+  double_click(type, access_value)
 end
 
-#steps to click on link
-
+# steps to click on link
 Then(/^I click on link having text "(.*?)"$/) do |access_name|
-    click("link",access_name)
+  click('link', access_name)
 end
 
 Then(/^I click on link having partial text "(.*?)"$/) do |access_name|
-    click("partial_link_text",access_name)
-end
+  click('partial_link_text', access_name)
+end

data/lib/selenium-cucumber/configuration_steps.rb

@@ -1,7 +1,6 @@
 require_relative 'methods/configuration_methods'
 
-# Step to print configuration
-
+# step to print configuration
 Then(/^I print configuration$/) do
-    print_congifugartion  
-end
+  print_congifugartion
+end

data/lib/selenium-cucumber/input_steps.rb

@@ -1,69 +1,69 @@
 require_relative 'methods/input_methods'
 
-#enter text into input field steps
+# enter text into input field steps
 Then(/^I enter "([^\"]*)" into input field having (.+) "([^\"]*)"$/) do |text, type, access_name|
-	validate_locator type
-  enter_text(type,text,access_name)
+  validate_locator type
+  enter_text(type, text, access_name)
 end
 
-#clear input field steps
+# clear input field steps
 Then(/^I clear input field having (.+) "([^\"]*)"$/) do |type, access_name|
   validate_locator type
-	clear_text(type, access_name)
+  clear_text(type, access_name)
 end
 
-#select option by text/value from dropdown/multiselect
-Then(/^I select "(.*?)" option by (.+) from\s*((?:multiselect)?)\sdropdown having (.+) "(.*?)"$/) do |option,option_by, present, type, access_name|
-	validate_locator type
+# select option by text/value from dropdown/multiselect
+Then(/^I select "(.*?)" option by (.+) from\s*((?:multiselect)?)\sdropdown having (.+) "(.*?)"$/) do |option, option_by, present, type, access_name|
+  validate_locator type
   validate_option_by option_by
-  select_option_from_dropdown(type, option_by,option,access_name)
+  select_option_from_dropdown(type, option_by, option, access_name)
 end
 
-#select option by index from dropdown/multiselect
+# select option by index from dropdown/multiselect
 Then(/^I select (\d+) option by index from\s*((?:multiselect)?)\sdropdown having (.+) "(.*?)"$/) do |option, present, type, access_name|
   validate_locator type
-  select_option_from_dropdown(type, "index", (option.to_i)-1, access_name)
+  select_option_from_dropdown(type, 'index', (option.to_i) -1, access_name)
 end
 
-#step to select option from mutliselect dropdown list
+# step to select option from mutliselect dropdown list
 Then(/^I select all options from multiselect dropdown having (.+) "(.*?)"$/) do |type, access_name|
   validate_locator type
   select_all_option_from_multiselect_dropdown(type, access_name)
 end
 
-#step to unselect option from mutliselect dropdown list
-Then(/^I unselect all options from multiselect dropdown having (.+) "(.*?)"$/)  do |type,access_name|
+# step to unselect option from mutliselect dropdown list
+Then(/^I unselect all options from multiselect dropdown having (.+) "(.*?)"$/) do |type, access_name|
   validate_locator type
   unselect_all_option_from_multiselect_dropdown(type, access_name)
 end
 
-#check checkbox steps
+# check checkbox steps
 Then(/^I check the checkbox having (.+) "(.*?)"$/) do |type, access_name|
   validate_locator type
   check_checkbox(type, access_name)
 end
 
-#uncheck checkbox steps
+# uncheck checkbox steps
 Then(/^I uncheck the checkbox having (.+) "(.*?)"$/) do |type, access_name|
   validate_locator type
-  uncheck_checkbox(type,access_name)
+  uncheck_checkbox(type, access_name)
 end
 
-#Steps to toggle checkbox
+# steps to toggle checkbox
 Then(/^I toggle checkbox having (.+) "(.*?)"$/) do |type, access_name|
   validate_locator type
-  toggle_checkbox(type,access_name)
+  toggle_checkbox(type, access_name)
 end
 
-#step to select radio button
-Then(/^I select radio button having (.+) "(.*?)"$/) do |type,access_name|
+# step to select radio button
+Then(/^I select radio button having (.+) "(.*?)"$/) do |type, access_name|
   validate_locator type
-  select_radio_button(type,access_name)
+  select_radio_button(type, access_name)
 end
 
-#steps to select option by text from radio button group 
-Then(/^I select "(.*?)" option by (.+) from radio button group having (.+) "(.*?)"$/) do |option,option_by, type, access_name|
+# steps to select option by text from radio button group
+Then(/^I select "(.*?)" option by (.+) from radio button group having (.+) "(.*?)"$/) do |option, option_by, type, access_name|
   validate_locator type
   validate_option_by option_by
-  select_option_from_radio_button_group(type,option_by,option,access_name)
-end
+  select_option_from_radio_button_group(type, option_by, option, access_name)
+end

data/lib/selenium-cucumber/javascript_handling_steps.rb

@@ -1,9 +1,9 @@
 require_relative 'methods/javascript_handling_methods'
 
 Then(/^I accept alert$/) do
-	handle_alert("accept")
+  handle_alert('accept')
 end
 
 Then(/^I dismiss alert$/) do
-	handle_alert("dismiss")
-end
+  handle_alert('dismiss')
+end

data/lib/selenium-cucumber/methods/assertion_methods.rb

@@ -1,222 +1,259 @@
+require 'net/https'
 require_relative 'required_files'
 
-
-#Page title checking
+# Page title checking
 def get_page_title
-	return $driver.title
+  $driver.title
 end
 
 def check_title(title)
-	if(get_page_title!=title)
-		raise TestCaseFailed ,"Page Title Not Matched"
-	end
+  raise TestCaseFailed, 'Page Title Not Matched' unless get_page_title == title
 end
 
-#method to get element text
-def get_element_text(access_type,access_name)
-	return WAIT.until {$driver.find_element(:"#{access_type}" => "#{access_name}")}.text
+# Method to get element text
+def get_element_text(access_type, access_name)
+  WAIT.until { $driver.find_element(:"#{access_type}" => "#{access_name}") }.text
 end
 
-#Method to check element text
+# Method to check element text
 def check_element_text(access_type, actual_value, access_name, test_case)
-	element_text = get_element_text(access_type,access_name)
-
-	if test_case
-		if(element_text!=actual_value)
-			raise TestCaseFailed ,"Text Not Matched"
-		end
-	else
-		if(element_text==actual_value)
-			raise TestCaseFailed ,"Text Matched"
-		end
-	end
+  element_text = get_element_text(access_type, access_name)
+
+  if test_case
+    if element_text != actual_value
+      raise TestCaseFailed, 'Text Not Matched'
+    end
+  else
+    if element_text == actual_value
+      raise TestCaseFailed, 'Text Matched'
+    end
+  end
 end
 
-#method to return element status - enabled?
-def is_element_enabled(access_type,access_name)
-	return WAIT.until{$driver.find_element(:"#{access_type}" => "#{access_name}")}.enabled?
+# Method to return element status - enabled?
+def is_element_enabled(access_type, access_name)
+  WAIT.until{ $driver.find_element(:"#{access_type}" => "#{access_name}") }.enabled?
 end
 
-#Element enabled checking
+# Element enabled checking
 def check_element_enable(access_type, access_name, test_case)
+  result = is_element_enabled(access_type, access_name)
 
-	result=is_element_enabled(access_type,access_name)
-
-	if test_case
-		if(!result)
-			raise TestCaseFailed ,"Element Not Enabled"
-		end
-	else
-		if(result)
-			raise TestCaseFailed ,"Element Enabled"
-		end
-	end
+  if test_case
+    raise TestCaseFailed, 'Element Not Enabled' unless result
+  else
+    raise TestCaseFailed, 'Element Enabled' unless !result
+  end
 end
 
-#method to get attribute value
-def get_element_attribute(access_type,access_name,attribute_name)
-	return WAIT.until{$driver.find_element(:"#{access_type}" => "#{access_name}")}.attribute("#{attribute_name}")
+# method to get attribute value
+def get_element_attribute(access_type, access_name, attribute_name)
+  WAIT.until{ $driver.find_element(:"#{access_type}" => "#{access_name}") }.attribute("#{attribute_name}")
 end
 
-#method to check attribute value
+# method to check attribute value
 def check_element_attribute(access_type, attribute_name, attribute_value, access_name, test_case)
 
-	attr_val=get_element_attribute(access_type, access_name, attribute_name)
+  attr_val = get_element_attribute(access_type, access_name, attribute_name)
 
-	if test_case
-		if(attr_val!=attribute_value)
-			raise TestCaseFailed ,"Attribute Value Not Matched"
-		end
-	else
-		if(attr_val==attribute_value)
-			raise TestCaseFailed ,"Attribute Value Matched"
-		end
-	end
+  if test_case
+    if attr_val != attribute_value
+      raise TestCaseFailed, 'Attribute Value Not Matched'
+    end
+  else
+    if attr_val == attribute_value
+      raise TestCaseFailed, 'Attribute Value Matched'
+    end
+  end
 end
 
-#method to get element status - displayed?
-def is_element_displayed(access_type,access_name)
-	WAIT.until{$driver.find_element(:"#{access_type}" => "#{access_name}")}.displayed?
+# method to get element status - displayed?
+def is_element_displayed(access_type, access_name)
+  WAIT.until{ $driver.find_element(:"#{access_type}" => "#{access_name}") }.displayed?
 end
 
 # method to check element presence
 def check_element_presence(access_type, access_name, test_case)
-	if test_case
-		if !is_element_displayed(access_type,access_name)
-			raise TestCaseFailed ,"Element Not Present"
-		end
-	else
-		begin
-			if is_element_displayed(access_type,access_name)
-				raise "Present"
-			end
-		rescue Exception => e
-			if e.message=="present"
-				raise TestCaseFailed ,"Element Present"
-			end
-		end
-	end
-end
-
-#method to assert checkbox check/uncheck
-def is_checkbox_checked(access_type, access_name, should_be_checked=true)
-	checkbox = WAIT.until{$driver.find_element(:"#{access_type}" => "#{access_name}")}
-
-	if !checkbox.selected? && should_be_checked
-		raise TestCaseFailed ,"Checkbox is not checked"
-  elsif checkbox.selected? && !should_be_checked
-    raise TestCaseFailed ,"Checkbox is checked"
-	end
+  if test_case
+    if !is_element_displayed(access_type, access_name)
+      raise TestCaseFailed, 'Element Not Present'
+    end
+  else
+    begin
+      if is_element_displayed(access_type, access_name)
+        raise 'Present'
+      end
+    rescue Exception => e
+      if e.message == 'present'
+        raise TestCaseFailed, 'Element Present'
+      end
+    end
+  end
 end
 
-#method to assert radio button selected/unselected
-def is_radio_button_selected(access_type, access_name, should_be_selected=true)
-	radio_button = WAIT.until{$driver.find_element(:"#{access_type}" => "#{access_name}")}
+# method to assert checkbox check/uncheck
+def is_checkbox_checked(access_type, access_name, should_be_checked = true)
+  checkbox = WAIT.until{ $driver.find_element(:"#{access_type}" => "#{access_name}") }
 
-  	if !radio_button.selected? && should_be_selected
-		raise TestCaseFailed ,"Radio Button not selected"
-  	elsif radio_button.selected? && !should_be_selected
-    	raise TestCaseFailed ,"Radio Button is selected"
-	end
+  if !checkbox.selected? && should_be_checked
+    raise TestCaseFailed, 'Checkbox is not checked'
+  elsif checkbox.selected? && !should_be_checked
+    raise TestCaseFailed, 'Checkbox is checked'
+  end
 end
 
+# method to assert radio button selected/unselected
+def is_radio_button_selected(access_type, access_name, should_be_selected = true)
+  radio_button = WAIT.until{ $driver.find_element(:"#{access_type}" => "#{access_name}") }
+
+  if !radio_button.selected? && should_be_selected
+    raise TestCaseFailed, 'Radio Button not selected'
+  elsif radio_button.selected? && !should_be_selected
+    raise TestCaseFailed, 'Radio Button is selected'
+  end
+end
 
-#method to assert option from radio button group is selected/unselected
-def is_option_from_radio_button_group_selected(access_type, by, option, access_name, should_be_selected=true)
-  radio_button_group = WAIT.until{$driver.find_elements(:"#{access_type}" => "#{access_name}")}
+# method to assert option from radio button group is selected/unselected
+def is_option_from_radio_button_group_selected(access_type, by, option, access_name, should_be_selected = true)
+  radio_button_group = WAIT.until{ $driver.find_elements(:"#{access_type}" => "#{access_name}") }
 
   getter = ->(rb, by) { by == 'value' ? rb.attribute('value') : rb.text }
 
   ele = radio_button_group.find { |rb| getter.call(rb, by) == option }
 
   if !ele.selected? && should_be_selected
-    raise TestCaseFailed ,'Radio button is not selected'
+    raise TestCaseFailed, 'Radio button is not selected'
   elsif ele.selected? && !should_be_selected
-    raise TestCaseFailed ,'Radio button is selected'
+    raise TestCaseFailed, 'Radio button is selected'
   end
 end
 
-#method to get javascript pop-up alert text
+# method to get javascript pop-up alert text
 def get_alert_text
-	$driver.switch_to.alert.text
+  $driver.switch_to.alert.text
 end
 
-#method to check javascript pop-up alert text
-def check_alert_text text
-	if get_alert_text!=text
-  		raise TestCaseFailed , "Text on alert pop up not matched"
-  	end
+# method to check javascript pop-up alert text
+def check_alert_text(text)
+  if get_alert_text != text
+    raise TestCaseFailed,  'Text on alert pop up not matched'
+  end
 end
 
 def is_option_from_dropdown_selected(access_type, by, option, access_name, should_be_selected=true)
-	dropdown = WAIT.until {$driver.find_element(:"#{access_type}" => "#{access_name}")}
-  	select_list = Selenium::WebDriver::Support::Select.new(dropdown)
+  dropdown = WAIT.until { $driver.find_element(:"#{access_type}" => "#{access_name}") }
+  select_list = Selenium::WebDriver::Support::Select.new(dropdown)
 
-  	if by=="text"
-  		actual_value = select_list.first_selected_option.text
-  	else
-  		actual_value = select_list.first_selected_option.attribute("value")
-  	end
+  if by == 'text'
+    actual_value = select_list.first_selected_option.text
+  else
+    actual_value = select_list.first_selected_option.attribute('value')
+  end
 
-  	if !actual_value==option && should_be_selected
-  		raise TestCaseFailed , "Option Not Selected From Dropwdown"
-  	elsif actual_value==option && !should_be_selected
-  		raise TestCaseFailed , "Option Selected From Dropwdown"
-  	end
+  if !actual_value == option && should_be_selected
+    raise TestCaseFailed, 'Option Not Selected From Dropwdown'
+  elsif actual_value == option && !should_be_selected
+    raise TestCaseFailed, 'Option Selected From Dropwdown'
+  end
 end
 
-#Method to find difference between images
+# Method to find difference between images
 def does_images_similar?(actual_img_access_type, actual_img_access_name, excp_img_access_type, excp_img_access_name)
-	if !compare_image(actual_img_access_type, actual_img_access_name, excp_img_access_type, excp_img_access_name)
-		raise TestCaseFailed , "Actual image is different from expected image"
-	end
+  if !compare_image(actual_img_access_type, actual_img_access_name, excp_img_access_type, excp_img_access_name)
+    raise TestCaseFailed, 'Actual image is different from expected image'
+  end
 end
 
-#Method to compare two images
+# Method to compare two images
 def compare_image(actual_img_access_type, actual_img_access_name, excp_img_access_type, excp_img_access_name)
+  if actual_img_access_type == 'url'
+    actual_img_url = actual_img_access_name
+  else
+    actual_img_url = get_element_attribute(actual_img_access_type, actual_img_access_name, 'src')
+  end
+
+  if excp_img_access_type == 'url'
+    expected_img_url = excp_img_access_name
+  elsif excp_img_access_type == 'image_name'
+    expected_img_url = './features/expected_images/' + excp_img_access_name
+  else
+    expected_img_url = get_element_attribute(excp_img_access_type, excp_img_access_name, 'src')
+  end
+
+  if actual_img_url.include? 'https'
+    actual_img_url['https'] = 'http'
+  end
 
-	if actual_img_access_type == "url"
-		actual_img_url = actual_img_access_name
-	else
-		actual_img_url = get_element_attribute(actual_img_access_type, actual_img_access_name, "src")
-	end
-
-	if excp_img_access_type == "url"
-		expected_img_url = excp_img_access_name
-	elsif excp_img_access_type == "image_name"
-        expected_img_url = File.absolute_path("expected_images/"+excp_img_access_name)
-    else
-		expected_img_url = get_element_attribute(excp_img_access_type, excp_img_access_name, "src")
-	end
-
-	puts "\nActual image url : #{actual_img_url}"
-
-	images = [
-	  ChunkyPNG::Image.from_file(open(actual_img_url)),
-	  ChunkyPNG::Image.from_file(open(expected_img_url))
-	 ]
-
-	 diff = []
-
-	 images.first.height.times do |y|
-	  images.first.row(y).each_with_index do |pixel, x|
-	    diff << [x,y] unless pixel == images.last[x,y]
-	  end
-	 end
-
-	if diff.length != 0
-		puts "\npixels (total):     #{images.first.pixels.length}"
-		puts "pixels changed:     #{diff.length}"
-		puts "pixels changed (%): #{(diff.length.to_f / images.first.pixels.length) * 100}%"
-
-		x, y = diff.map{ |xy| xy[0] }, diff.map{ |xy| xy[1] }
-	    images.last.rect(x.min, y.min, x.max, y.max, ChunkyPNG::Color.rgb(0,255,0))
-	    curTime = Time.now.strftime('%Y%m%d%H%M%S%L')
-	    images.last.save("image_difference/difference_#{curTime}.png")
-
-	    puts "\nDifference between images saved as : difference_#{curTime}.png\n"
-		return false
-	else
-		return true
-	end
+  if expected_img_url.include? 'https'
+    expected_img_url['https'] = 'http'
+  end
+
+  if expected_img_url.include? '.png'
+    image_type = 'png'
+  else
+    image_type = 'jpg'
+  end
+
+# Storing actual image locally
+  open('./features/actual_images/actual_image.' + image_type, 'wb') do |file|
+    file << open(actual_img_url).read
+  end
+  
+  actual_img_url = './features/actual_images/actual_image.' + image_type
+
+# Storing Expected image locally
+  if excp_img_access_type != 'image_name'
+    open('./features/expected_images/expected_image.' + image_type, 'wb') do |file|
+      file << open(expected_img_url).read
+    end
+    expected_img_url = './features/expected_images/expected_image.' + image_type
+  end
+
+# Verify image extension and call respective compare function
+  if image_type == 'png'
+    return compare_png_images(expected_img_url, actual_img_url)
+  end
+
+  compare_jpeg_images(expected_img_url, actual_img_url)
+end
+
+# Comparing jpg images
+def compare_jpeg_images(expected_img_url, actual_img_url)
+  if open(expected_img_url).read == open(actual_img_url).read
+    return true
+  else
+    puts 'Difference in images'
+    return false
+  end
+end
+
+# Comparing png images
+def compare_png_images(expected_img_url, actual_img_url)
+  images = [
+    ChunkyPNG::Image.from_file(expected_img_url),
+    ChunkyPNG::Image.from_file(actual_img_url)
+  ]
+
+  diff = []
+
+  images.first.height.times do |y|
+    images.first.row(y).each_with_index do |pixel, x|
+      diff << [x, y] unless pixel == images.last[x, y]
+    end
+  end
+
+  if diff.length != 0
+    puts "\npixels (total):     #{images.first.pixels.length}"
+    puts "pixels changed:     #{diff.length}"
+    puts "pixels changed (%): #{(diff.length.to_f / images.first.pixels.length) * 100}%"
+
+    x, y = diff.map { |xy| xy[0] }, diff.map { |xy| xy[1] }
+    images.last.rect(x.min, y.min, x.max, y.max, ChunkyPNG::Color.rgb(0, 255, 0))
+    cur_time = Time.now.strftime('%Y%m%d%H%M%S%L')
+    images.last.save("./features/image_difference/difference_#{cur_time}.png")
+
+    puts "\nDifference between images saved as : difference_#{cur_time}.png\n"
+    return false
+  end
+  true
 end