lapis_lazuli 0.6.1

data/test/features/click.feature

@@ -0,0 +1,35 @@
+@click @p
+Feature: clicks
+  When I want to test the Lapis Lazuli library
+  I want to run a webserver with some test files
+  And execute the each library function that handles clicks.
+
+  @click_01
+  Scenario: click_01 - use onClick event
+    Given I navigate to the button test page
+    And I click the last button
+    Then I should be able to click the first button by event
+
+  @click_02
+  Scenario: click_02 - use JavaScript
+    Given I navigate to the button test page
+    And I click the last button
+    Then I should be able to click the first button by using JavaScript
+
+  @click_03
+  Scenario Outline: click_03 - use click types
+    Given I navigate to the button test page
+    And I click the last button
+    Then I should be able to click the first button by click type <type>
+
+    Examples:
+      | type   |
+      | method |
+      | event  |
+      | js     |
+
+  @click_04
+  Scenario: click_04 - use force click
+    Given I navigate to the button test page
+    And I click the last button
+    Then I should be able to click the first button by force click

data/test/features/error.feature

@@ -0,0 +1,30 @@
+@error @p
+Feature: Error
+  When I want to test the Lapis Lazuli library
+  I want to run a webserver with some test files
+  And execute the each library function that handles errors.
+
+  @error_01
+  Scenario: error_01 - Has JS error
+    Given I navigate to the javascript error test page
+    Then I expect javascript errors
+
+  @error_02
+  Scenario: error_02 - Status Code 404
+    Given I navigate to the 404 test page
+    Then I expect a 404 status code
+
+  @error_04
+  Scenario: error_03 - Status Code 200
+    Given I navigate to the text fields test page
+    Then I expect a 200 status code
+
+  @error_04
+  Scenario: error_04 - HTML Error
+    Given I navigate to the error html test page
+    Then I expect 1 HTML error
+
+  @error_05
+  Scenario: error_05 - HTML Error
+    Given I navigate to the text fields test page
+    Then I expect no HTML error

data/test/features/find.feature

@@ -0,0 +1,92 @@
+@find @p
+Feature: Find
+When I want to test the Lapis Lazuli library
+I want to run a webserver with some test files
+And execute the each library function searches for elements.
+
+@find_01
+Scenario: Find by string
+  Given I navigate to the find test page
+  Then I expect the "header" to exist
+  And I expect the "footer" to exist
+
+@find_02
+Scenario: Find by element
+  Given I navigate to the find test page
+  Then I expect a nav element to exist
+  And I expect a div element to exist
+
+@find_03
+Scenario Outline: Find by attribute
+  Given I navigate to the find test page
+  Then I expect to find a <element> element with <attribute> "<text>" using <settings> settings
+
+  Examples:
+  | element | attribute | text       | settings        |
+  | button  | class     | submit     | method          |
+  | a       | href      | /full/link | method          |
+  | div     | text      | Second     | method          |
+  | button  | class     | submit     | like with hash  |
+  | a       | href      | /full/link | like with hash  |
+  | div     | text      | Second     | like with hash  |
+  | button  | class     | submit     | like with array |
+  | a       | href      | /full/link | like with array |
+  | div     | text      | Second     | like with array |
+  | button  | class     | submit     | tag name        |
+# :tag_name + :href not supported by watir
+# | a       | href      | /full/link | tag name        |
+  | div     | text      | Second     | tag name        |
+
+@find_04
+Scenario Outline: Find one of multiple
+  Given I navigate to the find test page
+  Then I expect to find a <element1> element or a <element2> element
+
+  Examples:
+  | element1 | element2 |
+  | a | does_not_exist |
+  | does_not_exist | a |
+
+@find_05
+Scenario Outline: Find with context
+  Given I navigate to the find test page
+  When I find "<context>" and name it "test_element"
+  Then I should find "<element>" using "test_element" as context
+  And I should not find "<error_element>" using "test_element" as context
+
+  Examples:
+  | context | element | error_element |
+  | deep3 | deep6 | deep1 |
+  | deep2 | deep7 | deep1 |
+  | deep6 | deep7 | header |
+
+@find_06
+Scenario Outline: FindAllPresent with context
+  Given I navigate to the find test page
+  When I find "<context>" and name it "test_element"
+  Then I should find "<element>" <number> times using "test_element" as context
+  Examples:
+  | context | element        | number |
+  | deep3   | deep6          | 1      |
+  | deep3   | count          | 4      |
+  | deep3   | does_not_exist | 0      |
+
+@find_07 @find_errors @issue_6
+Scenario: Find in always returns an element, defaulting to the document root
+  Given I navigate to the find test page
+  Then I expect not to find "does_not_exist"
+
+@find_08 @find_errors @issue_6
+Scenario Outline: Find with tagname to hash options seems broken
+  Given I navigate to the find test page
+  Then I expect to use tagname to hash options to <mode> find element <element>
+
+  Examples:
+  | element        | mode |
+  | deep3          |      |
+  | does_not_exist | not  |
+
+@find_09 @issue_8
+Scenario: Find should throw, unless no :throw is specified
+  Given I navigate to the find test page
+  Then I expect not to find "does_not_exist" with no :throw option

