taft 0.1.0 → 0.2.0

data/examples/ruby/rs/framework/red_sky/watir/pages/page_objects.rb

@@ -0,0 +1,166 @@
+# Base class that every defined page will inherit from
+class Page
+
+  attr_accessor :name, :displayed_field, :displayed_value
+  attr_accessor :browser
+  attr_accessor :field_parameters_array # stores parameters of each field added to the page
+
+  # Name : the name of this page, e.g. rsHomepage
+  # Field : the field used to determine if the page is displayed. More precisely,
+  # the name of the method that accesses the field. E.g. if the page has a field called 'page_title' 
+  # defined, then its accessor method 'page_title_field' will have been generated .
+  # If the displayed? check is against an expected value, specify the field name corresponding to 
+  # the read-method (e.g. page_title), and specify the value (String or Regexp).
+  # If the displayed? check is for a field to exist, specify the field's accessor method name 
+  # (e.g. page_title_field), and keep value nil.
+  def initialize(name, field, value = nil)
+    @name = name
+    @displayed_field = field
+    @displayed_value = value
+    @field_parameters_array = []
+  end
+
+  def displayed?(wait = true)
+    displayed = false
+    puts "in displayed? for page #{@name}"
+    if wait
+      puts "will wait for page to be loaded"
+      wait_until_displayed
+    end
+    
+    puts "about to send to #{@displayed_field.to_sym.inspect}"
+    begin
+      field_or_value = self.send(@displayed_field.to_sym)
+    rescue Watir::Exception::UnknownObjectException
+      # cannot find the field on the page
+      # do nothing, displayed will stay false
+    rescue Selenium::WebDriver::Error::StaleElementReferenceError
+      # TODO : fix! wait then call displayed? again?
+      puts "hit StaleElementReferenceError for page #{@name}"
+    end
+
+    puts "field_or_value retrieved is of class #{field_or_value.class}"
+    p field_or_value
+    if @displayed_value == nil
+      displayed = true if field_or_value.exists?
+    else
+      if @displayed_value.class == Regexp
+        displayed = true if field_or_value =~ @displayed_value
+      else
+        displayed = true if field_or_value == @displayed_value
+      end
+    end
+    displayed
+  end
+
+  # Method to wait for the page to be displayed, up to <timeout> seconds
+  # Returns displayed status (true/false)
+  def wait_until_displayed(timeout = 5)
+    max = timeout * 10
+    count = 0
+    displayed = false
+    while count < max
+      displayed = displayed?(false)
+      break if displayed
+      sleep 0.2
+      count += 2
+    end
+    displayed
+  end
+
+  # Defines methods to access the field of specified type, by specified key & value
+  def add_field(name, type, key, value)
+    field_parameters_array << [name, type, key, value]
+    add_field_using_constructor_class(name, type, key, value)
+  end
+  
+  # Add to self all fields that were defined on page_object
+  # E.g. the supplied page_object represents part of a panel/page that is common to several pages
+  def add_page(page_object)
+    page_object.field_parameters_array.each do |field_parameters|
+      add_field(field_parameters[0], field_parameters[1], field_parameters[2], field_parameters[3])
+    end
+  end
+
+  # Defines methods to access the field of specified type, by specified key & value
+  def add_field_using_constructor_class(name, type, key, value)
+    PageFieldConstructor.add_fields(self, name, type, key, value)
+  end
+
+end # end Page
+
+class PageFieldConstructor
+
+  # Defines methods to access the field of specified type, by specified key & value
+  def PageFieldConstructor.add_fields(page_object, name, type, key, value)
+
+    # Fields cannot have the following names : name
+    raise "Field on page #{page_object.name} with name of #{name} is not allowed" if RedSkyConfig::DISALLOWED_FIELD_NAMES.include?(name)
+    
+    case type
+    when :button
+      real_type = :input
+    else
+      real_type = type
+    end
+    
+    # add accessor to field
+    s = <<-METHOD
+    def page_object.#{name}_field
+#      puts "in #{name} method"
+      @browser.#{real_type}(#{key.inspect} => "#{value}")
+    end    
+    METHOD
+    #    page_object.class.module_eval(s) # do not do this - want to add methods (field) to the object, not the class!
+    eval(s)
+
+    case type
+      when :text_field
+        add_read_method(page_object, name)
+        add_write_method(page_object, name)
+      when :button
+        add_click_method(page_object, name)
+      when :link
+        add_read_method(page_object, name)
+        add_click_method(page_object, name)
+      else
+        add_read_method(page_object, name)
+    end
+
+  end
+
+  def PageFieldConstructor.add_read_method(page_object, name)
+    s = <<-READ
+        def page_object.#{name}
+#          puts "in #{name} read method"
+          #{name}_field.text # value
+        end    
+    READ
+    #    page_object.class.module_eval(s) # do not do this - want to add methods (field) to the object, not the class!
+    eval(s)
+  end
+
+  def PageFieldConstructor.add_write_method(page_object, name)
+    s = <<-WRITE
+        def page_object.#{name}=(v)
+#          puts "in #{name} write method"
+          #{name}_field.set(v) 
+        end    
+    WRITE
+    #    page_object.class.module_eval(s) # do not do this - want to add methods (field) to the object, not the class!
+    eval(s)
+  end
+
+  def PageFieldConstructor.add_click_method(page_object, name)
+    s = <<-CLICK
+        def page_object.click_#{name}
+#          puts "in #{name} click method"
+          #{name}_field.click
+        end    
+    CLICK
+    #    page_object.class.module_eval(s) # do not do this - want to add methods (field) to the object, not the class!
+    eval(s)
+  end
+
+end
+

