Create Account

Create Account Test Case Guide

Claude Instructions

IMPORTANT: When user asks a simple question like "How do I create an Oracle account?", provide a concise answer first with just the template/command, then offer to explain more if needed. Do NOT dump all documentation.

MANDATORY WORKFLOW: When creating account test cases (for ANY account type — supported or new):

1. Enter plan mode first — Do NOT start writing files immediately
2. Check which files already exist — Read the payload file and env file to see if they already have correct content
3. Present a plan showing: existing files (skip) vs. missing files (create)
4. After user approves, only create the files that are missing

The 4 required files are:

1. Payload file (acc_[type].json) in test/suite/test_data/accounts_payload/ — CREATE only if missing
2. Env file (.env.[type]) in env_files/[category]_accounts/ — CREATE only if missing
3. Robot test file (.robot) in test/suite/pipeline_tests/[type]/ — CREATE only if missing or empty
4. ACCOUNT_SETUP_README.md with file structure tree diagram in the same test directory — CREATE only if missing

Ensure all 4 files exist when done, but do NOT overwrite existing files that already have correct content. See the "IMPORTANT: Step-by-Step Workflow" section for details.

Response format for simple questions:

1. Give the direct template or test case first
2. Add a brief note if relevant
3. Offer "Want me to explain more?" only if appropriate

WHEN USER INVOKES /create-account WITH NO ARGUMENTS

Claude: When user types just /create-account with no specific request, present the menu below. Use this EXACT format:

SnapLogic Account Creation

What I Can Do

For every account type, I create the complete set of files you need:

• Payload file (acc_[type].json) — JSON template with Jinja variable placeholders
• Environment file (.env.[type]) — All required environment variables
• Robot test file (.robot) — Robot Framework test case using Create Account From Template
• ACCOUNT_SETUP_README.md — File structure diagram, prerequisites, and run instructions

I can also:

• Show you environment variables needed for any account type
• Explain payload templates and configuration
• Guide you through adding new account types

Supported Account Types

• Databases: oracle, postgres, mysql, sqlserver, snowflake, snowflake-keypair, db2, teradata
• Messaging: kafka, jms
• Services: s3, email, salesforce
• New/Custom: Not in the list above? No problem — I can create test cases for any account type (e.g., CockroachDB, Cassandra, MongoDB, etc.) with the full set of files: payload template, env file, robot test case, and README.

Try these sample prompts to get started:

Natural Language — Just Describe What You Need

You don't need special syntax. Just describe what you need after /create-account:

/create-account I need PostgreSQL and S3 accounts for my pipeline

/create-account What environment variables do I need to update and in which files to create a Snowflake account?

/create-account Show me the baseline test for Snowflake account creation as a reference

/create-account Generate a test case to create a Snowflake keypair account

/create-account Write a robot file that creates both Kafka and S3 accounts

/create-account I need a new robot test file to create a MySQL account in my project

Environment Variable Setup Questions

/create-account How do I set up environment variables for Snowflake?

/create-account I want to use my own Snowflake instance, not Docker

/create-account Where do I put my production database credentials?

/create-account Do I need to change anything if I'm using Docker services?

/create-account What's the difference between env_files and root .env?

Baseline test references:

• test/suite/pipeline_tests/snowflake/snowflake_baseline_tests.robot
• test/suite/pipeline_tests/oracle/oracle_baseline_tests.robot
• test/suite/pipeline_tests/postgres/postgres_baseline_tests.robot

Supported Account Types

Account Files Reference

Environment Variable Setup

Network Architecture

IMPORTANT: The SnapLogic Groundplex runs as a Docker container on the shared snaplogicnet bridge network — the same network as all other Docker services (SQL Server, Oracle, PostgreSQL, Kafka, MinIO, etc.). This means:

• Services reach each other via Docker container names (e.g., sqlserver-db, oracle-db, postgres-db)
• Do NOT use host.docker.internal or localhost for Docker service hostnames — these won't work from the Groundplex container
• The env files in env_files/ already contain the correct Docker container hostnames

