taft 0.1.0 → 0.2.4

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

data/lib/taft.rb

@@ -199,6 +199,8 @@ class Taft
             entries = Dir.entries(dest_base_folder)
             entries.delete(".")
             entries.delete("..")
+			entries.delete(".git")
+			entries.delete(".gitignore")
             entries.each do |f|
                 f = File.expand_path(f)
                 pd "Now looking at #{f}; is dir? #{Dir.exists?(f)}"

data/lib/taft_files/framework/zznamezz.rb

@@ -6,3 +6,6 @@ require "zznamezz/api_helpers/general"
 require "zznamezz/api_helpers/rest"
 
 require "zznamezz/ui_helpers/ui_general"
+
+require "zznamezz/watir/pages/xxabbrevxx_pages"
+require "zznamezz/watir/custom/all"

data/lib/taft_files/framework/zznamezz/api_helpers/general.rb

@@ -5,22 +5,22 @@ require "avro"
 require "csv"
 require "net/ssh"
 require "net/sftp"
+require "more_ruby"
 
 
 class XXabbrevupperxxHelper
     include Test::Unit::Assertions
-    include FrameworkHelpers
 
-    # initialize and method_missing are necessary for for allowing this class to access outside methods
-    attr_accessor :xxabbrevxx_context
-    def initialize(xxabbrevxx_context)
-        @xxabbrevxx_context = xxabbrevxx_context
-    end
-
-    def method_missing(meth, *args)
-        case meth.to_s
-        when /^xxabbrevxx/
-            @xxabbrevxx_context.send(meth, *args)
+    # 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 "XXabbrevupperxxHelper method_missing called; name = #{name.inspect}; #{name.class}"
+ 
+        case name.to_s
+        when /^xxabbrevxx/i
+            RSPages.find(name.to_s) # return the page so that the helper can use it
         else
             super
         end
@@ -28,7 +28,7 @@ class XXabbrevupperxxHelper
 
     # Reads in a file of CSV test data, e.g for use in data-driven tests
     def read_csv_test_data(filename)
-        path = File.join(File.dirname(File.expand_path(__FILE__)) + "/../../../../tests/data", filename)
+        path = File.join(File.dirname(File.expand_path(__FILE__)) + "/../../../tests/data", filename)
         read_csv_data_from_file(path)
     end
 
@@ -43,7 +43,7 @@ class XXabbrevupperxxHelper
 
     # Reads in a JSON schema
     def read_json_schema(schema_filename)
-        path = File.join(File.dirname(File.expand_path(__FILE__)) + "/../../../../tests/data", schema_filename)
+        path = File.join(File.dirname(File.expand_path(__FILE__)) + "/../../../tests/data", schema_filename)
         data = []
         File.open(path, "r") do |f|
             data = f.readlines

data/lib/taft_files/framework/zznamezz/ui_helpers/ui_general.rb

@@ -0,0 +1,26 @@
+
+class XXabbrevupperxxHelper
+
+    def new_browser_at_url(url)
+        puts "New browser at #{url}"
+        case ZZnamezzConfig::BROWSER
+        when :chrome
+            # Set detach to true so the browser remains open once the test finishes
+            options = Selenium::WebDriver::Chrome::Options.new
+            options.add_option(:detach, true)
+            b = Watir::Browser.new :chrome, :options => options
+
+        when :firefox
+            b = Watir::Browser.new :firefox
+
+        end
+
+        b.goto url
+
+        # Store the new browser in the global list
+        $browsers << b
+
+        b # return the browser
+    end
+
+end

data/lib/taft_files/framework/zznamezz/watir/custom/all.rb

@@ -0,0 +1,4 @@
+# simple require class for the Custom folder
+
+# use require_relative, not require
+require_relative 'xxabbrevxx_custom'

data/lib/taft_files/framework/zznamezz/watir/custom/xxabbrevxx_custom.rb

@@ -0,0 +1,32 @@
+
+# All methods in this module will be added to those classes. If methods with the 
+# same names exist, these methods will overwrite the pre-existing ones.
+
+module ZZnamezzCustom
+
+# Example code :
+#
+#  class XXabbrevupperxxPage
+#    
+#    # All page titles exist in the same-named element
+#    def title_field
+#      browser.h1(:id => "page_title")
+#    end
+#    
+#    def title
+#      title_field.value
+#    end
+#    
+#  end
+#  
+#  class XXabbrevupperxxHomepage
+#    
+#    def displayed?
+#      puts "In #{__method__}"
+#      title == "Welcome to ZZnamezz"
+#    end
+#    
+#  end
+#  
+  
+end

data/lib/taft_files/framework/zznamezz/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 ZZnamezzConfig::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
+