data/examples/ruby/rs/framework/red_sky/watir/pages/rs_pages.rb

@@ -0,0 +1,68 @@
+# Class that holds definitions for all of the pages in RedSky
+# These can be used to determine if the browser is currently displaying that page
+#
+# Field types :
+# Use :text_field instead of :input if it's a text-field
+# Use :button instead of :input if it's a button
+# Otherwise, use the actual HTML element type
+
+require_relative 'page_objects'
+
+class RSPages
+
+  @@browser = nil
+  @@pages = [] # an array of Page objects
+  @@page_names = []
+
+  def self.make_pages(browser)
+    @@browser = browser
+
+    # Google Search
+    page = Page.new("googleSearch", "search_term_field")
+
+    page.add_field("search_term", :text_field, :name, "q")
+    page.add_field("search_button", :button, :name, "btnK")
+
+    self.add_page(page)
+ 
+    
+    # Google Search Results
+    page = Page.new("googleSearchResults", "result_stats_field")
+
+    page.add_field("result_stats", :div, :id, "resultStats")
+
+    self.add_page(page)
+  end
+
+##################################################################################################
+
+
+  def self.add_page(page)
+    page.browser = @@browser # set the browser object for each page
+    # TODO have only one browser object (here in RSPages), and have each page know how to find it, instead of taking
+    # their own copy of the object
+    @@pages << page
+    @@page_names << page.name
+  end
+
+  # Outputs info on the pages currently stored
+  def self.info
+    s = ""
+    s += "#{@@pages.size} pages defined. Names :"
+    @@page_names.each {|f| s += "\n#{f}" }
+    s
+  end
+
+  # Will convert name to a string
+  def self.page_known?(name)
+    @@page_names.include?(name.to_s)
+  end
+
+  # Retrieves the specific page; raises if it cannot be found
+  # Will convert name to a string
+  def self.find(name)
+    raise "Could not locate page '#{name}'" unless self.page_known?(name)
+    @@pages[@@page_names.index(name.to_s)]
+  end
+end
+

data/examples/ruby/rs/framework/red_sky.rb

@@ -0,0 +1,12 @@
+$LOAD_PATH.unshift File.dirname(__FILE__)
+
+# Add a require line for every file within framework/red_sky
+
+require "red_sky/api_helpers/general"
+require "red_sky/api_helpers/rest"
+
+require "red_sky/ui_helpers/ui_general"
+
+require "red_sky/watir/pages/rs_pages"
+require "red_sky/watir/flows/rs_flows"
+require "red_sky/watir/custom/all"

data/examples/ruby/rs/lib/config/red_sky_config.rb

@@ -0,0 +1,27 @@
+# Holds system configuration parameters
+
+require_relative 'runtime_constants.rb'
+
+class RedSkyConfig
+    include RuntimeConstants
+    
+    CERTIFICATE_DIR = "certs"
+    CERTIFICATE_POPUP_TIMEOUT = 15
+
+    API_VERSION = "latest"
+
+    SERVERS = {
+        :test_1 => {:red_sky_url => "https://www.google.co.uk"},
+        :ref_1 => {:red_sky_url => "https://"},
+    }
+
+    SERVER = SERVERS[$TEST_ENV]
+
+
+    PASSED = "Passed"
+    FAILED = "Failed"
+
+    DISALLOWED_FIELD_NAMES = ["name"]
+
+    ALL_USER_ROLES = ["all"]
+end

data/examples/ruby/rs/lib/config/runtime_constants.rb