┌─────────────────────────── snaplogicnet (bridge network) ───────────────────────────┐
│                                                                                      │
│  ┌──────────────────┐  ┌──────────────┐  ┌──────────────┐  ┌──────────────────────┐ │
│  │ snaplogic-       │  │ sqlserver-db │  │ oracle-db    │  │ postgres-db          │ │
│  │ groundplex       │──│ :1433        │  │ :1521        │  │ :5432                │ │
│  │ :8090, :8081     │  └──────────────┘  └──────────────┘  └──────────────────────┘ │
│  └──────────────────┘  ┌──────────────┐  ┌──────────────┐  ┌──────────────────────┐ │
│                        │ mysql-db     │  │ kafka        │  │ minio-api            │ │
│                        │ :3306        │  │ :9092        │  │ :9000                │ │
│                        └──────────────┘  └──────────────┘  └──────────────────────┘ │
└──────────────────────────────────────────────────────────────────────────────────────┘

Case 1: Using Docker Services (Local Testing)

If you're creating an account for an endpoint brought up using Docker services (Oracle, PostgreSQL, MySQL, SQL Server, Kafka, MinIO, etc.):

• Use the default credentials from the respective file in env_files/
• No changes needed — the values are pre-configured with correct Docker container hostnames
• Hostnames use container names (e.g., sqlserver-db, oracle-db, postgres-db) because the Groundplex is on the same Docker network
• Just run the tests: make robot-run-tests TAGS="oracle"

NEVER change the default hostnames to host.docker.internal or localhost — the Groundplex communicates with other services via the snaplogicnet bridge network using container names.

Case 2: Using External/Your Own Instance

If you're using your own external instance (e.g., your company's Snowflake, production database, etc.):

1. Read the env file to understand the required variables:

   env_files/database_accounts/.env.snowflake
   

2. Copy the variables to root .env file (not the env_files one):

   # Copy these lines to your root .env file:
   SNOWFLAKE_HOSTNAME=your-account.snowflakecomputing.com
   SNOWFLAKE_USERNAME=your_username
   SNOWFLAKE_PASSWORD=your_password
   SNOWFLAKE_DATABASE=YOUR_DB
   SNOWFLAKE_WAREHOUSE=YOUR_WH
   

3. Update the values with your actual credentials

4. Do NOT copy the payload file variable — it remains constant:

   # DO NOT copy this to .env - leave it in env_files/
   SNOWFLAKE_ACCOUNT_PAYLOAD_FILE_NAME=acc_snowflake_s3_db.json
   

5. For database name overrides only — if you need a different database than the Docker default (e.g., SnapLogicTest instead of master), add just the database variable to root .env:

   # Override only what differs from Docker defaults
   SQLSERVER_DATABASE=SnapLogicTest
   

Why This Works

• Root .env file is loaded last and overrides everything
• env_files/ contains default Docker values with correct container hostnames
• Payload file names never change — they reference JSON templates
• The Groundplex and all services share the snaplogicnet Docker bridge network, so container names resolve automatically

REFERENCE DOCUMENTATION

You are helping a user create Robot Framework test cases that create SnapLogic accounts. Follow these conventions and patterns based on the account creation framework.

How to Use This Command

Invoking the Command

In Claude Code, type:

/create-account

Then add your specific request after the command.

Example Prompts

Create a specific account type:

/create-account

I need to create a Snowflake account test case using key pair authentication

Create multiple accounts:

/create-account

I need to create test cases for PostgreSQL and S3 accounts for my data pipeline

Ask about available options:

/create-account

What account types are supported? Show me the env file locations.

Get help with configuration:

/create-account

I want to create an Oracle account but I'm not sure what environment variables I need

Create accounts for a pipeline:

/create-account

I'm building a pipeline that reads from Kafka and writes to Snowflake. What accounts do I need?

Troubleshoot account issues:

/create-account

I'm getting an error creating my MySQL account. What JAR files do I need?

Add a new account type:

/create-account

I need to add support for a new database type called "CockroachDB". Guide me through the process.

Check environment setup:

/create-account

Help me verify my Snowflake environment variables are set correctly

Quick Start Template

Here's a basic test case template for creating accounts:

IMPORTANT: Required Libraries When creating any new Robot file, ALWAYS include these two Resource imports under *** Settings ***:

• snaplogic_common_robot/snaplogic_apis_keywords/snaplogic_keywords.resource - SnapLogic API keywords from installed package
• ../../resources/common/general.resource - Project-specific common keywords

