sealights-rspec-agent 2.0.2

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 5cc91027b052b89b83a7d22663733f1bf20ff0263b76e97e84d5978b993e62d0
+  data.tar.gz: d71970e5fab158eca4e44cdb1167a879ffdb82779b73dabfa542b474125c7030
+SHA512:
+  metadata.gz: 27ee78793e7e80babf278a255cc1f36f54c07a5c573051f1348c8e8af64778aa5e1da055f8a4cd13dc4c29c1cc5ae87e061664b74466a963218fce8422b48a7f
+  data.tar.gz: 886188ade8f1b296b60bf3f413a552955063f9f5e2a956aaa357cd31f7974304e35a6adb5a774f37c904c7c0f7d80612ce1f225faccdcde8f8e21068374b0822

data/agent/config.rb

@@ -0,0 +1,120 @@
+#
+# This script contains code responsible for gathering the Agent's configuration.
+#
+
+require_relative './utils'
+
+require 'json'
+require 'jwt'
+
+DEFAULT_TIA_DISABLED = 'false'
+DEFAULT_TIA_POLLING_INTERVAL_SECS = 5
+DEFAULT_TIA_POLLING_TIMEOUT_SECS = 60
+
+# environment variables used by the agent
+TOKEN_FILE_PATH_ENV_VAR = 'SL_TOKEN_FILE_PATH'
+TOKEN_ENV_VAR = 'SL_TOKEN'
+BUILD_SESSION_ID_ENV_VAR = 'SL_BUILD_SESSION_ID'
+BUILD_SESSION_ID_PATH_ENV_VAR = 'SL_BUILD_SESSION_ID_PATH'
+TEST_STAGE_ENV_VAR = 'SL_TEST_STAGE'
+TIA_DISABLED_ENV_VAR = 'SL_TIA_DISABLED'
+TIA_POLLING_INTERVAL_ENV_VAR = 'SL_TIA_POLL_INTERVAL'
+TIA_POLLING_TIMEOUT_ENV_VAR = 'SL_TIA_POLL_TIMEOUT'
+
+#
+# This class represents the Agent's configuration. On initialization, the fields get populated based on environment
+# variables, calls to the back-end server, and (optionally) files pointed to the by environment variables.
+#
+class AgentConfiguration
+  BUILD_SESSION_ENDPOINT = "/v2/agents/buildsession/"
+  TRUE_STRING = 'true'
+  SL_SERVER = 'x-sl-server'
+
+  attr_reader :build_session_id, :server, :customer_id, :test_stage, :tia_enabled, :jwt, :app_name, :branch, :build, :polling_timeout_secs, :polling_interval_secs
+
+  #
+  # An important side effect of AgentConfiguration's initialization is that it will set the value of `rest_client.jwt`.
+  #
+  def initialize(rest_client, env_reader = EnvironmentVariablesReader.new, file_reader = FileReader.new)
+    @env_vars = env_reader.read_vars
+    @file_reader = file_reader
+    @jwt = take_from_path_or_env(@env_vars, :tokenFile, :token)
+    @build_session_id = take_from_path_or_env(@env_vars, :buildSessionIdFile, :buildSessionId)
+    @server = server_from_token(@jwt)
+    rest_client.jwt = @jwt
+    build_session = JSON.parse(rest_client.get @server + BUILD_SESSION_ENDPOINT + @build_session_id)
+    @customer_id = build_session['customerId']
+    @app_name = build_session['appName']
+    @branch = build_session['branchName']
+    @build = build_session['buildName']
+    @test_stage = @env_vars[:testStage]
+    @tia_enabled = @env_vars.fetch(:tiaDisabled, DEFAULT_TIA_DISABLED) != TRUE_STRING
+
+    @polling_interval_secs = get_integer_from_env_vars(:pollingIntervalSecs, DEFAULT_TIA_POLLING_INTERVAL_SECS)
+    @polling_timeout_secs = get_integer_from_env_vars(:pollingTimeoutSecs, DEFAULT_TIA_POLLING_TIMEOUT_SECS)
+
+    info "RSpec agent config: #{pretty_fields(self, 'env_vars', 'file_reader')}"
+  rescue StandardError => e
+    error "Error while resolving agent configuration: #{e.message}"
+    raise(e)
+  end
+
+  private
+
+  def get_integer_from_env_vars(key, default_value)
+    Integer(@env_vars.fetch(key))
+  rescue
+    default_value
+  end
+
+  def take_from_path_or_env(env_vars, path_key, value_key)
+    path = env_vars[path_key]
+    @build_session_id = path.nil? ? env_vars[value_key] : read_value_from_file(path)
+  end
+
+  def read_value_from_file(path)
+    @file_reader.read(path).strip
+  end
+
+  def server_from_token(token)
+    JWT.decode(token, nil, false)[0].fetch(SL_SERVER)
+  end
+end
+
+class EnvironmentVariablesReader
+  def read_vars
+    env_vars = {
+        :tokenFile => ENV[TOKEN_FILE_PATH_ENV_VAR],
+        :token => ENV[TOKEN_ENV_VAR],
+        :buildSessionIdFile => ENV[BUILD_SESSION_ID_PATH_ENV_VAR],
+        :buildSessionId => ENV[BUILD_SESSION_ID_ENV_VAR],
+        :tiaDisabled => ENV[TIA_DISABLED_ENV_VAR],
+        :pollingIntervalSecs => ENV[TIA_POLLING_INTERVAL_ENV_VAR],
+        :pollingTimeoutSecs => ENV[TIA_POLLING_TIMEOUT_ENV_VAR],
+        :testStage => ENV.fetch(TEST_STAGE_ENV_VAR)
+    }
+
+    validate_exactly_one_is_set(TOKEN_FILE_PATH_ENV_VAR, env_vars[:tokenFile], TOKEN_ENV_VAR, env_vars[:token])
+    validate_exactly_one_is_set(BUILD_SESSION_ID_PATH_ENV_VAR, env_vars[:buildSessionIdFile], BUILD_SESSION_ID_ENV_VAR, env_vars[:buildSessionId])
+
+    env_vars
+  rescue StandardError => e
+    error "Error while resolving environment variables: #{e.message}."
+    raise(e)
+  end
+
+  private
+
+  def validate_exactly_one_is_set(first_name, first_value, second_name, second_value)
+    message = "Exactly one of the environment variables: '#{first_name}' or '#{second_name}' should be set."
+
+    # XORing to check if exactly one non-nil value
+    raise(KeyError.new(message)) unless first_value.nil? ^ second_value.nil?
+  end
+end
+
+class FileReader
+  def read(path)
+    File.read(path)
+  end
+end