data/test/features/har.feature

@@ -0,0 +1,9 @@
+@har @p
+Feature: HAR
+When I want to test the Lapis Lazuli library
+I want to run a webserver with some test files
+And execute the each library function handle HAR files.
+
+@har_01
+Scenario: Goto simple HTTP site
+  When I go to "http://ipecho.net/plain"

data/test/features/modules.feature

@@ -0,0 +1,14 @@
+@modules @p
+Feature: Modules
+  When I want to test the Lapis Lazuli library
+  I want to ensure that including modules works as expected
+
+  @modules_01
+  Scenario: modules_01 - World module
+    Given I include a world module
+    Then I expect the world module's functions to be available
+
+  @modules_02
+  Scenario: modules_02 - Browser module
+    Given I include a browser module
+    Then I expect the browser module's functions to be available

data/test/features/step_definitions/interaction_steps.rb

@@ -0,0 +1,154 @@
+################################################################################
+# Copyright 2014 spriteCloud B.V. All rights reserved.
+# Generated by LapisLazuli, version 0.0.1
+# Author: "Onno Steenbergen" <onno@steenbe.nl>
+
+require 'test/unit/assertions'
+
+include Test::Unit::Assertions
+
+Given(/^I navigate to the (.*) test page$/) do |page|
+  config = "server.url"
+  if has_env?(config)
+    url = env(config)
+    browser.goto "#{url}#{page.downcase.gsub(" ","_")}.html"
+  else
+    error(:env => config)
+  end
+end
+
+Given(/I click (the|a) (first|last|random|[0-9]+[a-z]+) (.*)$/) do |arg1, index, type|
+  # Convert the type text to a symbol
+  type = type.downcase.gsub(" ","_")
+
+  pick = 0
+  if ["first","last","random"].include?(index)
+    pick = index.to_sym
+  else
+    pick = index.to_i - 1
+  end
+  # Options for find
+  options = {}
+  # Select the correct element
+  options[type.to_sym] = {}
+  # Pick the correct one
+  options[:pick] = pick
+  # Execute the find
+  type_element = browser.find(options)
+  type_element.click
+end
+
+
+Given(/^I create a firefox browser named "(.*?)"( with proxy to "(.*?)")$/) do |name, proxy, proxy_url|
+  b = nil
+  if proxy
+    log.debug("Starting with profile")
+    profile = Selenium::WebDriver::Firefox::Profile.new
+    profile.proxy = Selenium::WebDriver::Proxy.new :http => proxy_url
+    b = browser.create :firefox, :profile => profile
+  else
+    b = browser.create :firefox
+  end
+  scenario.storage.set(name, browser)
+end
+
+Given(/^I close the browser named "(.*?)"$/) do |name|
+  if scenario.storage.has? name
+    browser = scenario.storage.get name
+    browser.close
+  else
+    error("No item in the storage named #{name}")
+  end
+end
+
+When(/^I find "(.*?)" and name it "(.*?)"$/) do |id, name|
+  element = browser.find(id)
+  scenario.storage.set(name, element)
+end
+
+xpath_fragment = nil
+Given(/^I specify a needle "(.+?)" and a node "(.+?)" (and an empty separator )?to xp_contains$/) do |needle, node, empty_sep|
+  if empty_sep.nil?
+    xpath_fragment = xp_contains(node, needle)
+  else
+    xpath_fragment = xp_contains(node, needle, '')
+  end
+end
+
+Then(/^I expect an xpath fragment "(.*?)"$/) do |fragment|
+  assert fragment == xpath_fragment, "Fragment was not as expected: got '#{xpath_fragment}' vs expected '#{fragment}'."
+end
+
+Then(/^I expect the fragment "(.*?)" to find (\d+) element\(s\)\.$/) do |fragment, n|
+  elems = browser.elements(:xpath => "//div[#{fragment}]")
+  assert n.to_i == elems.length, "Mismatched amount: got #{elems.length} vs. expected #{n}"
+end
+
+elems = []
+Given(/^I search for elements where node "(.+?)" contains "(.+?)" and not "(.+?)"$/) do |node, first, second|
+  clause = xp_and(xp_contains(node, first), xp_not(xp_contains(node, second)))
+  elems = browser.elements(:xpath => "//div[#{clause}]")
+end
+
+Then(/^I expect to find (\d+) elements\.$/) do |n|
+  assert n.to_i == elems.length, "Mismatched amount: got #{elems.length} vs. expected #{n}"
+end
+
+When(/^I go to "(.*?)"$/) do |url|
+  browser.goto url
+end
+
+Then(/^I should be able to click the first button by event$/) do
+  elem = browser.button(:id => 'first')
+  browser.on_click(elem)
+  browser.wait(
+    :timeout => 1,
+    :text => 'first clicked',
+    :groups => ['wait'],
+  )
+end
+
+Then(/^I should be able to click the first button by using JavaScript$/) do
+  elem = browser.button(:id => 'first')
+  browser.js_click(elem)
+  browser.wait(
+    :timeout => 1,
+    :text => 'first clicked',
+    :groups => ['wait'],
+  )
+end
+
+Then(/^I should be able to click the first button by click type (.*?)$/) do |type|
+  elem = browser.button(:id => 'first')
+  browser.click_type(elem, type)
+  browser.wait(
+    :timeout => 1,
+    :text => 'first clicked',
+    :groups => ['wait'],
+  )
+end
+
+
+Then(/^I should be able to click the first button by force click$/) do
+  elem = browser.button(:id => 'first')
+  browser.force_click(elem)
+  browser.wait(
+    :timeout => 1,
+    :text => 'first clicked',
+    :groups => ['wait'],
+  )
+end
+
+
+Given(/^I annotate a step with (.*?)$/) do |data|
+  annotate data
+end
+
+Then(/^the report should include (.*?) and (.*?) in the correct place$/) do |data1, data2|
+  # Our test completely ignores the "scope" part, because the scope is the
+  # scenario/example anyway. Instead we just check the stored values are
+  # as expected.
+  annotations.each do |scope, values|
+    assert ([[data1], [data2]] == values), "Stored values: #{values}, expected [[#{data1}], [#{data2}]]"
+  end
+end