*** Settings ***
Documentation    Creates SnapLogic accounts for pipeline testing
...              Uses JSON payload templates with Jinja variable substitution
Resource         snaplogic_common_robot/snaplogic_apis_keywords/snaplogic_keywords.resource    # SnapLogic API keywords from installed package
Resource         ../../resources/common/general.resource
Library          Collections

*** Variables ***
# Account configuration - uses environment variables
${account_name}    ${POSTGRES_ACCOUNT_NAME}

*** Test Cases ***
Create PostgreSQL Account
    [Documentation]    Creates a PostgreSQL account in the project space.
    ...    Uses the Create Account From Template keyword to set up
    ...    account credentials for subsequent pipeline operations.
    ...
    ...    Arguments:
    ...    - ${ACCOUNT_LOCATION_PATH}: Path where account is created
    ...    - ${POSTGRES_ACCOUNT_PAYLOAD_FILE_NAME}: JSON payload file
    ...    - ${account_name}: Account name in SnapLogic
    [Tags]    postgres    account_setup
    [Template]    Create Account From Template
    ${ACCOUNT_LOCATION_PATH}    ${POSTGRES_ACCOUNT_PAYLOAD_FILE_NAME}    ${account_name}    overwrite_if_exists=${TRUE}

IMPORTANT: Step-by-Step Workflow

Always follow this workflow when creating account test cases.

MANDATORY: For EVERY account type (supported or new), you MUST create ALL of the following files:

Before writing any files, enter plan mode and check which files already exist. Read each file to determine if it has correct content. Present a plan to the user showing which files exist (skip) and which are missing (create). Only create files that don't already exist or are empty. Ensure all 4 files exist when done.

IMPORTANT: Do NOT overwrite existing files that already have correct content. Only use the Write tool for files that are missing or empty.

Step 1: Identify the Account Type

Determine which account type you need based on your pipeline requirements.

Step 2: Create the Payload File (if missing)

Check if test/suite/test_data/accounts_payload/acc_[type].json already exists with correct content. If it does, skip this step. If missing, create it:

• Use SnapLogic account JSON structure with Jinja variable placeholders (e.g., {{VARIABLE_NAME}})
• For supported types, use the known payload structure from the reference section below
• For new types, create the JSON structure based on the account type's typical configuration

Step 3: Create the Environment File (if missing)

Check if the corresponding .env.[type] file in env_files/ already exists with correct content. If it does, skip this step. If missing, create it:

• Include all variables referenced in the payload file
• Include payload file name, account name, connection details, and authentication variables

Step 4: Understand the Variables

The env file tells you:

• *_PAYLOAD_FILE_NAME - The JSON template file name
• *_ACCOUNT_NAME - How the account appears in SnapLogic
• Connection details (hostname, port, database, etc.)
• Authentication (username, password, or key pair)
• Optional settings (S3 staging, URL properties, etc.)

Step 5: Update Variable Values

Option A: Edit the env file directly (for Docker/non-sensitive values) Option B: Copy variables to root .env file (for production/sensitive credentials - root .env overrides everything)

Step 6: Create the Robot Test Case (if missing or empty)

Check if the .robot test file in test/suite/pipeline_tests/[type]/ already exists with correct content. If it does, skip this step. If missing or empty, create it.

Step 7: Create ACCOUNT_SETUP_README.md with File Structure (if missing)

Check if ACCOUNT_SETUP_README.md already exists in the test directory. If it does, skip this step. If missing, create it with a file structure tree diagram. See the "MANDATORY: README with File Structure" section for the template.

Summary: Ensure all 4 files exist — only create what's missing

1. test/suite/test_data/accounts_payload/acc_[type].json       ← CHECK if exists, CREATE if missing
2. env_files/[category]_accounts/.env.[type]                   ← CHECK if exists, CREATE if missing
3. test/suite/pipeline_tests/[type]/[type]_account_setup.robot ← CHECK if exists, CREATE if missing/empty
4. test/suite/pipeline_tests/[type]/ACCOUNT_SETUP_README.md     ← CHECK if exists, CREATE if missing

All 4 files must exist when you are done. Only use the Write tool for files that are missing or empty — do NOT overwrite existing files with correct content.

COMPLETE EXAMPLE: Snowflake Account (All 4 Files)

When a user asks "Create a Snowflake account test case", you MUST create ALL of these files:

File 1: Payload File — test/suite/test_data/accounts_payload/acc_snowflake_s3_db.json

