dvla-application_helper 5.1.5

data/functional-tests/features/step_definitions/application_creation_steps.rb

@@ -0,0 +1,115 @@
+When(/^I create a "(non-processable|processable)" "(.*)" application( with "(.*)" flags?)?$/) do |processable, uodl_version, flags|
+  # start instance of builder, allows user to pass in either CODL, UODL (V1, V2, V3) to specify the specific builder
+  app_builder_instance = case uodl_version
+                         when 'UODL V1'
+                           DVLA::Application::ApplicationBuilder.new
+                         when 'UODL V2'
+                           DVLA::Application::UODLV2ApplicationBuilder.new
+                         when 'UODL V2 TYR'
+                           DVLA::Application::TYRV2ApplicationBuilder.new
+                         when 'UODL V2 REP'
+                           DVLA::Application::REPV2ApplicationBuilder.new
+                         when 'UODL V2 DUP'
+                           DVLA::Application::DUPV2ApplicationBuilder.new
+                         when 'UODL V2 EXC'
+                           DVLA::Application::EXCV2ApplicationBuilder.new
+                         when 'UODL V2 COP'
+                           DVLA::Application::COPV2ApplicationBuilder.new
+                         when 'UODL V3 TYR'
+                           DVLA::Application::TYRV3ApplicationBuilder.new
+                         when 'UODL V3 REP'
+                           DVLA::Application::REPV3ApplicationBuilder.new
+                         when 'UODL V3 DUP'
+                           DVLA::Application::DUPV3ApplicationBuilder.new
+                         when 'UODL V3 EXC'
+                           DVLA::Application::EXCV3ApplicationBuilder.new
+                         when 'UODL V3 COP'
+                           DVLA::Application::COPV3ApplicationBuilder.new
+                         when 'CODL'
+                           DVLA::Application::CODLApplicationBuilder.new
+                         when 'CSUDL'
+                           DVLA::Application::CSUDLApplicationBuilder.new
+                         else
+                           raise "Unsupported app version: #{uodl_version}"
+                         end
+
+  # set and stores artefacts.processable as bool
+  artefacts.processable = processable == 'processable'
+
+  app_attributes = []
+  split_flags = flags&.split(',')&.map(&:strip)
+  split_flags&.each do |flag|
+    opts = case flag
+           when 'with_user_image'
+             # with user image expects passport_available param to be passed in as either true or false
+             true
+           when 'with_driver_id'
+             # sets a random uuid as the driver_id and stores as an artefact
+             artefacts.driver_id = SecureRandom.uuid
+           when 'with_customer_id'
+             # sets a random uuid as the customer_id and stores as an artefact
+             artefacts.customer_id = SecureRandom.uuid
+           when 'is_organ_donor'
+             artefacts.organ_donor
+           when 'with_payments'
+             artefacts.payment = [
+               {
+                 paymentId: 1234567890,
+                 paymentStatus: 'SETTLED',
+                 paymentAmount: '14.00',
+                 paymentReference: 'AB1234567',
+               },
+             ]
+           when 'with_applicant'
+             artefacts.applicant = DVLA::Application::PersonFactory.new.build.to_applicant
+           when 'with_review_state', 'with_photo_review_state'
+             artefacts.review_state
+           when 'with_signature_review_state'
+             artefacts.signature_review_state
+           when 'with_application_status'
+             artefacts.application_status
+           when 'with_driving_licence_actions'
+             # EXAMPLE: {updatePhoto: {  photographImageId: '617d6689-e03e-44e7-962d-ceb6e158e031',}}
+             artefacts.driving_licence_action = { updatePhoto: { photographImageId: '617d6689-e03e-44e7-962d-ceb6e158e031' } }
+           when 'with_product_type'
+             artefacts.product_type = Settings.test.product_type.sample
+           when 'with_unable_to_prove_licence_possession_reason'
+             'LOST_OR_STOLEN'
+           when 'with_update_address'
+             {
+               newAddress: {
+                 unstructuredAddress: {
+                   line1: 'TEST 5357 Gilberto Forge',
+                   line5: 'New Lewisfort',
+                   postcode: 'SA3 1AD',
+                 },
+               },
+             }
+           else
+             nil
+           end
+
+    if !flag.nil?
+      app_attributes << if opts.nil?
+                          SimpleSymbolize.symbolize(flag)
+                        else
+                          [SimpleSymbolize.symbolize(flag), (opts unless opts.nil?)]
+                        end
+    end
+  end
+
+  # set processable / non-processable flag
+  if artefacts.processable
+    app_attributes << [:processable]
+  elsif artefacts.application_status.nil?
+    app_attributes << [:with_application_status, 'Started']
+  end
+
+  # add build flag to end of array
+  app_attributes << :build
+
+  LOG.info "Schema class version: #{app_builder_instance.class}".bg_magenta.black
+  artefacts.submitted_application = Array(app_attributes).inject(app_builder_instance) { |instance, attribute| instance.send(*attribute) }
+
+  LOG.info "\nRetrieved Application: #{JSON.pretty_generate(JSON.parse(artefacts.submitted_application.to_json))}".blue
+end

