Test_Framework1.0 1.6.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 03e552c62291411f5305cad227dedfff3fc2a85e
+  data.tar.gz: 45dbb238a2a92e8adc5b4f542b65dee646007780
+SHA512:
+  metadata.gz: 702918fb710b1d20b89c19478a77a776611eac6f8061a9da245ca6e5fa20e7f4ba74bb2de4d0aca9bac750f19db4fbe50c1c22975915f980d40e03d63b6f8da7
+  data.tar.gz: e517fbf5f86ec9c2f61b8d826256705d068fd5718b9437fe94a6743a89c601bda78996ff220aeddbfe57469057b224d93b5eddca0855b4ab54a23ce0c2e4f651

data/LICENSE

@@ -0,0 +1,19 @@
+Copyright (c) 2013 Medidata Solutions Worldwide
+
+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,41 @@
+# MediTAF
+
+Test frameworks are one of the key requirements for implementing a successful automated software testing solution. A good test framework reduces maintenance costs, and speeds up test development. Currently at Medidata, we have several test frameworks that are successfully used in various projects. However, they have been designed with a focus on a product or a project, rendering them unusable in cross-product or multi-interface automation projects.
+
+MediTAF is a generic ruby-based test automation framework intended to allow automation engineers and testers to design end-to-end automated integration tests for distributed systems. Specifically, MediTAF will allow testers to automate using two different interfaces i.e. UI and web services.
+
+
+## Key Features
+
+  * **UI testing:** MediTAF uses Selenium to allow users to write tests for the web user interface. For Selenium implementation, the framework uses the Page Object pattern. The Page Object pattern represents screens of a web application in a series of objects and encapsulates the features represented by a web page. It reduces the duplication of code and improves the maintainability of the automated tests. MediTAF uses a ruby gem called **site_prism** (an extension to **Capybara**) as an interface to **selenium-webdriver** to implement the Page Object pattern.
+  * **Services testing:** MediTAF provides an interface to connect with the services. Testers will be able to make calls to the service APIs, save results and perform comparisons with the expected results. Framework provides wrapper classes so nothing changes in the implementation. The framework also allows for future expansion to other services without affecting existing implementations.
+  * **Logging and Exception Handling:** The framework has an exception handler with multiple severity levels that can be logged to a configured file.
+
+
+## Advantages of using MediTAF
+
+ * Enables testers to automate tests across multiple Medidata interfaces and applications.
+ * The framework interprets the **Cucumber/Gherkin** language for the creation and execution of requirement/feature files.
+ * Allows for central location repository of features and step definitions - [MIST](https://github.com/mdsol/MIST.git) ( MediTAF Integration Steps and Tests )
+ * Enhances collaboration among testers, developers, and product managers to facilitate and simplify cross-team and cross-platform testing efforts.
+ * Reduces maintenance by minimizing duplication of code.
+ * Provides a way for standardized logging and validation output across multiple products.
+ * Allows easy execution of end-to-end automated tests.
+
+
+## Home Page
+  [https://github.com/mdsol/MediTAF.git](https://github.com/mdsol/MediTAF.git)
+
+## Documentation
+  [Medinet - MediTAF](https://sites.google.com/a/mdsol.com/knowledgebase/home/departments/r-d/sqa/utilities/meditaf)
+
+## Report Issues
+Refer to JIRA Story [MCC-96074](https://medidata.atlassian.net/browse/MCC-96074) and add sub-tasks for issues.
+
+## Installation Instructions
+
+MediTAF is released privately as a gem, and it works with MIST. For more information and installation instructions for MIST, please refer to the git repository at [https://github.com/mdsol/MIST.git](https://github.com/mdsol/MIST.git).
+
+## Copyright
+
+Copyright © 2013-2015 Medidata Solutions, Inc. All Rights Reserved.

data/lib/MediTAF.rb

@@ -0,0 +1,14 @@
+$:.unshift File.dirname(__FILE__)
+
+module MediTAF
+  def self.root
+    File.expand_path '../..', __FILE__
+  end
+end
+
+require 'MediTAF/version'
+require 'MediTAF/services'
+require 'MediTAF/ui'
+require 'MediTAF/utils/meditaf_faker'
+require 'MediTAF/utils/sticky'
+require 'MediTAF/utils/mail'

data/lib/MediTAF/services.rb

@@ -0,0 +1,22 @@
+require 'MediTAF/utils/exceptions'
+
+module MediTAF
+  # Enables MediTAF to interact with available resources. It depends on resource adapters that implement
+  # a set of require methods. The underlying adapters have the knowledge of the type resource with which
+  # it communicates.
+  module Services
+    # @return [ResourcesMgr] a new instance of ResourceMgr
+    def self.new
+      ResourcesMgr.new
+    end
+
+    class ServiceConfigurationMissing < MediTAF::Utils::Exceptions::MediTAFException; end
+    class ResourceAdapterLoadError < MediTAF::Utils::Exceptions::MediTAFException; end
+    class ResourceAdapterMissing < MediTAF::Utils::Exceptions::MediTAFException; end
+    class ResourceAdapterMethodMissing < MediTAF::Utils::Exceptions::MediTAFException; end
+    class ResourceAdapterConfigurationMissing < MediTAF::Utils::Exceptions::MediTAFException; end
+    class ResourceAdapterRequestError < MediTAF::Utils::Exceptions::MediTAFException; end
+  end
+end
+
+require_relative 'services/resources_mgr'

data/lib/MediTAF/services/clients.rb

@@ -0,0 +1,7 @@
+module MediTAF
+  module Services
+    # Reserved namespace for specific, underlying resource adapters
+    module Clients
+    end
+  end
+end

data/lib/MediTAF/services/clients/euresource_adapter.rb

@@ -0,0 +1,115 @@
+require 'euresource'
+
+module MediTAF
+  module Services
+    module Clients
+      # The specific resource adapter for Euresource. It depends on the following configurations
+      # * services.euresource
+      #   * mauth_url
+      #   * app_uuid
+      #   * key_file : location of file containing private key
+      #   * eureka_url
+      #   * stage
+      #   * mauth_logger (optional)
+      #   * eureka_logger (optional)
+      #   * authenticate_responses (optional)
+      class EuresourceAdapter
+
+        # verifies needs configuration items exist for eureka-client
+        def initialize
+          errs = []
+          errs << 'euresource configuration' unless euresource_config
+          if errs.empty?
+            errs << 'eureka_url' unless euresource_config['eureka_url']
+            errs << 'mauth_url' unless euresource_config['mauth_url']
+            errs << 'app_uuid' unless euresource_config['app_uuid']
+            errs << 'key_file' unless euresource_config['key_file']
+            errs << 'stage' unless euresource_config['stage']
+            errs << 'authenticate_responses' if euresource_config['authenticate_responses'].nil?
+          end
+          unless errs.empty?
+            raise ResourceAdapterConfigurationMissing, 'Euresource Adapter Configurations: cannot find ' + errs.join(', ')
+          end
+        end
+
+        # require configurations for eureka-client
+        def configure
+          cfg = euresource_config
+          Euresource.configure do
+            config.stage_defaults do |defaults|
+              defaults.mauth(cfg['mauth_url']) do |mauth_config|
+                mauth_config.app_uuid cfg['app_uuid']
+                mauth_config.private_key_file cfg['key_file']
+
+                # Only set if you want different logger for MAuth
+                mauth_config.logger cfg['mauth_logger'].constantize.new if cfg['mauth_logger']
+              end
+              defaults.use MAuth::Faraday::RequestSigner, defaults.mauth_config
+
+              # Turns on develop mode for local development, which adds extra logging and forces API deployments to Eureka
+              # without having to delete prior versions of an API document for local development while making changes to an
+              # API document.
+              defaults.develop_mode false
+
+              # Rails logger will be used for all logging if this is not set in Rails.
+              defaults.logger EuresourceLogger.new if cfg['eureka_logger']
+
+              #Un-comment this option if you want to skip authenticating eureka responses
+              defaults.mauth_authenticate_responses cfg['authenticate_responses']
+
+              defaults.use FaradayMiddleware::RackCompatible, CacheComplainer::Complainer
+            end
+
+            # This applies all default from above to configure a Eureka::Client instance for a specific eureka stage
+            config.stage(cfg['eureka_url'], cfg['stage']) do |builder|
+              builder.deployment_base_uri 'http://localhost:3000'
+              builder.faraday_adapter :typhoeus
+            end
+          end
+        end
+
+        # @param resource [Symbol] the resource to get
+        # @return [Euresource::Base] The anonymous class.
+        def load(resource)
+          Euresource.class_for_resource(resource)
+        rescue => e
+          raise ResourceAdapterLoadError, "Can't load resource #{resource}. Inner Exception: #{e.to_s}"
+        end
+
+        # @note not implemented
+        # checks if the resource is deployed within eureka
+        # @param resource [Symbol] the resource to check
+        def deployed?(resource)
+        end
+
+        # @note not implemented
+        # check if the resource is consumable
+        # @param resource [Symbol] the resource to check
+        def connected?(resource)
+        end
+
+        # @return [String] the stage value from the configuration
+        def stage
+          euresource_config['stage']
+        end
+
+        # @return [Symbol] the euresource clients by stage from euresource configuration
+        def clients_by_stage
+          Euresource.config.clients_by_stage
+        end
+
+        # @return [Symbol] the default stage from euresource configuration
+        def default_stage
+          Euresource.config.default_stage
+        end
+
+        private
+
+        def euresource_config
+          raise ServiceConfigurationMissing, "services not found in configuration" unless MediTAF::Utils::Configuration['services']
+          MediTAF::Utils::Configuration['services']['euresource']
+        end
+      end
+    end
+  end
+end

data/lib/MediTAF/services/clients/mauth_adapter.rb

@@ -0,0 +1,125 @@
+require 'mauth-client'
+require 'faraday'
+require 'faraday_middleware'
+
+module MediTAF
+  module Services
+    module Clients
+      # The specific resource adapter for MAuthClient. It depends on the following configurations
+      # * services.mauth
+      #   * mauth_url
+      #   * mauth_api_version
+      #   * app_uuid
+      #   * key_file : location of file containing private key
+      #   * mauth_logger (optional)
+      #   * authenticate_responses (optional)
+      class MauthAdapter
+
+        # verifies needed configuration items exist for mauth-client
+        # @raise [ResourceAdapterConfigurationMissing] lists the missing required configuration items
+        def initialize
+          errs = []
+          errs << 'mauth configuration' unless mauth_config
+          if errs.empty?
+            errs << 'mauth_api_version' unless mauth_config[:mauth_api_version]
+            errs << 'mauth_url' unless mauth_config[:mauth_baseurl]
+            errs << 'app_uuid' unless mauth_config[:app_uuid]
+            errs << 'key_file' unless mauth_config[:private_key_file]
+            errs << 'authenticate_responses' if mauth_config[:authenticate_response].nil?
+          end
+          unless errs.empty?
+            raise ResourceAdapterConfigurationMissing, 'Mauth Adapter Configurations: cannot find ' + errs.join(', ')
+          end
+        end
+
+        # configure a new MAuth::Client based on configuration items
+        # @note configures MAuth::Client to return all response in JSON format
+        def configure
+          @mauth_client = ::MAuth::Client.new(mauth_config)
+
+          @connection = Faraday.new do |builder|
+            builder.use MAuth::Faraday::MAuthClientUserAgent, "MediTAF Mauth Client Adapter"
+            builder.use MAuth::Faraday::RequestSigner, :mauth_client => @mauth_client
+            builder.use MAuth::Faraday::ResponseAuthenticator, :mauth_client => @mauth_client if mauth_config[:authenticate_response]
+            builder.use FaradayMiddleware::ParseJson, content_type: /\bjson$/
+            builder.use FaradayMiddleware::ParseXml, content_type: /\bxml$/
+            builder.adapter Faraday.default_adapter
+          end
+        end
+
+        # loads a new MauthClient object for request on base_url
+        # @param args [Hash] arguments
+        # @option args [String] :baseurl the base url of this resource
+        # @return [MediTAF::Services::Clients::MauthClient]
+        # @raise [ResourceAdapterLoadError] when instantiating a new MauthClient
+        def load(args)
+          raise MauthClientBaseURLMissing, "supply a base url" unless args.is_a?(Hash) && args.has_key?(:baseurl)
+          MauthClient.new(@connection, args[:baseurl])
+        end
+
+        private
+
+        def mauth_config
+          raise ServiceConfigurationMissing, "services not found in configuration" unless  MediTAF::Utils::Configuration['services']
+          raise ServiceConfigurationMissing, "euresource not found in configuration" unless  MediTAF::Utils::Configuration['services']['mauth']
+          unless @mauth_config
+            cfg =  MediTAF::Utils::Configuration['services']['mauth']
+            @mauth_config = {}
+            @mauth_config[:mauth_baseurl] = cfg['mauth_url']
+            @mauth_config[:private_key_file] = cfg['key_file']
+            @mauth_config[:app_uuid] = cfg['app_uuid']
+            @mauth_config[:mauth_api_version] = cfg['mauth_api_version']
+            @mauth_config[:authenticate_response] = cfg['authenticate_responses']
+          end
+          @mauth_config
+        rescue => e
+          nil
+        end
+      end
+
+      # A MauthClient object set to a specific base_url and uses the common MAuth::Client object
+      # @note only MauthAdapter object instantiate objects of this type
+      class MauthClient
+        # @param connection [Faraday] defines the MAuth::Faraday parameters/handlers/response formats
+        # @param base_url [String] the base url for all paths
+        # @raise [MauthClientBaseURLMissing] when the no base url is given
+        def initialize(connection, base_url)
+          @connection, @base_url = connection, base_url
+        end
+
+        # @param [Hash] opts the arguments to do an HTTP request
+        # @option opts [Symbol] :verb :get, :post, :put, or :delete
+        # @option opts [Symbol] :resource
+        # @option opts [Symbol] :body
+        # @option opts [Symbol] :content_type
+        # @return [Faraday::Response]
+        # @raise [ResourceAdapterRequestError]
+        def request(opts)
+          headers = {}
+          headers['Content-Type'] = opts[:content_type] if opts[:content_type]
+          headers['Content-Type'] = 'application/json' if opts[:content_type].nil? && opts[:body]
+          headers['Accept'] = opts[:accept] || 'text/html,application/xhtml+xml,application/xml,application/json'
+          @connection.run_request(opts[:verb], @base_url + '/' + opts[:resource], opts[:body], headers)
+        rescue MAuth::InauthenticError, MAuth::UnableToAuthenticateError => e
+          raise ResourceAdapterRequestError, "Failed to #{opts[:verb]} #{opts[:resource]}. Inner Exception: #{e.to_s}"
+        rescue => e
+          raise ResourceAdapterRequestError, "#{opts}. Inner Exception: #{e.to_s}"
+        end
+
+        # @note not implemented
+        # checks if the resource is deployed within eureka
+        # @param resource [Symbol] the resource to check
+        def deployed?(resource)
+        end
+
+        # @note not implemented
+        # check if the resource is consumable
+        # @param resource [Symbol] the resource to check
+        def connected?(resource)
+        end
+      end
+
+      class MauthClientBaseURLMissing < MediTAF::Utils::Exceptions::MediTAFException; end
+    end
+  end
+end

data/lib/MediTAF/services/resources_mgr.rb

@@ -0,0 +1,110 @@
+# ResourcesMgr manages the requested resources.
+# the manager needs a specific adapter from where it will interact with resources
+# if no adapter is specified in the configuration i.e. ['services']['adapter']
+#   then 'euresource' adapter is used the default
+# all resources are expressed as method
+# each accessed resources exposes the underlying adapter implementation
+
+require 'MediTAF/utils/configuration'
+require 'active_support/core_ext/string/inflections'
+
+module MediTAF
+  module Services
+    class ResourcesMgr
+      include Logging
+
+      attr_reader :adapters
+      attr_reader :resources
+      attr_reader :stage
+
+      # @note loads euresource adapter by default, otherwise attempts to load a specific adapter. adapters are
+      #  specified in *MediTAF_configuration.services.adapter* value. the location of the adapter defaults
+      #  to services/clients within MediTAF, otherwise it can be specified in *MediTAF_configuration.services.adapter_home*
+      #  value. when MediTAF attempts to load the adapter and no location has been specified, MediTAF assumes that the
+      #  adapter has been load into the environment.
+      # @note the adapter must be in namespace *MediTAF::Services::Clients*
+      # @raise [ResourceAdapterMethodMissing] when adapter does not respond to configure
+      # @raise [ResourceAdapterLoadError] when adapter could not be loaded
+      def initialize
+        @resources = {}
+        @adapters = {}
+
+        raise ServiceConfigurationMissing, "services not found in configuration" unless MediTAF::Utils::Configuration['services']
+
+        adapter_home =  MediTAF::Utils::Configuration['services']['adapter_home']
+        adapter_home ||= "#{MediTAF.root}/lib/MediTAF/services/clients"
+
+        adapters =  MediTAF::Utils::Configuration['services']['adapters']
+
+        if adapters
+          adapters.split(/ *, */).each do |adapter|
+            begin
+              require "#{adapter_home}/#{adapter}_adapter" if File.exist? "#{adapter_home}/#{adapter}_adapter.rb"
+              @adapters[adapter.to_sym] = "MediTAF::Services::Clients::#{adapter.camelize}Adapter".constantize.new
+              @adapters[adapter.to_sym].configure
+            rescue NoMethodError => e
+              raise ResourceAdapterMethodMissing, %Q|"#{adapter.camelize}Adapter" is missing required configure method|
+            rescue NameError => e
+              raise ResourceAdapterLoadError, %Q|Couldn't load resource adapter "#{adapter.camelize}Adapter". Inner Exception: #{e.to_s}|
+            end
+          end
+        end
+      end
+
+      # removes all or one resource from the resources hash
+      # @param resource [Symbol] the resource to remove
+      def delete(resource=nil)
+        if resource
+          @resources.delete(resource) if @resources.include?(resource)
+        else
+          @resources.clear
+        end
+      end
+
+      # checks if a resource has been deployed
+      # @note not implemented
+      # @param resource [Symbol] the resource to check
+      def deployed?(resource)
+        raise "not implemented"
+      end
+
+      # checks if a resource is consumable
+      # @note not implemented
+      # @param resource [Symbol] the resource to check
+      def connected?(resource)
+        raise "not implemented"
+      end
+
+      # @param adapter [Symbol] the adapter to get the stage from
+      # @return [Symbol] gets the current stage set for the adapter
+      def stage(adapter=:euresource)
+        @adapters[adapter].stage.to_sym if @adapters.has_key? adapter
+      end
+
+      # @param adapter [Symbol] the adapter to get the stage from
+      # @return [Symbol] gets the default stage set for the adapter
+      def default_stage(adapter=:euresource)
+        @adapters[adapter].default_stage if @adapters.has_key? adapter
+      end
+
+      # @param resource [Symbol] resource as a method name
+      # @param args [Object] args are passed to underlying adapter
+      # @return [Object] the specific resource adapter object
+      # @raise [ResourceAdapterMethodMissing] when adapter does not respond to load
+      def method_missing(resource, *args, &block)
+        opts = args[0] || {}
+        unless @resources.include?(resource)
+          unless @adapters.has_key? opts[:adapter]
+            raise ResourceAdapterMissing, %Q/'#{opts[:adapter]}' adapter not found/
+          end
+          adapter = @adapters[ opts[:adapter] ]
+          opts.delete(:adapter)
+          @resources[resource] = ( opts.nil? || opts.empty?) ? adapter.load(resource) : adapter.load(opts)
+        end
+        @resources[resource]
+      rescue NoMethodError => e
+        raise ResourceAdapterMethodMissing, "required load method missing"
+      end
+    end
+  end
+end

data/lib/MediTAF/ui.rb

@@ -0,0 +1,25 @@
+# Module ui namespace for all ui related capabilities
+require 'MediTAF/utils/exceptions'
+
+module MediTAF
+  # Enables MediTAF to interact with the UI via the page object model design pattern. It manages applications and their
+  # associated pages (i.e. page objects).
+  module UI
+    # @param pages_root [String] specifies location of applications' pages. default location: pages
+    def self.new(pages_root='pages')
+      Applications.new('./' + Dir.glob(File.join("**", pages_root)).first)
+    end
+
+    # Applications manager was unable to find a directory with the name of the application
+    class AppLoadError < MediTAF::Utils::Exceptions::MediTAFException; end
+
+    # Pages Manager (i.e. the Application) was unable to find a file presentation the page model
+    class PageLoadError < MediTAF::Utils::Exceptions::MediTAFException; end
+
+    # BaseURL for launching the application is missing.
+    class BaseURLMissing < MediTAF::Utils::Exceptions::MediTAFException; end
+
+  end
+end
+
+require_relative 'ui/applications'

data/lib/MediTAF/ui/application.rb

@@ -0,0 +1,72 @@
+require 'active_support/core_ext/string/inflections'
+
+module MediTAF
+  module UI
+    # Manages all of the application's pages in the application's root directory
+    class Application
+      attr_reader :app_root
+      attr_reader :pages
+      attr_reader :current_page
+
+      # @param app_root [String] path to the application's page models
+      def initialize(app_root)
+        @pages = {}
+        @app_root = app_root
+      end
+
+      # references the page as a method name
+      # @param page [Symbol] the page name as a symbol
+      # @return [Object] the current page
+      def method_missing(page, *args, &block)
+        @current_page =
+            if @pages.include?(page)
+              @pages[page]
+            elsif in_namespace?(page)
+              new_page(@app_root + '/' + page.to_s)
+            else
+              load_page(page)
+            end
+      end
+
+      # iterates over the loaded pages collection
+      # @param block [Proc]
+      def each(&block)
+        @pages.each(&block) if @pages
+      end
+
+      # @return [Symbol] the current page in use
+      def current_page
+        @current_page
+      end
+
+      private
+
+      # @param page [Symbol] the page name as a symbol
+      # @return [MediTAF::UI:BasePage] the newly accessed page
+      # @raise [PageLoadError] when manager cannot fully load the requested page
+      def load_page(page)
+        raise "File #{@app_root}/#{page.to_s}.rb not found" unless Dir["#{@app_root}/#{page.to_s}.rb"].detect do |f|
+          !File.directory?(f) && File.basename(f, ".*").downcase.to_sym == page
+        end
+        class_path = @app_root + '/' + page.to_s
+        require class_path
+        new_page(class_path)
+      rescue => e
+        raise PageLoadError, "Couldn't load page #{page.to_s}. Inner Exception: #{e.to_s}"
+      end
+
+      def new_page(class_path)
+        @pages[class_path.split('/').last.to_sym] = /^.+\/([^\/]+\/[^\/]+)$/.match(class_path)[1].camelize.constantize.new
+      rescue => e
+        raise PageLoadError, "Couldn't instantiate page #{page.to_s}. Inner Exception #{e.to_s}"
+      end
+
+      def in_namespace?(page)
+        ns = /^.+\/[^\/]+\/([^\/]+)$/.match(@app_root)[1].camelize.constantize
+        ns.constants.detect { |c| ns.const_get(c).is_a?(Class) && c == page.to_s.camelize.to_sym }
+      rescue => e
+        nil
+      end
+    end
+  end
+end

data/lib/MediTAF/ui/applications.rb

@@ -0,0 +1,60 @@
+# Class Applications manages all configured applications in a single browser session
+
+require_relative '../ui/application'
+
+module MediTAF
+  module UI
+    # Manages all of the applications in the applications root directory
+    class Applications
+      include Enumerable
+
+      attr_reader :apps_root
+      attr_reader :apps
+      attr_reader :current_app
+
+      # @param apps_root [String] root location of applications with their defined pages
+      def initialize(apps_root)
+        @apps = {}
+        @apps_root = apps_root
+      end
+
+      # only empties the applications internal apps collection
+      def close
+        @apps.clear
+      end
+
+      # references an application as a method name
+      # @param app [Symbol] the application name as a symbol
+      # @return [Application] the current application
+      def method_missing(app, *args, &block)
+        @current_app = @apps.include?(app) ? @apps[app] : load_app(app)
+      end
+
+      # iterates over the loaded applications collection
+      # @param block [Proc]
+      def each(&block)
+        @apps.each(&block) if @apps
+      end
+
+      # @return [Symbol] the current application in use
+      def current_app
+        @current_app
+      end
+
+      private
+
+      # @param app [Symbol] the application name as a symbol
+      # @return [Application] the newly accessed application
+      # @raise [AppLoadError] when manager cannot fully load the requested app
+      def load_app(app)
+        raise "Directory #{@apps_root}/#{app} not found" unless Dir["#{@apps_root}/*"].detect do |f|
+          File.directory?(f) && File.basename(f).downcase.to_sym == app
+        end
+        new_app = Application.new("#{@apps_root}/#{app.to_s.downcase}")
+        @apps[app] = new_app
+      rescue => e
+        raise AppLoadError, "Couldn't load #{app}. Inner Exception: #{e.to_s}"
+      end
+    end
+  end
+end

data/lib/MediTAF/utils/configuration.rb

@@ -0,0 +1,84 @@
+require 'MediTAF/utils/exceptions'
+
+module MediTAF
+  # Representation of the meditaf_config.yml configuration file.
+  module Utils
+    module Configuration
+
+      class << self
+        # @param filepath [String] path/to/file
+        # @raise [ConfigurationNotFoundError] when YAML cannot load the file
+        def new(filepath = nil)
+          filepath ||= Dir.glob(File.join("**", "meditaf_config.yml")).first
+          yml_hashes = []
+
+          # load main yaml file
+          yml_hashes << YAML.load_file(filepath)
+          raise FileEmpty, "#{filepath} is empty. Nothing to config, YAY!"  unless yml_hashes[0]
+
+          # load additional yml files
+          if yml_hashes[0]['modules']['config_files']
+            yml_hashes[0]['modules']['config_files'].split(/ *, */).each { |f| yml_hashes << YAML.load_file(f) }
+            modules = yml_hashes.shift
+            added = yml_hashes.each_with_object({}) { |oh, nh| nh.merge!(oh) }
+            modules['modules'].merge!(added)
+          end
+          modules ||= yml_hashes[0]
+
+          # merge all yml hashes into one hash
+          @modules = Settings.new('modules', modules['modules'] )
+        rescue Errno::ENOENT => e
+          raise FileNotFound, "missing configuration. check you have meditaf_config in the 'config' or " +
+              "project root directory and is valid."
+        rescue Psych::SyntaxError => e
+          raise Error, "Configuration Error : #{e}"
+        end
+
+        # backward compatibility for older style references of Configuration['modules']['xxx']
+        def [](key)
+          (key == 'modules') ? @modules : @modules['modules'][key]
+        end
+      end
+
+      class Settings
+        def initialize(key, settings)
+          @key = key
+          @settings = settings
+          self
+        end
+
+        def [](key)
+          # backward compatibility for older style references of $config['modules']['xxx']
+          return self if key == 'modules' && @key == 'modules'
+          (@settings[key].is_a?(Hash)) ? Settings.new(@key + '/' + key, @settings[key]) : @settings[key] if @settings.has_key?(key)
+        end
+
+        def include?(key)
+          @settings.has_key?(key)
+        end
+
+        private
+
+        def []=(key, value)
+          @settings[key] = value
+        end
+
+        def delete(key)
+          @settings.delete(key) if @settings.has_key?(key)
+        end
+      end
+
+      # When the specified configuration file has not configuration items i.e. EMPTY
+      class FileEmpty < StandardError; end
+
+      # Specified configuration file or meditaf_config.yml file not in config directory or project root directory
+      class FileNotFound < StandardError; end
+
+      # General configuration error: usually invalid YAML syntax
+      class Error < StandardError; end
+
+      # When request modules key is not found in configuration
+      class ItemNotFound < StandardError; end
+    end
+  end
+end

data/lib/MediTAF/utils/exceptions.rb

@@ -0,0 +1,21 @@
+require 'MediTAF/utils/logger'
+
+module MediTAF
+  module Utils
+    module Exceptions
+
+      # MediTAF Exception with logging
+      class MediTAFException < StandardError
+        include MediTAF::Utils::Logger
+
+        # @param message [String] error message.
+        def initialize(message = 'MediTAF Exception') # Default Message
+          log.error message
+          super(message)
+        end
+
+      end
+
+    end
+  end
+end

data/lib/MediTAF/utils/logger.rb

@@ -0,0 +1,63 @@
+
+require 'logging'
+
+module MediTAF
+  module Utils
+    # Logging Mechanism based on Logging gem
+    module Logger
+
+      # @return [Logging::Logger]
+      def log
+        @log ||= Logger.logger_for(self.class.name)
+      end
+
+      attr_reader :loggers
+      @loggers = {}
+
+      class << self
+
+        # for unit testing purposes only
+        def loggers
+          @loggers
+        end
+
+        # @param classname [Class] the class for which to log
+        # @return [Logging::Logger]
+        def logger_for(classname)
+          @loggers[classname] ||= configure_logger_for(classname)
+        end
+
+        # @param classname [Class] the class for which to log
+        # @return [Logging::Logger]
+        def configure_logger_for(classname)
+          raise LoggingConfigurationMissing, 'logging not found in configuration' unless  MediTAF::Utils::Configuration['logging']
+          raise LoggingFilePathMissing, 'logging filepath not found in configuration' unless  MediTAF::Utils::Configuration['logging']['filepath']
+          raise LoggingLevelMissing, 'logging level not found in configuration' unless  MediTAF::Utils::Configuration['logging']['level']
+
+          config =  MediTAF::Utils::Configuration['logging']
+          log = Logging.logger[classname]
+
+          log.add_appenders(
+              Logging.appenders.stdout('stdout', :layout => Logging.layouts.pattern(:pattern => '[%d] %-5l %c: %m\n')),
+              Logging.appenders.file("#{config['filepath']}", :layout => Logging.layouts.pattern(:pattern => '[%d] %-5l %c: %m\n'))
+          )
+
+          # valid levels are debug, info, warn, error, fatal
+          log.level = config['level'].to_sym
+          log
+        rescue LoggingConfigurationMissing, LoggingFilePathMissing, LoggingLevelMissing => e
+          raise e
+        rescue => e
+          raise LoggingConfigurationError, "Inner Exception: #{e.to_s}"
+        end
+
+      end
+
+      class LoggingConfigurationError < StandardError; end
+      class LoggingConfigurationMissing < StandardError; end
+      class LoggingFilePathMissing < StandardError; end
+      class LoggingLevelMissing < StandardError; end
+
+    end
+  end
+end

data/lib/MediTAF/utils/mail.rb

@@ -0,0 +1,118 @@
+require 'gmail'
+require 'MediTAF/utils/exceptions'
+
+module MediTAF
+  module Utils
+    module Email
+      class Mail < Gmail::Client::Base
+
+        attr_reader :gmail
+
+        def initialize(username, options = {})
+          @gmail = Gmail.new(username, options)
+        end
+
+        # finds the unread invite email from iMedidata
+        # @param from [String] the from email address.
+        # @param subject [String] the subject of the email.
+        # @param newest [Boolean] the subject of the email.
+        # @param date [String] the date of the email. Defaults to today's date.
+        # @param to [String] the recepient email address.
+        def find_email(from, subject=nil, newest=true, date=Time.now, to=nil)
+          email_options={}
+          email_options[:from]= "#{from}" if from
+          email_options[:to]= "#{to}" if to
+          email_options[:on]= Date.parse("#{date}") if date
+          Message.new do
+
+            @gmail.inbox.find(:unread,email_options).each do |email|
+              subject.nil? || email.message.subject == subject
+            end.send(newest ? :last : :first)
+
+          end
+        end
+
+        # finds and deletes the email
+        # @param from [String] the from email address.
+        # @param subject [String] the subject of the email.
+        # @param date [String] the date of the email. Defaults to today's date.
+        def delete(from, subject=nil, date=Time.now)
+          raise SubjectNil if subject.nil?
+          @gmail.inbox.find(:all, on: Date.parse("#{date}"), from: "#{from}", subject: subject).each do |email|
+            email.delete!
+          end
+        end
+
+        # logs out of Mail
+        def logout
+          @gmail.logout
+        end
+
+        # whether or not you are logged in
+        def logged_in?
+          @gmail.logged_in?
+        end
+
+        # sends mail using configured email address
+        # @param addr [String] the address to send to
+        # @param title [String] the subject of the email
+        # @param contents [String] the glob of the email
+        def send_mail(addr, title, contents)
+          if logged_in?
+            @gmail.deliver do
+              to addr
+              subject title
+              html_part do
+                content_type 'text/html; charset=UTF-8'
+                body contents
+              end
+              delivery_method :smtp, {address: 'smtp.lab1.hdc.mdsol.com', port: 80} if `hostname` =~ /hdc505lb/
+            end
+          end
+        end
+
+      end
+
+      class Message
+        attr_reader :email, :url, :body
+
+        def initialize()
+          if block_given?
+            @email = yield
+            raise InviteEmailNotFoundError, 'Invitation email was not found' if @email.nil?
+            @body = @email.html_part.body.dup
+          end
+          self
+        end
+
+        def email
+          @email
+        end
+
+        def subject
+          @email.message.subject
+        end
+
+        def body
+          raise InviteBodyNotFoundError, 'Invitation body was not found' if @body.nil?
+          @body.decoded
+        end
+
+        def url
+          body.scan(/https?:\/\/\S+imedidata\.\S+\/users\S+\/activation/).first.delete("'")
+        rescue => e
+          raise URLNotFoundError, "URL is missing or does not contain a valid invite link. Inner Exception: #{e.to_s}"
+        end
+      end
+
+      class InviteEmailNotFoundError < MediTAF::Utils::Exceptions::MediTAFException;
+      end
+      class InviteBodyNotFoundError < MediTAF::Utils::Exceptions::MediTAFException;
+      end
+      class URLNotFoundError < MediTAF::Utils::Exceptions::MediTAFException;
+      end
+      class SubjectNil < MediTAF::Utils::Exceptions::MediTAFException;
+      end
+    end
+  end
+end

data/lib/MediTAF/utils/meditaf_faker.rb

@@ -0,0 +1,122 @@
+# MeditafFaker is a module that provides random fake data for uid codes, random numbers, timestamp  based on the Faker gem
+#
+#*********************************************************************************************************************S**c*#
+require 'MediTAF/utils/configuration'
+require 'faker'
+
+require 'i18n'
+
+I18n.enforce_available_locales = true
+I18n.reload!
+
+module MediTAF
+  module Utils
+    class Base < Faker::Base
+
+      class << self
+        def stringify(param, *params)
+          "#{param}#{params.join()}"
+        end
+
+        protected
+        def random_generator
+          rand(1000..9999)
+        end
+      end
+    end
+
+    # TimeStamp: a class that provides the current date time format
+    class MediTAFFaker < Base
+      class << self
+
+        ##using Faker address
+        def address
+          Faker::Address
+        end
+
+        # using Faker name
+        def name
+          Faker::Name
+        end
+
+        # using Faker code
+        def code
+          Faker::Code
+        end
+
+        # using Faker number
+        def number
+          Faker::Number
+        end
+
+        # using Faker phone_number
+        def phone_number
+          Faker::PhoneNumber
+        end
+
+        # Default representation of the current date format
+        def timestamp
+          DateTime.now.strftime()
+        end
+
+        # Default representation of the current date format
+        def medidata_date_format
+          DateTime.now.strftime("%d-%b-%Y")
+        end
+
+        # Long representation of the current date format - Missing Year
+        def timestamp_long
+          DateTime.now.strftime("%m%d%H%M%S%6N")
+        end
+
+        # Short representation of the current date format with minutes, seconds and micro seconds
+        def timestamp_short
+          DateTime.now.strftime("%M%S%6N")
+        end
+
+        # Complete representation of the current date format including picosecons
+        def timestamp_complete
+          DateTime.now.strftime("%m-%d-%Y:%H%M%S.%12N")
+        end
+
+        # Random: a class that displays a random string in the MD5 format based on DateTime as string
+        def random
+          random_generator.to_s
+        end
+
+        # UID: a class that displays a random string in the MD5 format based on DateTime as string
+        def uid
+          Digest::MD5.hexdigest(DateTime.now.strftime("%m-%d-%Y:%H%M%S.%12N")).to_s
+        end
+
+        # Code: a class that inherits from Faker:Code. It provides UID (32/40-bit length).
+        def uid_md5(no_dash=true)
+          no_dash ? generate_32_bit_checkmateUID_without_dash : generate_32_bit_checkmateUID_with_dash
+        end
+
+        def uid_sha1(no_dash=true)
+          no_dash ? generate_40_bit_checkmateUID_without_dash : generate_40_bit_checkmateUID_with_dash
+        end
+
+        private
+
+        def generate_32_bit_checkmateUID_with_dash
+          regexify(/[a-f0-9]{8}-([a-f0-9]{4}-){3}[a-f0-9]{12}/)
+        end
+
+        def generate_32_bit_checkmateUID_without_dash
+          regexify(/[a-f0-9]{32}/)
+        end
+
+        def generate_40_bit_checkmateUID_with_dash
+          regexify(/[a-f0-9]{12}-([a-f0-9]{4}-){4}[a-f0-9]{12}/)
+        end
+
+        def generate_40_bit_checkmateUID_without_dash
+          regexify(/[a-f0-9]{40}/)
+        end
+
+      end
+    end
+  end
+end

data/lib/MediTAF/utils/sticky.rb

@@ -0,0 +1,31 @@
+module MediTAF
+  module Utils
+    class Sticky < Hash
+
+      def initialize(default_value=nil)
+        super default_value
+      end
+
+      def [](key)
+        raise MediTAF::Utils::StickyKeyNotFound, "I don't have '#{key}' key" unless has_key? key
+        super key
+      end
+
+      def set_value(key, value)
+        self[key] = value
+      end
+
+      # @param data [String] reference to stored value
+      # @return [Object] the stored value at reference
+      # @raise [] when the reference is not found
+      def get_value(data)
+        result = data.dup
+        result.scan(/(\w+|\w)\s*/).each { |memo| result.sub!("#{memo[0]}", self["#{memo[0]}"]) if self["#{memo[0]}"] } if result.is_a? String
+        result
+      end
+    end
+
+    class StickyKeyNotFound < MediTAF::Utils::Exceptions::MediTAFException; end
+  end
+end
+

data/lib/MediTAF/version.rb

@@ -0,0 +1,3 @@
+module MediTAF
+  VERSION = "1.6.0"
+end

metadata

@@ -0,0 +1,147 @@
+--- !ruby/object:Gem::Specification
+name: Test_Framework1.0
+version: !ruby/object:Gem::Version
+  version: 1.6.0
+platform: ruby
+authors:
+- Medidata Test Automation Framework Team
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2016-07-16 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: require_all
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 1.3.2
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 1.3.2
+- !ruby/object:Gem::Dependency
+  name: logging
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 1.8.2
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 1.8.2
+- !ruby/object:Gem::Dependency
+  name: faker
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '1.3'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '1.3'
+- !ruby/object:Gem::Dependency
+  name: gmail
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: multi_xml
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: selenium-webdriver
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '2.46'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '2.46'
+description: " Test Automation Framework"
+email:
+- chriwilliams_23@yahoo.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- LICENSE
+- README.md
+- lib/MediTAF.rb
+- lib/MediTAF/services.rb
+- lib/MediTAF/services/clients.rb
+- lib/MediTAF/services/clients/euresource_adapter.rb
+- lib/MediTAF/services/clients/mauth_adapter.rb
+- lib/MediTAF/services/resources_mgr.rb
+- lib/MediTAF/ui.rb
+- lib/MediTAF/ui/application.rb
+- lib/MediTAF/ui/applications.rb
+- lib/MediTAF/utils/configuration.rb
+- lib/MediTAF/utils/exceptions.rb
+- lib/MediTAF/utils/logger.rb
+- lib/MediTAF/utils/mail.rb
+- lib/MediTAF/utils/meditaf_faker.rb
+- lib/MediTAF/utils/sticky.rb
+- lib/MediTAF/version.rb
+homepage: ''
+licenses:
+- MIT
+- LICENSE
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.4.5.1
+signing_key: 
+specification_version: 4
+summary: Test Automation Framework
+test_files: []