dvla-application_helper 5.1.5

data/functional-tests/features/codl.feature

@@ -0,0 +1,170 @@
+Feature: CODL
+  As a Test engineer
+  I want to ensure that CODL test applications can be built using a variety of flags
+  So that they can be used to functionally test each of our components
+
+  Scenario: AC-01a Create a NON processable app and ensure it exists in the domain
+    When I create a "non-processable" "CODL" application
+    Then the application exists within the database
+
+  Scenario: AC-01b Create processable app and ensure state machine is on preparation hook and in a running state
+    When I create a "processable" "CODL" application
+    Then the application exists within the database
+    And I allow the state machine time to be started
+    And the application process engine fulfilment execution has a status of "RUNNING"
+    And the state machine is waiting on the PreparationHook
+
+  Scenario: AC-02a Create NON processable app with passport images flag and ensure it exists in domain
+    When I create a "non-processable" "CODL" application with "with_passport_images" flag
+    Then the application exists within the database
+    And the application has Passport images
+
+  Scenario: AC-02b Create processable app with passport images flag and ensure state machine is on preparation hook and in a running state
+    When  I create a "processable" "CODL" application with "with_passport_images" flag
+    Then the application exists within the database
+    And the application has Passport images
+    And I allow the state machine time to be started
+    And the application process engine fulfilment execution has a status of "SUCCEEDED"
+
+  @delete_images
+  Scenario: AC-03a Create NON processable app with unique images flag and add ensure it exists in domain
+    When I create a "non-processable" "CODL" application with "unique_images" flag
+    Then the application exists within the database
+    And the application has unique_image_ids for photos and signatures
+
+  @delete_images
+  Scenario: AC-03b Create processable app with unique images flag and ensure state machine is on preparation hook and in a running state
+    When I create a "processable" "CODL" application with "unique_images" flag
+    Then the application exists within the database
+    And the application has unique_image_ids for photos and signatures
+    And I allow the state machine time to be started
+    And the state machine is waiting on the PreparationHook
+
+  Scenario: AC-03c NON processable app which contains the static_image ids
+    When I create a "non-processable" "CODL" application
+    Then the application exists within the database
+    And the application has static_image_ids for photos and signatures
+
+  Scenario: AC-03d Create processable app with static_image ids, ensure retrieved application contains them and ensure state machine is on preparation hook and in a running state
+    When I create a "processable" "CODL" application
+    Then the application exists within the database
+    And the application has static_image_ids for photos and signatures
+    And I allow the state machine time to be started
+    And the application process engine fulfilment execution has a status of "RUNNING"
+    And the state machine is waiting on the PreparationHook
+
+  Scenario: AC-04a Create NON processable app with a home office comparison photo
+    When I create a "non-processable" "CODL" application with "with_home_office_comparison_photo" flag
+    Then the application exists within the database
+    And the application has a Home Office image
+
+  Scenario: AC-04b Create processable app with a home office comparison photo, ensure retrieved application contains them and ensure state machine is on preparation hook and in a running state
+    When I create a "processable" "CODL" application with "with_home_office_comparison_photo" flag
+    Then the application exists within the database
+    And the application has a Home Office image
+    And I allow the state machine time to be started
+    And the application process engine fulfilment execution has a status of "RUNNING"
+    And the state machine is waiting on the PreparationHook
+
+  Scenario: AC-10a Create NON processable app with 'has_phone_number' and add it into domain
+    When I create a "non-processable" "CODL" application with "has_phone_number" flag
+    Then the application exists within the database
+    And the application contains a phone number
+
+  Scenario: AC-10b Create processable app with user 'has_phone_number' and ensure state machine is on preparation hook and in a running state
+    When I create a "processable" "CODL" application with "has_phone_number" flag
+    Then the application exists within the database
+    And the application contains a phone number
+    And I allow the state machine time to be started
+    And the application process engine fulfilment execution has a status of "RUNNING"
+    And the state machine is waiting on the PreparationHook
+
+  Scenario: AC-11 Create NON processable app with 'with_customer_id' and add it into domain
+    When I create a "non-processable" "CODL" application with "with_customer_id" flag
+    Then the application exists within the database
+    And the application contains the seeded customer id
+
+# AC-11b Cannot create a processable CODL app with a custom customer_id in the dev environment, as the customer_id is used by the channel-api-stub
+
+  Scenario Outline: AC-12a Create NON processable app with 'is_organ_donor' and add it into domain
+    Given organ_donation is set to <organ_donation>
+    When I create a "non-processable" "CODL" application with "is_organ_donor" flag
+    Then the application exists within the database
+    And the application any_organs field is <organ_donation>
+    Examples:
+      | organ_donation |
+      | true           |
+      | false          |
+
+  Scenario Outline: AC-12b Create processable app with user 'is_organ_donor' and ensure state machine is on preparation hook and in a running state
+    Given organ_donation is set to <organ_donation>
+    When I create a "processable" "CODL" application with "is_organ_donor" flag
+    Then the application exists within the database
+    And the application any_organs field is <organ_donation>
+    And I allow the state machine time to be started
+    And the application process engine fulfilment execution has a status of "RUNNING"
+    And the state machine is waiting on the PreparationHook
+    Examples:
+      | organ_donation |
+      | true           |
+      | false          |
+
+  Scenario: AC-13a Create NON processable app with 'with_payments' and add it into domain
+    When I create a "non-processable" "CODL" application with "with_payments" flag
+    Then the application exists within the database
+    And the application contains the seeded payment
+
+  Scenario: AC-13b Create processable app and ensure a payment is present and state machine is on preparation hook and in a running state
+    When I create a "processable" "CODL" application
+    Then the application exists within the database
+    And the application contains a payment object
+    And I allow the state machine time to be started
+    And the application process engine fulfilment execution has a status of "RUNNING"
+    And the state machine is waiting on the PreparationHook
+
+  Scenario: AC-14a Create NON processable app with 'with_applicant' and add it into domain
+    When I create a "non-processable" "CODL" application with "with_applicant" flag
+    Then the application exists within the database
+    And the application contains the seeded applicant
+
+  Scenario: AC-14b Create processable app with user 'with_applicant' and ensure state machine is on preparation hook and in a running state
+    When I create a "processable" "CODL" application with "with_applicant" flag
+    Then the application exists within the database
+    And the application contains the seeded applicant
+    And I allow the state machine time to be started
+    And the application process engine fulfilment execution has a status of "RUNNING"
+    And the state machine is waiting on the PreparationHook
+
+  Scenario Outline: AC-17a Create NON processable app with 'with_application_status' and add it into domain
+    Given I want the application to have the specific status of "<app status>"
+    When I create a "non-processable" "CODL" application with "with_application_status" flag
+    Then the application exists within the database
+    And the application status matches "<app status>"
+    Examples:
+      | app status                   |
+      | Started                      |
+      | Received                     |
+      | Payment settlement requested |
+      | Preparing                    |
+      | Submitted                    |
+      | Approved                     |
+      | Returned                     |
+      | Unapproved                   |
+      | Rejected                     |
+      | Cancelled                    |
+      | Deleted                      |
+
+# This is a sense check, processable apps cannot have a different status passed in, it will always be Started!, need to update the helper code to handle the flags better
+  Scenario: AC-17b Create processable app with user 'with_application_status' and ensure state machine is on preparation hook and in a running state
+    Given I want the application to have a random status which is not Started
+    When I create a "processable" "CODL" application with "with_application_status" flag
+    Then the application exists within the database
+    And the application status matches "Started"
+    And I allow the state machine time to be started
+    And the application process engine fulfilment execution has a status of "RUNNING"
+    And the state machine is waiting on the PreparationHook
+
+  Scenario: AC-18a Create NON processable app with 'extend_application_deadline' and add it into domain
+    When I create a "non-processable" "CODL" application with "extend_application_deadline" flag
+    Then the application exists within the database
+    And the application contains the call to action field