data/functional-tests/features/step_definitions/image_steps.rb

@@ -0,0 +1,144 @@
+And(/^the application has (a )?(Passport|User|Home Office) image(s)?$/) do |_, image_origin, multiple_images|
+  expected_number_images = multiple_images.nil? ? 1 : 2
+  LOG.info "checking if #{expected_number_images} active images are present for: #{image_origin} image"
+  passport_images = artefacts.retrieved_application.images.find_all { |image| image.image_origin_type == image_origin && image.image_status == 'Active' }
+  expect(passport_images.length).to be(expected_number_images), "Expected #{expected_number_images} #{image_origin} images with status of Active"
+end
+
+And(/^the application has (unique_image_ids|static_image_ids) for photos$/) do |unique|
+  if unique == 'unique_image_ids'
+    expect(artefacts.retrieved_application.images.find { |image| image.image_origin_type == 'Passport' }.image_id).to_not eq(DVLA::Application::PhotoImageFactory::PASSPORT_IMAGE_SERVICE_ID), 'Expected seeded image_id for Driving Licence to NOT MATCH static uuid'
+    expect(artefacts.retrieved_application.images.find { |image| image.image_origin_type == 'User' }.image_id).to_not eq(DVLA::Application::PhotoImageFactory::USER_IMAGE_ID), 'Expected seeded image_id for Driving Licence to NOT MATCH static uuid'
+    expect(artefacts.retrieved_application.images.find { |image| image.image_origin_type == 'Driving Licence' }.image_id).to_not eq(DVLA::Application::PhotoImageFactory::COMPARISON_IMAGE_ID), 'Expected seeded image_id for Driving Licence to NOT MATCH static uuid'
+  else
+    expect(artefacts.retrieved_application.images.find { |image| image.image_origin_type == 'Passport' }.image_id).to eq(DVLA::Application::PhotoImageFactory::PASSPORT_IMAGE_SERVICE_ID), 'Expected seeded image_id for Driving Licence to MATCH static uuid'
+    expect(artefacts.retrieved_application.images.find { |image| image.image_origin_type == 'User' }.image_id).to eq(DVLA::Application::PhotoImageFactory::USER_IMAGE_ID), 'Expected seeded image_id for Driving Licence to MATCH static uuid'
+    expect(artefacts.retrieved_application.images.find { |image| image.image_origin_type == 'Driving Licence' }.image_id).to eq(DVLA::Application::PhotoImageFactory::COMPARISON_IMAGE_ID), 'Expected seeded image_id for Driving Licence to MATCH static uuid'
+  end
+end
+
+And(/^the application has (unique_image_ids|static_image_ids) for photos and signatures$/) do |unique|
+  if unique == 'unique_image_ids'
+    expect(artefacts.retrieved_application.images.find { |image| image.image_origin_type == 'Passport' && image.image_type == 'Photo' }.image_id).to_not eq(DVLA::Application::PhotoSignatureImageFactory::PASSPORT_COMPARISON_IMAGE_ID), 'Expected seeded image_id for Driving Licence to NOT MATCH static uuid'
+    expect(artefacts.retrieved_application.images.find { |image| image.image_origin_type == 'User' && image.image_type == 'Photo' }.image_id).to_not eq(DVLA::Application::PhotoImageFactory::USER_IMAGE_ID), 'Expected seeded image_id for Driving Licence to NOT MATCH static uuid'
+    expect(artefacts.retrieved_application.images.find { |image| image.image_origin_type == 'User' && image.image_type == 'Signature' }.image_id).to_not eq(DVLA::Application::PhotoSignatureImageFactory::USER_SIGNATURE_IMAGE_ID), 'Expected seeded image_id for Driving Licence to NOT MATCH static uuid'
+  else
+    expect(artefacts.retrieved_application.images.find { |image| image.image_origin_type == 'Passport' && image.image_type == 'Photo' }.image_id).to eq(DVLA::Application::PhotoSignatureImageFactory::PASSPORT_COMPARISON_IMAGE_ID), 'Expected seeded image_id for Driving Licence to MATCH static uuid'
+    expect(artefacts.retrieved_application.images.find { |image| image.image_origin_type == 'User' && image.image_type == 'Photo' }.image_id).to eq(DVLA::Application::PhotoImageFactory::USER_IMAGE_ID), 'Expected seeded image_id for Driving Licence to MATCH static uuid'
+    expect(artefacts.retrieved_application.images.find { |image| image.image_origin_type == 'User' && image.image_type == 'Signature' }.image_id).to eq(DVLA::Application::PhotoSignatureImageFactory::USER_SIGNATURE_IMAGE_ID), 'Expected seeded image_id for Driving Licence to MATCH static uuid'
+  end
+end
+
+Given(/^I want a specific (Photo|Signature) review state of "([^"]*)" to be set$/) do |image_type, review_state|
+  if image_type == 'Photo'
+    artefacts.review_state = DVLA::Application::ReviewState.const_get(review_state)
+  else
+    artefacts.signature_review_state = DVLA::Application::SignatureReviewState.const_get(review_state)
+  end
+end
+
+
+And(/^the (CSUDL )?application contains the seeded (Photo|Signature) review state of "([^"]*)"$/) do |is_csudl, image_type, review_state|
+  app_type = is_csudl.nil? ? 'UODL' : 'CSUDL'
+  active_user_image = get_user_image(images: artefacts.retrieved_application.images, image_type:, app_type: app_type)
+
+  case review_state
+  when 'CLERK_IN_PROGRESS'
+    expect(active_user_image.review_history.empty?).to be(true), 'Error, clerk in progress state, use image review should be empty'
+  when 'CLERK_REJECTED'
+    assert_review_history(review_history: active_user_image.review_history[0], outcome: 'Rejection on standards', review_level: 'Clerk', outcome_reasons_required: true)
+  when 'CLERK_REFER_TO_SUPERVISOR_STANDARDS'
+    assert_review_history(review_history: active_user_image.review_history[0], outcome: 'Referral at standards', review_level: 'Clerk')
+  when 'CLERK_REFER_TO_SUPERVISOR_COMPARE'
+    assert_review_history(review_history: active_user_image.review_history[0], outcome: 'Referral at compare', review_level: 'Clerk')
+  when 'CLERK_APPROVED'
+    assert_review_history(review_history: active_user_image.review_history[0], outcome: 'Success', review_level: 'Clerk')
+  when 'SUPERVISOR_REJECTED'
+    assert_review_history(review_history: active_user_image.review_history[0], outcome: 'Rejection on standards', review_level: 'Supervisor', outcome_reasons_required: true)
+    assert_review_history(review_history: active_user_image.review_history[1], outcome: 'Referral at standards', review_level: 'Clerk')
+  when 'SUPERVISOR_REFER_TO_FRAUD'
+    assert_review_history(review_history: active_user_image.review_history[0], outcome: 'Referral at compare', review_level: 'Supervisor')
+    if artefacts.processable
+      assert_review_history(review_history: active_user_image.review_history[1], outcome: 'Referral at compare', review_level: 'Clerk')
+    else
+      assert_review_history(review_history: active_user_image.review_history[1], outcome: 'Referral at standards', review_level: 'Clerk')
+    end
+  when 'SUPERVISOR_APPROVED'
+    assert_review_history(review_history: active_user_image.review_history[0], outcome: 'Success', review_level: 'Supervisor')
+    assert_review_history(review_history: active_user_image.review_history[1], outcome: 'Referral at standards', review_level: 'Clerk')
+  when 'FRAUD_BEGIN_INVESTIGATION'
+    assert_review_history(review_history: active_user_image.review_history[0], outcome: 'Begin investigation', review_level: 'Fraud', outcome_reasons_required: true)
+    assert_review_history(review_history: active_user_image.review_history[1], outcome: 'Referral at compare', review_level: 'Supervisor')
+    if artefacts.processable
+      assert_review_history(review_history: active_user_image.review_history[2], outcome: 'Referral at compare', review_level: 'Clerk')
+    else
+      assert_review_history(review_history: active_user_image.review_history[2], outcome: 'Referral at standards', review_level: 'Clerk')
+    end
+  when 'FRAUD_APPROVED'
+    if artefacts.processable
+      assert_review_history(review_history: active_user_image.review_history[0], outcome: 'Success', review_level: 'Fraud')
+      assert_review_history(review_history: active_user_image.review_history[1], outcome: 'Referral at compare', review_level: 'Supervisor')
+      assert_review_history(review_history: active_user_image.review_history[2], outcome: 'Referral at standards', review_level: 'Clerk')
+    else
+      assert_review_history(review_history: active_user_image.review_history[0], outcome: 'Referral at compare', review_level: 'Clerk')
+      assert_review_history(review_history: active_user_image.review_history[1], outcome: 'Referral at standards', review_level: 'Clerk')
+    end
+  when 'FRAUD_REJECTED'
+    if artefacts.processable
+      assert_review_history(review_history: active_user_image.review_history[0], outcome: 'Rejection on standards', review_level: 'Fraud', outcome_reasons_required: true)
+      assert_review_history(review_history: active_user_image.review_history[1], outcome: 'Referral at compare', review_level: 'Supervisor')
+    else
+      assert_review_history(review_history: active_user_image.review_history[0], outcome: 'Rejection on standards', review_level: 'Clerk', outcome_reasons_required: true)
+      assert_review_history(review_history: active_user_image.review_history[1], outcome: 'Referral at compare', review_level: 'Clerk')
+    end
+    assert_review_history(review_history: active_user_image.review_history[2], outcome: 'Referral at standards', review_level: 'Clerk')
+  when 'FRAUD_REVIEW_REJECTION_WITH_REFUND'
+    assert_review_history(review_history: active_user_image.review_history[0], outcome: 'Rejection with refund', review_level: 'Fraud review')
+    assert_review_history(review_history: active_user_image.review_history[1], outcome: 'Begin investigation', review_level: 'Fraud', outcome_reasons_required: true)
+    assert_review_history(review_history: active_user_image.review_history[2], outcome: 'Referral at compare', review_level: 'Supervisor')
+    if artefacts.processable
+      assert_review_history(review_history: active_user_image.review_history[3], outcome: 'Referral at compare', review_level: 'Clerk')
+    else
+      assert_review_history(review_history: active_user_image.review_history[3], outcome: 'Referral at standards', review_level: 'Clerk')
+    end
+  when 'FRAUD_REVIEW_REJECTION_WITHOUT_REFUND'
+    assert_review_history(review_history: active_user_image.review_history[0], outcome: 'Rejection no refund', review_level: 'Fraud review')
+    assert_review_history(review_history: active_user_image.review_history[1], outcome: 'Begin investigation', review_level: 'Fraud', outcome_reasons_required: true)
+    assert_review_history(review_history: active_user_image.review_history[2], outcome: 'Referral at compare', review_level: 'Supervisor')
+    if artefacts.processable
+      assert_review_history(review_history: active_user_image.review_history[3], outcome: 'Referral at compare', review_level: 'Clerk')
+    else
+      assert_review_history(review_history: active_user_image.review_history[3], outcome: 'Referral at standards', review_level: 'Clerk')
+    end
+  when 'FRAUD_REVIEW_APPROVED'
+    assert_review_history(review_history: active_user_image.review_history[0], outcome: 'Success', review_level: 'Fraud review')
+    assert_review_history(review_history: active_user_image.review_history[1], outcome: 'Begin investigation', review_level: 'Fraud', outcome_reasons_required: true)
+    assert_review_history(review_history: active_user_image.review_history[2], outcome: 'Referral at compare', review_level: 'Supervisor')
+    if artefacts.processable
+      assert_review_history(review_history: active_user_image.review_history[3], outcome: 'Referral at compare', review_level: 'Clerk')
+    else
+      assert_review_history(review_history: active_user_image.review_history[3], outcome: 'Referral at standards', review_level: 'Clerk')
+    end
+  else
+    Raise DVLA::Application.logger.warn 'Unknown review state passed in'
+  end
+end
+
+And(/^the application contains the seeded Comparison review state of "([^"]*)"$/) do |review_state|
+  active_user_image = get_user_image(images: artefacts.retrieved_application.images, image_type: 'Photo')
+  active_comparison_image = get_comparison_image(images: artefacts.retrieved_application.images)
+
+  case review_state
+  when 'CLERK_REJECT_COMPARISON_PHOTO'
+    assert_review_history(review_history: active_comparison_image.review_history[0], outcome: 'Reject comparison photo', review_level: 'Clerk')
+  when 'FRAUD_REJECT_COMPARISON_PHOTO'
+    assert_review_history(review_history: active_comparison_image.review_history[0], outcome: 'Reject comparison photo', review_level: 'Fraud')
+    assert_review_history(review_history: active_user_image.review_history[0], outcome: 'Referral at compare', review_level: 'Supervisor')
+    assert_review_history(review_history: active_user_image.review_history[1], outcome: 'Referral at standards', review_level: 'Clerk')
+  when 'SUPERVISOR_REJECT_COMPARISON_PHOTO'
+    assert_review_history(review_history: active_comparison_image.review_history[0], outcome: 'Reject comparison photo', review_level: 'Supervisor')
+    assert_review_history(review_history: active_user_image.review_history[0], outcome: 'Referral at standards', review_level: 'Clerk')
+  else
+    raise DVLA::Application.logger.warn 'Unknown review state passed in'
+  end
+end