data/test/features/step_definitions/validation_steps.rb

@@ -0,0 +1,350 @@
+################################################################################
+# Copyright 2014-2015 spriteCloud B.V. All rights reserved.
+# Generated by LapisLazuli, version 0.0.1
+# Author: "Onno Steenbergen" <onno@steenbe.nl>
+
+require 'test/unit/assertions'
+
+include Test::Unit::Assertions
+
+Then(/(first|last|random|[0-9]+[a-z]+) (.*) should (not )?be the (first|last|[0-9]+[a-z]+) element on the page$/) do |index, type, differ, location_on_page|
+	# Convert the type text to a symbol
+	type = type.downcase.gsub(" ","_")
+
+	pick = 0
+	if ["first","last","random"].include?(index)
+		pick = index.to_sym
+	else
+		pick = index.to_i - 1
+	end
+	# Options for find
+	options = {}
+	# Select the correct element
+	options[type.to_sym] = {}
+	# Pick the correct one
+	options[:pick] = pick
+	# Execute the find
+	type_element = browser.find(options)
+
+	# All elements on the page
+	body_elements = browser.body.elements
+	# Find the element we need
+	page_element = nil
+	if location_on_page == "first"
+		page_element = body_elements.first
+	elsif location_on_page == "last"
+		page_element = body_elements.last
+	else
+		page_element = body_elements[location_on_page.to_i - 1]
+	end
+
+	# No page element
+	if not page_element
+		error("Could not find an element on the page")
+	# Elements are the same but it should not be
+	elsif page_element == type_element and differ
+		error("Elements on the page are the same")
+	# Elements are different but should be the same
+	elsif page_element != type_element and not differ
+		error("Elements should be the same")
+	end
+end
+
+Then(/(first|last|random|[0-9]+[a-z]+) (.*) should (not )?be present$/) do |index, type, hidden|
+  # Convert the type text to a symbol
+	type = type.downcase.gsub(" ","_")
+
+	pick = 0
+	if ["first","last","random"].include?(index)
+		pick = index.to_sym
+	else
+		pick = index.to_i - 1
+	end
+
+	# Options for find_all
+  options = {}
+	# Select the correct element
+	options[type.to_sym] = {}
+	# Pick the correct one
+	options[:pick] = pick
+	# Execute the find
+	type_element = browser.find(options)
+	# Find all
+	all_elements = browser.find_all(options)
+
+  options[:filter_by] = :present?
+	all_present = browser.find_all(options)
+
+	if hidden and type_element.present?
+		error("Hidden element is visible")
+	elsif not hidden and not type_element.present?
+		error("Element is hidden")
+	elsif hidden and not type_element.present? and
+		(not all_elements.include?(type_element) or all_present.include?(type_element))
+		error("Hidden element (not) found via find_all(:filter_by => :present?)")
+	elsif not hidden and type_element.present? and
+		(not all_elements.include?(type_element) or not all_present.include?(type_element))
+		error("Visible element (not) found via find_all(:filter_by => :present?)")
+	end
+end
+
+Then(/^within (\d+) seconds I should see "([^"]+?)"( disappear)?$/) do |timeout, text, condition|
+  if condition
+		condition = :while
+	else
+		condition = :until
+	end
+
+	browser.wait(
+		:timeout => timeout,
+		:text => text,
+		:condition => condition,
+		:groups => ["wait"]
+	)
+end
+
+Then(/^within (\d+) seconds I should see "([^"]+?)" and "([^"]+?)"( disappear)?$/) do |timeout, first, second, condition|
+	if condition
+		condition = :while
+	else
+		condition = :until
+	end
+
+	browser.multi_wait_all(
+		:timeout => timeout,
+		:condition => condition,
+		:mode => :match_all,
+		:groups => ["wait"],
+		:selectors => [
+			{ :tag_name => 'span', :class => /foo/ },
+			{ :tag_name => 'div', :id => 'bar' }
+		]
+	)
+end
+
+Then(/^within (\d+) seconds I should see added elements with matching$/) do |timeout|
+	elems = browser.multi_wait_all(
+		:timeout => timeout,
+		:condition => :until,
+		:mode => :match_all,
+		:groups => ["wait"],
+		:selectors => [
+			{ :tag_name => 'span', :class => /foo/, :text => /foo/ },
+			{ :tag_name => 'div', :id => 'bar', :html => "bar" }
+		]
+	)
+ 	assert (2 == elems.length), "Expected two elements, found #{elems.length}"
+end
+
+Then(/^within 10 seconds I should see either added element/) do
+	browser.multi_wait_all(
+			{ :tag_name => 'a', :class => /foo/ },
+			{ :tag_name => 'div', :id => 'bar' }
+	)
+end
+
+Then(/^within (\d+) seconds I get an error waiting for "(.*?)"( disappear)?$/) do |timeout, text, condition|
+	if condition
+		condition = :while
+	else
+		condition = :until
+	end
+
+	begin
+		browser.wait(
+			:timeout => timeout,
+			:text => text,
+			:condition => condition,
+			:screenshot => true,
+			:groups => ["wait"]
+		)
+		error(
+			:message => "Didn't receive an error with this timeout",
+			:screenshot => true,
+			:groups => ["wait"]
+		)
+	rescue StandardError => err
+	end
+end
+
+
+Then(/^within (\d+) seconds I should not see nonexistent elements$/) do |timeout|
+
+  ex = nil
+  begin
+    browser.wait_all(:timeout => timeout, :id => "does_not_exist")
+  rescue StandardError => e
+    ex = e
+  end
+
+  assert !ex.nil?, "We need a timeout error to occur here!"
+end
+
+
+Then(/^a screenshot should have been created$/) do
+	# Check if there is a screenshot with the correct name
+	name = browser.screenshot_name
+	if Dir[name].empty?
+		error(
+			:message => "Didn't find a screenshot for this scenario: #{name}",
+			:groups => ["screenshot"]
+		)
+	end
+end
+
+Then(/^I expect javascript errors$/) do
+	errors = browser.get_js_errors
+	if !errors.nil? and errors.length > 0
+		scenario.check_browser_errors = false
+	else
+		error(
+			:message => "No Javascript errors detected",
+			:groups => ["error"]
+		)
+	end
+end
+
+Then(/^I expect a (\d+) status code$/) do |expected|
+	expected = expected.to_i
+	if browser.get_http_status == expected && expected > 299
+		scenario.check_browser_errors = false
+	elsif browser.get_http_status != expected
+		error(
+			:message => "Incorrect status code: #{browser.get_http_status}",
+			:groups => ["error"]
+		)
+	end
+end
+
+Then(/^I expect (no|\d+) HTML errors?$/) do |expected|
+	expected = expected.to_i
+	scenario.check_browser_errors = false
+	if browser.get_html_errors.length != expected
+		error(
+			:message => "Expected #{expected} errors: #{browser.get_html_errors}",
+			:groups => ["error"]
+		)
+	end
+end
+
+Then(/^the firefox browser named "(.*?)" has a profile$/) do |name|
+	if scenario.storage.has? name
+		browser = scenario.storage.get name
+		if browser.driver.capabilities.firefox_profile.nil?
+			raise "Profile is not set"
+		end
+	else
+		error("No item in the storage named #{name}")
+	end
+end
+
+Then(/^I expect the "(.*?)" to exist$/) do |name|
+	browser.find(name)
+end
+
+Then(/^I expect an? (.*?) element to exist$/) do |element|
+	browser.find(element.to_sym)
+end
+
+Then(/^I expect to find an? (.*?) element with (.*?) "(.*?)" using (.*?) settings$/) do |element, attribute, text, setting_choice|
+	settings = {
+		"method" => {element.downcase => { attribute.to_sym => /#{text}/}},
+		"like with hash" => {:like =>{
+			:element => element.downcase,
+			:attribute => attribute,
+			:include => text
+			}},
+		"like with array" => {:like => [element.downcase, attribute, text]},
+		"tag name" => {:tag_name => element.downcase, attribute.to_sym => /#{text}/}
+	}
+	setting = settings[setting_choice]
+	# Find always throws an error if not found
+	elem_find = browser.find(setting)
+	elem_findall = browser.find_all(setting).first
+	if elem_find != elem_findall
+		error "Incorrect results"
+	end
+end
+
+Then(/^I expect to find an? (.*?) element or an? (.*?) element$/) do |element1, element2|
+	element = browser.multi_find(element1.to_sym, element2.to_sym)
+end
+
+Then(/^I should (not )?find "(.*?)" ([0-9]+ times )?using "(.*?)" as context$/) do |result, id, number, name|
+	context = scenario.storage.get name
+	if context.nil?
+		error(:not_found => "Find context in storage")
+	end
+	begin
+		settings = {:element => id, :context => context}
+		settings[:filter_by] = :present?
+		settings[:throw] = false
+		elements = browser.find_all(settings)
+		if not number.nil? and elements.length != number.to_i
+			error("Incorrect number of elements: #{elements.length}")
+		end
+	rescue
+		if result.nil?
+			raise $!
+		end
+	end
+end
+
+Given(/^I generate and store an email$/) do
+  x = variable("%{email}")
+  storage.set("test_email", x)
+end
+
+Then(/^I can retrieve the email$/) do
+  x = storage.get("test_email")
+  assert !x.nil?, "Could not retrieve email from storage."
+end
+
+Then(/^I expect the email to contain the domain name I specified\.$/) do
+  x = storage.get("test_email")
+  domain = env_or_config('email_domain')
+  assert x.include?(domain), "Generated email #{x} does not contain configured domain #{domain}!"
+end
+
+
+Given(/^I include a (world|browser) module$/) do |type|
+  # Nothing to do - see features/support/env.rb
+  true
+end
+
+Then(/^I expect the (world|browser) module's functions to be available$/) do |type|
+  # We're essentially testing that NoMethodError is not being raised here.
+  case type
+  when "browser"
+    browser.test_func
+  when "world"
+    test_func
+  else
+    raise "No such module type: #{type}"
+  end
+end
+
+Then(/^I expect not to find "(.*?)"(.*?)$/) do |id, extra|
+  throw_opt = !(extra.length > 0)
+  if throw_opt
+    ex = nil
+    begin
+      element = browser.find(:id => id, :throw => throw_opt)
+    rescue RuntimeError => e
+      ex = e
+    end
+    assert !ex.nil?, "No exception thrown when finding element that doesn't exist."
+  else
+    assert element.nil?, "Found the some element!"
+  end
+end
+
+Then(/^I expect to use tagname to hash options to (.*?) find element (.*?)$/) do |mode, elem_id|
+  element = browser.find(:div => {:id => elem_id}, :throw => false)
+  if mode.length > 0 # "not "
+    assert element.nil?, "Could find element with a tagname => hash selector"
+  else
+    assert element.exists?, "Could not find element with a tagname => hash selector"
+  end
+end
+