data/functional-tests/features/codl_image_review_states.feature

@@ -0,0 +1,140 @@
+Feature: CODL Image Review States
+  As a Test engineer
+  I want to ensure that CODL image review states update correctly
+  So that they can be used to functionally test each of our components
+# These tests have been seperated from main UODL feature to help speed up the pipeline
+
+  Scenario Outline: AC-16a Create NON processable app with 'with_photo_review_state' and add it into domain and ensure images review update correctly
+    Given I want a specific Photo review state of "<review state>" to be set
+    When I create a "non-processable" "CODL" application with "with_photo_review_state" flag
+    Then the application exists within the database
+    And the application contains the seeded Photo review state of "<review state>"
+
+    Examples:
+      | review state                          |
+      | CLERK_IN_PROGRESS                     |
+      | CLERK_REJECTED                        |
+      | CLERK_REFER_TO_SUPERVISOR_STANDARDS   |
+      | CLERK_REFER_TO_SUPERVISOR_COMPARE     |
+      | CLERK_APPROVED                        |
+      | SUPERVISOR_REJECTED                   |
+      | SUPERVISOR_REFER_TO_FRAUD             |
+      | SUPERVISOR_APPROVED                   |
+      | FRAUD_BEGIN_INVESTIGATION             |
+      | FRAUD_APPROVED                        |
+      | FRAUD_REJECTED                        |
+      | FRAUD_REVIEW_REJECTION_WITH_REFUND    |
+      | FRAUD_REVIEW_REJECTION_WITHOUT_REFUND |
+      | FRAUD_REVIEW_APPROVED                 |
+
+  Scenario Outline: AC-16b Create processable app with 'with_photo_review_state' and add it into domain and ensure images review update correctly for rejected states
+    Given I want a specific Photo review state of "<review state>" to be set
+    And I want a specific Signature review state of "CLERK_APPROVED" to be set
+    And I create a "processable" "CODL" application with "with_photo_review_state,with_signature_review_state" flag
+    And I allow the application actions time to be updated
+    When the application exists within the database
+    Then the application contains the seeded Photo review state of "<review state>"
+    And I allow the state machine time to be started
+    And the application process engine fulfilment execution has a status of "RUNNING"
+    And the state machine is waiting on the PreparationHook
+
+    Examples:
+      | review state                        |
+      | CLERK_IN_PROGRESS                   |
+      | CLERK_REJECTED                      |
+      | CLERK_REFER_TO_SUPERVISOR_STANDARDS |
+      | CLERK_REFER_TO_SUPERVISOR_COMPARE   |
+      | SUPERVISOR_REJECTED                 |
+      | SUPERVISOR_REFER_TO_FRAUD           |
+      | FRAUD_BEGIN_INVESTIGATION           |
+      | FRAUD_REJECTED                      |
+
+  Scenario Outline: AC-16c Create processable app with 'with_photo_review_state' and add it into domain and ensure images review update correctly and app succeeds
+    Given I want a specific Photo review state of "<review state>" to be set
+    And I want a specific Signature review state of "CLERK_APPROVED" to be set
+    And I create a "processable" "CODL" application with "with_photo_review_state,with_signature_review_state" flag
+    And I allow the application actions time to be updated
+    When the application exists within the database
+    Then the application contains the seeded Photo review state of "<review state>"
+    And I allow the state machine time to be started
+    And the application process engine fulfilment execution has a status of "SUCCEEDED"
+
+    Examples:
+      | review state                          |
+      | CLERK_APPROVED                        |
+      | SUPERVISOR_APPROVED                   |
+      | FRAUD_APPROVED                        |
+      | FRAUD_REVIEW_APPROVED                 |
+      | FRAUD_REVIEW_REJECTION_WITH_REFUND    |
+      | FRAUD_REVIEW_REJECTION_WITHOUT_REFUND |
+
+  Scenario Outline: AC-16d Create NON processable app with 'with_signature_review_state' and add it into domain and ensure images review update correctly
+    Given I want a specific Signature review state of "<review state>" to be set
+    When I create a "non-processable" "CODL" application with "with_signature_review_state" flag
+    Then the application exists within the database
+    And the application contains the seeded Signature review state of "<review state>"
+
+    Examples:
+      | review state      |
+      | CLERK_IN_PROGRESS |
+      | CLERK_REJECTED    |
+      | CLERK_APPROVED    |
+
+  Scenario: AC-16e Create processable app with 'with_signature_review_state' and add it into domain and ensure images review update correctly for rejected states
+    Given I want a specific Signature review state of "CLERK_IN_PROGRESS" to be set
+    And I want a specific Photo review state of "CLERK_APPROVED" to be set
+    And I create a "processable" "CODL" application with "with_signature_review_state,with_photo_review_state" flag
+    And I allow the application actions time to be updated
+    When the application exists within the database
+    Then the application contains the seeded Signature review state of "CLERK_IN_PROGRESS"
+    And I allow the state machine time to be started
+    And the application process engine fulfilment execution has a status of "RUNNING"
+    And the state machine is waiting on the PreparationHook
+
+  Scenario: AC-16f Create processable app with 'with_signature_review_state' and add it into domain and ensure images review update correctly and app succeeds
+    Given I want a specific Signature review state of "CLERK_APPROVED" to be set
+    And I want a specific Photo review state of "CLERK_APPROVED" to be set
+    And I create a "processable" "CODL" application with "with_signature_review_state,with_photo_review_state" flag
+    And I allow the application actions time to be updated
+    When the application exists within the database
+    Then the application contains the seeded Signature review state of "CLERK_APPROVED"
+    And I allow the state machine time to be started
+    And the application process engine fulfilment execution has a status of "SUCCEEDED"
+
+  Scenario: AC-16g Create processable app with 'with_signature_review_state' and add it into domain and ensure images review update correctly for rejected states
+    Given I want a specific Signature review state of "CLERK_REJECTED" to be set
+    And I want a specific Photo review state of "CLERK_APPROVED" to be set
+    And I create a "processable" "CODL" application with "with_signature_review_state,with_photo_review_state" flag
+    And I allow the application actions time to be updated
+    When the application exists within the database
+    Then the application contains the seeded Signature review state of "CLERK_REJECTED"
+    And I allow the state machine time to be started
+    And the application process engine fulfilment execution has a status of "RUNNING"
+    And the state machine is waiting on the PreparationHook
+
+  Scenario Outline: AC-16h Create processable app with 'with_photo_review_state' and add it into domain and ensure images review update correctly and app succeeds
+    Given I want a specific Photo review state of "<review state>" to be set
+    And I create a "processable" "CODL" application with "with_home_office_comparison_photo,with_photo_review_state" flag
+    And I allow the application actions time to be updated
+    When the application exists within the database
+    Then the application contains the seeded Comparison review state of "<review state>"
+    And I allow the state machine time to be started
+    And the application process engine fulfilment execution has a status of "SUCCEEDED"
+
+    Examples:
+      | review state                       |
+      | CLERK_REJECT_COMPARISON_PHOTO      |
+      | FRAUD_REJECT_COMPARISON_PHOTO      |
+      | SUPERVISOR_REJECT_COMPARISON_PHOTO |
+
+  Scenario Outline: AC-16i Create NON processable app with 'with_photo_review_state' and add it into domain and ensure images review update correctly
+    Given I want a specific Photo review state of "<review state>" to be set
+    When I create a "non-processable" "CODL" application with "with_home_office_comparison_photo,with_photo_review_state" flag
+    Then the application exists within the database
+    And the application contains the seeded Comparison review state of "<review state>"
+
+    Examples:
+      | review state                       |
+      | CLERK_REJECT_COMPARISON_PHOTO      |
+      | FRAUD_REJECT_COMPARISON_PHOTO      |
+      | SUPERVISOR_REJECT_COMPARISON_PHOTO |