data/functional-tests/features/step_definitions/state_machine_steps.rb

@@ -0,0 +1,43 @@
+And(/^the state machine is waiting on the PreparationHook$/) do
+  last_entered_state = nil
+  BlockRepeater::Repeater.new do
+    DVLA::Application.logger.info 'Waiting for state machine to start Preparation hook'.blue
+    execution_instance = DVLA::Application::StateMachineExecution.new.generate_execution_arn(execution_uuid: artefacts.submitted_application.application_id,
+                                                                                             state_machine_name: 'application-process-engine-fulfilment',
+                                                                                             calling_service: 'application-process-engine')
+    events = execution_instance.get_history.data[:events].reverse
+    events.each do |event|
+      unless event[:state_entered_event_details].nil?
+        last_entered_state = event[:state_entered_event_details][:name]
+        break
+      end
+    end
+  end.until do
+    DVLA::Application.logger.info "Current hook: #{last_entered_state}".blue
+    last_entered_state == 'PreparationHook'
+  end.repeat(times: 10, delay: 3)
+
+  expect(last_entered_state).to eq 'PreparationHook'
+end
+
+And(/^I allow the (state machine time to be started|application actions time to be updated)$/) do |_|
+  # Reviewed this step and i saw no flakiness with dropping the sleep down to 1 second, updated to 2 seconds for now to review
+  LOG.info 'Waiting for 2 seconds to allow the state machine / lambdas to process'.blue
+  sleep 2
+end
+
+And(/^the application process engine fulfilment execution has a status of "([^"]*)"$/) do |expected_status|
+  actual_execution_status = nil
+  BlockRepeater::Repeater.new do
+    LOG.info("Waiting for the state machine to reach status of: #{expected_status}")
+    execution_instance = DVLA::Application::StateMachineExecution.new.generate_execution_arn(execution_uuid: artefacts.submitted_application.application_id,
+                                                                                             state_machine_name: 'application-process-engine-fulfilment',
+                                                                                             calling_service: 'application-process-engine')
+
+    actual_execution_status = execution_instance.describe_execution.data[:status]
+    LOG.info("The status of the execution is: #{actual_execution_status}")
+  end.until do
+    actual_execution_status == expected_status
+  end.repeat(times: 15, delay: 4)
+  expect(actual_execution_status).to eq(expected_status)
+end