{
  "entity_map": {
    "Snowflake - S3 Database": {
      "acc_snowflake_s3_db": {
        "property_map": {
          "account_label": {
            "value": "{{SNOWFLAKE_ACCOUNT_NAME}}"
          },
          "hostname": {
            "value": "{{SNOWFLAKE_HOSTNAME}}"
          },
          "username": {
            "value": "{{SNOWFLAKE_USERNAME}}"
          },
          "password": {
            "value": "{{SNOWFLAKE_PASSWORD}}"
          },
          "database": {
            "value": "{{SNOWFLAKE_DATABASE}}"
          },
          "warehouse": {
            "value": "{{SNOWFLAKE_WAREHOUSE}}"
          },
          "schema_name": {
            "value": "{{SNOWFLAKE_SCHEMA}}"
          },
          "role": {
            "value": "{{SNOWFLAKE_ROLE}}"
          }
        }
      }
    }
  }
}

File 2: Env File — env_files/database_accounts/.env.snowflake

# ============================================================================
#                      SNOWFLAKE DATABASE ACCOUNT - PASSWORD AUTHENTICATION
# ============================================================================

# Account payload file name
SNOWFLAKE_ACCOUNT_PAYLOAD_FILE_NAME=acc_snowflake_s3_db.json

# Account Label
SNOWFLAKE_ACCOUNT_NAME=SNOWFLAKE_acct

# Connection Configuration
SNOWFLAKE_HOSTNAME=your_account.snowflakecomputing.com

# Authentication
SNOWFLAKE_USERNAME=your_username
SNOWFLAKE_PASSWORD=your_password

# Database Configuration
SNOWFLAKE_DATABASE=YOUR_DB
SNOWFLAKE_WAREHOUSE=YOUR_WH
SNOWFLAKE_SCHEMA=PUBLIC
SNOWFLAKE_ROLE=SYSADMIN

File 3: Robot Test File — test/suite/pipeline_tests/snowflake/snowflake_account_setup.robot

*** Settings ***
Documentation    Creates Snowflake account(s) in SnapLogic for pipeline testing
...              Uses JSON payload templates with Jinja variable substitution
Resource         snaplogic_common_robot/snaplogic_apis_keywords/snaplogic_keywords.resource
Resource         ../../resources/common/general.resource
Library          Collections

*** Test Cases ***
Create Snowflake Account
    [Documentation]    Creates a Snowflake account using password authentication.
    [Tags]    snowflake    account_setup
    [Template]    Create Account From Template
    ${ACCOUNT_LOCATION_PATH}    ${SNOWFLAKE_ACCOUNT_PAYLOAD_FILE_NAME}    ${SNOWFLAKE_ACCOUNT_NAME}    overwrite_if_exists=${TRUE}

File 4: README — test/suite/pipeline_tests/snowflake/ACCOUNT_SETUP_README.md

# Snowflake Account Creation Tests

To create account-related test cases, you need 3 files:
- **Account payload file** — JSON template with Jinja variable placeholders for SnapLogic account configuration
- **Environment file** — Contains the environment variables referenced in the payload file
- **Test case file** — Robot Framework test that uses `Create Account From Template` to create the account

## Purpose
Creates Snowflake database account(s) in SnapLogic for pipeline testing.

## File Structure
```
project-root/
├── test/
│   └── suite/
│       ├── pipeline_tests/
│       │   └── snowflake/
│       │       ├── snowflake_account_setup.robot          ← Test case file
│       │       └── ACCOUNT_SETUP_README.md                ← This file
│       └── test_data/
│           └── accounts_payload/
│               └── acc_snowflake_s3_db.json               ← Account payload file
├── env_files/
│   └── database_accounts/
│       └── .env.snowflake                                 ← Environment file
└── .env                                                   ← Override credentials here
```

## Prerequisites
Configure in `env_files/database_accounts/.env.snowflake` or override in root `.env`:
- `SNOWFLAKE_HOSTNAME` — Snowflake account URL
- `SNOWFLAKE_USERNAME` — Database username
- `SNOWFLAKE_PASSWORD` — Database password
- `SNOWFLAKE_DATABASE` — Target database name
- `SNOWFLAKE_WAREHOUSE` — Compute warehouse

