Update load test script to use opaque data

Author: landonshumway-ia

backend/compact-connect/tests/smoke/load_test_privilege_purchasing.py

@@ -1,14 +1,13 @@
 # ruff: noqa: BLE001 allowing broad exception catching for load testing script
 #!/usr/bin/env python3
-import random
 import time
 
 import requests
 from config import config, logger
-from faker import Faker
 from smoke_common import (
     SmokeTestFailureException,
     call_provider_users_me_endpoint,
+    generate_opaque_data,
     get_license_type_abbreviation,
     get_provider_user_auth_headers_cached,
 )
@@ -24,11 +23,6 @@
 # and the 'Transaction IP Velocity Filter', which you can do through the Account Settings under the
 # 'Fraud Detection Suite'
 
-name_faker = Faker(['en_US'])
-faker = Faker(['en_US'])
-
-AMEX_CARD_NUMBER = '370000000000002'
-
 # List of valid test card numbers from Authorize.net documentation
 # https://developer.authorize.net/hello_world/testing_guide.html
 TEST_CARD_NUMBERS = [
@@ -38,14 +32,12 @@
     '5424000000000015',  # Mastercard
     '2223000010309703',  # Mastercard
     '2223000010309711',  # Mastercard
-    AMEX_CARD_NUMBER,  # American Express
     '6011000000000012',  # Discover
-    '3088000000000017',  # JCB
 ]
 
 
-def delete_existing_privileges():
-    """Delete all existing privileges for the current user."""
+def deactivate_existing_privileges():
+    """Deactivate all existing privileges for the current user by setting administratorSetStatus to 'inactive'."""
     provider_data = call_provider_users_me_endpoint()
     privileges = provider_data.get('privileges')
     if not privileges:
@@ -59,12 +51,13 @@ def delete_existing_privileges():
         license_type_abbreviation = get_license_type_abbreviation(privilege['licenseType'])
         privilege_pk = f'{compact}#PROVIDER#{provider_id}'
         privilege_sk = f'{compact}#PROVIDER#privilege/{privilege["jurisdiction"]}/{license_type_abbreviation}#'