@@ -0,0 +1,20 @@
+
+# This class holds parameters that may frequently change between test runs, e.g the test environment
+module RuntimeConstants
+
+    $TEST_ENV = :test_1
+
+    CLOSE_BROWSER_AFTER_TEST = true # close the browser if the test passed?
+    FORCE_CLOSE_BROWSER_AFTER_TEST = false # always close the browser?
+
+    MAKE_ERROR_SCREENSHOTS = true
+    ERROR_SCREENSHOT_LOCATION = "screenshots"
+
+    WRITE_CI_REPORTS = false
+
+    BROWSER = :chrome
+
+    RESULTS_CSV = "results.csv"
+
+end
+

data/examples/ruby/rs/lib/red_sky_test_case.rb

@@ -0,0 +1,218 @@
+
+# This file defines a module to be included in all test cases for the testing of RED SKY.
+# This module contains a general setup and teardown method that each test should run.
+# If tests wish to perform their own specific seup and/or teardown routines, they 
+# should implement their own methods and call super within them to trigger these common
+# setup/teardown methods at the right time.
+
+$LOAD_PATH.unshift(File.expand_path(File.dirname(__FILE__) + "/.."))
+
+gem 'test-unit'
+require 'test/unit'
+require 'tmpdir'
+require 'time'
+require 'fileutils'
+require 'timeout'
+require 'watir'
+
+# Config
+require 'config/red_sky_config.rb'
+
+# Helpers
+require 'framework/red_sky.rb'
+
+
+
+STDOUT.sync = true
+
+if RedSkyConfig::WRITE_CI_REPORTS
+    require 'ci/reporter/rake/test_unit_loader'
+    
+    ENV["CI_REPORTS"] = $CI_REPORTS_PATH # supplied in invokation to test
+    puts "Will create XML reports in #{ENV["CI_REPORTS"]}"
+end
+
+module RedSkyTestCase
+
+    attr_accessor :browser_has_been_opened
+
+    # optional field
+    # If the cause of a test's failure is already likely to be known, the contents of this variable 
+    # will automatically be added to the test result's Notes field, to help with reporting.
+    # If there are multiple tests in a file, this variable needs to be set within each test 
+    # method (if they have any relevent failure notes).
+    attr_accessor :failure_notes
+
+    # E.g. calling homepage.displayed? from a test script :
+    # Test cannot see homepage so its call is routed through method_missing
+    # If method_missing returns an instance of the class, .displayed? can be called on it (seamlessly)
+    # At present this will happen for every call to a page from a test script
+    def method_missing(name, *args, &block)
+        #puts "RedSkyTestCase method_missing called; name = #{name.inspect}; #{name.class}"
+ 
+        case name.to_s
+        when /^browser$/
+            browser
+        when /^rs/i, /^google/
+            RSPages.find(name.to_s) # return the page so that the helper-method can use it
+        else
+            super
+        end
+    end
+
+    if $WRITE_RESULTS # supplied from invokation
+        WRITE_RESULTS = true
+    else
+        WRITE_RESULTS = false
+    end
+
+    # Connect to RED SKY and reinitialise the context, etc.
+    def rs_login(url = RedSkyConfig::SERVER[:red_sky_url])
+        browser = @help.new_browser_at_url(url)
+        load_pages(browser)
+    end
+
+    # Connect to RED SKY and reinitialise the context, etc.
+    def google_login(url = RedSkyConfig::SERVER[:red_sky_url])
+        browser = @help.new_browser_at_url(url)
+        load_pages(browser)
+    end
+    
+    def load_pages(browser)
+        RSPages.make_pages(browser) # cannot have pages without a browser object
+        @browser_has_been_opened = true
+    end
+
+    # Close the current browser
+    def close_browser
+        browser.close
+    end
+
+    def close(browser)
+        if browser.exists? && ((RedSkyConfig::CLOSE_BROWSER_AFTER_TEST && passed?) || RedSkyConfig::FORCE_CLOSE_BROWSER_AFTER_TEST)
+            browser.close
+            $browsers.delete_at($current_browser_position - 1) # array indexing
+            browser = $browsers[-1] # set browser to the last one that is still in the array
+        end
+    end
+
+    def close_all_browsers
+        if (RedSkyConfig::CLOSE_BROWSER_AFTER_TEST && passed?) || RedSkyConfig::FORCE_CLOSE_BROWSER_AFTER_TEST
+            until $browsers.empty?
+                browser = $browsers.shift
+                browser.close
+            end
+        end
+    end
+
+
+    @@browser = nil
+
+    def browser
+        @@browser
+    end
+
+    def browser=(b)
+        @@browser = b
+    end
+    alias set_browser browser= # note : calls of "browser = " do not work, calls of "browser=" do
+
+    # Ensure that every test (that wants one) has a browser that is already logged in to the system
+    def setup
+
+        @help = RSHelper.new
+
+        Watir.always_locate = true # default is true; setting to false speeds up Watir to a degree
+
+        # Get start time for later output in results
+        @test_start_time = Time.now
+
+        # Get the directory that the specific test lives in, so that it can be included in the results file
+        @test_file_dir = @test_file.split(File::SEPARATOR)[-2] if @test_file
+
+        # Select default certificate if none is configured
+        @certificate ||= :regular
+
+        @timeout = RedSkyConfig::CERTIFICATE_POPUP_TIMEOUT
+
+        # Open the browser & ensure page contenxt and helper are available
+        $browsers = [] # global array containing all browser objects
+        # $current_browser_position = nil # global variable to track the position in $browsers of the active browser # TODO used?
+        # When that browser is closed, we can ensure that the corresponding browser object is removed from the array
+        if @initialBrowser == :rs
+            rs_login
+        elsif (@initialBrowser == :none || @initialBrowser == nil)
+            browser = nil
+        end
+
+    end # end setup
+
+    # Close all browsers and write the result of the test to the results CSV
+    def teardown
+
+        begin
+            # Get end time
+            @test_end_time = Time.now
+            elapsed_time = (@test_end_time - @test_start_time).to_s
+            elapsed_time_in_minutes = (elapsed_time.to_i/60.0).to_s
+
+            test_name = self.to_s.split("(")[0] # self.to_s gives output like test_ABC5_01(TC_ABC5_01)
+
+            puts "Test has now finished; #{test_name} : #{passed?}"
+
+            if WRITE_RESULTS
+                puts "Will now write results to #{RedSkyConfig::RESULTS_BASE_DIR}"
+
+                notes = ""
+                success_text = passed? ? RedSkyConfig::PASSED : RedSkyConfig::FAILED
+
+                unless passed?
+                    begin
+                        if RedSkyConfig::MAKE_ERROR_SCREENSHOTS
+                            puts "Now taking error screenshots"
+                            dir_2 = RedSkyConfig::ERROR_SCREENSHOT_LOCATION
+                            Dir.mkdir(dir_2) unless File.exists?(dir_2)
+                            $browsers.each do |browser|
+                                browser.screenshot.save(RedSkyConfig::ERROR_SCREENSHOT_LOCATION + "/#{test_name}_Time_#{@test_end_time.strftime("%H-%M-%S")}_Browser_#{$browsers.index(browser)}.png")
+                            end
+                        end
+                    rescue
+                        puts "Failed to make screenshot"
+                    end
+                    notes = @failure_notes
+                    puts "Notes : #{notes}"
+                end # end unless passed?
+
+                
+                # Write to the results file
+                begin
+                    File.open(RedSkyConfig::RESULTS_CSV, "a") do |f|
+                        row = [@test_file_dir, test_name, success_text, @test_start_time.strftime("%Y-%m-%d %H:%M:%S"), @test_end_time.strftime("%Y-%m-%d %H:%M:%S"), elapsed_time, elapsed_time_in_minutes, notes]
+                        f.puts row.join(",")
+                        puts "Result for test #{test_name} written"
+                    end
+                rescue
+                    puts "Had to rescue from writing results to file #{RedSkyConfig::RESULTS_CSV}"
+                end
+            end # end if WRITE_RESULTS
+            
+            close_all_browsers
+
+        rescue Timeout::Error => t_error
+            puts "Timeout::Error :"
+            puts t_error
+            puts "Backtrace :"
+            puts t_error.backtrace
+        rescue Exception => error
+            puts "Error :"
+            puts error
+            puts "Backtrace :"
+            puts error.backtrace
+        end # end begin
+    end
+
+
+
+end
+
+