## How to Run
```bash
make robot-run-all-tests TAGS="snowflake" PROJECT_SPACE_SETUP=True
```

Claude: The above is a COMPLETE example. When creating account test cases for ANY account type, follow the same pattern — always create all 4 files. Never create just the .robot file alone.

Example: Reading the Snowflake Key Pair Env File

When user asks for Snowflake Key Pair account, first read env_files/database_accounts/.env.snowflake_s3_keypair:

# ============================================================================
#                      SNOWFLAKE DATABASE ACCOUNT - KEY PAIR AUTHENTICATION
# ============================================================================

# Account payload file name
SNOWFLAKE_ACCOUNT_PAYLOAD_KEY_PAIR_FILE_NAME=acc_snowflake_s3_keypair.json

# Account Label
SNOWFLAKE_KEYPAIR_ACCOUNT_NAME=SNOWFLAKE_KEYPAIR_acct

# Authentication Configuration
SNOWFLAKE_KEYPAIR_AUTHENTICATION_TYPE=Key Pair
SNOWFLAKE_KEYPAIR_USERNAME=your_username
# SNOWFLAKE_KEYPAIR_PRIVATE_KEY=-----BEGIN ENCRYPTED PRIVATE KEY-----...
# SNOWFLAKE_KEYPAIR_PRIVATE_KEY_PASSPHRASE=

# Connection Configuration
SNOWFLAKE_KEYPAIR_HOSTNAME=your_account.snowflakecomputing.com
SNOWFLAKE_ACCOUNT_IDENTIFIER=your_account

# Database Configuration
SNOWFLAKE_KEYPAIR_DATABASE=YOUR_DB
SNOWFLAKE_KEYPAIR_WAREHOUSE=YOUR_WH
SNOWFLAKE_KEYPAIR_SCHEMA=
SNOWFLAKE_KEYPAIR_ROLE=SYSADMIN

# S3 Configuration (External Stages)
SNOWFLAKE_KEYPAIR_S3_BUCKET=
SNOWFLAKE_KEYPAIR_S3_ACCESS_KEY_ID=
SNOWFLAKE_KEYPAIR_S3_SECRET_KEY=

From this, you know:

• Use ${SNOWFLAKE_ACCOUNT_PAYLOAD_KEY_PAIR_FILE_NAME} for the payload file
• Use ${SNOWFLAKE_KEYPAIR_ACCOUNT_NAME} for the account name
• User needs to update: hostname, username, private key, database, warehouse, and optionally S3 settings

How Account Creation Works

┌─────────────────────┐     ┌─────────────────────┐     ┌─────────────────────┐
│   Environment       │     │   Payload Template  │     │   SnapLogic API     │
│   Variables         │     │   (JSON with Jinja) │     │   Account Creation  │
│   (.env files)      │     │                     │     │                     │
└──────────┬──────────┘     └──────────┬──────────┘     └──────────┬──────────┘
           │                           │                           │
           │  POSTGRES_HOST=...        │  "hostname": "{{...}}"    │
           │  POSTGRES_USER=...        │  "username": "{{...}}"    │
           │  POSTGRES_PASSWORD=...    │  "password": "{{...}}"    │
           │                           │                           │
           └───────────────┬───────────┘                           │
                           │                                       │
                           ▼                                       │
                ┌─────────────────────┐                           │
                │   Variable          │                           │
                │   Substitution      │                           │
                │   (Jinja Rendering) │                           │
                └──────────┬──────────┘                           │
                           │                                       │
                           │  Final JSON with                      │
                           │  actual values                        │
                           │                                       │
                           └───────────────────────────────────────┘
                                           │
                                           ▼
                                ┌─────────────────────┐
                                │   Account Created   │
                                │   in SnapLogic      │
                                └─────────────────────┘

Supported Account Types

File Locations

Account Payload Files

test/suite/test_data/
├── accounts_payload/                    # JSON payload templates
│   ├── acc_postgres.json
│   ├── acc_mysql.json
│   ├── acc_oracle.json
│   ├── acc_sqlserver.json
│   ├── acc_snowflake_s3_db.json
│   ├── acc_snowflake_s3_keypair.json
│   ├── acc_db2.json
│   ├── acc_teradata.json
│   ├── acc_kafka.json
│   ├── acc_jms.json
│   ├── acc_s3.json
│   ├── acc_email.json
│   └── acc_salesforce.json
│
└── accounts_jar_files/                  # JDBC drivers (if required)
    ├── db2/
    ├── mysql/
    ├── jms/
    └── teradata/