data/functional-tests/features/support/data/artefacts.rb

@@ -0,0 +1,27 @@
+# A lightweight class (Struct) to hold all the vars we'll be using in the tests to avoid
+# the proliferation of @vars
+Struct.new('TestArtefacts',
+           :applicant,
+           :application_status,
+           :application_id,
+           :customer_id,
+           :driver_id,
+           :driving_licence_action,
+           :execution_response,
+           :organ_donor,
+           :payment,
+           :processable,
+           :product_type,
+           :retrieved_application,
+           :review_state,
+           :signature_review_state,
+           :submitted_application) do
+  # naked asterisk - a splat operator that allow any number of arguments to be passed in
+  def initialize(*)
+    super
+  end
+end
+
+def artefacts
+  @artefacts ||= Struct::TestArtefacts.new
+end

data/functional-tests/features/support/data/image_helpers.rb

@@ -0,0 +1,20 @@
+def get_user_image(images:, image_type:, app_type: 'UODL')
+  if app_type === 'CSUDL'
+    return images.find { |image| image.image_origin_type == 'Counter Service' && image.image_type == image_type }
+  end
+
+  images.find { |image| image.image_origin_type == 'User' && image.image_type == image_type && image.image_source == 'driving-licence-image-service' }
+end
+
+def get_comparison_image(images:)
+  images.find { |image| image.image_origin_type == 'Home Office' && image.image_source == 'driving-licence-image-service' && image.image_purpose == 'Comparison' }
+end
+
+def assert_review_history(review_history:, outcome:, review_level:, outcome_reasons_required: false)
+  expect(review_history.outcome).to eq(outcome), "Expected image outcome: #{outcome} did not match the retrieved image outcome: #{review_history.outcome}"
+  expect(review_history.review_level).to eq(review_level), "Expected image review level: #{review_level} did not match the retrieved image review level: #{review_history.review_level}"
+  expect(review_history.task_id.empty?).to be(false), 'Expected taskId to be present but none found'
+
+  #  check outcome reasons are not empty if they are required
+  expect(review_history.outcome_reasons.empty?).to be(false), 'Expected outcome_reasons to be present but none found' if outcome_reasons_required
+end

