Scheduled Tasks

Setup

Local

To test and run this locally you'll first need to:

1. Install Go :-)
2. Install Node.js and npm
3. Install Docker
4. Install client web app node modules cd app and npm install
5. Install end-to-end test runner cd app-test and npm install
6. Copy default.env to env/local-dev/.env (these environment variables are injected into containers and used in the apps when running locally)
7. Create an Auth0 tenant for the local-dev environment (See Auth0 Authentication section below)
8. Create another Auth0 tenant for the local-test environment if you wish

AWS Staging

App will be public, but NOT protected with an SSL cert (which will break auth requests in chromium browsers)

1. Install Terraform
2. Setup AWS credentials on your local machine
3. Create a hosted zone for your domain name with a staging subdomain in AWS Route53
4. Create a key pair to connect to your EC2 instance in AWS EC2 under Network & Security -> Key Pairs
5. Copy default.secret.auto.tfvars to env/local-stage/.secret.auto.tfvars (these are used when spinning up cloud infrastructure with terraform)
6. Create an Auth0 tenant for the staging environment and set the .secret.auto.tfvars appropriately
7. Build/push the containers and spin up AWS infrastructure, will incur costs (terraform destroy to tear down)

cd ./services
docker build -t benjohns1/scheduled-tasks-services .
docker push benjohns1/scheduled-tasks-services

cd ../app
docker build -t benjohns1/scheduled-tasks-webapp .
docker push benjohns1/scheduled-tasks-webapp

cd ../env/aws-stage
terraform taint module.ecs.aws_ecs_task_definition.tasks
terraform apply

Auth0 Tenant Setup

Sign-up and create an Auth0 tenant for each environment you want with the following:

1. An API (e.g. 'Dev API') with the HS256 signing alg and a single permission of 'type:anon', then set the AUTH0_API_* env vars appropriately
2. A machine to machine application (e.g. 'Dev Anon User') with 'type:anon' scoped access to your API, then set the AUTH0_ANON_CLIENT_* env vars
3. A machine to machine application (e.g. 'Dev E2E Test User') with no scoped access to your API, then set the AUTH0_E2E_DEV_CLIENT_* env vars
4. A single page application (e.g. 'Dev Web App') with Allowed Callback URLs, Allowed Web Origins, Allowed Logout URLs, and Allowed Origins (CORS) set to http://localhost:3000, then set the AUTH0_DOMAIN and AUTH0_WEBAPP_CLIENT_ID env vars

Quick Run Scripts

Setup local environments in one command (Windows only, for now)

• Development (hot reloading for the Sapper app and Cypress interactive test runner):
  • cd env/local-dev and run
• Test build (builds and creates container images for the web app and API):
  • cd env/local-test and run

Default URLs

• local-dev
  • Web app: http://localhost:3000
  • DB adminer: http://localhost:3001
  • API server: http://localhost:3002
• local-test
  • Web app: http://localhost:3100
  • DB adminer: http://localhost:3101
  • API server: http://localhost:3102

Test Build Environment

1. cd ./env/local-test
2. Point to the test version of the env vars:
   • on nix: export ENV_FILEPATH=$PWD/.env
   • -or- on windows: set ENV_FILEPATH=%CD%\.env
3. Build the app and container images: docker-compose build
4. Start the containers: docker-compose up
5. Tear it down: docker-compose down

Development Environment

Run the app and services locally with a transient DB container

1. cd ./env/local-dev
2. Point to the dev version of the env vars:
   • on nix: export ENV_FILEPATH=$PWD/.env
   • -or- on windows: set ENV_FILEPATH=%CD%\.env
3. Start DBs: docker-compose up
4. Modify ./services code, rebuild as-needed
5. Rebuild and run the services in ./services/cmd/srv:
   • on nix: go build && ./srv
   • -or- on windows: go build && srv
6. Start the web app with hot reloading in ./app with: npm run dev
7. Open cypress for live testing in ./app-test with: npm run cy:open
8. Modify ./app code
9. Tear down the DBs in ./env/local-dev with: docker-compose down

Local Development Testing

Run services unit tests

1. Run tests in ./services with: go test ./...

Run services integration tests

Connects to DB containers for integration testing

1. Start DBs in ./env/local-dev with: docker-compose up
2. Point to the test version of the env vars:
   • on nix: export ENV_FILEPATH=$PWD/.env
   • -or- on windows: set ENV_FILEPATH=%CD%\.env
3. Run tests in ./services with: go test ./... -tags='integration'
4. Tear down the DBs in ./env/local-dev with: docker-compose down

Run client web app cypress tests

1. Start DBs in ./env/local-dev with: docker-compose up
2. Build and run the API server & scheduler processes (in a new terminal) in ./services/cmd/srv with: go build && ./srv
3. Run the tests in ./app-test with: npm test
4. Tear down the DBs in ./env/local-dev with: docker-compose down