taft 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: bd9ae23e1324c24c5a99e25a21858ea93ade0f8f1993379501fdfaf76c67ea19
+  data.tar.gz: 5efce5a842f8a21f3b9c75a3a8edce0211aab23ac006f683fb7a562f1193ab31
+SHA512:
+  metadata.gz: b4cc3d8926584f3b14c60f99475c85c5ecdb9265a1d2258c4b9e827037b8bdb25f640ab944fd309bfbb7c40f84da3c4a9237424ce8e390f540b324b18f07c37b
+  data.tar.gz: cf13e673c7f5d6abb4594e42ab55006a3adad34492b3b7bae2f9e9e1bae6f1be702c97e446e6f47820de837fcfa803bff83cf4c4c974b245f8e72879bdeac6b1

data/LICENCE.txt

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2016 Richard Morrisby
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

data/README.md

@@ -0,0 +1,17 @@
+### Test Automation Framework Template
+
+This gem will deploy/install a skeleton code framework for the automated testing of applications with APIs and/or web-UIs.
+
+Languages : Ruby
+
+## How to use
+
+Command line : `ruby -e "require 'taft'; Taft.install"`
+
+
+
+
+## TODO 
+
+* More languages : Java
+* Ruby installation will also install some gems (bundled within TAFT)

data/build.rb

@@ -0,0 +1,51 @@
+# Simple build script
+# Deletes the existing gem file (if present)
+# Uninstalls the gem
+# Builds the gem
+# Installs the new gem
+
+# Note : when calling system (or backticks, etc.) th enew process starts at the system default, not the current working directory.
+# Therefore we need to use a syntax of : system "cd #{gem_dir} && #{i_cmd}"
+
+# Run from this directory!
+
+gem_dir = Dir.getwd
+
+# Delete existing .gem files in the dir
+
+gemfiles = Dir.entries(gem_dir).collect {|q| q if q =~ /.gem$/}.compact
+
+gemfiles.each do |q| 
+	File.delete q
+	puts "Deleted #{q}"
+end
+
+gemfiles = Dir.entries(gem_dir).collect {|q| q if q =~ /.gem$/}.compact
+raise "Gem has not been deleted" unless gemfiles.size == 0
+
+# Uninstall, build, install
+gemspecs = Dir.entries(gem_dir).collect {|q| q if q =~ /.gemspec$/}.compact
+
+raise "Did not find a .gemspec in #{gem_dir}" if gemspecs.size < 1
+raise "Found more than one .gemspec in #{gem_dir}" if gemspecs.size > 1
+
+gemspec = gemspecs[0]
+
+gemname = File.basename(gemspec, File.extname(gemspec))
+
+u_cmd = "gem uninstall #{gemname}"
+system u_cmd
+
+b_cmd = "gem build #{gemspec}"
+system "cd #{gem_dir} && #{b_cmd}"
+
+gemfiles = Dir.entries(gem_dir).collect {|q| q if q =~ /.gem$/}.compact
+raise "Gem was not built" unless gemfiles.size == 1
+
+gemfile = gemfiles[0]
+raise "Gem file is not for the expected gem, expected a #{gemname} gem but found #{gemfile}" unless gemfile =~ /^#{gemname}/
+
+i_cmd = "gem install #{gemfile}"
+system "cd #{gem_dir} && #{i_cmd}"
+
+puts "Gem #{gemname} built & installed"

data/lib/taft.rb