data/functional-tests/features/support/data/schema_helpers.rb

@@ -0,0 +1,3 @@
+def is_app_v3?(data_schema)
+  data_schema == Settings.application.v3_schema
+end

data/functional-tests/features/support/data/string_manipulation.rb

@@ -0,0 +1,9 @@
+module StringManipulation
+  def convert_to_bool?
+    self.to_s == 'true'
+  end
+end
+
+class String
+  include StringManipulation
+end

data/functional-tests/features/support/env.rb

@@ -0,0 +1,25 @@
+require 'bundler/setup'
+require 'rspec/expectations'
+
+Bundler.require
+
+require 'dvla/application_helper'
+
+# Allows creation and use of the config/settings.yml
+environment = ENV.fetch('ENVIRONMENT', 'local-dev')
+Config.load_and_set_settings(Config.setting_files('./config', environment))
+
+# Application helper gem config
+DVLA::Application.config do |config|
+  config.environment = environment
+end
+
+# Configure and initialise Logger
+configuration = DVLA::Herodotus.config do |config|
+  config.display_pid = true
+end
+
+LOG = DVLA::Herodotus.logger('Application Helper', config: configuration)
+
+# Set the Logger Level to output in terminal
+LOG.level = Logger.const_get(Settings.logs.log_level)