Environment Files

env_files/
├── database_accounts/                   # Database credentials
│   ├── .env.postgres
│   ├── .env.mysql
│   ├── .env.oracle
│   ├── .env.sqlserver
│   ├── .env.snowflake
│   ├── .env.snowflake_s3_keypair
│   ├── .env.db2
│   └── .env.teradata
│
├── messaging_service_accounts/          # Messaging services
│   ├── .env.kafka
│   └── .env.jms
│
└── mock_service_accounts/               # Mock/cloud services
    ├── .env.s3
    ├── .env.salesforce
    └── .env.email

Test Case Examples by Account Type

Database Accounts

Oracle Account

Create Oracle Account
    [Documentation]    Creates an Oracle database account in SnapLogic.
    [Tags]    oracle    account_setup
    [Template]    Create Account From Template
    ${ACCOUNT_LOCATION_PATH}    ${ORACLE_ACCOUNT_PAYLOAD_FILE_NAME}    ${ORACLE_ACCOUNT_NAME}    overwrite_if_exists=${TRUE}

PostgreSQL Account

Create PostgreSQL Account
    [Documentation]    Creates a PostgreSQL database account in SnapLogic.
    [Tags]    postgres    account_setup
    [Template]    Create Account From Template
    ${ACCOUNT_LOCATION_PATH}    ${POSTGRES_ACCOUNT_PAYLOAD_FILE_NAME}    ${POSTGRES_ACCOUNT_NAME}    overwrite_if_exists=${TRUE}

MySQL Account

Create MySQL Account
    [Documentation]    Creates a MySQL database account in SnapLogic.
    ...    Note: Requires JAR file upload for JDBC driver.
    [Tags]    mysql    account_setup
    [Template]    Create Account From Template
    ${ACCOUNT_LOCATION_PATH}    ${MYSQL_ACCOUNT_PAYLOAD_FILE_NAME}    ${MYSQL_ACCOUNT_NAME}    overwrite_if_exists=${TRUE}

SQL Server Account

Create SQL Server Account
    [Documentation]    Creates a SQL Server database account in SnapLogic.
    [Tags]    sqlserver    account_setup
    [Template]    Create Account From Template
    ${ACCOUNT_LOCATION_PATH}    ${SQLSERVER_ACCOUNT_PAYLOAD_FILE_NAME}    ${SQLSERVER_ACCOUNT_NAME}    overwrite_if_exists=${TRUE}

Snowflake Account (Password Auth)

Create Snowflake Account
    [Documentation]    Creates a Snowflake account using password authentication.
    [Tags]    snowflake    account_setup
    [Template]    Create Account From Template
    ${ACCOUNT_LOCATION_PATH}    ${SNOWFLAKE_ACCOUNT_PAYLOAD_FILE_NAME}    ${SNOWFLAKE_ACCOUNT_NAME}    overwrite_if_exists=${TRUE}

Snowflake Account (Key Pair Auth)

Create Snowflake Key Pair Account
    [Documentation]    Creates a Snowflake account using key pair authentication.
    ...    Requires private key and passphrase configuration.
    [Tags]    snowflake    account_setup    keypair
    [Template]    Create Account From Template
    ${ACCOUNT_LOCATION_PATH}    ${SNOWFLAKE_ACCOUNT_PAYLOAD_KEY_PAIR_FILE_NAME}    ${SNOWFLAKE_KEYPAIR_ACCOUNT_NAME}    overwrite_if_exists=${TRUE}

Messaging Accounts

Kafka Account

Create Kafka Account
    [Documentation]    Creates a Kafka messaging account in SnapLogic.
    [Tags]    kafka    account_setup    messaging
    [Template]    Create Account From Template
    ${ACCOUNT_LOCATION_PATH}    ${KAFKA_ACCOUNT_PAYLOAD_FILE_NAME}    ${KAFKA_ACCOUNT_NAME}    overwrite_if_exists=${TRUE}

JMS Account