@@ -0,0 +1,286 @@
+require 'fileutils'
+require 'pathname'
+require 'more_ruby'
+
+def pd(s)
+    puts s if $TAFT_DEBUGGING
+end
+
+class Taft
+    TEMPLATE_PROJECT_NAME_REGEX = /(zznamezz)/ # e.g. redsky if one word, red_sky if two # regex to use when matching a template file name
+    TEMPLATE_PROJECT_NAME_UPPERCASE_REGEX = /(ZZnamezz)/ # e.g. Redsky if one word, RedSky if two # regex to use when matching a template file name
+    TEMPLATE_PROJECT_ABBREV_REGEX = /(xxabbrevxx)/ # e.g. bs # regex to use when matching a template file name
+    TEMPLATE_PROJECT_ABBREV_UPPERCASE_REGEX = /(xxabbrevupperxx)/i # e.g. BS # regex to use when matching some template text
+    TEMPLATE_PROJECT_RAW_NAME_REGEX = /(yyrawnameyy)/i # e.g. RED SKY # regex to use when matching some template text
+
+    NAMES_AND_ABBREVS_REGEXES = [TEMPLATE_PROJECT_ABBREV_REGEX, TEMPLATE_PROJECT_ABBREV_UPPERCASE_REGEX, TEMPLATE_PROJECT_NAME_REGEX, TEMPLATE_PROJECT_NAME_UPPERCASE_REGEX]
+    TEMPLATE_GEM_NAME_REGEX = /-\d+.\d+.\d+.gem/
+
+    LANGUAGES = [:ruby]#, :java] # Java not yet supported
+
+    @project_name_part = nil
+    @project_name_uppercase_part = nil
+    @project_abbrev_part = nil
+    @project_abbrev_uppercase_part = nil
+
+    def self.install_ruby(debugging = false, dest = "", overwrite_ok = false, project_name = "", project_abbrev = "")
+        install(:ruby, debugging, dest, overwrite_ok, project_name, project_abbrev)
+    end
+
+    def self.install_java(debugging = false, dest = "", overwrite_ok = false, project_name = "", project_abbrev = "")
+        install(:java, debugging, dest, overwrite_ok, project_name, project_abbrev)
+    end
+
+    def self.install(lang = nil, debugging = false, dest = "", overwrite_ok = false, project_name = "", project_abbrev = "")
+        $TAFT_DEBUGGING = true if debugging
+
+        unless dest.empty?
+            puts "Taft.install has been called with the following parameters :"
+            puts "Language             : #{lang}"
+            puts "Project name         : #{project_name}"
+            puts "Project abbreviation : #{project_abbrev}"
+            puts "Destination folder (relative to #{Dir.getwd} if a relative path) : #{dest}"
+            puts "Press Enter to continue..."
+            gets
+        end
+
+        base_wd = Dir.getwd
+        dest_base_folder = ""
+
+        if lang == nil
+            puts "\nPlease enter the language of this project : #{LANGUAGES.join(", ")}"
+            lang = gets.chomp.downcase.to_sym
+            raise "TAFT cannot install a new project in that language" unless LANGUAGES.include?(lang)
+        end
+
+        if dest.empty?
+            puts "\nPlease enter the path of the base folder that TAFT should create, up to and including the name of the base folder"
+            puts "TAFT will create this folder if it does not exist"
+            puts "If a relative path is entered, it will be taken as being relative to path : #{Dir.getwd}"
+            dest = gets.chomp
+            raise "The base folder path entered was empty" if dest.empty?
+
+            puts "Does this folder already exist? Entering Y will grant TAFT permission to write into that folder, overwriting any files with matching names that are aready present."
+            folder_exists = gets.chomp
+
+            overwrite_ok = (folder_exists == "Y")
+        end
+        # if dest has been specified in the call, then overwrite_ok has as well
+
+        case lang
+        when :ruby
+            raw_file_path = "#{File.expand_path(File.dirname(__FILE__))}/taft_files"
+            # TODO determine list of gems & put in folder
+            # Might be better to output a list of gem install commands instead? What if people are using earlier/later versions of Ruby?
+            # bundled_gem_path = "#{File.expand_path(File.dirname(__FILE__))}/bundled_gems"
+            # install_gems(bundled_gem_path)
+        when :java
+            raw_file_path = "#{File.expand_path(File.dirname(__FILE__))}/java_taft_files"
+        end
+
+        # TODO does this handle dests like "~/foo" ?
+        if (Pathname.new dest).absolute?
+            dest_base_folder = dest
+        else
+            dest_base_folder = File.join(Dir.getwd, dest)
+        end
+        dest_base_folder = File.expand_path(dest_base_folder)
+        puts "TAFT will install to #{dest_base_folder}"
+
+        raise "Folder #{dest_base_folder} already exists, and you did not grant TAFT permission to write into the folder" if Dir.exists?(dest_base_folder) && !overwrite_ok
+
+        # Create the base folder
+        begin
+            Dir.mkdir(dest_base_folder) unless Dir.exists?(dest_base_folder)
+        ensure
+            raise "The base folder '#{dest_base_folder}' did not exist" if folder_exists && !Dir.exists?(dest_base_folder)
+            raise "The base folder '#{dest_base_folder}' could not be created" unless Dir.exists?(dest_base_folder)
+        end
+
+        # Copy the raw files into the base folder, preserving the structure
+        FileUtils.copy_entry(raw_file_path, dest_base_folder, false, false, true)
+
+        puts "\nFiles have been copied"
+        if project_name.empty?
+            puts "\nPlease enter the name of your project (e.g. RED SKY) :"
+            project_name = gets.chomp
+            raise "The project name entered was empty" if project_name.empty?
+        end
+
+        if project_abbrev.empty?
+            puts "\nPlease enter the abbreviation of your project (e.g. RS) :"
+            project_abbrev = gets.chomp
+            raise "The project abbreviation entered was empty" if project_abbrev.empty?
+        end
+
+
+        @project_name_part = project_name.gsub(/[\s-]+/, "_").downcase # TODO use .snakecase ?
+        @project_name_uppercase_part = @project_name_part.upcase
+        @project_abbrev_part = project_abbrev.gsub(/[\s-]+/, "_").delete("_").downcase # TODO use .snakecase ?
+        @project_abbrev_uppercase_part = @project_abbrev_part.upcase
+
+        # Now sweep over the copied files, adjusting the names accordingly
+        Taft.adjust_file_names(dest_base_folder, project_name, project_abbrev)
+
+        # Now sweep over the copied files, adjusting the contents accordingly
+        Taft.adjust_file_contents(dest_base_folder, project_name, project_abbrev)
+
+        puts "\nFiles have been tailored to your project."
+
+        puts "\nTAFT has installed a tailored copy of the #{lang.capitalize} Automation Framework to #{dest_base_folder}"
+        puts "Installation complete."
+    end
+
+    # Looks at the names of each file & folder within dest_base_folder and renames them, applying the project_name or project_abbrev as appropriate
+    def self.adjust_file_names(dest_base_folder, project_name, project_abbrev)
+        pd "Now in #{__method__}; #{dest_base_folder}; #{project_name}; #{project_abbrev}"
+        project_file_name_part = project_name.gsub(/[\s-]+/, "_").downcase # TODO use .snakecase ?
+        project_file_abbrev_part = project_abbrev.gsub(/[\s-]+/, "_").delete("_").downcase # TODO use .snakecase ?
+
+        pd "project_file_name_part : #{project_file_name_part}" # snakecase
+        pd "project_file_abbrev_part : #{project_file_abbrev_part}" # lowercase
+        Dir.chdir(dest_base_folder) do
+            entries = Dir.entries(dest_base_folder)
+            entries.delete(".")
+            entries.delete("..")
+            entries.each do |f|
+                f = File.expand_path(f)
+                pd "Now looking at #{f}; is dir? #{Dir.exists?(f)}"
+                if Dir.exists?(f) # if this is a dir, call recursively
+                    Taft.adjust_file_names(f, project_name, project_abbrev)
+                end
+
+                # After processing the contents of the directory, rename it
+                # Or if the entry was actually a file, rename it
+                basename = File.basename(f, ".*")
+                NAMES_AND_ABBREVS_REGEXES.each do |regex|
+                    if basename =~ regex
+                        ext = File.extname(f)
+                        dir = File.split(f)[0]
+
+                        # For the given regex, work out what the replacement text should be
+                        case regex.inspect
+                        when TEMPLATE_PROJECT_NAME_REGEX
+                            replacement = @project_name_part
+                        when TEMPLATE_PROJECT_NAME_UPPERCASE_REGEX
+                            replacement = @project_name_uppercase_part
+                        when TEMPLATE_PROJECT_ABBREV_REGEX
+                            replacement = @project_abbrev_part
+                        when TEMPLATE_PROJECT_ABBREV_UPPERCASE_REGEX
+                            replacement = @project_abbrev_uppercase_part
+                        end
+
+                        new_f = basename.gsub(regex, replacement)
+                        new_f += ext # must add the extension back on
+                        new_f = File.join(dir, new_f) # this is the full path
+                        pd "Will rename #{f}\n to       #{new_f}"
+                        Taft.delete_file(new_f)
+                        File.rename(f, new_f)
+                    end
+                end
+            end
+        end
+    end
+
+    
+    # Looks at the contents of each file within dest_base_folder and edits their contents, applying the project_name or project_abbrev as appropriate
+    def self.adjust_file_contents(dest_base_folder, project_name, project_abbrev)
+        pd "Now in #{__method__}; #{dest_base_folder}; #{project_name}; #{project_abbrev}"
+        raw_name = project_name # should have been entered in form like RED SKY
+        project_class_name_part = project_name.gsub(/[\s-]+/, "_").downcase # TODO use .snakecase ?
+        project_class_name_uppercase_part = project_name.pascalcase
+        project_class_abbrev_part = project_abbrev.gsub(/[\s-]+/, "_").delete("_").downcase # TODO use .snakecase ?
+        
+        pd "project_class_name_part : #{project_class_name_part}" # snakecase
+        pd "project_class_name_uppercase_part : #{project_class_name_uppercase_part}" # pascalcase
+        pd "project_class_abbrev_part : #{project_class_abbrev_part}" # lowercase
+
+        Dir.chdir(dest_base_folder) do
+            entries = Dir.entries(dest_base_folder)
+            entries.delete(".")
+            entries.delete("..")
+            entries.each do |f|
+                f = File.expand_path(f)
+                pd "Now looking at #{f}; is dir? #{Dir.exists?(f)}"
+                if Dir.exists?(f) # if this is a dir, call recursively
+                    Taft.adjust_file_contents(f, project_name, project_abbrev)
+                    next
+                end
+
+                lines = []
+                File.open(f, "r") do |file_obj|
+                    lines = file_obj.readlines
+                end
+
+                
+                # Each line may match more than one regex
+                # Hence each line should be passed through all of the regexes, not stopping after the first one it matches
+                # i.e. separate if-ends, not one big case-when or if-elsif routine
+                lines.each do |line|
+                    if line =~ TEMPLATE_PROJECT_NAME_REGEX
+                        line.gsub!(TEMPLATE_PROJECT_NAME_REGEX, project_class_name_part)
+                    end
+                    if line =~ TEMPLATE_PROJECT_NAME_UPPERCASE_REGEX
+                        line.gsub!(TEMPLATE_PROJECT_NAME_UPPERCASE_REGEX, project_class_name_uppercase_part)
+                    end
+                    if line =~ TEMPLATE_PROJECT_ABBREV_REGEX
+                        line.gsub!(TEMPLATE_PROJECT_ABBREV_REGEX, project_class_abbrev_part)
+                    end
+                    if line =~ TEMPLATE_PROJECT_ABBREV_UPPERCASE_REGEX
+                        line.gsub!(TEMPLATE_PROJECT_ABBREV_UPPERCASE_REGEX, project_class_abbrev_part.upcase)
+                    end
+                    if line =~ TEMPLATE_PROJECT_RAW_NAME_REGEX
+                        line.gsub!(TEMPLATE_PROJECT_RAW_NAME_REGEX, raw_name)
+                    end
+                end
+                
+                File.open(f, "w") do |file_obj|
+                    file_obj.puts lines
+                end
+            end
+        end
+    end
+
+    def self.delete_file(abs_file_path)
+        if Dir.exists?(abs_file_path)
+            FileUtils.remove_dir(abs_file_path)
+        elsif File.exists?(abs_file_path)            
+            File.delete(abs_file_path)
+        end
+    end
+
+    def self.install_gems(bundled_gem_path)
+        puts "\nWill first install all gems bundled in with the TAFT gem."
+
+        gem_list = Dir.entries(bundled_gem_path)
+        gem_list.delete(".")
+        gem_list.delete("..")
+        gems_to_install = []
+        gem_list.each do |gem_name|
+            # For each gem, try to require it. Only install those that couldn't be required.
+            begin
+                gem_base_name = gem_name.gsub(TEMPLATE_GEM_NAME_REGEX, "")
+                require gem_base_name
+            rescue LoadError
+                puts "#{gem_base_name} could not be required; will install #{gem_name}"
+                gems_to_install << gem_name
+            end
+        end
+
+        if gems_to_install.empty?
+            puts "All required gems are already installed"
+        else
+            puts "Will install the following gems :"
+            gems_to_install.each {|gem_name| puts gem_name }
+
+            Dir.chdir(bundled_gem_path) # set this to be the working directory while installing the gems
+            gems_to_install.each do |gem_name|
+                puts "\nNow installing #{gem_name}..."
+                system("gem install #{gem_name}")
+                puts "Gem installed."
+            end
+            Dir.chdir(base_wd) # reset the working directory
+        end
+    end
+
+end