data/agent/listener.rb

@@ -0,0 +1,229 @@
+#
+# This script contains code for listening for test events and in turn sending notifications to the back-end.
+#
+
+require_relative './rest-client-wrapper'
+require_relative './utils'
+
+require 'json'
+require 'securerandom'
+require 'singleton'
+
+#
+# RSpecListener implements methods needed for subscription to RSpec::Core::Reporter. The messages from RSpec are then
+# passed to the EventsDispatcher.
+#
+class RSpecListener
+  def initialize(http_client, server, customer_id, app_name, build, branch, test_stage, build_session_id, test_selection_status)
+    @events_handler = EventsDispatcher.new(http_client, server, customer_id, app_name, build, branch, test_stage, build_session_id, test_selection_status)
+    info "Started RSpec Agent for application name: '#{customer_id}', build: '#{branch}', build '#{build}', build session id: '#{build_session_id}', test selection status: '#{test_selection_status}'"
+  end
+
+  def start(notification)
+    @execution_id = SecureRandom.uuid
+    @events_handler.execution_started(@execution_id)
+  end
+
+  def stop(notification)
+    @events_handler.execution_ended(@execution_id)
+    @execution_id = nil
+  end
+
+  def example_started(notification)
+    TestIdTracker.instance.set_current_test_identifier(notification.example.full_description)
+    @events_handler.test_started(notification.example.full_description, notification.example.example_group.description, @execution_id)
+  end
+
+  def example_passed(notification)
+    @events_handler.test_passed(notification.example.full_description, notification.example.example_group.description, @execution_id, get_duration_millis(notification))
+  end
+
+  def example_failed(notification)
+    @events_handler.test_failed(notification.example.full_description, notification.example.example_group.description, @execution_id, get_duration_millis(notification))
+  end
+
+  def example_pending(notification)
+    @events_handler.test_skipped(notification.example.full_description, notification.example.example_group.description, @execution_id, get_duration_millis(notification))
+  end
+
+  def example_finished(notification)
+    TestIdTracker.instance.set_current_test_identifier(nil)
+  end
+
+  private
+
+  MILLIS_PER_SECOND = 1000
+
+  def get_duration_millis(notification)
+    notification.example.execution_result.run_time * MILLIS_PER_SECOND
+  end
+end
+
+#
+# EventsDispatcher is used for sending the test events to the back-end. The events are aggregated into batches of 10.
+#
+class EventsDispatcher
+  RSPEC_FRAMEWORK_NAME = :RSpec
+  EVENTS_ENDPOINT = '/v2/agents/events'
+
+  PASSED_STATUS = :passed
+  FAILED_STATUS = :failed
+  SKIPPED_STATUS = :skipped
+
+  def initialize(http_client, server, customer_id, app_name, build, branch, test_stage, build_session_id, test_selection_status)
+    @http_client = http_client
+    @server = server
+    @customer_id = customer_id
+    @app_name = app_name
+    @build = build
+    @branch = branch
+    @test_stage = test_stage
+    @build_session_id = build_session_id
+    @test_selection_status = test_selection_status
+    @buffered_events = []
+
+    # adding an exit hook to make sure that any remaining events get sent in case of a problem
+    at_exit do
+      flush_events_buffer
+    end
+  end
+
+  def test_started(test_name, example_group, execution_id)
+    evt = create_test_event(:testStart, example_group, test_name, execution_id)
+    add_to_buffer evt
+  end
+
+  def test_passed(test_name, example_group, execution_id, duration)
+    evt = create_test_end_event(example_group, test_name, execution_id, PASSED_STATUS, duration)
+    add_to_buffer evt
+  end
+
+  def test_failed(test_name, example_group, execution_id, duration)
+    evt = create_test_end_event(example_group, test_name, execution_id, FAILED_STATUS, duration)
+    add_to_buffer evt
+  end
+
+  def test_skipped(test_name, example_group, execution_id, duration)
+    evt = create_test_end_event(example_group, test_name, execution_id, SKIPPED_STATUS, duration)
+    add_to_buffer evt
+  end
+
+  def execution_started(execution_id)
+    evt = create_basic_test_event(:executionIdStarted, execution_id)
+    add_to_buffer evt
+  end
+
+  def execution_ended(execution_id)
+    evt = create_basic_test_event(:executionIdEnded, execution_id)
+    add_to_buffer evt
+
+    flush_events_buffer
+  end
+
+  def flush_events_buffer
+    unless @buffered_events.empty?
+      send_buffered_events
+    end
+  end
+
+  private
+
+  EVENTS_BATCH_SIZE = 10
+  MILLIS_IN_SECOND = 1000
+
+  def add_to_buffer evt
+    @buffered_events.append(evt)
+
+    if @buffered_events.size >= EVENTS_BATCH_SIZE
+      send_buffered_events
+    end
+  end
+
+  def send_buffered_events
+    msg = {
+        :appName => @app_name,
+        :customerId => @customer_id,
+        :environment => {
+            :agentType => RSPEC_FRAMEWORK_NAME,
+            :environmentName => @test_stage,
+            :testStage => @test_stage,
+            :labId => @build_session_id
+        },
+        :testSelectionStatus => @test_selection_status,
+        :events => @buffered_events
+    }
+
+    unless @branch.nil?
+      msg[:branch] = @branch
+    end
+    unless @build.nil?
+      msg[:build] = @build
+    end
+
+    url = @server + EVENTS_ENDPOINT
+    begin
+      msg_json = msg.to_json
+      info "Sending #{@buffered_events.size} buffered events"
+      @http_client.post url, msg_json
+      clear_buffer
+    rescue Exception => e
+      error "Failed sending data '#{msg}' to '#{url}'", e
+    end
+  end
+
+  def clear_buffer
+    @buffered_events = []
+  end
+
+  def create_basic_test_event(type, execution_id)
+    {
+        :type => type,
+        :testFramework => RSPEC_FRAMEWORK_NAME,
+        :executionId => execution_id,
+        :timestamp => current_millis
+    }
+  end
+
+  def create_test_event(type, example_group, test_name, execution_id)
+    evt = create_basic_test_event(type, execution_id)
+    evt[:testName] = replace_reserved_characters(test_name)
+    evt[:suitePath] = example_group
+    evt
+  end
+
+  def create_test_end_event(example_group, test_name, execution_id, result, duration)
+    evt = create_test_event(:testEnd, example_group, test_name, execution_id)
+    evt[:result] = result
+    evt[:duration] = duration
+    evt
+  end
+
+  def current_millis
+    (Time.now.to_f * MILLIS_IN_SECOND).to_i
+  end
+end
+
+class TestIdTracker
+  include Singleton
+
+  def initialize
+    @current_test_identifier = nil
+  end
+
+  def to_s
+    unless @current_test_identifier.nil?
+      return "State:" + @current_test_identifier
+    end
+    "Not in test"
+  end
+
+  def get_current_test_identifier
+    @current_test_identifier
+  end
+
+  def set_current_test_identifier(test_id)
+    if @current_test_identifier != test_id
+      @current_test_identifier = test_id
+    end
+  end
+end

