dvla-application_helper 5.1.5

data/README.md

@@ -0,0 +1,674 @@
+# DVLA::Application::Helper
+
+This gem allows you to submit test data and create new applications in the application-domain.  It uploads images to the driving licence channel api and image service (where necessary) to ensure that applications have the required data.  This should be used to aid automated testing for DVLA projects.
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+```ruby
+gem 'dvla-application_helper', '~> 3.9'
+```
+
+And then execute:
+
+    $ bundle install
+
+Or install it yourself as:
+
+    $ gem install dvla-application_helper
+
+## Usage
+
+This Gem allows you to create applications within application domain. The goal is for these applications to be used within QE testing, but these can also be used during local development and debugging to quickly create an application in the required format.
+
+### Required environment variables
+
+- You will need AWS access to the account which you are running this gem within, these can obtained either via an aws-login.sh script from another repository, or via the aws management console.
+- Access is required to an instance of each, the driving-licence-channel-api, application-domain, image-service, and image-utility
+
+### Configuration
+
+You will need to add some configuration to your `settings.yml` files to point at the various services. Some of the common configurations are provided in the `config/settings/` directory:
+
+- Dev environment from a local machine (`local-dev.yml`)
+- Dev environment from drone (`drone-dev.yml`)
+- Link environment from a local machine (`local-link.yml`)
+- Link environment from drone (`drone-link.yml`)
+- Ext environment from a local machine (`local-ext.yml`)
+- Ext environment from drone (`drone-ext.yml`)
+- Perf environment from a local machine (`local-perf.yml`)
+- Perf environment from drone (`drone-perf.yml`)
+
+### Example of the required config for local-dev:
+```
+services:
+  driving_licence_channel_api:
+    stage_name: dev
+    host: v5xx72m7z5-vpce-0c9077c8fe760fea6.execute-api.eu-west-2.amazonaws.com
+  application_domain:
+    stage_name: dev
+    host: pc4j6sohv8-vpce-0c9077c8fe760fea6.execute-api.eu-west-2.amazonaws.com
+  image_service:
+    base_url: https://flvh6n0yx6-vpce-0c9077c8fe760fea6.execute-api.eu-west-2.amazonaws.com/link/
+  image_utility:
+    base_url: https://r8t8c9sl7g-vpce-0c9077c8fe760fea6.execute-api.eu-west-2.amazonaws.com/link/
+```
+
+### Settings config in functional tests
+In your env.rb, you will need to add this in order to allow the gem to prepend your config settings into its own:
+
+```ruby
+DVLA::Application.config do |config|
+  config.environment = environment
+end
+```
+
+### Logger
+
+By default the gem will use `DVLA::Herotodus` as a logger with a system name of `application-helper`.
+You can override this with your own logger in the configuration e.g.
+
+```ruby
+DVLA::Application.config do |config|
+  config.logger = Logger.new($stdout)
+end
+```
+
+### Email addresses
+This gem currently uses the Poirot gem that generates an email address with the `@mailsac.com` domain.  This is slowly being phased out in favour of `@dvla.msdc.co`.
+The standard for email addresses now also requires that you prefix your email address with the project name. As you can't control that directly in the builder via Poirot, you can achieve it with env vars.
+
+NOTE:  Do not include the @ in your domain!
+
+In your .env, you can add the following to format the email address correctly:
+
+```ruby
+EMAIL_PREFIX='my-project-name-'
+EMAIL_DOMAIN='emaildomain.com'
+```
+
+These values will also need to be added to your CI/CD pipeline.
+
+Alternatively, you can add these two settings to your own settings.yml to overwrite the values:
+
+```yaml
+application_helper:
+  applicant_email:
+    email_prefix: test-app-
+    email_domain: test-domain
+```
+
+## Deployed Stages
+By default the app helper always points towards dev / link stage.
+This however can be overrided and you can point towards a specific stage if you wish. You will need pass a few variable to your env to overide the default ones.
+
+APE:
+
+APPLICATION_PROCESS_ENGINE_STAGE_NAME
+
+APPLICATION_PROCESS_ENGINE_API_ID
+
+APPLICATION_PROCESS_ENGINE_VPCE_ID
+
+Domain:
+
+APPLICATION_DOMAIN_STAGE_NAME
+
+APPLICATION_DOMAIN_API_ID
+
+APPLICATION_DOMAIN_VPCE_ID
+
+Channel Api:
+
+CHANNEL_API_STAGE_NAME
+
+CHANNEL_API_API_ID
+
+CHANNEL_API_VPCE_ID
+
+
+## Functional Test Set up
+
+### Setup:
+
+#### .env
+In root directory, make a copy of the .env.template file, rename it to .env
+
+If using rubymine, edit the cucumber run configuration and add in the .env file
+
+#### AWS Login
+From root directory, run the following command to log the terminal into AWS, this will also update your credentials into your .env file
+
+```bash
+. scripts/application-login.sh
+```
+
+#### Bundle Gems
+Run the following command from within the root directory
+```bash
+bundle install
+```
+
+#### Running the functional tests
+Tests can be run either through the IDE UI (eg rubymine)
+
+or, 
+
+tests can be run through the terminal and use the following command:
+````
+bundle exec cucumber
+````
+
+If you want to run a single test, easiest way is to add a tag above the scenario name eg: @Test
+
+Then run the following command to run that single test (NOTE, if you tag multiple tests with the same tag, they will all be run)
+```
+bundle exec cucumber -t@Test
+```
+## Running Functional tests locally in parallel
+You can utilise the rake command to run the tests locally, this will speed them up substantially, however, if you use too many threads it can and will cause issues.
+I have found using up to 16 threads is relatively stable and gives quick feedback
+It is also possible to specify the exact feature file you wish to run. Output can take a while to appear if running the whole pack
+#### You must run this command while in the functional test directory
+e.g.
+```
+bundle exec rake test:functional\["features/","12"\] 
+```
+```
+bundle exec rake test:functional\["features/uodl.feature","12"\] 
+```
+
+
+## Creating a new application
+
+#### Using the application builder
+
+This gem has been built following the builder pattern to make creating applications easier. To build an application you will need to use the application_builder class. 
+
+To create a new Application Builder you would execute one of the following, depending on the required schema and application type:
+
+```
+V1 schema:
+DVLA::Application::CODLApplicationBuilder.new
+DVLA::Application::ApplicationBuilder.new - Marked as Deprecated in 4.7.3
+DVLA::Application::CSUDLApplicationBuilder.new
+
+V2 Schema:
+DVLA::Application::UODLV2ApplicationBuilder.new - Marked as Deprecated in 4.7.3
+DVLA::Application::TYRV2ApplicationBuilder.new
+DVLA::Application::COPV2ApplicationBuilder.new
+DVLA::Application::EXCV2ApplicationBuilder.new
+DVLA::Application::REPV2ApplicationBuilder.new
+DVLA::Application::DUPV2ApplicationBuilder.new
+
+V3 Schema:
+DVLA::Application::TYRV3ApplicationBuilder.new
+DVLA::Application::COPV3ApplicationBuilder.new
+DVLA::Application::EXCV3ApplicationBuilder.new
+DVLA::Application::REPV3ApplicationBuilder.new
+DVLA::Application::DUPV3ApplicationBuilder.new
+```
+
+**NOTE**
+All the application builder classes follow the same pattern, they specify the same methods where applicable and then have specific ones for their application schema or type.
+
+You can then use the `build` method to create a new application.
+
+As of 4.7.3 the UODL V2 and ApplicationBuilder builders have been marked as deprecated in favour of the transaction specific builders. Please attempt to migrate to specific builders and if any issues occur contact Ben Bonsor or David Sambucci.
+
+*Examples*
+```
+# Will return a UODL V1 application in the default state
+builder =  DVLA::Application::ApplicationBuilder.new
+builder.build
+```
+
+#### Build Options
+
+As we follow the builder pattern, we have multiple build commands available. It is suggested that these are 'chained' together to create an application e.g. `DVLA::Application::ApplicationBuilder.new.processable.with_change_of_address.build `. You could store the builder in an intermediate state in a variable if you wish as each step will return an instance of builder so far. Only the build method will result in the application being created. 
+
+The options available can be found below:
+
+##### processable
+Marks the application as processable, doing this will ensure that real services are used to create the application. More information on this can be found in the [Processable vs non-processable applications section](#processable-vs-non-processable-applications)
+
+*Examples*
+
+```
+DVLA::Application::ApplicationBuilder.new.processable.build 
+```
+
+##### eligible_paper_to_plastic
+For a REP or DUP application you can use the `eligible_paper_to_plastic` option to mark the application as eligible for the conversion paper to plastic, this is one of the fields used to mark a driver holding a paper application and is automatically set for an EXC application.
+
+*Examples*
+
+```
+DVLA::Application::DUPApplicationBuilder.new.eligible_paper_to_plastic.build
+DVLA::Application::REPApplicationBuilder.new.eligible_paper_to_plastic.build
+```
+
+##### with_passport_image / with_passport_images
+For a UODL application you can use the `with_passport_image` option to contain a passport photo of the applicant to be submitted, disabling user photo.
+For a CODL, EXC or a Paper REP/DUP application the option is `with_passport_images` and will use a passport photo and a passport signature of the applicant, disabling the submission of user images.
+The application contains a passport image to the applicant to be submitted. Disables user photo.
+
+*Examples*
+
+```
+DVLA::Application::ApplicationBuilder.new.with_passport_image.build
+
+DVLA::Application::CODLApplicationBuilder.new.with_passport_images.build
+
+DVLA::Application::REPApplicationBuilder.new.eligible_paper_to_plastic.with_passport_images.build
+```
+
+
+##### with_user_image
+The UODL application will contain a user image. If a boolean value of true is passed in a fallback passport option will also be provided.
+
+*Examples*
+
+```
+DVLA::Application::ApplicationBuilder.new.with_user_image(false).build 
+DVLA::Application::ApplicationBuilder.new.with_user_image(true).build 
+
+DVLA::Application::UODLV2ApplicationBuilder.new.with_user_image(false).build 
+DVLA::Application::UODLV2ApplicationBuilder.new.with_user_image(true).build 
+```
+
+##### with_review_state / with_photo_review_state / with_signature_review_state
+For a UODL application there is the `with_review_state` option that will progress the application in the provided review state. In this context we mean that the expected images will contain the correct reviews.
+
+For a CODL, EXC or a Paper REP/DUP application there are 2 options for this, `with_photo_review_state` and `with_signature_review_state` which control the review state of the 2 type of images of the application.
+
+How this state is reached will depend on if the application has been marked as processable or not. If the application is non-processable, the application will simply be created in the given state. Otherwise we will use the channel-api to move into this state.
+
+While calling `with_review_state` or `with_photo_review_state` the input should be a constant from the DVLA::Application::ReviewState class of this repository.
+When calling `with_signature_review_state` the input will be a constant from the DVLA::Application::SignatureReviewState class.
+
+*Examples*
+```
+DVLA::Application::ApplicationBuilder.new.with_review_state(DVLA::Application::ReviewState::CLERK_REJECTED).build
+DVLA::Application::UODLV2ApplicationBuilder.new.with_review_state(DVLA::Application::ReviewState::CLERK_REJECTED).build
+
+DVLA::Application::CODLApplicationBuilder.new.with_photo_review_state(DVLA::Application::ReviewState::CLERK_REJECTED).build 
+DVLA::Application::CODLApplicationBuilder.new.with_signature_review_state(DVLA::Application::SignatureReviewState::CLERK_REJECTED).build 
+
+DVLA::Application::REPApplicationBuilder.new.eligible_paper_to_plastic.with_photo_review_state(DVLA::Application::ReviewState::CLERK_REJECTED).build
+```
+
+
+##### with_application_status
+
+The application will be progressed to contain the given application status.
+
+How this state is reached will depend on if the application has been marked as processable or not. 
+
+If the application is processable this value is ignored. This is because, when calling real services, the application should naturally reach a desired state.
+
+If the application is not processable, then this value it used to place the application in the given state. This is achieved by calling the update-application status endpoint of application domain, so actions should be present.
+
+The input status can currently be any of the following: 
+
+- Preparing 
+- Submitted 
+- Approved 
+- Returned 
+- Unapproved 
+- Rejected 
+- Completed 
+- Deleted 
+- Cancelled
+
+The update reason is optional and currently only used with Cancelled status. If supplied it can currently be any of the following:
+
+- Timed out
+- Fraud outcome with refund
+- Fraud outcome without refund
+- Casework outcome
+- Manual cancel
+- Returned
+
+It is worth noting, we currently do not support any status before preparing. 
+Additionally, a 'Cancelled' status will give the update reason of 'Timed Out' unless another is supplied.
+
+*Examples*
+```
+DVLA::Application::ApplicationBuilder.new.with_application_status('Completed', 'Returned').build 
+
+DVLA::Application::UODLV2ApplicationBuilder.new.with_application_status('Completed', 'Returned').build 
+
+DVLA::Application::CODLApplicationBuilder.new.with_application_status('Completed', 'Returned').build 
+```
+
+
+##### with_change_of_address
+The UODL application will contain a change of address.
+
+*Examples*
+
+```
+DVLA::Application::ApplicationBuilder.new.with_change_of_address.build 
+
+DVLA::Application::UODLV2ApplicationBuilder.new.with_change_of_address.build 
+```
+
+
+##### has_phone_number
+The application will contain a phone number.
+
+*Examples*
+
+```
+DVLA::Application::ApplicationBuilder.new.has_phone_number.build 
+
+DVLA::Application::UODLV2ApplicationBuilder.new.has_phone_number.build 
+
+DVLA::Application::CODLApplicationBuilder.new.has_phone_number.build 
+```
+
+
+##### is_organ_donor
+Sets the organ donor status of the application.
+By default the application will have no organ donation.
+Passing true will cause all_organs to be selected.
+Passing false will ensure no organs are selected.
+
+*Examples*
+
+```
+DVLA::Application::ApplicationBuilder.new.is_organ_donor(true).build 
+DVLA::Application::ApplicationBuilder.new.is_organ_donor(false).build 
+
+DVLA::Application::UODLV2ApplicationBuilder.new.is_organ_donor(true).build 
+DVLA::Application::UODLV2ApplicationBuilder.new.is_organ_donor(false).build 
+
+DVLA::Application::CODLApplicationBuilder.new.is_organ_donor(true).build 
+DVLA::Application::CODLApplicationBuilder.new.is_organ_donor(false).build 
+```
+
+
+##### with_payments
+The application will contain the provided payment option. This is ignored for processable applications.
+
+
+##### with_applicant
+Override the provided applicant in applicant.data with the provided applicant object.
+
+##### with_customer_id
+Override the random customer ID with the provided UUID. Useful if you want to tie an application to a specific customer record.
+
+##### with_driver_id
+Override the random driver ID with the provided UUID. Useful if you want to tie an application to a specific driver record.  
+This is available just for a UODL application.
+
+##### with_home_office_comparison_photo
+Use a comparison photo coming from Home Office instead of Passport.  
+This parameter is available just on a CODL, EXC or a Paper REP/DUP application.
+
+##### with_unable_to_prove_licence_possession_reason
+For a UODL-V2 application this sets the reason why the customer was unable to prove the possession of the licence.
+This field can exist on a UODL-V2 application for any optional transaction, like a REP application.
+
+##### unique_images
+Use unique image ids when creating the application, this will ensure that the images are freshly uploaded to image_service and are not shared with other applications.
+By default the gem will use the same image IDs for all applications when uploading to image-service and utility. This helps to speed up the creation of the applications.
+This flag is useful when changing / interacting with the images (such as deleting the image).
+
+*Examples*
+
+```
+DVLA::Application::ApplicationBuilder.new.unique_images.build 
+
+DVLA::Application::UODLV2ApplicationBuilder.new.unique_images.build 
+```
+
+#### CSUDL specific options
+
+##### with_update_address
+The CSUDL application will contain a new address to be updated. If an address isn't passed in, it will generate a random address.
+
+
+*Examples*
+
+```
+DVLA::Application::CSUDLApplicationBuilder.new.with_update_address.build 
+```
+
+##### with_photo_compliance_checks
+The application wil have Photo Compliance Checks Present
+
+##### with_investigation_required
+Flags the application as requiring an investigation by a counter service clerk.
+
+##### with_no_applicant - **In Development**
+Driver reminder service may not bew able to find a customer, which could cause this case.
+
+_NOTE: At the moment, this will not function, as the happy path expects an applicant to be present._
+
+#### with_reminder_barcode_contents
+Sets the contents of the scanned bartcode from the reminder letter sent to the applicant.
+
+#### with_licence_data
+Sets the data captured from the driver's licence. if licence_data is not provided, it will default to a set of values.
+
+#### with_counter_service_metadata
+Override the counter service metadata for the application.
+
+#### Processable vs non-processable applications
+
+We have two methods to create an application, these are processable and non-processable.
+
+This concept covers how we create the application. A non-processable application is very much a test application. It does not interact with the task service to create its state, it is quick and cheap to make, but may not be completely accurate.
+
+This is most likely to be used in QA testing as this allows a temporary application to be made in the given state quickly.
+
+A processable application is an application which can be acted on. This is generated by using the channel-api to call task service and process engine to get the application into its current state. This results in an application which is very representative of a real application in this state; however, this is expensive and time consuming to create. These should not be used lightly within QA testing.
+
+#### The default build state
+Not providing any options will result in the default state being used.
+
+The application will:
+ - Be non-processable
+ - Have a user uploaded photo
+ - Have a user uploaded signature if applicable
+ - Have a fallback photo available if applicable
+ - Have the photo in a CLERK_IN_PROGRESS review state
+ - Have the signature in a CLERK_IN_PROGRESS review state if applicable
+ - Have a preparing application status
+ - Don't have any organ selected for dontaion
+ - Not have a phone number
+ - Not have a change of address
+ - Reuse existsing image ids
+
+### Configuration
+
+You can use standard YAML config files to configure required environment variables.
+
+## Development
+
+After cloning the repo, install the gem's dependencies:
+
+    $ bundle install
+
+To run tests, execute:
+
+    $ bundle exec rake spec
+
+To install this gem onto your local machine, execute:
+
+    $ bundle exec rake install
+
+To interact with the helper and create Applications from the terminal, ensure you are authenticated with the appropriate AWS account, then execute:
+
+    $ bundle exec irb -r dvla/application_helper
+
+Set an appropriate [environment configuration](#configuration) in irb:
+
+```ruby
+DVLA::Application.config { |config| config.environment = 'local-dev' }
+```
+
+To release a new version, update the version number in `version.rb`, and perform one of the following tasks:
+- Run `bundle exec rake release`, which will create a git tag for the version, push git commits and the created tag, and push the `.gem` file to [rubygems.org](https://rubygems.org).
+- Or alternatively once your changes are merged into main, simply tag the commit with the updated version number.
+
+## Seed new application
+
+If you need to seed a new application in the dev or link environment there are some easy to use commands to do so.  
+It's possible to seed a new application either by checking out this repo or by using drone.
+
+You can decide to seed the data in the `dev` or `link` environment.  
+
+In the `dev` environment you can create any type of application, processable or non-processable and with any build option available.  
+In the `link` environment however it's not possible to create non-processable applications, it's also not possible to use the parameters: `build_with_customer_id`, `build_with_driver_id` and `build_with_applicant`.
+
+### Seed from local
+
+To seed an application from the repo you'll need to login in AWS and export the AWS credentials for the correct environment in the terminal.
+
+After logging in AWS, if you are creating an application in the `link` environment you'll also need to export the `DRIVER_DATA_LOADER_LINK__API_KEY` environment variable. This is needed to create a correct driver record.
+
+Once all the environment variables are defined, you can create a simple UODL application by running one of the following commands depending the environment you want to use:
+
+```bash
+bundle exec rake seed_app:dev
+bundle exec rake seed_app:link
+```
+
+You can also specify additional build options by passing parameters, for example you can create a processable UODL-V2 application with a change of address and an image rejected by a supervisor:
+
+```bash
+bundle exec rake seed_app:dev build_type=uodl-v2 build_processable= build_with_change_of_address= build_with_review_state=:supervisor_rejected
+
+bundle exec rake seed_app:link build_type=uodl-v2 build_processable= build_with_change_of_address= build_with_review_state=:supervisor_rejected
+```
+
+All the parameters are explained in the section below.
+
+### Seed from Drone
+
+To seed a new application using Drone, you'll need first to find the latest build for the main branch and then promote it.  
+When promoting the build you'll need to set the **Target** value to `seed`.
+
+This will start a new execution in the pipeline, and in the last step "seed application" a new customer and a new application will be created. By default this will point to the `dev` environment and create a normal non-processable UODL application.
+
+You can personalise the application by setting different **Parameters**.  
+To do that you'll need to type the key and the value of the parameter and then click on the **+Add** button. If the **+Add** button is not clicked the parameter will not be used.
+
+In the **Parameters** you can specify the environment where to create the application and any build options.
+
+For example to create a processable UODL-V2 application in the link environment you'll need to set the following parameters:
+* **ENVIRONMENT**: `drone-link`
+* **build_type**: `uodl-v2`
+* **build_processable**: `-`
+
+### Parameters and Build options
+
+There are many parameters that can be passed, and they depend on what application type you are creating.
+
+#### Environment
+
+The `ENVIRONMENT` parameter is used in drone to specify where the application will be seeded.  
+The possible values for this parameter are:
+* `drone-dev` - this is also the default value
+* `drone-link`
+
+This parameter is set automatically when creating an application locally.
+
+#### Build type
+
+To specify the type of the application to create you can set the `build_type` parameter.  
+The possible values are:
+* `uodl` - This will create a UODL application. This is also the default option.
+* `uodl-v2` - This will create a UODL-V2 application.
+* `cop` - This will create a UODL-V2 COP application.
+* `rep` - This will create a UODL-V2 REP application.
+* `dup` - This will create a UODL-V2 DUP application.
+* `exc` - This will create a UODL-V2 EXC application.
+* `codl` - This will create a CODL application.
+* `csudl` - This will create a CSUDL application.
+
+#### Dynamic build options
+
+Using the parameters is also possible to specify any existing build option available on the builder classes.  
+All you need to do is to prefix the build option with the `build_` prefix.
+
+For example to set the `has_phone_number` build option, and create the application's customer with a phone number, we can pass the `build_has_phone_number` parameter with an empty value.
+
+##### No data
+
+Any build option that doesn't require additional data can be specified by setting the parameter with an empty value (`build_processable=`) or with a dash (`build_processable=-`)
+
+##### Null
+
+To set a build option with the value of `nil`, you can set the value in the command to `null`  
+e.g `build_with_customer_id=null`
+
+##### Boolean
+
+To set build options that require a boolean flag, we can set the values `true` or `false` to the parameter.  
+e.g. `build_is_organ_donor=true`
+
+##### String data
+
+The build options that require a string can be specified just by setting the value directly to the parameter.  
+e.g. `build_with_customer_id=62814c62-8170-46f2-9ec1-093b3df5d42f`  
+
+##### Symbols
+
+Some build options require to set ruby symbols, you can do this by using the normal ruby syntax using the `:` char.  
+e.g. `build_with_review_state=:supervisor_approved`
+
+##### Objects or Arrays
+
+Any other type of data required by build options can be passed by setting the parameter to a valid json string.
+e.g. `build_with_payments=[{"paymentId":"7117422","paymentStatus":"SETTLEMENT_REQUESTED","timeInitiated":"2024-08-13T07:45:34.343Z","redirectType":"IFRAME","paymentAmount":"14.00","paymentReference":"pay-ref-7117422"}]`
+
+If working in the terminal some of these characters might need to be escaped or enclosed in double quotes.
+
+#### Examples
+
+Seed a processable UODL V2 application in DEV with a change of address and the review state of SUPERVISOR_REJECTED
+
+```bash
+bundle exec rake seed_app:dev build_type=uodl-v2 build_processable= build_with_change_of_address= build_with_review_state=:supervisor_rejected
+```
+
+Seed a DUP application in LINK that is eligible to go from a paper to plastic licence
+
+```bash
+bundle exec rake seed_app:link build_type=dup-v3 build_processable= build_eligible_paper_to_plastic=
+```
+
+Seed a REP application in LINK that is eligible to go from a paper to plastic licence
+
+```bash
+bundle exec rake seed_app:link build_type=rep-v3 build_processable= build_eligible_paper_to_plastic=
+```
+
+Seed a EXC application in LINK that is eligible to go from a paper to plastic licence
+
+```bash
+bundle exec rake seed_app:link build_type=exc-v3 build_processable=
+```
+
+Send a CSUDL application in DEV with CSUDL specific fields
+
+```bash
+bundle exec rake seed_app:dev build_type=csudl build_with_unable_to_prove_licence_possession_reason=LOST_OR_STOLEN build_with_investigation_required= build_with_reminder_barcode_contents='9826943224281001848986045116301GAIR    GERARD SWAN    34 SAXON CLOSE    SA1 1SD' build_with_licence_data= build_with_photo_compliance_checks='{"photoOverride":true,"icaoCompliant":true,"eyesOpen":true,"exposure":true,"frontalView":true,"greyscaleDensity":true,"uniformLighting":true,"headWidth":true,"headLength":true,"widthHeightRatio":true,"resolution":true,"verticalPosition":true,"horizontallyCentered":true}' build_is_organ_donor=true build_with_update_address=
+```
+
+## Contributing
+
+
+## Known Issues/Future improvements
+- Currently we are unable to call image utility using the link development role. Due to this we are unable to use this gem in the link environment from a local machine.
+
+- To create an external task, it is suggested that we create a processable task that is either rejected for comparison at the clerk or supervisor level.
+
+- A non processable task will be in the 'Cancelled' state and will include a updateReason of 'Timed out'.
+
+- The user submitting tasks is currently a fixed value. These will always claim to be carried out by `tom.collins@dvla.gov.uk`.