data/functional-tests/features/csudl.feature

@@ -0,0 +1,54 @@
+Feature: CSUDL
+
+  As a Test engineer
+  I want to ensure that CSUDL test applications can be built using a variety of flags
+  So that they can be used to functionally test each of our components
+
+  Scenario: AC-01a Create NON processable CSUDL app with no flags, add it into domain
+    When I create a "non-processable" "CSUDL" application
+    Then the application exists within the database
+    And the CSUDL application contains the correct images
+
+  Scenario: AC-01b Create NON processable CSUDL app with passport photo flag and ensure it exists in domain
+    When  I create a "non-processable" "CSUDL" application with "with_passport_images" flag
+    Then the application exists within the database
+    And the application has Passport images
+
+  Scenario Outline: AC-02a Create NON processable app with each application status, add it into domain
+    Given I want the application to have the specific status of "<app status>"
+    When I create a "non-processable" "CSUDL" application with "with_application_status" flag
+    Then the application exists within the database
+    And the application status matches "<app status>"
+    Examples:
+      | app status                   |
+      | Started                      |
+      | Received                     |
+      | Payment settlement requested |
+      | Preparing                    |
+      | Submitted                    |
+      | Approved                     |
+      | Returned                     |
+      | Unapproved                   |
+      | Cancelled                    |
+      | Rejected                     |
+      | Deleted                      |
+
+  Scenario: AC-02b Create NON processable CSUDL app with licence possession reason, add it into domain
+    When I create a "non-processable" "CSUDL" application with "with_unable_to_prove_licence_possession_reason" flag
+    Then the application exists within the database
+    And the application contains an unable to prove licence possession reason of "LOST_OR_STOLEN"
+
+  Scenario: AC-02c Create NON processable CSUDL app with photo compliance, add it into domain
+    When I create a "non-processable" "CSUDL" application with "with_photo_compliance_checks" flag
+    Then the application exists within the database
+    And the application contains photo compliance checks
+
+  Scenario: AC-02d Create NON processable CSUDL app with licence data, add it into domain
+    When I create a "non-processable" "CSUDL" application with "with_licence_data" flag
+    Then the application exists within the database
+    And the application contains licence data
+
+  Scenario: AC-02e Create NON processable CSUDL app with updateAddress, add it into domain
+    When I create a "non-processable" "CSUDL" application with "with_update_address" flag
+    Then the application exists within the database
+    And the application contains the address to be updated