-        logger.info(f'Deleting privilege record:\n{privilege_pk}\n{privilege_sk}')
-        dynamodb_table.delete_item(
-            Key={
-                'pk': privilege_pk,
-                'sk': privilege_sk,
-            }
+        logger.info(f'Deactivating privilege record:\n{privilege_pk}\n{privilege_sk}')
+
+        # Update the privilege record to set administratorSetStatus to 'inactive'
+        dynamodb_table.update_item(
+            Key={'pk': privilege_pk, 'sk': privilege_sk},
+            UpdateExpression='SET administratorSetStatus = :status',
+            ExpressionAttributeValues={':status': 'inactive'},
         )
     # give dynamodb time to propagate
     time.sleep(0.5)
@@ -111,25 +104,11 @@ def get_required_attestations(provider_data: dict) -> list[dict]:
 
 def purchase_privilege(jurisdiction: str, card_number: str, attestations: list[dict], license_type: str) -> str:
     """Purchase a privilege for the given jurisdiction using the specified card number."""
+    # Generate opaque data using the card number
+    payment_nonce = generate_opaque_data(card_number)
+
     post_body = {
-        'orderInformation': {
-            'card': {
-                'number': card_number,
-                # this needs to be a random 3-digit number for everything but American Express,
-                # which is 4 digits
-                'cvv': str(random.randint(100, 999))
-                if card_number != AMEX_CARD_NUMBER
-                else str(random.randint(1000, 9999)),
-                'expiration': '2050-12',
-            },
-            'billing': {
-                'zip': '44628',
-                'firstName': name_faker.first_name(),
-                'lastName': name_faker.last_name(),
-                'streetAddress': faker.street_address(),
-                'state': faker.state_abbr(include_territories=False, include_freely_associated_states=False),
-            },
-        },
+        'orderInformation': {'opaqueData': payment_nonce},
         'selectedJurisdictions': [jurisdiction],
         'attestations': attestations,
         'licenseType': license_type,
@@ -165,8 +144,8 @@ def run_load_test(num_iterations: int):
         logger.info(f'Starting iteration {iteration + 1} of {num_iterations}')
 
         try:
-            # Delete existing privileges
-            delete_existing_privileges()
+            # Deactivate existing privileges
+            deactivate_existing_privileges()
 
             # Use different card numbers for each jurisdiction
             card_index = iteration % len(TEST_CARD_NUMBERS)

backend/compact-connect/tests/smoke/purchasing_privileges_smoke_tests.py

@@ -1,7 +1,5 @@
 #!/usr/bin/env python3
-import json
 import time
-import uuid
 from datetime import UTC, datetime
 
 import requests
@@ -17,6 +15,7 @@
 from smoke_common import (
     SmokeTestFailureException,
     call_provider_users_me_endpoint,
+    generate_opaque_data,
     get_provider_user_auth_headers_cached,
     load_smoke_test_env,
 )
@@ -28,8 +27,8 @@
 
 
 def _generate_post_body(attestations_from_system, license_type):
-    # Generate a payment nonce for testing
-    payment_nonce = _generate_opaque_data()
+    # Generate a payment nonce for testing using the default test card
+    payment_nonce = generate_opaque_data('4111111111111111')
 
     return {
         'orderInformation': {'opaqueData': payment_nonce},
@@ -255,83 +254,6 @@ def test_purchasing_privilege(delete_current_privilege: bool = True):
     logger.info(f'Successfully purchased privilege record: {matching_privilege}')
 
 
-def _generate_opaque_data():
-    """
-    Generate a payment nonce using Authorize.Net's Secure Payment Container API.
-    This allows us to create payment nonces programmatically for testing.
-    """
-
-    # Call the purchase privilege options endpoint and extract the api login id and
-    # public key from the compact configuration object that is returned.
-    headers = get_provider_user_auth_headers_cached()
-    response = requests.get(
-        url=f'{config.api_base_url}/v1/purchases/privileges/options',
-        headers=headers,
-        timeout=10,
-    )
-
-    if response.status_code != 200:
-        raise SmokeTestFailureException(f'Failed to get purchase privilege options. Response: {response.json()}')
-
-    response_body = response.json()
-    compact_data = next((item for item in response_body['items'] if item.get('type') == 'compact'), None)
-
-    if not compact_data:
-        raise SmokeTestFailureException('No compact data found in purchase privilege options response')
-
-    if 'paymentProcessorPublicFields' not in compact_data:
-        raise SmokeTestFailureException('No paymentProcessorPublicFields found in compact data')
-
-    payment_fields = compact_data['paymentProcessorPublicFields']
-    api_login_id = payment_fields.get('apiLoginId')
-    public_client_key = payment_fields.get('publicClientKey')
-
-    if not api_login_id or not public_client_key:
-        raise SmokeTestFailureException(f'Missing credentials in paymentProcessorPublicFields: {payment_fields}')
-
-    # Generate the payment nonce using the secure payment container API
-    unique_id = str(uuid.uuid4())
-
-    # Create the secure payment container request
-    request_data = {
-        'securePaymentContainerRequest': {
-            'merchantAuthentication': {
-                'name': api_login_id,
-                'clientKey': public_client_key,  # Use the public client key
-            },
-            'refId': '12345',
-            'data': {
-                'type': 'TOKEN',
-                'id': unique_id,
-                'token': {
-                    'cardNumber': '4111111111111111',  # Visa test card
-                    'expirationDate': '122030',
-                    'cardCode': '999',
-                    'fullName': 'SmokeTest User',
-                },
-            },
-        }
-    }
-
-    # Make the API request
-    test_url = 'https://apitest.authorize.net/xml/v1/request.api'
-    headers = {'Content-Type': 'application/json'}
-    response = requests.post(test_url, json=request_data, headers=headers, timeout=30)
-
-    if response.status_code == 200:
-        response_data = json.loads(response.content.decode('utf-8-sig'))
-
-        # Extract the payment nonce from the response
-        # The exact structure may vary, but it should contain the opaque data
-        if 'opaqueData' in response_data:
-            logger.info('Generated opaque data.')
-            return response_data['opaqueData']
-        logger.error(f'No opaqueData in response: {response_data}')
-        raise SmokeTestFailureException(f'No opaqueData in response: {response_data}')
-    logger.error(f'Failed to generate payment nonce: {response.status_code} - {response.text}')
-    raise SmokeTestFailureException(f'Failed to generate payment nonce: {response.status_code} - {response.text}')
-
-
 if __name__ == '__main__':
     # Load environment variables from smoke_tests_env.json
     load_smoke_test_env()

backend/compact-connect/tests/smoke/smoke_common.py

@@ -1,6 +1,7 @@
 import json
 import os
 import sys
+import uuid
 
 import boto3
 import requests
@@ -237,3 +238,83 @@ def get_all_provider_database_records():
     )
 
     return query_result['Items']
+
+
+def generate_opaque_data(card_number: str):
+    """
+    Generate a payment nonce using Authorize.Net's Secure Payment Container API.
+    This allows us to create payment nonces programmatically for testing.
+
+    :param card_number: The test card number to use for generating the opaque data
+    :return: The opaque data object containing the payment nonce
+    """
+
+    # Call the purchase privilege options endpoint and extract the api login id and
+    # public key from the compact configuration object that is returned.
+    headers = get_provider_user_auth_headers_cached()
+    response = requests.get(
+        url=f'{config.api_base_url}/v1/purchases/privileges/options',
+        headers=headers,
+        timeout=10,
+    )
+
+    if response.status_code != 200:
+        raise SmokeTestFailureException(f'Failed to get purchase privilege options. Response: {response.json()}')
+
+    response_body = response.json()
+    compact_data = next((item for item in response_body['items'] if item.get('type') == 'compact'), None)
+
+    if not compact_data:
+        raise SmokeTestFailureException('No compact data found in purchase privilege options response')
+
+    if 'paymentProcessorPublicFields' not in compact_data:
+        raise SmokeTestFailureException('No paymentProcessorPublicFields found in compact data')
+
+    payment_fields = compact_data['paymentProcessorPublicFields']
+    api_login_id = payment_fields.get('apiLoginId')
+    public_client_key = payment_fields.get('publicClientKey')
+
+    if not api_login_id or not public_client_key:
+        raise SmokeTestFailureException(f'Missing credentials in paymentProcessorPublicFields: {payment_fields}')
+
+    # Generate the payment nonce using the secure payment container API
+    unique_id = str(uuid.uuid4())
+
+    # Create the secure payment container request
+    request_data = {
+        'securePaymentContainerRequest': {
+            'merchantAuthentication': {
+                'name': api_login_id,
+                'clientKey': public_client_key,  # Use the public client key
+            },
+            'refId': '12345',
+            'data': {
+                'type': 'TOKEN',
+                'id': unique_id,
+                'token': {
+                    'cardNumber': card_number,
+                    'expirationDate': '122030',
+                    'cardCode': '999',
+                    'fullName': 'SmokeTest User',
+                },
+            },
+        }
+    }
+
+    # Make the API request
+    test_url = 'https://apitest.authorize.net/xml/v1/request.api'
+    headers = {'Content-Type': 'application/json'}
+    response = requests.post(test_url, json=request_data, headers=headers, timeout=30)
+
+    if response.status_code == 200:
+        response_data = json.loads(response.content.decode('utf-8-sig'))
+
+        # Extract the payment nonce from the response
+        # The exact structure may vary, but it should contain the opaque data
+        if 'opaqueData' in response_data:
+            logger.info('Generated opaque data.')
+            return response_data['opaqueData']
+        logger.error(f'No opaqueData in response: {response_data}')
+        raise SmokeTestFailureException(f'No opaqueData in response: {response_data}')
+    logger.error(f'Failed to generate payment nonce: {response.status_code} - {response.text}')
+    raise SmokeTestFailureException(f'Failed to generate payment nonce: {response.status_code} - {response.text}')