test

## 1. Build your Lambda package

From the project root:

```bash
chmod +x build.sh
./build.sh
```

You should see:

```text
Building DocumentParser Lambda...
Installing Python dependencies...
Copying Lambda source...
Build complete.
```



## 2. Format Terraform

```bash
terraform fmt
```



## 3. Check the infrastructure

```bash
terraform plan
```

Look through it and make sure there are no unexpected changes.


## 4. Deploy

```bash
terraform apply
```

Type:

```text
yes
```


## 5. Get your testing values

Now:

```bash
terraform output
```

You'll see:

```text
upload_url = "https://..."
bucket_name = "..."
queue_url = "https://..."
dlq_url = "https://..."
parser_log_group = "/aws/lambda/..."
upload_log_group = "/aws/lambda/..."
error_handler_log_group = "/aws/lambda/..."
```

Now put them into variables:

```bash
export API_URL=$(terraform output -raw upload_url)
export BUCKET=$(terraform output -raw bucket_name)
export QUEUE_URL=$(terraform output -raw queue_url)
export DLQ_URL=$(terraform output -raw dlq_url)
```

Check:

```bash
echo $API_URL
echo $BUCKET
echo $QUEUE_URL
echo $DLQ_URL
```


# 6. Prepare a test PDF

Create/use a real PDF called:

```text
urgent.pdf
```

Make sure the PDF contains:

```text
URGENT
This is a test invoice.
```


# 7. Open CloudWatch logs

Open **two terminals**.

### Terminal 1 — UploadProcessor

```bash
aws logs tail "$(terraform output -raw upload_log_group)" --follow
```

### Terminal 2 — DocumentParser

```bash
aws logs tail "$(terraform output -raw parser_log_group)" --follow
```

Leave both running.


# 8. Upload the PDF through API Gateway

Open a **third terminal**.

Encode the PDF:

```bash
BASE64=$(base64 -w 0 urgent.pdf)
```

Then:

```bash
curl -X POST "$API_URL" \
  -H "Content-Type: application/pdf" \
  -d "$BASE64"
```

Watch Terminal 1.

You should see something like:

```text
UPLOAD_SUCCESS: abc123....bin
```


# 9. Check S3

Run:

```bash
aws s3 ls "s3://$BUCKET/"
```

You should see your uploaded file.

You can also open:

**AWS Console → S3 → your bucket**

and see the object.


# 10. Check SQS

Run:

```bash
aws sqs get-queue-attributes \
  --queue-url "$QUEUE_URL" \
  --attribute-names ApproximateNumberOfMessages
```

Don't worry if it says `0`.

Your Lambda may have already picked the message up.

Instead, watch **Terminal 2**.

You should see:

```text
PROCESSING_STARTED: ...
SQS_MESSAGE_ID: ...
Found keywords: [...]
DOCUMENT_PROCESSED: ...
```


# 11. Check your email

Because your PDF contains `urgent`, your `DocumentParser` currently publishes to SNS **whenever it finds any of your keywords**.

So you should receive the SNS email.

Check your inbox.


# 12. Verify the complete chain

At this point you've tested:

```text
curl
 ↓
API Gateway
 ↓
UploadProcessor Lambda
 ↓
S3
 ↓
S3 Event
 ↓
SQS
 ↓
DocumentParser Lambda
 ↓
PDF extraction
 ↓
Keyword detection
 ↓
SNS
 ↓
Email
```

That's your **happy-path test**.



# 13. Now test failure / DLQ

After the happy path works, test your failure handling.

Temporarily put this inside `DocumentParser`:

```python
raise Exception("TEST_DLQ")
```

Then rebuild and deploy:

```bash
./build.sh
terraform apply
```

Upload another PDF:

```bash
BASE64=$(base64 -w 0 urgent.pdf)

curl -X POST "$API_URL" \
  -H "Content-Type: application/pdf" \
  -d "$BASE64"
```

Watch the parser logs:

```bash
aws logs tail "$(terraform output -raw parser_log_group)" --follow
```

You should see failures.

Because your queue has:

```hcl
maxReceiveCount = 3
```

the message should eventually move to the DLQ.

Check:

```bash
aws sqs get-queue-attributes \
  --queue-url "$DLQ_URL" \
  --attribute-names ApproximateNumberOfMessages
```

Then watch your error handler:

```bash
aws logs tail "$(terraform output -raw error_handler_log_group)" --follow
```

You should see:

```text
DLQ_DOCUMENT_RECEIVED
DLQ_ALERT_SENT
```

And your SNS email should arrive.



## So your entire testing routine is:

```bash
./build.sh

terraform fmt

terraform plan

terraform apply

terraform output

export API_URL=$(terraform output -raw upload_url)
export BUCKET=$(terraform output -raw bucket_name)
export QUEUE_URL=$(terraform output -raw queue_url)
export DLQ_URL=$(terraform output -raw dlq_url)
```

Then:

**Terminal 1**

```bash
aws logs tail "$(terraform output -raw upload_log_group)" --follow
```

**Terminal 2**

```bash
aws logs tail "$(terraform output -raw parser_log_group)" --follow
```

**Terminal 3**

```bash
BASE64=$(base64 -w 0 urgent.pdf)

curl -X POST "$API_URL" \
  -H "Content-Type: application/pdf" \
  -d "$BASE64"
```

Then inspect:

**S3 → SQS → Parser logs → SNS email**

Once that works, deliberately break the parser and test:

**Lambda failure → SQS retry → DLQ → ErrorHandler → SNS email.**

That's the exact testing workflow I'd use for your project.