Create JMS Account
    [Documentation]    Creates a JMS (ActiveMQ) account in SnapLogic.
    ...    Note: Requires JAR file upload for JMS driver.
    [Tags]    jms    account_setup    messaging
    [Template]    Create Account From Template
    ${ACCOUNT_LOCATION_PATH}    ${JMS_ACCOUNT_PAYLOAD_FILE_NAME}    ${JMS_ACCOUNT_NAME}    overwrite_if_exists=${TRUE}

Mock/Cloud Service Accounts

S3 / MinIO Account

Create S3 Account
    [Documentation]    Creates an S3/MinIO account in SnapLogic.
    [Tags]    s3    minio    account_setup
    [Template]    Create Account From Template
    ${ACCOUNT_LOCATION_PATH}    ${S3_ACCOUNT_PAYLOAD_FILE_NAME}    ${S3_ACCOUNT_NAME}    overwrite_if_exists=${TRUE}

Email Account

Create Email Account
    [Documentation]    Creates an Email account in SnapLogic.
    [Tags]    email    account_setup
    [Template]    Create Account From Template
    ${ACCOUNT_LOCATION_PATH}    ${EMAIL_ACCOUNT_PAYLOAD_FILE_NAME}    ${EMAIL_ACCOUNT_NAME}    overwrite_if_exists=${TRUE}

Salesforce Account

Create Salesforce Account
    [Documentation]    Creates a Salesforce account in SnapLogic.
    [Tags]    salesforce    account_setup
    [Template]    Create Account From Template
    ${ACCOUNT_LOCATION_PATH}    ${SALESFORCE_ACCOUNT_PAYLOAD_FILE_NAME}    ${SALESFORCE_ACCOUNT_NAME}    overwrite_if_exists=${TRUE}

Template Keyword Arguments

Creating Multiple Accounts in One Test Suite

*** Settings ***
Documentation    Creates all required accounts for end-to-end testing
Resource         ../../resources/common/general.resource

*** Test Cases ***
Create Oracle Account
    [Tags]    oracle    account_setup
    [Template]    Create Account From Template
    ${ACCOUNT_LOCATION_PATH}    ${ORACLE_ACCOUNT_PAYLOAD_FILE_NAME}    ${ORACLE_ACCOUNT_NAME}    overwrite_if_exists=${TRUE}

Create Snowflake Account
    [Tags]    snowflake    account_setup
    [Template]    Create Account From Template
    ${ACCOUNT_LOCATION_PATH}    ${SNOWFLAKE_ACCOUNT_PAYLOAD_KEY_PAIR_FILE_NAME}    ${SNOWFLAKE_KEYPAIR_ACCOUNT_NAME}    overwrite_if_exists=${TRUE}

Create S3 Account
    [Tags]    s3    account_setup
    [Template]    Create Account From Template
    ${ACCOUNT_LOCATION_PATH}    ${S3_ACCOUNT_PAYLOAD_FILE_NAME}    ${S3_ACCOUNT_NAME}    overwrite_if_exists=${TRUE}

Usage Scenarios

Scenario 1: Using Dockerized Services (Default)

No changes needed — credentials in env_files/ are pre-configured for local Docker containers. Hostnames use Docker container names (e.g., sqlserver-db, oracle-db) because the Groundplex runs on the same snaplogicnet bridge network.

# Start Docker services
make start-services

# Run tests - uses default Docker credentials and container hostnames
make robot-run-all-tests TAGS="oracle"

IMPORTANT: Do NOT change hostnames to host.docker.internal or localhost. The Groundplex container communicates with service containers via Docker's internal DNS using container names.

Scenario 2: Overriding Database Name Only

If you need a different database than the Docker default (e.g., SnapLogicTest instead of master for SQL Server), override only the database variable in root .env:

# In root .env - override only what's different from Docker defaults
SQLSERVER_DATABASE=SnapLogicTest

The hostname (sqlserver-db) stays as the Docker container name — do NOT override it.

Scenario 3: Using Your Own External Credentials

Copy variables to root .env file and update with your values:

# Copy from env_files/database_accounts/.env.snowflake to root .env:
SNOWFLAKE_KEYPAIR_ACCOUNT_NAME=my_production_snowflake
SNOWFLAKE_KEYPAIR_HOSTNAME=mycompany.snowflakecomputing.com
SNOWFLAKE_KEYPAIR_USERNAME=my_username
SNOWFLAKE_KEYPAIR_DATABASE=PRODUCTION_DB
SNOWFLAKE_KEYPAIR_WAREHOUSE=COMPUTE_WH
SNOWFLAKE_KEYPAIR_PRIVATE_KEY=-----BEGIN ENCRYPTED PRIVATE KEY-----...
SNOWFLAKE_KEYPAIR_PRIVATE_KEY_PASSPHRASE=your_passphrase