data/functional-tests/features/support/hooks.rb

@@ -0,0 +1,56 @@
+Before('@wip') do |_scenario|
+  ENV['wip'] = 'true'
+  skip_this_scenario
+end
+
+Before do |scenario|
+  DVLA::Application.logger.new_scenario(scenario.id)
+  # LOG.new_scenario(scenario.id)
+  DVLA::Application.logger.info "Started running scenario: #{scenario.name}"
+end
+
+# custom: delete any images which have been stored in S3 during test
+After('@delete_images') do
+  artefacts.retrieved_application.images.each do |image|
+    response = DVLA::Application::ImageService.image_service_http_post(endpoint: 'set-image-retention', body: DVLA::Application::ImageService.image_retention_body(false, image.image_id, image.image_origin_type))
+    DVLA::Application.logger.info"Image ID: #{image.image_id} retention has been set to delete"
+    DVLA::Application.logger.info "Image retention response status #{response.status}"
+  end
+end
+
+# TODO: add this one in once Diary helpers has been added into the main gems services
+# custom: delete any left over diary triggers
+# After do
+#   LOG.info "Attempting to delete any triggers for application: #{artefacts.application_id}"
+#   delete_triggers_by_app_id(app_id: artefacts.application_id)
+# end
+
+After do
+  unless ENV['wip']
+    DVLA::Application.logger.info 'State machine clean up, attempting to abort execution'.blue
+    DVLA::Application.logger.info "Attempting to abort any execution for application: #{artefacts.submitted_application.application_id}".blue
+    execution_instance = DVLA::Application::StateMachineExecution.new.generate_execution_arn(execution_uuid: artefacts.submitted_application.application_id,
+                                                                                             state_machine_name: 'application-process-engine-fulfilment',
+                                                                                             calling_service: 'application-process-engine')
+
+    response = execution_instance.stop_execution
+    DVLA::Application.logger.info response.to_s.blue
+  end
+end
+
+After do |scenario|
+  if ENV['YARP_ENABLED'] == 'true' && scenario.failed?
+    add_attachments(scenario_name: generate_scenario_name(scenario: scenario))
+  end
+end
+
+# Build scenario name with line number for unique file name in logs
+def generate_scenario_name(scenario:)
+  line_number = scenario
+                  .location
+                  .inspect
+                  .split(':')
+                  .last
+                  .tr('>', '')
+  "#{scenario.name.slice(0..23)}-#{line_number}"
+end

data/functional-tests/features/support/yarp_integration/yarp_helpers.rb

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+def add_attachments(scenario_name:)
+  LOG.info { "Taking attachment of '#{scenario_name}'" }
+
+  report_generated_time = Time.now.strftime('%Y-%m-%d_%H-%M-%S')
+  attachments_directory = "./failure-reports/#{scenario_name}"
+
+  # FileUtils.mkdir_p("#{attachments_directory}/screenshots")
+  FileUtils.mkdir_p("#{attachments_directory}/test-data")
+
+  # screenshot_path = "#{attachments_directory}/screenshots/#{report_generated_time}.png"
+  test_data_path = "#{attachments_directory}/test-data/#{report_generated_time}.json"
+
+  File.open(test_data_path, 'w') { |f| f.write(JSON.pretty_generate(artefacts.as_json)) }
+
+  # Capybara.save_screenshot(screenshot_path, full: true)
+
+  if Settings.yarp.enabled.to_s.eql?('true')
+    # attach(screenshot_path, 'image/png', 'Test Image')
+    attach(test_data_path, 'application/json', 'Test Data')
+  end
+end