data/examples/ruby/rs/tests/v1/tc_r001_01_an_example_test.rb

@@ -0,0 +1,112 @@
+$LOAD_PATH.unshift(File.expand_path(File.dirname(__FILE__) + "/../../lib")
+
+require "red_sky_test_case"
+
+class TC_R001_01_AN_EXAMPLE_TEST < Test::Unit::TestCase
+    include RedSkyTestCase
+    
+    def setup
+        # specify setup parameters
+        @certificate = :regular # this is the default user for this test
+        @initialBrowser = :none # if you want this test to navigate to your webapp automatically as part of setup, change this value to the value referring to your webapp
+
+        super # must call super so that the common setup method in RedSkyTestCase is called
+    end
+
+    def test_r001_01_an_example_test
+
+        ############################################################################################
+        # PURPOSE :
+        #   Verify that <description of your test's intent>
+        # 
+        # PRECONDITIONS :
+        #   <list your preconditions>
+        ############################################################################################
+
+        filename = "data_for_example_test.csv" # file must be in the data/ directory
+        data = @help.read_csv_test_data(filename)
+        header = data.shift
+
+        # Step 1 :
+        #   Send a request to the RED SKY API Options method
+
+        random_row = data.random
+        search_term = random_row[0]
+        expected_result_count = random_row[1]
+
+        # This is too raw - it would be better to bundle these lines into a separate "search_options" method,
+        # with additional validation (e.g. to throw a clean error if the request failed)
+        @client = @help.get_rest_client(:options, @certificate, search_term)
+        json = client.get
+        response = JSON.pretty_unparse(json)
+
+        # Expected Result :
+        #   The request has succeeded & returned the expected results
+
+        # This is quite brittle
+        # A better approach is to create a new class which would parse the response & convert
+        # it into a bespoke Object, so that the various values could be accessed in a better OO-fashion.
+        # E.g. response.number_of_results. The object could also have extra methods, 
+        # e.g. response.check_results_are_valid, and so on.
+        assert_equal(expected_result_count, response["number_of_results"], "The search request did not return the expected number of results")
+
+        
+        # Step 2 :
+        #   Log in to RED SKY
+
+        rs_login
+
+        # Expected Result :
+        #   The RED SKY homepage is displayed
+
+        assert(rsHomepage.displayed?, "The RED SKY homepage is not displayed")
+
+        
+        # Step 3 :
+        #   Enter in a search term and click the Search button.
+
+        data.each do |row|
+            search_term = row[0]
+            expected_result_text = row[2]
+            puts "Will now search for '#{term}'; expect to see '#{expected_result_text}'"
+
+            rsHomepage.term = search_term
+            rsHomepage.click_search
+
+
+            # Expected Result :
+            #   Results are displayed
+
+            assert(rsSearchResults.displayed?, "The RED SKY search results page is not displayed")
+            assert_equal(expected_result_text, rsSearchResults.result, "The RED SKY search results page did not display the expected result")
+
+        
+            # Step 4 :
+            #   Return to the previous page
+
+            browser.back
+
+
+
+            # Expected Result :
+            #   The RED SKY homepage is displayed
+            
+            assert(rsHomepage.displayed?, "The RED SKY homepage is not displayed")
+
+            
+            # Step 5 :
+            #   Repeat steps 3 and 4 for a few more search terms
+
+            # Actions performed in above steps
+
+
+            # Expected Result :
+            #   Results are displayed for each term
+
+            # Assertions performed in above steps
+   
+        end # end .each
+
+    end
+
+end

data/examples/ruby/rs/tests/v1/tc_r001_01_google_search.rb

@@ -0,0 +1,64 @@
+$LOAD_PATH.unshift("#{File.expand_path(File.dirname(__FILE__))}/../../lib")
+
+require "red_sky_test_case"
+
+class TC_R001_01_GOOGLE_SEARCH < Test::Unit::TestCase
+    include RedSkyTestCase
+    
+    def setup
+        # specify setup parameters
+        @certificate = :regular # this is the default user for this test
+        @initialBrowser = :none # if you want this test to navigate to your webapp automatically as part of setup, change this value to the value referring to your webapp
+
+        super # must call super so that the common setup method in RedSkyTestCase is called
+    end
+
+    def test_r001_01_google_search
+
+        ############################################################################################
+        # PURPOSE :
+        #   Verify that Google searches can be made
+        # 
+        # PRECONDITIONS :
+        #   None
+        ############################################################################################
+
+        @help.ui_helper_test
+
+        # Step 1 :
+        #   Open the Google Search page
+
+        google_login
+
+        # Expected Result :
+        #   The RED SKY homepage is displayed
+
+        assert(googleSearch.displayed?, "The Google search page is not displayed")
+
+        
+        # Step 3 :
+        #   Enter in a search term and click the Search button.
+
+        term = "Ruby"
+
+        puts "Will now search for '#{term}'"
+
+        #googleSearch.search_term = term
+        @help.enter_google_term(term) # use @help to set the field, demonstrating that this can be done outside the test
+        googleSearch.click_search_button
+
+
+        # Expected Result :
+        #   Results are displayed
+
+        assert(googleSearchResults.displayed?, "The Google search results page is not displayed")
+        
+        puts googleSearchResults.result_stats
+        
+        assert_not_nil(googleSearchResults.result_stats, "The Google search results page did not display any result-stats")
+        assert_not_empty(googleSearchResults.result_stats, "The Google search results page did not display any result-stats")
+
+
+    end
+
+end