taft 0.1.0 → 0.2.4

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: bd9ae23e1324c24c5a99e25a21858ea93ade0f8f1993379501fdfaf76c67ea19
-  data.tar.gz: 5efce5a842f8a21f3b9c75a3a8edce0211aab23ac006f683fb7a562f1193ab31
+  metadata.gz: '0796c9a982c5849970634d3ce2e2838a76816694f12f26089089a7ca4a23098c'
+  data.tar.gz: 86e5aa8c9eec54af5025edd76c95e2fd1374fdb8839e7ab437842e8d6c48a0d1
 SHA512:
-  metadata.gz: b4cc3d8926584f3b14c60f99475c85c5ecdb9265a1d2258c4b9e827037b8bdb25f640ab944fd309bfbb7c40f84da3c4a9237424ce8e390f540b324b18f07c37b
-  data.tar.gz: cf13e673c7f5d6abb4594e42ab55006a3adad34492b3b7bae2f9e9e1bae6f1be702c97e446e6f47820de837fcfa803bff83cf4c4c974b245f8e72879bdeac6b1
+  metadata.gz: 7ebec6f4f7bf92bf2da2454a88c9d9c38eed7495e960618a0087f3cace1fd9a1941610620e2b0b249aa75614d5a5adbb8f3569bd8e93c468f5b9bfb5154dd3a1
+  data.tar.gz: 4d20ab7b94790bcffc53ea9065a00c856d4e313ab410dbd4d184d5ce27c64fdecbd45a14c44eb3a6d42db802450af913bb1b66dc43ab487570c018473037504d

data/README.md

@@ -1,4 +1,4 @@
-### Test Automation Framework Template
+# Test Automation Framework Template (TAFT)
 
 This gem will deploy/install a skeleton code framework for the automated testing of applications with APIs and/or web-UIs.
 
@@ -7,11 +7,17 @@ Languages : Ruby
 ## How to use
 
 Command line : `ruby -e "require 'taft'; Taft.install"`
+This will prompt you for all pertinent parameters.
 
+## Post-deployment
 
+TAFT deploys a skeleton code framework that attempts to cover several common test areas. These often include the use of additional libraries. To reduce deployment bloat, TAFT will **not** attempt to install those additional libraries. You must install them yourself (using your preferred lib-manager), or deactivate the skeleton code that calls these libraries.
 
 
+## Example code
+
+`examples/[language]` contains an example codebase generated from TAFT.
+
 ## TODO 
 
-* More languages : Java
-* Ruby installation will also install some gems (bundled within TAFT)
+* More languages : Java, Python, Golang

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

@@ -0,0 +1,11 @@
+$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/custom/all"

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