Note: You don't need to copy the *_PAYLOAD_FILE_NAME variable — the payload template structure doesn't change.

Adding a New Account Type

Step 1: Create Payload Template

1. Create a new JSON file in test/suite/test_data/accounts_payload/
2. Use SnapLogic's account export feature to get the base structure
3. Replace hardcoded values with Jinja variables: {{VARIABLE_NAME}}
4. Name the file: acc_[account_type].json

Step 2: Create Environment File

1. Create .env.[account_type] in appropriate env_files/ subdirectory
2. Define all variables used in the payload template
3. Include a reference to the payload file name

Step 3: Add JAR Files (if needed)

1. Create subdirectory in accounts_jar_files/
2. Add required JDBC driver JAR files
3. Update payload template to reference the JAR location

Step 4: Create Test Case

Create New Account Type
    [Documentation]    Creates a [NewType] account in SnapLogic.
    [Tags]    newtype    account_setup
    [Template]    Create Account From Template
    ${ACCOUNT_LOCATION_PATH}    ${NEWTYPE_ACCOUNT_PAYLOAD_FILE_NAME}    ${NEWTYPE_ACCOUNT_NAME}    overwrite_if_exists=${TRUE}

MANDATORY: ACCOUNT_SETUP_README.md with File Structure

IMPORTANT: Every time you create account test cases, you MUST also create an ACCOUNT_SETUP_README.md in the same directory with a file structure diagram.

This is required for ALL account types — both supported (Oracle, Snowflake, PostgreSQL, etc.) and new/unsupported types. No exceptions.

What to Include in the README

1. Purpose — Brief description of what the test suite does
2. File Structure — A tree diagram showing all related files (test files, payload files, env files, JAR files if applicable)
3. Prerequisites — Environment variables that need to be configured
4. How to Run — The make command to execute the tests

README Template

# [Account Type] Account Creation Tests

To create account-related test cases, you need 3 files:
- **Account payload file** — JSON template with Jinja variable placeholders for SnapLogic account configuration
- **Environment file** — Contains the environment variables referenced in the payload file
- **Test case file** — Robot Framework test that uses `Create Account From Template` to create the account

## Purpose
Creates [Account Type] account(s) in SnapLogic for pipeline testing.

## File Structure
```
project-root/
├── test/
│   └── suite/
│       ├── pipeline_tests/
│       │   └── [account_type]/
│       │       ├── [account_type]_account_setup.robot    ← Test case file
│       │       └── ACCOUNT_SETUP_README.md                ← This file
│       └── test_data/
│           └── accounts_payload/
│               └── acc_[account_type].json                ← Account payload file
├── env_files/
│   └── [category]_accounts/
│       └── .env.[account_type]                            ← Environment file
└── .env                                                   ← Override credentials here
```

## Prerequisites
Configure the following environment variables in `env_files/[category]_accounts/.env.[account_type]` or override in root `.env`:
- `[ACCOUNT_TYPE]_HOSTNAME` — Database/service hostname
- `[ACCOUNT_TYPE]_USERNAME` — Authentication username
- `[ACCOUNT_TYPE]_PASSWORD` — Authentication password
- *(list all relevant variables)*

## How to Run
```bash
make robot-run-all-tests TAGS="[account_type]" PROJECT_SPACE_SETUP=True
```

Example: Snowflake README

# Snowflake Account Creation Tests

To create account-related test cases, you need 3 files:
- **Account payload file** — JSON template with Jinja variable placeholders for SnapLogic account configuration
- **Environment file** — Contains the environment variables referenced in the payload file
- **Test case file** — Robot Framework test that uses `Create Account From Template` to create the account

## Purpose
Creates Snowflake database account(s) in SnapLogic for pipeline testing.

## File Structure
```
project-root/
├── test/
│   └── suite/
│       ├── pipeline_tests/
│       │   └── snowflake/
│       │       ├── snowflake_account_setup.robot          ← Test case file
│       │       └── ACCOUNT

…(truncated)