data/lib/taft_files/framework/zznamezz.rb

@@ -0,0 +1,8 @@
+$LOAD_PATH.unshift File.dirname(__FILE__)
+
+# Add a require line for every file within framework/zznamezz
+
+require "zznamezz/api_helpers/general"
+require "zznamezz/api_helpers/rest"
+
+require "zznamezz/ui_helpers/ui_general"

data/lib/taft_files/framework/zznamezz/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"
+
+
+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)
+        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 = ZZnamezzConfig::SERVER[:zznamezz_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 = ZZnamezzConfig::SERVER[:zznamezz_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/lib/taft_files/framework/zznamezz/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 XXabbrevupperxxHelper
+
+    # 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 = ZZnamezzConfig::SERVER[:zznamezz_url], version = nil, timeout = 150)
+        
+        separator = "/"
+        api_version_string = separator + ZZnamezzConfig::API_VERSION.to_s # as the version parameter can be entirely absent, let's build the separator into the term
+        api_version_string = "" if ZZnamezzConfig::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(ZZnamezzConfig::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 = ZZnamezzConfig::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/lib/taft_files/lib/config/runtime_constants.rb

@@ -0,0 +1,16 @@
+
+# This class holds parameters that may frequently change between test runs, e.g the test environment
+class 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"
+
+    RESULTS_CSV = "results.csv"
+
+end
+

data/lib/taft_files/lib/config/zznamezz_config.rb

@@ -0,0 +1,22 @@
+# Holds system configuration parameters
+
+require_relative 'runtime_constants.rb'
+
+class ZZnamezzConfig
+    include RuntimeConstants
+    
+    CERTIFICATE_DIR = "certs"
+
+    API_VERSION = "latest"
+
+    SERVERS = {
+        :test_1 => {:zznamezz_url = "https://"},
+        :ref_1 => {:zznamezz_url = "https://"},
+    }
+
+    SERVER = SERVERS[$TEST_ENV]
+
+
+    PASSED = "Passed"
+    FAILED = "Failed"
+end

data/lib/taft_files/lib/zznamezz_test_case.rb

@@ -0,0 +1,212 @@
+
+# This file defines a module to be included in all test cases for the testing of yyrawnameyy.
+# 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.dirname(__FILE__) + "/..")
+
+gem 'test-unit'
+require 'test/unit'
+require 'tmpdir'
+require 'time'
+require 'fileutils'
+require 'timeout'
+
+# Config
+require 'config/zznamezz_config'
+
+# Helpers
+require 'framework/zznamezz.rb'
+
+
+
+STDOUT.sync = true
+
+if ZZnamezzConfig::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 ZZnamezzTestCase
+
+    include ZZnamezz
+
+    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
+
+    # By default, unknown methods (e.g. xxabbrevupperxxPage names) are sent to the different contexts 
+    # for resolution. This allows pages to be accessed as xxabbrevxxHomePage rather than
+    # @xxabbrevxx_context.xxabbrevxxHomePage
+    def method_missing(meth, *args)
+        case meth.to_s
+        when /^xxabbrevxx/
+            @xxabbrevxx_context.send(meth, *args)
+#        when /^some_other_app/
+#            @some_other_app_context.send(meth, *args)
+        else
+            super
+        end
+    end
+
+
+    if $WRITE_RESULTS # supplied from invokation
+        WRITE_RESULTS = true
+    else
+        WRITE_RESULTS = false
+    end
+
+    # Close the current browser and log in again
+    def re_login
+        browser.close
+
+        new_browser_on_login_page
+        # Reinitialise the contexd and @help
+        reinitialisexxabbrevupperxxContext(browser)
+    end
+
+    # Connect to yyrawnameyy and reinitialise the context, etc.
+    def xxabbrevxx_login(url = ZZnamezzConfig::SERVER[:zznamezz_url])
+        puts url
+        new_browser_on_login_page(url)
+        reinitialisexxabbrevupperxxContext(browser)
+    end
+
+    # Reinitialise xxabbrevupperxx context only
+    def reinitialisexxabbrevupperxxContext(new_browser)
+        @xxabbrevxx_context = ZZnamezz::Context.new(new_browser)
+        @help = xxabbrevupperxxHelper.new(@xxabbrevxx_context)
+    end
+
+    # Return to the previous xxabbrevupperxx session
+    def return_to_xxabbrevxx
+        self.browser = @xxabbrevxx_context.browser
+    end
+
+    # Close the current browser
+    def close_browser
+        self.browser.close
+    end
+
+    def close(browser)
+        if browser.exists? && ((ZZnamezzConfig::CLOSE_BROWSER_AFTER_TEST && passed?) || ZZnamezzConfig::FORCE_CLOSE_BROWSER_AFTER_TEST)
+            browser.close
+            $browsers.delete_at($current_browser_position - 1) # array indexing
+            self.browser = $browsers[-1] # set browser to the last one that is still in the array
+        end
+    end
+
+    def close_all_browsers
+        if (ZZnamezzConfig::CLOSE_BROWSER_AFTER_TEST && passed?) || ZZnamezzConfig::FORCE_CLOSE_BROWSER_AFTER_TEST
+            until $browsers.empty?
+                self.browser = $browsers.shift
+                browser.close
+            end
+        end
+    end
+
+    # Ensure that every test (that wants one) has a browser that is already logged in to the system
+    def setup
+
+        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]
+
+        # Select default certificate if none is configured
+        @certificate ||= :regular
+
+        @timeout = ZZnamezzConfig::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 == :xxabbrevxx
+            xxabbrevxx_login
+        elsif (@initialBrowser == :none || @initialBrowser == nil)
+            browser = nil
+            reinitialisexxabbrevupperxxContext(browser)
+        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 #{ZZnamezzConfig::RESULTS_BASE_DIR}"
+
+                notes = ""
+                success_text = passed? ? ZZnamezzConfig::PASSED : ZZnamezzConfig::FAILED
+
+                unless passed?
+                    begin
+                        if ZZnamezzConfig::MAKE_ERROR_SCREENSHOTS
+                            puts "Now taking error screenshots"
+                            dir_2 = ZZnamezzConfig::ERROR_SCREENSHOT_LOCATION
+                            Dir.mkdir(dir_2) unless File.exists?(dir_2)
+                            $browsers.each do |browser|
+                                browser.screenshot.save(ZZnamezzConfig::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?
+
+                close_all_browsers
+
+                # Write to the results file
+                begin
+                    File.open(ZZnamezzConfig::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 #{ZZnamezzConfig::RESULTS_CSV}"
+                end
+            end # end if WRITE_RESULTS
+        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/lib/taft_files/tests/v1/tc_r001_01_an_example_test.rb

@@ -0,0 +1,112 @@
+$LOAD_PATH.unshift("#{File.expand_path(File.dirname(__FILE__))}/../../lib")
+
+require "zznamezz_test_case"
+
+class TC_R001_01_AN_EXAMPLE_TEST < Test::Unit::TestCase
+    include ZZnamezzTestCase
+    
+    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 ZZnamezzTestCase 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 yyrawnameyy 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 yyrawnameyy
+
+        xxabbrevxx_login
+
+        # Expected Result :
+        #   The yyrawnameyy homepage is displayed
+
+        assert(xxabbrevxxHomepage.displayed?, "The yyrawnameyy 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}'"
+
+            xxabbrevxxHomepage.term = search_term
+            xxabbrevxxHomepage.click_search
+
+
+            # Expected Result :
+            #   Results are displayed
+
+            assert(xxabbrevxxSearchResults.displayed?, "The yyrawnameyy search results page is not displayed")
+            assert_equal(expected_result_text, xxabbrevxxSearchResults.result, "The yyrawnameyy search results page did not display the expected result")
+
+        
+            # Step 4 :
+            #   Return to the previous page
+
+            browser.back
+
+
+
+            # Expected Result :
+            #   The yyrawnameyy homepage is displayed
+            
+            assert(xxabbrevxxHomepage.displayed?, "The yyrawnameyy 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/taft.gemspec

@@ -0,0 +1,14 @@
+Gem::Specification.new do |s|
+  s.name        = 'taft'
+  s.version     = '0.1.0'
+  s.licenses    = ['MIT']
+  s.summary     = "Test Automation Framework Template"
+  s.description = "This gem will deploy/install a skeleton code framework for the automated testing of applications with APIs and/or web-UIs"
+  s.authors     = ["Richard Morrisby"]
+  s.email       = 'rmorrisby@gmail.com'
+  s.files       = ["lib/taft.rb"]
+  s.homepage    = 'https://rubygems.org/gems/taft'
+  s.required_ruby_version = '>=1.9'
+  s.files = Dir['**/**']
+  s.test_files = Dir["test/test*.rb"]
+end

data/test/test_example.rb

@@ -0,0 +1,10 @@
+require "test/unit"
+require_relative "../lib/ex"
+
+class TestEx < Test::Unit::TestCase
+
+    def test_ex
+       
+    end
+    
+end

metadata

@@ -0,0 +1,58 @@
+--- !ruby/object:Gem::Specification
+name: taft
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Richard Morrisby
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2019-08-25 00:00:00.000000000 Z
+dependencies: []
+description: This gem will deploy/install a skeleton code framework for the automated
+  testing of applications with APIs and/or web-UIs
+email: rmorrisby@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- LICENCE.txt
+- README.md
+- build.rb
+- lib/taft.rb
+- lib/taft_files/framework/zznamezz.rb
+- lib/taft_files/framework/zznamezz/api_helpers/general.rb
+- lib/taft_files/framework/zznamezz/api_helpers/rest.rb
+- lib/taft_files/framework/zznamezz/ui_helpers/ui_general.rb
+- lib/taft_files/lib/config/runtime_constants.rb
+- lib/taft_files/lib/config/zznamezz_config.rb
+- lib/taft_files/lib/zznamezz_test_case.rb
+- lib/taft_files/tests/v1/tc_r001_01_an_example_test.rb
+- taft.gemspec
+- test/test_example.rb
+homepage: https://rubygems.org/gems/taft
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '1.9'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.0.3
+signing_key: 
+specification_version: 4
+summary: Test Automation Framework Template
+test_files:
+- test/test_example.rb