data/functional-tests/features/csudl_image_review_states.feature

@@ -0,0 +1,20 @@
+Feature: CSUDL Image Review States
+
+  As a Test engineer
+  I want to ensure that CSUDL image review states update correctly
+  So that they can be used to functionally test each of our components
+
+# These tests have been seperated from main CSUDL feature to help speed up the pipeline
+
+  Scenario Outline: AC-02 Create NON processable app with 'with_review_state' and add it into domain and ensure images review update correctly
+    Given I want a specific Photo review state of "<review state>" to be set
+    When I create a "non-processable" "CSUDL" application with "with_photo_review_state" flag
+    Then the application exists within the database
+    And the CSUDL application contains the seeded Photo review state of "<review state>"
+    Examples:
+      | review state                          |
+      | CLERK_IN_PROGRESS                     |
+      | CLERK_REJECTED                        |
+      | CLERK_REFER_TO_SUPERVISOR_STANDARDS   |
+      | CLERK_REFER_TO_SUPERVISOR_COMPARE     |
+      | CLERK_APPROVED                        |

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

@@ -0,0 +1,213 @@
+Then(/^the application exists within the database$/) do
+  artefacts.retrieved_application = DVLA::Application::ApplicationDomain.retrieve_application_by_app_id(application_id: artefacts.submitted_application.application_id)
+
+  # iterate through the retrieved application object and check them against the submitted application
+  artefacts.retrieved_application.instance_variable_names.each do |field|
+    LOG.info "checking if fields match for: #{field}"
+
+    # added conditional here to ignore images array when a review state is passed in, images review history checked in another step and will differ from original seeded images
+    if artefacts.review_state.nil? && artefacts.signature_review_state.nil? && field != '@images'
+      expect(artefacts.retrieved_application.instance_variable_get(field)).to eq(artefacts.submitted_application.instance_variable_get(field)), "Error, #{field} does not match between submitted and retrieved application"
+    end
+  end
+end
+
+Given(/^organ_donation is set to (true|false)$/) do |organ_donor|
+  #  sets organ_donor boolean
+  artefacts.organ_donor = organ_donor == 'true'
+end
+
+And(/^the application has welsh language preference$/) do
+  LOG.info 'checking if language preference field matches'
+  expect(artefacts.retrieved_application.data.applicant.language_preference).to eq('Welsh'), 'Expected applicant language preference to be welsh'
+end
+
+And(/^the application contains a (BFPO|Free Key) address$/) do |address_type|
+  expected_class = if address_type == 'BFPO'
+                     DVLAApplicationDomainServiceOpenAPIClient::BFPOAddress
+                   else
+                     DVLAApplicationDomainServiceOpenAPIClient::UnstructuredAddress
+                   end
+
+  # logic to handle location of updated address field depending on schema used
+  retrieved_address_class = if is_app_v3?(artefacts.retrieved_application.data_schema)
+                              artefacts.retrieved_application.data.update_address.new_address.class
+                            else
+                              artefacts.retrieved_application.data.driving_licence_actions.update_address.new_address.class
+                            end
+  expect(retrieved_address_class).to eq(expected_class), "Expected #{address_type} to match the OpenApiClient class"
+end
+
+And(/^the application contains the driver_id in the product_id$/) do
+  expect(artefacts.retrieved_application.product_id).to eq(artefacts.driver_id), 'Expected driver_id to be stored within the application.product_id'
+end
+
+And(/^the application no fee flag is set to (true|false)$/) do |no_fee_flag|
+  expect(artefacts.retrieved_application.no_fee_application).to eq(no_fee_flag.convert_to_bool?), "Expected no_fee flag to be set to: #{no_fee_flag}"
+end
+
+And(/^the application contains a phone number$/) do
+  expect(artefacts.retrieved_application.data.applicant.phone_number).to_not be_nil, 'Expected Phone number to be present, but field is empty'
+end
+
+And(/^the application contains the seeded customer id$/) do
+  expect(artefacts.retrieved_application.customer_id).to eq(artefacts.customer_id), 'Expected customer_id to match the seeded customer_id'
+end
+
+And(/^the application any_organs field is (true|false)$/) do |any_organ|
+  if any_organ.convert_to_bool?
+    expect(artefacts.retrieved_application.data.organ_donor.any_organs).to be(any_organ.convert_to_bool?), "Expected any_organs field to be: #{any_organ}"
+  else
+    expect(artefacts.retrieved_application.data.organ_donor.to_json).to eq('{}'), 'Expected organ_donor to be an empty object'
+  end
+end
+
+And(/^the application contains the seeded payment$/) do
+  expect(artefacts.retrieved_application.payments[0].payment_amount).to eq(artefacts.payment[0][:paymentAmount]), 'Expected application to contain seeded payment amount'
+  expect(artefacts.retrieved_application.payments[0].payment_id).to eq(artefacts.payment[0][:paymentId]), 'Expected application to contain seeded paymentId'
+  expect(artefacts.retrieved_application.payments[0].payment_status).to eq(artefacts.payment[0][:paymentStatus]), 'Expected application to contain seeded payment status'
+  expect(artefacts.retrieved_application.payments[0].payment_reference).to eq(artefacts.payment[0][:paymentReference]), 'Expected application to contain seeded payment reference'
+end
+
+And(/^the application contains a payment object$/) do
+  expect(artefacts.retrieved_application.payments[0].class).to eq(DVLAApplicationDomainServiceOpenAPIClient::Payment), 'Expected payment object to be of the correct type'
+end
+
+And(/^the application contains the seeded applicant$/) do
+  # iterate through the submitted applicant fields to check the retrieved ones match
+  artefacts.submitted_application.data.applicant.instance_variable_names.each do |field|
+    LOG.info "checking if applicant fields match for: #{field}"
+    retrieved_field = artefacts.retrieved_application.data.applicant.instance_variable_get(field)
+    submitted_field = artefacts.submitted_application.data.applicant.instance_variable_get(field)
+    expect(retrieved_field).to eq(submitted_field), "Error, #{field} does not match between submitted and retrieved applicant"
+  end
+end
+
+And(/^the application contains the driving licence action updateAddress$/) do
+  # added logic to handle difference in schema structure between V3 and V1/V2
+  if is_app_v3?(artefacts.retrieved_application.data_schema)
+    expect(artefacts.retrieved_application.data.instance_variables.include?(:@update_address)).to be(true), 'Error, update address field not present in driving licence actions'
+  else
+    expect(artefacts.retrieved_application.data.driving_licence_actions.instance_variable_names.include?('@update_address')).to be(true), 'Error, update address field not present in driving licence actions'
+  end
+end
+
+Given(/^I want the application to have a random status which is not Started$/) do
+  artefacts.application_status = ['Received', 'Payment settlement requested', 'Preparing', 'Submitted', 'Approved', 'Returned', 'Unapproved', 'Rejected', 'Completed', 'Deleted', 'Cancelled'].sample
+  LOG.info "Setting Application Status to: #{artefacts.application_status}"
+end
+
+Given(/^I want the application to have the specific status of "([^"]*)"$/) do |status|
+  LOG.info "Setting Application Status to: #{status}"
+  artefacts.application_status = status
+end
+
+And(/^the application status matches "([^"]*)"$/) do |status|
+  retrieved_status = artefacts.retrieved_application.application_state.status
+  expect(retrieved_status).to eq(status), "Expected retrieved app status: #{retrieved_status} to match the seeded status of: #{status}"
+end
+
+And(/^the application contains the customer context for "([^"]*)"$/) do |context|
+  expect(artefacts.retrieved_application.data.customer_context.customer_intent).to eq(context), 'Error, update address field not present in customer context'
+  expect(artefacts.retrieved_application.data.customer_context.transaction_outcome).to eq(context), 'Error, update address field not present in customer context'
+end
+
+And(/^the application contains the call to action field$/) do
+  expect(artefacts.retrieved_application.instance_variable_names.include?('@call_to_action_deadline_date')).to be(true), 'Error, Call to action field not present in the retrieved application'
+  expect(artefacts.retrieved_application.call_to_action_deadline_date).not_to be_nil, 'Error, Call to action field not present in the retrieved application'
+end
+
+And(/^the application has the correct driving licence action$/) do
+  expect(artefacts.retrieved_application.data.driving_licence_actions).to include(artefacts.driving_licence_action), "Error, specified driving licence actions not found
+                                                                                                                                          \nExpected: #{artefacts.driving_licence_action.to_json}
+                                                                                                                                          \nRetrieved: #{artefacts.retrieved_application.data.driving_licence_actions.to_json}"
+end
+
+And(/^the application contains the product type$/) do
+  expected_product_type = artefacts.product_type
+  retrieved_product_type = artefacts.retrieved_application.product_type
+  expect(retrieved_product_type).to eq(expected_product_type), "Expected product type: #{expected_product_type}\n Retrieved product type: #{retrieved_product_type}"
+end
+
+And(/^the application has the "inform-paper-to-plastic" eligibility$/) do
+  expect(artefacts.retrieved_application.data.customer_context.applications_eligibility_response.length).to be >= 1, 'Expected an applications_eligibility_response but found none'
+  expect(artefacts.retrieved_application.data.customer_context.applications_eligibility_response[0].application_type).to eq('update-ordinary-licence'), 'Expected the applications_eligibility_response to be for UODL'
+  paper_to_plastic_action = artefacts.retrieved_application.data.customer_context.applications_eligibility_response[0].available_actions.find { |item| item.action_type == 'inform-paper-to-plastic' }
+  expect(paper_to_plastic_action).not_to be_nil, 'Expected inform-paper-to-plastic eligibility to be present in the applications_eligibility_response'
+end
+
+And(/^the application has a reference number starting with "([^"]*)"$/) do |prefix|
+  expect(artefacts.retrieved_application.application_reference_number).to start_with(prefix)
+end
+
+And(/^the application contains the driver_id in the product_id for (.*)$/) do |application_type|
+  expected_driver_id = case application_type
+                       when 'paper-dup'
+                         Settings.test.driver_id.paper_duplicate
+                       when 'paper-rep'
+                         Settings.test.driver_id.paper_replacement
+                       else
+                         raise 'Specified application type does not have a driver id in config'
+                       end
+  expect(artefacts.retrieved_application.product_id).to eq(expected_driver_id), 'Expected driver_id to be stored within the application.product_id'
+end
+
+And(/^the CSUDL application contains the correct images$/) do
+  user_image = artefacts.retrieved_application.images.find { |image| image.image_type == 'Photo' && image.image_purpose == 'Application' && image.image_origin_type == 'Counter Service' && image.image_source == 'image-utility' }
+  comparison_image = artefacts.retrieved_application.images.find { |image| image.image_type == 'Photo' && image.image_purpose == 'Comparison' && image.image_origin_type == 'Driving Licence' && image.image_source == 'image-utility' }
+  signature_image = artefacts.retrieved_application.images.find { |image| image.image_type == 'Signature' && image.image_purpose == 'Application' && image.image_origin_type == 'Counter Service' && image.image_source == 'image-utility' }
+  front_image = artefacts.retrieved_application.images.find { |image| image.image_type == 'Photocard front' && image.image_purpose == 'Application' && image.image_origin_type == 'Counter Service' && image.image_source == 'image-utility' }
+  back_image = artefacts.retrieved_application.images.find { |image| image.image_type == 'Photocard back' && image.image_purpose == 'Application' && image.image_origin_type == 'Counter Service' && image.image_source == 'image-utility' }
+
+  expect(user_image).not_to be_nil, 'Expected to find a counter service application image in the application images'
+  expect(comparison_image).not_to be_nil, 'Expected to find a comparison image in the application images'
+  expect(signature_image).not_to be_nil, 'Expected to find a counter service signature image in the application images'
+  expect(front_image).not_to be_nil, 'Expected to find a front photocard image in the application images'
+  expect(back_image).not_to be_nil, 'Expected to find a back photocard image in the application images'
+end
+
+And(/^the application contains an unable to prove licence possession reason of "([^"]*)"$/) do |reason|
+  expect(artefacts.retrieved_application.data.unable_to_prove_licence_possession_reason).to eq(reason), 'Error, licence possession field not present in application'
+end
+
+And(/^the application contains photo compliance checks$/) do
+  expected_compliance = {
+    photoOverride: false,
+    icaoCompliant: true,
+    eyesOpen: true,
+    exposure: true,
+    frontalView: true,
+    greyscaleDensity: true,
+    uniformLighting: true,
+    headWidth: true,
+    headLength: true,
+    widthHeightRatio: true,
+    resolution: true,
+    verticalPosition: true,
+    horizontallyCentered: true,
+  }
+
+  expect(artefacts.retrieved_application.data.photo_compliance_checks.as_json).to eq(expected_compliance.as_json), 'Error, photo compliance checks not present in application'
+end
+
+And(/^the application contains licence data$/) do
+  expected_licence_data = {
+    photoCardIssueNumber: '2',
+  }
+
+  expect(artefacts.retrieved_application.data.licence_data.as_json).to eq(expected_licence_data.as_json), 'Error, licence data not present in application'
+end
+
+And(/^the application contains the address to be updated$/) do
+  expected_update_address = {
+    newAddress: {
+      unstructuredAddress: {
+        line1: 'TEST 5357 Gilberto Forge',
+        line5: 'New Lewisfort',
+        postcode: 'SA3 1AD',
+      },
+    },
+  }
+
+  expect(artefacts.retrieved_application.data.update_address.as_json).to eq(expected_update_address.as_json), 'Error, licence possession field not present in application'
+end