lapis_lazuli 2.0.1 → 2.1.3

data/lib/lapis_lazuli/generators/cucumber/template/config/users.yml

@@ -0,0 +1,21 @@
+---
+users:
+  default-user: # See ./features/helpers/user_helper.rb
+    username: ta_RAND-ALPHA_
+    password: Ab!2_RAND_
+    gender: male
+    experience: Ruby,Gherkin
+    biography: This is the default test user
+    complete_all: 1
+  production:
+    test-user:
+      username: test
+      password: test
+  test:
+    test-user:
+      username: ta-test-user
+      password: ^%8jah7hH
+  uat:
+    test-user:
+      username: ta-uat-user
+      password: (87hsjaJH#

data/lib/lapis_lazuli/generators/cucumber/template/features/1_basic.feature

@@ -0,0 +1,42 @@
+@basic @all_env
+Feature: Example Feature
+When I want to learn how to make test cases
+As a user of the test automation tool
+I want to run and adjust the tests below
+
+  @basic_01
+  Scenario: example01 - Spritecloud search
+    Given the user navigates to "blog"
+    When the user searches for "lapis lazuli"
+    Then text "Open Source" should display somewhere on the page
+
+  @basic_02
+  Scenario: example02 - Going to a search result
+    Given the user navigates to "https://spritecloud.com/?s=lapis+lazuli"
+    When the user clicks on link "/announcing-lapislazuli/"
+    Then text "Let's talk about testing" should display somewhere on the page
+
+  @basic_03
+  Scenario Outline: example03 - checking multiple pages for the logo
+    Given the user navigates to "<page>"
+    When the user clicks on the spritecloud logo
+    Then the user should be on page "home"
+    Scenarios:
+      | page               |
+      | blog               |
+      | home               |
+      | about-us           |
+      | testing            |
+      | functional-testing |
+
+  ### LEARNING TO DEBUG ###
+  # Scenario' or Feature's including the tag @dev will be ingored when running a regular profile. To run this do:
+  # bundle exec cucumber -t @basic_04 -p debug
+  # or, if you want to test it on a specific environment:
+  # bundle exec cucumber -p production -p debug -t @basic_04
+  # Good luck fixing the problems!
+  @basic_04 @dev
+  Scenario: example_04 - confirming there is a no results page
+    Given the user navigates to "blog"
+    When the user searches for "no_results_expected"
+    Then the text "Nothing Found" should display on the blog page

data/lib/lapis_lazuli/generators/cucumber/template/features/2_account.feature

@@ -0,0 +1,38 @@
+@account @all_env
+Feature: User accounts
+  This feature will make sure the user account functionality is working as expected
+  By checking registration, login and logout functionality
+
+  # This is a best practise example. Please note the following
+  # By defining a register, log-in and log-out state, we can easily re-use all these preconditions
+  # All the scenario's aren't completed, but it should be easy to implement it into your own project.
+
+  @account_01 @log_in #@pause # You can add @pause to have a break between every step.
+  Scenario: account_01 - Logging in
+    Given the user is logged out
+    When "test-user" logs in
+    Then the page should display as logged in state
+
+  @account_02 @log_out
+  Scenario: account_02 - Logging out
+    Given "test-user" is logged in
+    When the user clicks on the logout button
+    Then the page should display as logged out state
+
+  @account_03
+  Scenario: account_03 - Opening the registration form
+    Given the user is logged out
+    When the user clicks on the registration button
+    Then the registration form should display
+
+  @account_04
+  Scenario: account_04 - Successful registration
+    Given "default-user" has the registration form opened
+    When the user completes registration
+    Then the successful registration message should display
+
+  @account_05
+  Scenario: account_05 - Logging in a new registration
+    Given "default-user" has registered a new account
+    When the user logs in
+    Then the page should display as logged in state

data/lib/lapis_lazuli/generators/cucumber/template/features/3_todo_list.feature

@@ -0,0 +1,23 @@
+@todo @all_env
+Feature: Todo list
+  In this feature we will test the todo functionality
+  We do this by adding, completing and deleting the todo lists'
+
+  @todo_01
+  Scenario: todo_01 - adding a todo item
+    Given "test-user" is logged in
+    When a todo item with text "Hello world" is added
+    Then a todo item with text "Hello world" should be present
+
+  @todo_02
+  Scenario: todo_02 - removing all todo items
+    Given "test-user" has at least 1 todo item
+    When the user marks all todo items as completed
+    And the clear completed button is pressed
+    Then no todo items should display
+
+  @todo_03
+  Scenario: todo_03 - confirming the progress bar
+    Given "test-user" has exactly 8 todo items
+    When the user marks 4 todo items as completed
+    Then the progress bar should display at 50 percent

data/lib/lapis_lazuli/generators/cucumber/template/features/helpers/authentication_helper.rb

@@ -0,0 +1,122 @@
+module Auth
+  # This is the Authentication helper, it will have all functions to log in, log out or ensure one of these statusses.
+  # For every part of functionality of a project, you can create a new helper, to keep your TA organised.
+  extend LapisLazuli
+  class << self
+
+    @@user = ''
+    @login_page = 'training-page'
+
+    # This is a list of elements relevant for this helper.
+    # The following is short notation, *only* use this if the element selector can be done in 1 line.
+    # @formatter:off
+    def form_container; browser.wait(:like => [:form, :id, 'form-login']); end
+    def username_field; form_container.input(:xpath => '//*[@id="login-username"]'); end
+    def password_field; form_container.input(:id => 'login-password'); end
+    def login_button; browser.button(:id => 'button-login'); end
+    # @formatter:on
+
+    # Following elements that need more advanced options/search patterns
+    def logged_in_element(timeout=10, throw=true)
+      browser.wait(
+        :like => [:a, :id, 'user_dropdown'],
+        :timeout => timeout,
+        :throw => throw
+      )
+    end
+
+    def logged_out_element(timeout=10, throw=true)
+      browser.wait(
+        :like => [:form, :id, 'form-login'],
+        :timeout => timeout,
+        :throw => throw
+      )
+    end
+
+    # Next are the functions called from the step definitions
+    # `ensure_something` is best practise to be used for functions that should get the test to a certain state. For example:
+    # `ensure_log_out` only logs out if you're logged in
+    # `log_out` will blindly try to log out and fail if you're already logged out
+    def ensure_log_out
+      Nav.to('training-page')
+      if Auth.is_logged_in?
+        Auth.log_out
+        if Auth.is_logged_in?
+          error 'Page did not display in logged out state after logging out'
+        end
+      end
+    end
+
+    # Makes sure that a specific user is logged in, if it's not already.
+    def ensure_log_in(user='default-user')
+      Nav.to('training-page')
+      unless Auth.is_logged_in?(user)
+        # If the wrong user is logged in, we should ensure a log out action and then log in again
+        Auth.ensure_log_out
+        Auth.log_in(user)
+        # Double check if the login was successful, if not, throw an error.
+        unless Auth.is_logged_in?(user)
+          error "Failed to log in `#{user}`."
+        end
+      end
+    end
+
+    # If user=nil, any logged in user is acceptable, else we want to make sure the username matches with the logged in user.
+    def is_logged_in?(user=nil)
+      # For performance, we do a 0 second wait for the logged_out_element
+      if Auth.logged_out_element(0, false)
+        return false
+      end
+      login_elm = Auth.logged_in_element(5, false)
+      if login_elm.nil?
+        # Logged in element not found, check if the logged out element is present
+        logout_elm = Auth.logged_out_element(0, false)
+        if logout_elm.nil?
+          # Neither of the elements were present, this should not be possible.
+          error 'Failed to find the logged_out element and the logged_in element. The user is not logged in, nor logged out.'
+        else
+          # Logged out element was found the second time.
+          return false
+        end
+      else
+        # The logged in element was found, should we match the username?
+        if user.nil?
+          # No, any user is fine
+          return true
+        else
+          # Yes, load the user data and match the username
+          User.load_user_data(user)
+          return login_elm.span(:class => ['username', 'ng-binding']).text == User.get('username')
+        end
+      end
+    end
+
+    def log_out
+      Auth.logged_in_element.click
+      dropdown = browser.wait(:like => [:ul, :class, 'dropdown-menu'])
+      browser.find(
+        :like => [:a, :id, 'link-logout'],
+        :context => dropdown
+      ).click
+    end
+
+    def log_in(user=nil, renew_session=false)
+      # If user=nil, we expect that there already is user data loaded in a previous step.
+      User.load_user_data(user) unless user.nil?
+
+      Auth.username_field.to_subtype.set(User.get('username'))
+      Auth.password_field.to_subtype.set(User.get('password'))
+      Auth.login_button.click
+
+      unless Auth.is_logged_in? user
+        alert = browser.find(:like => [:div, :class, 'alert'], :throw => false)
+        if alert.nil?
+          error "Failed to log in user #{user}"
+        else
+          alert.flash
+          error "Found error while logging in #{user}: `#{alert.text}`"
+        end
+      end
+    end
+  end
+end

data/lib/lapis_lazuli/generators/cucumber/template/features/helpers/navigation_helper.rb

@@ -0,0 +1,64 @@
+# Simple helper that makes navigating using the config file easier
+# It will check if a given string is a URL or a config value and goto that page accordingly
+module Nav
+  extend LapisLazuli
+  class << self
+
+    # Navigates to a given URL or page.url configuration if the current URL is not the same
+    # Then confirms that the new URL is loaded.
+    def to(config_page_or_url, force_refresh = false)
+      url = self.set_url(config_page_or_url)
+      browser.goto url unless url == browser.url and !force_refresh
+      Nav.wait_for_url url
+    end
+
+    # Waits until the browser URL is the same as the given URL
+    def wait_for_url(url)
+      browser.wait_until(timeout: 5, message: "URL did not become `#{url}`") {
+        browser.url.include? url
+      }
+    end
+
+    # Loads the URL from the config, prioritized from top to bottom:
+    # production.pages.home
+    # production.pages.home.path
+    # pages.home
+    # pages.home.path
+    def get_url page
+      begin
+        return env_or_config("pages.#{page}")
+      rescue RuntimeError
+        return env_or_config("pages.#{page}.path")
+      end
+    end
+
+    # Confirms if the given URL is a valid URL
+    def is_url? string
+      uri = URI.parse(string)
+      %w( http https ).include?(uri.scheme)
+    rescue URI::BadURIError
+      false
+    rescue URI::InvalidURIError
+      false
+    end
+
+    # returns the expected URL
+    def set_url(config_page_or_url)
+      if Nav.is_url? config_page_or_url
+        # Return the given URL if it alreadt is a valid URL
+        return config_page_or_url
+      else
+        # Look for the URL in the config files
+        path_or_url = get_url config_page_or_url
+        if Nav.is_url? path_or_url
+          # If it is a URL now, then return it
+          return path_or_url
+        else
+          # Else add an expected 'root' to the path.
+          return env('root') + path_or_url
+        end
+      end
+    end
+
+  end
+end

data/lib/lapis_lazuli/generators/cucumber/template/features/helpers/registration_helper.rb

@@ -0,0 +1,93 @@
+module Register
+
+  extend LapisLazuli
+  class << self
+
+    # This is a list of elements relevant for this helper.
+    # The following is short notation, *only* use this if the element selector can be done in 1 line.
+    # @formatter:off
+    def form; browser.wait(:like => [:form, :id, 'form-register']); end
+    def open_register_button; browser.find(:like => [:button, :id, 'button-register']); end
+    def username_field; browser.find(:element => {:name => 'username'}, :context => Register.form); end
+    def password_field; browser.find(:element => {:name => 'password'}, :context => Register.form); end
+    def experience_field; browser.find(:like => [:select, :id, "register-experience"], :context => form); end
+    def biography_field; browser.find(:like => [:textarea, :id, 'register-bio']); end
+    def policy_checkbox; browser.find(:like => [:input, :id, 'register-complete-all']) end
+    def submit_button; browser.find(:button => {:id => 'button-save'}, :context => Register.form); end
+    # @formatter:on
+
+    def gender_radio(gender)
+      browser.find(
+        :label => {:text => /#{gender}/i},
+        :context => Register.form,
+        :message => "Unable to find gender `#{gender}`, are you sure it's an option to select?"
+      )
+    end
+
+    def select_experiences(*experience_list)
+      experience_list.each do |exp|
+        option = browser.find(
+          :option => {:value => /#{exp}/i},
+          :context => Register.experience_field
+        )
+        option.click(:control)
+      end
+    end
+
+    # The following 3 functions are a typical example of something to use.
+    # First a function in which you perform an action (open_something, click_something, press_something)
+    def open_registration
+      Register.open_register_button.click
+    end
+
+    # Second, a function that confirms that the action was successful
+    def is_registration_open?
+      return Register.form rescue false
+    end
+
+    # And finally as function that ensures an action was successfully completed.
+    def ensure_open_registrarion
+      Auth.ensure_log_out
+      Register.open_registration unless Register.is_registration_open?
+    end
+
+    def fill_form
+      Register.username_field.set(User.get('username'))
+      Register.password_field.set(User.get('password'))
+      Register.gender_radio(User.get('gender')).click
+      Register.select_experiences(User.get('experience').split(','))
+      Register.biography_field.set(User.get('biography'))
+      Register.policy_checkbox.set((User.get('complete_all').to_i == 1))
+    end
+
+    def submit_form
+      Register.submit_button.click
+    end
+
+    def register_user
+      Register.fill_form
+      Register.submit_form
+    end
+
+    def registration_result
+      alert = browser.wait(like: [:div, :class, 'alert'], timeout: 2, throw: false)
+      if alert.nil?
+        return false, 'No message was displayed after registering'
+      elsif !alert.text.include? User.get('username')
+        return false, "An error message did display, but didn't contain the expected text: `#{alert.text}`"
+      end
+      return true, 'Successfully found the success message'
+    end
+
+    def ensure_registered(user)
+      begin
+        Auth.ensure_log_in(user)
+        Auth.log_out
+      rescue Exception => e
+        Register.ensure_open_registrarion
+        Register.register_user
+      end
+    end
+
+  end
+end

data/lib/lapis_lazuli/generators/cucumber/template/features/helpers/user_helper.rb

@@ -0,0 +1,74 @@
+# This helper loads user data from the config files.
+# After loading the data, it will overwrite certain strings, like __TIMESTAMP__ to randomize information
+module User
+  extend LapisLazuli
+
+  class << self
+    @@data = nil
+
+    def load_user_data(user)
+      data = config('users.default-user')
+      begin
+        specific_data = config("users.#{user}")
+      rescue Exception => err1
+        begin
+          specific_data = config("users.#{ENV['TEST_ENV']}.#{user}")
+        rescue Exception => err2
+          error "The given user `#{user}` was not found in any of the config files:\n- #{err1.message}\n- #{err2.message}"
+        end
+      end
+      new_data = data.merge specific_data
+      @@data = replace_hash_constants(new_data)
+    end
+
+    def get(field)
+      return @@data[field]
+    end
+
+    def set(field, value)
+      @@data[field] = User.replace_constants(value)
+    end
+
+    # Replace random or time values of a complete hash
+    def replace_hash_constants(hash)
+      if hash.respond_to? :each
+        new_hash = {}
+        hash.each do |key, value|
+          new_hash[key] = replace_constants(value)
+        end
+      else
+        new_hash = replace_constants(hash)
+      end
+      return new_hash
+    end
+
+    # replace certain constants in a string, for example '_TIMESTAMP_' becomes '154875631'
+    def replace_constants(value)
+      if value.to_s == value
+        epoch = Time.now.to_i
+        alpha = number_to_letter(epoch)
+        timestamp = Time.now.strftime("D%Y-%M-%d-T%H-%M-%S")
+
+        old_val = value.to_s
+        value = value.sub('_RAND_', epoch.to_s)
+        value = value.sub('_TIMESTAMP_', timestamp)
+        value = value.sub('_RAND-ALPHA_', alpha)
+        unless value == old_val
+          log.debug "#{old_val} > #{value}"
+        end
+      end
+      return value
+    end
+
+    def number_to_letter(numbers)
+      num_string = numbers.to_s
+      alpha26 = ("a".."j").to_a
+      letters = ''
+      num_string.scan(/./).each do |number|
+        letters += alpha26[number.to_i]
+      end
+      return letters
+    end
+
+  end
+end