@@ -0,0 +1,140 @@
+require "test/unit/assertions" # required for the assert_ methods
+
+require "json-schema"
+require "avro"
+require "csv"
+require "net/ssh"
+require "net/sftp"
+require "more_ruby"
+
+
+class RSHelper
+    include Test::Unit::Assertions
+
+    # 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 "RSHelper method_missing called; name = #{name.inspect}; #{name.class}"
+
+        case name.to_s
+        when /^rs/i, /^google/
+            RSPages.find(name.to_s) # return the page so that the helper-method can use it
+        else
+            super
+        end
+    end
+
+    # 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)
+        read_csv_data_from_file(path)
+    end
+
+    # Reads in a CSV
+    def read_csv_data_from_file(full_file_path)
+        data = []
+        CSV.open(full_file_path, "r") do |csv|
+            data = csv.readlines
+        end
+        data
+    end
+
+    # Reads in a JSON schema
+    def read_json_schema(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
+        end
+        schema = JSON.parse(data.chomp) # there may be trailing whitespace
+        schema
+    end
+
+    # Reads in a serialised AVRO file
+    # Returns an array of the deserialised data rows
+    def read_avro_file(filename)
+        lines = []
+        File.open(path, "rb") do |f|
+            reader = Avro::IO::DatumReader.new
+            dr = Avro::DataFile::Reader.new(f, reader)
+            dr.each do |record|
+                lines << record
+            end
+        end
+        lines
+    end
+
+    # Validates the supplied hash against the JSON schema
+    def validate_hash_against_json_schema(hash, schema_filename)
+        raise "Must supply a hash to #{__method__}" unless hash.class == Hash
+
+        schema = read_json_schema(schema_filename)
+        errors = JSON::Validator.fully_validate(schema, hash)
+        errors
+    end
+
+    # Calls the build_number REST method
+    # This is an example of how to use get_rest_client
+    def get_version_number_from_api(cert_symbol = :regular)
+        client = get_rest_client(:build_number, cert_symbol)
+        json = client.get # {"message":"1.8.0"}
+        parsed = JSON.parse(json)
+        parsed["message"]
+    end
+
+    # Forms a .tar.gz archive from the specified source file
+    # Creates the file in the working directory
+    # Creates the .tar.gz via a call to system
+    def create_tar_gz_file(gz_base_file_name, source_file)
+        gz_name = "#{gz_base_file_name}.tar.gz"
+        cmd = "tar -czf #{gz_name} #{source_file}"
+        system(cmd)
+        gz_name
+    end
+
+    # Renames the specified file on the Linux server
+    # Needs the full path
+    def rename_linux_file(old_file, new_file, cert_symbol = :regular)
+        # Derive the FTP host & path from the URL in config
+        host = RedSkyConfig::SERVER[:red_sky_url].split("//")[1].split(":")[0]
+        host_short_form = host.split(".")[0]
+        user = get_user_id(cert_symbol)
+        pass = get_user_cert_pw(cert_symbol)
+
+        Net::SFTP.start(host, user, :password => pass) do |sftp|
+            puts "Renaming file : #{old_file} -> #{new_file}"
+            sftp.rename(old_file, new_file)
+        end
+    end
+
+    # Sets 777 permissions to the Linux server file
+    # Need the file name & dir
+    def chmod_linux_file(host, user, pass, path, file_name)
+        Net::SSH.start(host, user, :password => pass) do |ssh|
+            ssh.exec!("cd #{path}; chmod 777 #{file_name}")
+        end
+    end
+
+    # Executes the supplied curl command on the server
+    def submit_curl_command(cmd, cert_symbol = :regular)
+        # Derive the FTP host & path from the URL in config
+        host = RedSkyConfig::SERVER[:red_sky_url].split("//")[1].split(":")[0]
+        host_short_form = host.split(".")[0]
+        user = get_user_id(cert_symbol)
+        pass = get_user_cert_pw(cert_symbol)
+
+        output = ""
+        Net::SSH.start(host, user, :password => pass) do |ssh|
+            output = ssh.exec!(cmd)
+        end
+
+        # We expect a JSON response from the server
+        # The recorded output will contain this inside curl's own SDTOUT, so we need to extract the JSON
+        output = output[output.index("{") .. output.index("}")]
+        JSON.parse(output)
+    end
+
+
+end

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

@@ -0,0 +1,249 @@
+require "rest_client"
+require "uri"
+require "openssl"
+require "json"
+
+# File contains methods conductive to the execution of tests and scripts that call REST interfaces
+
+
+class RSHelper
+
+    # Returns a RestClient::Resource object pointing to the URL of the requested service
+    def get_rest_client(service, cert_symbol = :regular, parameter_array_or_hash = [], base_url = RedSkyConfig::SERVER[:red_sky_url], version = nil, timeout = 150)
+        
+        separator = "/"
+        api_version_string = separator + RedSkyConfig::API_VERSION.to_s # as the version parameter can be entirely absent, let's build the separator into the term
+        api_version_string = "" if RedSkyConfig::API_VERSION == :none # special case
+
+        api_version_string = separator + version if version # override always wins
+
+        parameter_array_or_hash = [parameter_array_or_hash] if parameter_array_or_hash.class != Array && parameter_array_or_hash.class != Hash # convert to array if a non-array/hash was supplied
+        
+        # If common headers are needed
+        # headers = {"foo" => bar}
+
+        # Build up the path-string, then append it to the base URL
+        s = "" # initialise before manipulating it
+
+        if service.class == String
+            s = service
+        else
+            case service
+            when :options
+                s = "options#{api_version_string}"
+                s += "/#{parameter_array_or_hash[0]}"
+            when :build_number
+                s = "query/info#{api_version_string}/buildnumber"
+            else
+                raise "Unknown service #{service} supplied to #{__method__}"
+            end
+        end
+
+        encoded = encode_uri(s).to_s # Generates a URI::Generic object; we want a string
+        url = base_url + encoded
+
+        puts url
+
+        #######################################################
+        # Get certificate and other parameters needed for valid credentials
+        #######################################################
+
+        OpenSSL::SSL::SSLContext::DEFAULT_PARAMS[:ssl_version] = "SSLv3" # this may or may not be needed
+
+        cert_path = File.expand_path(RedSkyConfig::CERTIFICATE_DIR) # this must be an absolute filepath
+        cert_extension = get_user_cert_ext(cert_symbol).to_s
+
+        cert_name = get_user_p12_cert_name(cert_symbol)
+        cert_pw = get_user_cert_pw(cert_symbol)
+
+        # ca_file = RedSkyConfig::CA_CERTIFICATE_FILE # needed for VERIFY_PEER mode # VERIFY_PEER mode currently disabled
+
+        if cert_extension.to_sym == :pem
+            # If PEM, the credentials are in two parts - the certs.pem file and the key.pem file
+            # Need to read in the two separate files & construct OpenSSL::X509::Certificate & OpenSSL::PKey::RSA objects
+            cert_key_name = get_user_pem_cert_key_name(cert_symbol)
+            cert_key_pw = get_user_cert_key_pw(cert_symbol)
+            pem = File.read(File.join(cert_path, cert_name))
+            key_pem = File.read(File.join(cert_path, cert_key_name))
+
+            cert = OpenSSL::X509::Certificate.new(pem)
+
+            begin
+                key = OpenSSL::PKey::RSA.new(key_pem, cert_key_pw)
+            rescue
+                raise "Could not form OpenSSL::PKey::RSA object for the corresponding key.pem file. Does it have the right password?"
+            end
+            return RestClient::Resource.new(url, {:ssl_client_cert => cert, :ssl_client_key => key, :verify_ssl => OpenSSL::SSL::VERIFY_NONE, :timeout => timeout})
+        else
+            # If P12 or PFX, only need to construct the one object - the certificate and key are both stored within it
+            begin
+                p12 = OpenSSL::PKCS12.new(File.read(File.join(cert_path, cert_name), :binmode => true), cert_pw)
+            rescue OpenSSL::PKCS12::PKCS12Error => e
+                if e.to_s.include?("mac verify failure")
+                    raise "Could not create PKCS12 object from certificate #{cert_name}; please specify a password for the certificate"
+                else
+                    raise e
+                end
+            end
+
+            # Use if performing SSL Peer verification - needs a ca certificate
+            return RestClient::Resource.new(url, {:ssl_client_cert => p12.certificate, :ssl_client_key => p12.key, :ssl_ca_file => ca_file, :verify_ssl => OpenSSL::SSL::VERIFY_PEER, :headers => headers, :timeout => timeout})
+
+            # Use if not performing SSL Peer verification - does not need a ca certificate
+            return RestClient::Resource.new(url, {:ssl_client_cert => p12.certificate, :ssl_client_key => p12.key, :verify_ssl => OpenSSL::SSL::VERIFY_NONE, :timeout => timeout})
+        end
+
+    end
+
+    # Method to encode the URI
+    # Takes a string or an array of path fragments. If an array, the contents will be joined using / characters
+    def encode_uri(uri)
+        uri = uri.join("/") if uri.class == Array
+        additional_encoding(URI.parse(URI.encode(uri)).to_s)
+    end
+
+
+    # Method to perform additional encoding
+    # URI.encode does not convert the following chars: : + 
+    def additional_encoding(s)
+        encoding_hash = {":" => "%3A", "+" => "%2B"}
+        encoding_hash.each_pair do |k, v|
+            s.gsub!(k, v)
+        end
+        s
+    end
+
+    # Converts a string or int representing the number of microseconds since the Time epoch (1970/01/01) into a DateTime object
+    def read_epoch_time(microseconds_since_epoch)
+        Time.at(microseconds_since_epoch.to_i/1000)
+    end
+
+    # Converts the body of the response object from JSON to Ruby, and sets the defaults for the main hash and all sub-hashes
+    def get_response_body(response)
+        raise "REST response was nil" if response == nil
+        raise "REST response had no attached body" if response.body == nil
+        begin
+            body = JSON.parse(response.body, {:max_nesting => 100})
+            set_all_defaults(body)
+        rescue JSON::ParserError => e
+            puts "rescued : ParserError"
+            puts e
+            body = response.body
+        end
+        body
+    end
+
+
+    # Converts the header of the response object from JSON to Ruby, and sets the defaults for the main hash and all sub-hashes
+    def get_response_header(response)
+        raise "REST response was nil" if response == nil
+        raise "REST response had no attached header" if response.headers == nil
+        begin
+            header = response.headers # already in Ruby Hash format
+            set_all_defaults(body)
+        rescue JSON::ParserError => e
+            puts "rescued : ParserError"
+            puts e
+            header = response.headers
+        end
+        header
+    end
+
+    # Takes a hash a recursively sets the default of the hash and all sub-hashes
+    def set_all_defaults(hash, default = nil)
+        return unless hash.class == Hash
+        hash.default = default
+        hash.each_pair do |k, v|
+            set_all_defaults(v) if v.class == Hash
+            if v.class == Array
+                v.each {|z| set_all_defaults(z) if z.class == Hash}
+            end
+        end
+    end
+
+    # Method to perform a POST request. Requires the RESTClient Resource client and a hash of the information to be sent in the POST body. This hash is converted to JSON for the POST.
+    # Optionally also takes an additional hash which contains desired headers for the POST request.
+    # Returns a RESTClient::Response object
+    def post_request(client, post_information_hash, additional_hash = nil)
+        new_hash = {:content_type => "application/json"}
+        additional_hash ||= {} 
+        new_hash.merge!(additional_hash)
+
+        begin
+            client.post(JSON.generate(post_information_hash, {:max_nesting => 100}), new_hash)
+        rescue OpenSSL::SSL::SSLError => e
+            raise "SSLError occurred when calling REST service; #{e}"
+        rescue RestClient::Exception => e # if the request failed, RestClient will throw an error. We want to retrieve that error and the response within
+            puts "RestClient::Exception hit when calling REST service"
+            puts e
+            puts e.response
+            return e.response
+        rescue => e
+            raise "Unexpected error occurred when calling REST service; #{e}"
+        end
+    end
+
+    # Method to perform a POST request that sends a file. Requires the RESTClient Resource client and a hash of the information to be sent in the POST body.
+    # Assumes that all file information (including the File object itself) is included in the supplied hash
+    # Optionally also takes an additional hash which contains desired headers for the POST request.
+    # Returns a RESTClient::Response object
+    def post_file_request(client, post_information_hash, additional_hash = nil)
+        new_hash = {}
+        additional_hash ||= {} 
+        new_hash.merge!(additional_hash)
+
+        begin
+            client.post(post_information_hash, new_hash)
+        rescue OpenSSL::SSL::SSLError => e
+            raise "SSLError occurred when calling REST service; #{e}"
+        rescue RestClient::Exception => e # if the request failed, RestClient will throw an error. We want to retrieve that error and the response within
+            puts "RestClient::Exception hit when calling REST service"
+            puts e
+            puts e.response
+            return e.response
+        rescue => e
+            raise "Unexpected error occurred when calling REST service; #{e}"
+        end
+    end
+
+    
+    # Method to perform a PUT request. Requires the RESTClient Resource client and a hash of the information to be sent in the PUT body. This hash is converted to JSON for the PUT.
+    # Optionally also takes an additional hash which contains desired headers for the PUT request, e.g. {:content_type => "application/json"}
+    # Returns a RESTClient::Response object
+    def put_request(client, put_information_hash, additional_hash = nil)
+        new_hash = {:content_type => "application/json"}
+        additional_hash ||= {} 
+        new_hash.merge!(additional_hash)
+
+        begin
+            client.put(JSON.generate(put_information_hash, {:max_nesting => 100}), new_hash)
+        rescue OpenSSL::SSL::SSLError => e
+            raise "SSLError occurred when calling REST service; #{e}"
+        rescue RestClient::Exception => e # if the request failed, RestClient will throw an error. We want to retrieve that error and the response within
+            puts "RestClient::Exception hit when calling REST service"
+            puts e
+            puts e.response
+            return e.response
+        rescue => e
+            raise "Unexpected error occurred when calling REST service; #{e}"
+        end
+    end
+
+    
+    # Method to perform a DELETE request. Requires the RESTClient Resource client.
+    # Returns a RESTClient::Response object
+    def delete_request(client)
+        begin
+            client.delete
+        rescue OpenSSL::SSL::SSLError => e
+            raise "SSLError occurred when calling REST service; #{e}"
+        rescue RestClient::Exception => e # if the request failed, RestClient will throw an error. We want to retrieve that error and the response within
+            puts "RestClient::Exception hit when calling REST service"
+            puts e
+            puts e.response
+            return e.response
+        rescue => e
+            raise "Unexpected error occurred when calling REST service; #{e}"
+        end
+    end
+end

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

@@ -0,0 +1,36 @@
+
+class RSHelper
+
+    def new_browser_at_url(url)
+        puts "New browser at #{url}"
+        case RedSkyConfig::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
+
+    def ui_helper_test
+        puts "in #{__method__}"
+    end
+       
+    # Simple method to show that @help can access the browser
+    def enter_google_term(term)
+        googleSearch.search_term = term
+        puts "@help set term"
+    end
+
+end