data/agent/rest-client-wrapper.rb

@@ -0,0 +1,27 @@
+require_relative './utils'
+
+require 'rest-client'
+
+#
+# This simple RestClient wrapper automatically adds the necessary headers to HTTP requests. It is required to
+# initialize the :jwt field for RestClientWrapper to work.
+#
+class RestClientWrapper
+  attr_writer :jwt
+
+  def get(url)
+    RestClient.get URI::encode(url), :Authorization => auth_header_value(@jwt)
+  end
+
+  def post(url, msg_json)
+    info "Sending request: POST #{url}  #{msg_json}"
+    RestClient.post URI::encode(url), msg_json, :content_type => :json, :accept => :json, :Authorization => auth_header_value(@jwt)
+  end
+
+  private
+
+  def auth_header_value(jwt)
+    "Bearer #{jwt}"
+  end
+
+end

data/agent/sealights-rspec-agent.rb

@@ -0,0 +1,30 @@
+#
+# This script is used for:
+#   - subscribing the SeaLights Agent to RSpec test events
+#   - apply TIA configuration to perform test selections.
+#
+# This script has to be run before the RSpec test script to take effect.
+#
+
+require_relative './config'
+require_relative './listener'
+require_relative './rest-client-wrapper'
+require_relative './tia'
+require_relative './utils'
+
+require 'rspec'
+
+RSpec.configure do |rspec_config|
+  http_client = RestClientWrapper.new
+
+  cfg = AgentConfiguration.new(http_client, EnvironmentVariablesReader.new)
+
+  tia_config = TiaConfig.new(cfg.tia_enabled, cfg.server, cfg.build_session_id, cfg.test_stage, cfg.polling_interval_secs, cfg.polling_timeout_secs)
+  tia_applier = TiaApplier.new(http_client, RspecExampleClassModifier.new, tia_config)
+  tia_applier.apply_configuration
+
+  listener = RSpecListener.new(http_client, cfg.server, cfg.customer_id, cfg.app_name, cfg.build, cfg.branch, cfg.test_stage, cfg.build_session_id, tia_applier.test_selection_status)
+  rspec_config.reporter.register_listener listener, :start, :example_started, :example_passed, :example_failed, :example_pending, :example_finished, :stop
+rescue Exception => e
+  error "Could not subscribe RSpec Agent to test run. #{e.message}.", e
+end

data/agent/tia.rb

@@ -0,0 +1,154 @@
+#
+# This script contains code for obtaining and applying TIA recommendations.
+#
+
+require_relative './utils'
+
+require 'json'
+require 'rspec'
+
+TEST_SELECTION_DISABLED = 'disabled'
+TEST_SELECTION_DISABLED_BY_CONFIG = 'disabledByConfiguration'
+TEST_SELECTION_RECOMMENDATION_TIMEOUT = 'recommendationsTimeout'
+TEST_SELECTION_ERROR = 'error'
+TEST_SELECTION_RECOMMENDED_TEST = 'recommendedTests'
+
+class TiaConfig
+  attr_reader :tia_enabled, :server, :build_session_id, :test_stage, :polling_interval_secs, :polling_timeout_secs
+
+  def initialize(tia_enabled, server, build_session_id, test_stage, polling_interval_secs, polling_timeout_secs)
+    @tia_enabled = tia_enabled
+    @server = server
+    @build_session_id = build_session_id
+    @test_stage = test_stage
+    @polling_interval_secs = polling_interval_secs
+    @polling_timeout_secs = polling_timeout_secs
+  end
+end
+
+#
+# TiaApplier uses the TIA config to get the list of excluded tests and then calls the RSpec modifier to apply test
+# selection.
+#
+class TiaApplier
+  attr_reader :test_selection_status
+
+  def initialize(http_client, rspec_modifier, cfg)
+    @http_client = http_client
+    @cfg = cfg
+    @rspec_modifier = rspec_modifier
+
+    info "TIA applier initialized with configuration: #{pretty_fields(@cfg)}."
+
+    # We're starting with the status indicating that TIA recommendations were acquired successfully.
+    # The status gets changed, if something goes "wrong" on the way.
+    @test_selection_status = TEST_SELECTION_RECOMMENDED_TEST
+  end
+
+  def apply_configuration
+    unless @cfg.tia_enabled
+      @test_selection_status = TEST_SELECTION_DISABLED_BY_CONFIG
+      return
+    end
+
+    excluded_tests = get_excluded_tests
+    @rspec_modifier.add_test_exclusion(excluded_tests)
+
+    info "Applied TIA with excluded tests: #{excluded_tests}"
+  rescue Exception => e
+    error "An error occurred while applying TIA configuration. Test selection will be skipped.", e
+  end
+
+  private
+
+  TEST_RECOMMENDATIONS_ENDPOINT = "/v1/test-recommendations/"
+  URL_SEPARATOR = "/"
+  HTTP_OK = 200
+  TEST_SELECTION_ENABLED_FIELD = 'testSelectionEnabled'
+  EXCLUDED_TESTS_FIELD = 'excludedTests'
+  RECOMMENDATION_SET_STATUS_FIELD = 'recommendationSetStatus'
+  NOT_READY_RECOMMENDATION_STATUS = 'notReady'
+
+  def get_excluded_tests
+    url = @cfg.server + TEST_RECOMMENDATIONS_ENDPOINT + @cfg.build_session_id + URL_SEPARATOR + @cfg.test_stage
+    recommendations = poll_for_recommendations(url)
+
+    selection_enabled = recommendations[TEST_SELECTION_ENABLED_FIELD]
+    unless selection_enabled
+      unless selection_enabled.nil?
+        @test_selection_status = TEST_SELECTION_DISABLED
+      end
+      return []
+    end
+
+    recommendations.fetch(EXCLUDED_TESTS_FIELD, []).map { |excluded_test| excluded_test['name'] }
+  rescue Exception => e
+    @test_selection_status = TEST_SELECTION_ERROR
+    error "Error while getting excluded tests: '#{e.message}'. Proceeding without excluded tests.", e
+  end
+
+  def poll_for_recommendations(url)
+    total_wait = 0
+    while total_wait < @cfg.polling_timeout_secs
+      recommendations = fetch_recommendations(url)
+      unless should_keep_polling(recommendations)
+        return recommendations
+      end
+      sleep(@cfg.polling_interval_secs)
+      total_wait += @cfg.polling_interval_secs
+    end
+
+    @test_selection_status = TEST_SELECTION_RECOMMENDATION_TIMEOUT
+    {}
+  end
+
+  def should_keep_polling(recommendations)
+    !recommendations.empty? &&
+        recommendations[TEST_SELECTION_ENABLED_FIELD] &&
+        recommendations[RECOMMENDATION_SET_STATUS_FIELD] == NOT_READY_RECOMMENDATION_STATUS &&
+        @cfg.polling_interval_secs > 0 && @cfg.polling_timeout_secs > 0
+  end
+
+  def fetch_recommendations(url)
+    http_response = @http_client.get url
+    if http_response.code != HTTP_OK
+      @test_selection_status = TEST_SELECTION_ERROR
+      return {}
+    end
+
+    JSON.parse(http_response)
+  end
+end
+
+#
+# This class modifies the `RSpec::Core::Example.run` method to skip the currently run test based on checking if
+# the test's name is in the `excluded_tests` list.
+#
+class RspecExampleClassModifier
+  def add_test_exclusion(excluded_tests)
+    if excluded_tests.empty?
+      return
+    end
+
+    mod = Module.new do
+      define_method(:run) do |*args, &blk|
+        begin
+          test_name = self.metadata[:full_description]
+          if excluded_tests.include? replace_reserved_characters(test_name)
+            info "Test '#{test_name}' excluded by TIA."
+
+            def skipped?
+              return true
+            end
+          end
+        rescue Exception => e
+          error "Unsuccessful TIA test exclusion check. #{e.message}", e
+        end
+
+        super(*args, &blk)
+      end
+    end
+
+    RSpec::Core::Example.prepend(mod)
+  end
+end

data/agent/utils.rb

@@ -0,0 +1,51 @@
+DOT = '.'
+DOT_REPLACEMENT = '_'
+SLASH = '/'
+SLASH_REPLACEMENT = '#'
+
+#
+# The '.' and '/' are treated by the back-end as separators of package/class/method names. To avoid unexpected
+# processing of RSpec test names, these characters are replaced.
+#
+def replace_reserved_characters(test_name)
+  test_name.gsub(DOT, DOT_REPLACEMENT).gsub(SLASH, SLASH_REPLACEMENT)
+end
+
+def info(message)
+  log(message, :INFO)
+end
+
+def error(message, e = nil)
+  log(message + (e.nil? ? '' : pretty_backtrace(e)), :ERROR)
+end
+
+private
+
+def log(message, level)
+  puts "[SEALIGHTS] #{Time.now.strftime("%F %T.%3N")} #{level} #{message}"
+end
+
+#
+# This method creates a mapping of the field names (without the '@' sign) to their values.
+# An optional list of excluded fields can be passed.
+# For any field called `jwt`only the last six characters of its value are taken. It is assumed that such a field will
+# always hold a JSON Web Token.
+#
+def pretty_fields(object, *excluded_fields)
+  fields_values = {}
+  object.instance_variables.each do |var|
+    field_name = var.to_s.delete('@')
+    field_value = object.instance_variable_get(var)
+    unless excluded_fields.include? field_name
+      fields_values[field_name] = field_name == 'jwt' ? "...#{field_value[-6..-1]}" : field_value
+    end
+  end
+
+  fields_values
+end
+
+def pretty_backtrace(exception)
+  initial_whitespace = "\n\t"
+  backtrace_lines = exception.backtrace.map { |s| "#{initial_whitespace}#{s}" }.join
+  "#{initial_whitespace}Backtrace:#{backtrace_lines}"
+end

metadata

@@ -0,0 +1,47 @@
+--- !ruby/object:Gem::Specification
+name: sealights-rspec-agent
+version: !ruby/object:Gem::Version
+  version: 2.0.2
+platform: ruby
+authors:
+- SeaLights
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2019-10-31 00:00:00.000000000 Z
+dependencies: []
+description: 
+email: 
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- agent/config.rb
+- agent/listener.rb
+- agent/rest-client-wrapper.rb
+- agent/sealights-rspec-agent.rb
+- agent/tia.rb
+- agent/utils.rb
+homepage: 
+licenses: []
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- agent
+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: []
+rubygems_version: 3.0.3
+signing_key: 
+specification_version: 4
+summary: SeaLights RSpec Agent
+test_files: []