create-account

Compare original and translation side by side

🇺🇸

Original

English

🇨🇳

Translation

Chinese

Create Account Test Case Guide

账户测试用例创建指南

Claude Instructions

Claude 使用说明

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: When creating account test cases (for ANY account type — supported or new), you MUST call the Write tool to create ALL 4 files. Do NOT read files to check if they exist first. Do NOT say "file already exists" or "already complete". Always write them fresh:

Payload file (

acc_[type].json

) in

test/suite/test_data/accounts_payload/

— WRITE this

Env file (

.env.[type]

) in

env_files/[category]_accounts/

— WRITE this

Robot test file (
```
.robot
```
) in
```
test/suite/pipeline_tests/[type]/
```
— WRITE this
ACCOUNT_SETUP_README.md with file structure tree diagram in the same test directory — WRITE this

This applies to ALL account types — both supported and new/unsupported types. No exceptions. You must call Write exactly 4 times. See the "IMPORTANT: Step-by-Step Workflow" section for details.

Response format for simple questions:

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

重要说明: 当用户提出类似“如何创建Oracle账户？”这类简单问题时，请先提供简洁的答案，仅包含模板/命令，然后视情况询问用户是否需要更多说明。请勿直接输出全部文档内容。

强制要求: 创建账户测试用例时（无论账户类型是否受支持），必须调用Write工具创建全部4个文件。请勿先读取文件检查是否存在，请勿提及“文件已存在”或“已完成”，始终重新生成文件：

Payload文件 (

acc_[type].json

) 存放于

test/suite/test_data/accounts_payload/

—— 必须创建

环境配置文件 (
```
.env.[type]
```
) 存放于
```
env_files/[category]_accounts/
```
—— 必须创建
Robot测试文件 (
```
.robot
```
) 存放于
```
test/suite/pipeline_tests/[type]/
```
—— 必须创建
ACCOUNT_SETUP_README.md 包含文件结构树状图，存放在对应测试目录下 —— 必须创建

此要求适用于所有账户类型，包括已支持和新增/未支持的类型，无例外情况。必须调用Write工具恰好4次。详细步骤请查看“重要说明：分步工作流”章节。

简单问题的回复格式:

先给出直接的模板或测试用例
如有需要添加简短说明
仅在合适时询问“需要我进一步解释吗？”

WHEN USER INVOKES

/create-account

WITH NO ARGUMENTS

当用户仅调用

/create-account

无参数时

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:

Sample Prompt	What It Does
`Create an Oracle account test case`	Generates all 4 files: payload, env, .robot, and README
`What environment variables do I need for Snowflake?`	Shows required env vars and which files to update
`I need PostgreSQL and S3 accounts for my pipeline`	Creates the complete file set for multiple account types
`Show me the baseline test for Postgres`	Displays existing reference test as an example
`Help me add support for CockroachDB account`	Generates all files for a new/custom account type
`Create a Cassandra account test case`	Generates payload, env file, robot test, and README from scratch

Claude操作要求: 当用户仅输入

/create-account

无具体请求时，请展示以下菜单，必须严格使用此格式：

SnapLogic 账户创建工具

功能说明

针对每种账户类型，我会创建所需的完整文件集：

Payload文件 (
```
acc_[type].json
```
) —— 包含Jinja变量占位符的JSON模板
环境配置文件 (
```
.env.[type]
```
) —— 所有必填的环境变量
Robot测试文件 (
```
.robot
```
) —— 使用
```
Create Account From Template
```
的Robot Framework测试用例
ACCOUNT_SETUP_README.md —— 文件结构示意图、前置条件及运行说明

我还可以：

展示任意账户类型所需的环境变量
解释Payload模板及配置方式
指导添加新的账户类型

支持的账户类型

数据库类:

oracle

postgres

mysql

sqlserver

snowflake

snowflake-keypair

db2

teradata

消息服务类:
```
kafka
```
,
```
jms
```
云服务类:
```
s3
```
,
```
email
```
,
```
salesforce
```
新增/自定义类型: 不在上述列表中的类型也支持 —— 我可以为任意账户类型（如CockroachDB、Cassandra、MongoDB等）创建完整的文件集：Payload模板、环境配置文件、Robot测试用例及README文档。

示例指令参考:

示例指令	功能说明
`Create an Oracle account test case`	生成全部4个文件：Payload、环境配置、.robot及README
`What environment variables do I need for Snowflake?`	展示所需环境变量及对应的文件位置
`I need PostgreSQL and S3 accounts for my pipeline`	为多种账户类型创建完整文件集
`Show me the baseline test for Postgres`	展示现有参考测试用例示例
`Help me add support for CockroachDB account`	为新增/自定义账户类型生成全部文件
`Create a Cassandra account test case`	从头生成Payload、环境配置文件、Robot测试用例及README

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

无需使用特殊语法，只需在

/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

/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?

基准测试参考文件:

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

支持的账户类型

Type	Description
`oracle`	Oracle Database
`postgres`	PostgreSQL Database
`mysql`	MySQL Database
`sqlserver`	SQL Server Database
`snowflake`	Snowflake (Password Auth)
`snowflake-keypair`	Snowflake (Key Pair Auth)
`db2`	IBM DB2
`teradata`	Teradata
`kafka`	Apache Kafka
`jms`	JMS/ActiveMQ
`s3`	AWS S3 / MinIO
`email`	Email/SMTP
`salesforce`	Salesforce

类型	描述
`oracle`	Oracle数据库
`postgres`	PostgreSQL数据库
`mysql`	MySQL数据库
`sqlserver`	SQL Server数据库
`snowflake`	Snowflake（密码认证）
`snowflake-keypair`	Snowflake（密钥对认证）
`db2`	IBM DB2
`teradata`	Teradata
`kafka`	Apache Kafka
`jms`	JMS/ActiveMQ
`s3`	AWS S3 / MinIO
`email`	Email/SMTP
`salesforce`	Salesforce

Account Files Reference

账户文件参考

Account Type	Payload File	Env File
PostgreSQL	`acc_postgres.json`	`env_files/database_accounts/.env.postgres`
MySQL	`acc_mysql.json`	`env_files/database_accounts/.env.mysql`
Oracle	`acc_oracle.json`	`env_files/database_accounts/.env.oracle`
SQL Server	`acc_sqlserver.json`	`env_files/database_accounts/.env.sqlserver`
Snowflake	`acc_snowflake_s3_db.json`	`env_files/database_accounts/.env.snowflake`
Snowflake (Key Pair)	`acc_snowflake_s3_keypair.json`	`env_files/database_accounts/.env.snowflake_s3_keypair`
DB2	`acc_db2.json`	`env_files/database_accounts/.env.db2`
Teradata	`acc_teradata.json`	`env_files/database_accounts/.env.teradata`
Kafka	`acc_kafka.json`	`env_files/messaging_service_accounts/.env.kafka`
JMS	`acc_jms.json`	`env_files/messaging_service_accounts/.env.jms`
S3 / MinIO	`acc_s3.json`	`env_files/mock_service_accounts/.env.s3`
Email	`acc_email.json`	`env_files/mock_service_accounts/.env.email`
Salesforce	`acc_salesforce.json`	`env_files/mock_service_accounts/.env.salesforce`

账户类型	Payload文件	环境配置文件
PostgreSQL	`acc_postgres.json`	`env_files/database_accounts/.env.postgres`
MySQL	`acc_mysql.json`	`env_files/database_accounts/.env.mysql`
Oracle	`acc_oracle.json`	`env_files/database_accounts/.env.oracle`
SQL Server	`acc_sqlserver.json`	`env_files/database_accounts/.env.sqlserver`
Snowflake	`acc_snowflake_s3_db.json`	`env_files/database_accounts/.env.snowflake`
Snowflake（密钥对）	`acc_snowflake_s3_keypair.json`	`env_files/database_accounts/.env.snowflake_s3_keypair`
DB2	`acc_db2.json`	`env_files/database_accounts/.env.db2`
Teradata	`acc_teradata.json`	`env_files/database_accounts/.env.teradata`
Kafka	`acc_kafka.json`	`env_files/messaging_service_accounts/.env.kafka`
JMS	`acc_jms.json`	`env_files/messaging_service_accounts/.env.jms`
S3 / MinIO	`acc_s3.json`	`env_files/mock_service_accounts/.env.s3`
Email	`acc_email.json`	`env_files/mock_service_accounts/.env.email`
Salesforce	`acc_salesforce.json`	`env_files/mock_service_accounts/.env.salesforce`

Environment Variable Setup

环境变量配置

Case 1: Using Docker Services (Local Testing)

场景1：使用Docker服务（本地测试）

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

Use the default credentials from the respective file in
```
env_files/
```
No changes needed - the values are pre-configured for Docker containers
Just run the tests:
```
make robot-run-tests TAGS="oracle"
```

如果是为Docker启动的服务（Oracle、PostgreSQL、MySQL、Kafka、MinIO等）创建账户：

使用
env_files/
目录下对应文件的默认凭据
无需修改——所有值已针对Docker容器预配置
直接运行测试：
```
make robot-run-tests TAGS="oracle"
```

Case 2: Using External/Your Own Instance

场景2：使用外部/自有实例

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

Read the env file to understand the required variables:
```
env_files/database_accounts/.env.snowflake
```

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

bash

# 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

Update the values with your actual credentials

Do NOT copy the payload file variable - it remains constant:

bash

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

如果使用自有外部实例（如公司的Snowflake、生产数据库等）：

读取环境配置文件了解所需变量：
```
env_files/database_accounts/.env.snowflake
```

将变量复制到根目录的
.env
文件（不是

env_files/

下的文件）：

bash

# 将以下内容复制到根目录的.env文件中：
SNOWFLAKE_HOSTNAME=your-account.snowflakecomputing.com
SNOWFLAKE_USERNAME=your_username
SNOWFLAKE_PASSWORD=your_password
SNOWFLAKE_DATABASE=YOUR_DB
SNOWFLAKE_WAREHOUSE=YOUR_WH

更新为实际凭据值

请勿复制Payload文件变量——此值保持不变：

bash

# 请勿复制此内容到.env——保留在env_files/目录下
SNOWFLAKE_ACCOUNT_PAYLOAD_FILE_NAME=acc_snowflake_s3_db.json

Why This Works

配置原理

Root
```
.env
```
file is loaded last and overrides everything
```
env_files/
```
contains default Docker values
Payload file names never change - they reference JSON templates

根目录的
```
.env
```
文件最后加载，会覆盖所有其他配置
```
env_files/
```
目录下是Docker环境的默认值
Payload文件名不会变化——始终指向JSON模板

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.

你正在协助用户创建用于在SnapLogic中创建账户的Robot Framework测试用例。请遵循以下基于账户创建框架的约定和模式。

How to Use This Command

命令使用方法

Invoking the Command

调用命令

In Claude Code, type:

/create-account

Then add your specific request after the command.

在Claude Code中输入：

/create-account

然后在命令后添加具体需求。

Example Prompts

示例指令

Create a specific account type:

创建特定账户类型：

/create-account

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

/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

/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.

/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-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?

/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?

/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.

/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

/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

robotframework

*** 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 ***

以下是创建账户的基础测试用例模板：

重要说明：必填依赖库 创建任何新的Robot文件时，必须在
*** Settings ***
下添加以下两个Resource导入：
snaplogic_common_robot/snaplogic_apis_keywords/snaplogic_keywords.resource
- 来自已安装包的SnapLogic API关键字
../../resources/common/general.resource
- 项目通用关键字

robotframework

*** 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}

undefined

${account_name} ${POSTGRES_ACCOUNT_NAME}

undefined

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:

#	File	Location	Purpose
1	Payload file	`test/suite/test_data/accounts_payload/acc_[type].json`	JSON template with Jinja variables
2	Env file	`env_files/[category]_accounts/.env.[type]`	Environment variables for the payload
3	Robot test file	`test/suite/pipeline_tests/[type]/[type]_account_setup.robot`	Robot Framework test case
4	ACCOUNT_SETUP_README.md	`test/suite/pipeline_tests/[type]/ACCOUNT_SETUP_README.md`	File structure diagram and instructions

ALWAYS create all 4 files using the Write tool. There are NO exceptions — not for supported account types, not for new ones. Even if a file already exists, you MUST still use the Write tool to create/overwrite it. Do NOT skip any file. Do NOT say "file already exists" or "marking it complete" — actually write the file content.

CRITICAL: Do NOT read files to check if they exist first. Do NOT skip writing a file because it already exists. Always use the Write tool to create every file, every time.

创建账户测试用例时请始终遵循此工作流。

强制要求：对于所有账户类型（已支持或新增类型），必须创建以下全部文件：

序号	文件	位置	用途
1	Payload文件	`test/suite/test_data/accounts_payload/acc_[type].json`	包含Jinja变量的JSON模板
2	环境配置文件	`env_files/[category]_accounts/.env.[type]`	Payload对应的环境变量
3	Robot测试文件	`test/suite/pipeline_tests/[type]/[type]_account_setup.robot`	Robot Framework测试用例
4	ACCOUNT_SETUP_README.md	`test/suite/pipeline_tests/[type]/ACCOUNT_SETUP_README.md`	文件结构示意图及说明文档

必须始终使用Write工具创建这4个文件。 无例外情况——无论账户类型是否已支持，即使文件已存在，也必须使用Write工具重新创建/覆盖。请勿跳过任何文件，请勿提及“文件已存在”或“标记为完成”——必须实际写入文件内容。

关键要求：请勿先读取文件检查是否存在。请勿因文件已存在而跳过写入步骤。每次都必须使用Write工具创建所有文件。

Step 1: Identify the Account Type

步骤1：确定账户类型

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

根据数据管道需求确定所需的账户类型。

Step 2: Create the Payload File (ALWAYS — use Write tool)

步骤2：创建Payload文件（必须——使用Write工具）

ALWAYS use the Write tool to create

test/suite/test_data/accounts_payload/acc_[type].json

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
Do NOT check if the file exists. Do NOT skip. Use Write tool to create the file.

必须使用Write工具创建

test/suite/test_data/accounts_payload/acc_[type].json

。

使用包含Jinja变量占位符（如
```
{{VARIABLE_NAME}}
```
）的SnapLogic账户JSON结构
对于已支持的类型，使用参考章节中的已知Payload结构
对于新增类型，根据账户类型的典型配置创建JSON结构
请勿检查文件是否存在。请勿跳过。必须使用Write工具创建文件。

Step 3: Create the Environment File (ALWAYS — use Write tool)

步骤3：创建环境配置文件（必须——使用Write工具）

ALWAYS use the Write tool to create the corresponding

.env.[type]

file in

env_files/

Include all variables referenced in the payload file
Include payload file name, account name, connection details, and authentication variables
Do NOT check if the file exists. Do NOT skip. Use Write tool to create the file.

Account Type	Env File Location
Oracle	`env_files/database_accounts/.env.oracle`
PostgreSQL	`env_files/database_accounts/.env.postgres`
MySQL	`env_files/database_accounts/.env.mysql`
SQL Server	`env_files/database_accounts/.env.sqlserver`
Snowflake (Password)	`env_files/database_accounts/.env.snowflake`
Snowflake (Key Pair)	`env_files/database_accounts/.env.snowflake_s3_keypair`
DB2	`env_files/database_accounts/.env.db2`
Teradata	`env_files/database_accounts/.env.teradata`
Kafka	`env_files/messaging_service_accounts/.env.kafka`
JMS	`env_files/messaging_service_accounts/.env.jms`
S3 / MinIO	`env_files/mock_service_accounts/.env.s3`
Email	`env_files/mock_service_accounts/.env.email`
Salesforce	`env_files/mock_service_accounts/.env.salesforce`

必须使用Write工具在

env_files/

目录下创建对应的

.env.[type]

文件。

包含Payload文件中引用的所有变量
包含Payload文件名、账户名、连接详情及认证变量
请勿检查文件是否存在。请勿跳过。必须使用Write工具创建文件。

账户类型	环境配置文件位置
Oracle	`env_files/database_accounts/.env.oracle`
PostgreSQL	`env_files/database_accounts/.env.postgres`
MySQL	`env_files/database_accounts/.env.mysql`
SQL Server	`env_files/database_accounts/.env.sqlserver`
Snowflake（密码认证）	`env_files/database_accounts/.env.snowflake`
Snowflake（密钥对认证）	`env_files/database_accounts/.env.snowflake_s3_keypair`
DB2	`env_files/database_accounts/.env.db2`
Teradata	`env_files/database_accounts/.env.teradata`
Kafka	`env_files/messaging_service_accounts/.env.kafka`
JMS	`env_files/messaging_service_accounts/.env.jms`
S3 / MinIO	`env_files/mock_service_accounts/.env.s3`
Email	`env_files/mock_service_accounts/.env.email`
Salesforce	`env_files/mock_service_accounts/.env.salesforce`

Step 4: Understand the Variables

步骤4：理解变量含义

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.)

环境配置文件包含以下信息：

```
*_PAYLOAD_FILE_NAME
```
- JSON模板文件名
```
*_ACCOUNT_NAME
```
- 在SnapLogic中显示的账户名
连接详情（主机名、端口、数据库等）
认证信息（用户名、密码或密钥对）
可选配置（S3 staging、URL属性等）

Step 5: Update Variable Values

步骤5：更新变量值

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)

选项A： 直接编辑环境配置文件（适用于Docker/非敏感值） 选项B： 将变量复制到根目录

.env

文件（适用于生产/敏感凭据——根目录

.env

会覆盖所有配置）

Step 6: Create the Robot Test Case (ALWAYS — use Write tool)

步骤6：创建Robot测试用例（必须——使用Write工具）

ALWAYS use the Write tool to create the

.robot

test file in

test/suite/pipeline_tests/[type]/

. Do NOT skip this step. Do NOT check if it exists first.

必须使用Write工具在

test/suite/pipeline_tests/[type]/

目录下创建

.robot

测试文件。请勿跳过此步骤，请勿先检查文件是否存在。

Step 7: Create ACCOUNT_SETUP_README.md with File Structure (ALWAYS — use Write tool)

步骤7：创建带文件结构的ACCOUNT_SETUP_README.md（必须——使用Write工具）

ALWAYS use the Write tool to create an ACCOUNT_SETUP_README.md in the test directory with a file structure tree diagram. See the "MANDATORY: README with File Structure" section for the template. Do NOT skip this step.

必须使用Write工具在测试目录下创建ACCOUNT_SETUP_README.md，包含文件结构树状图。请查看“强制要求：带文件结构的ACCOUNT_SETUP_README.md”章节的模板。请勿跳过此步骤。

Summary: You MUST use the Write tool to create these 4 files every time

总结：每次必须使用Write工具创建以下4个文件

1. test/suite/test_data/accounts_payload/acc_[type].json       ← WRITE this file
2. env_files/[category]_accounts/.env.[type]                   ← WRITE this file
3. test/suite/pipeline_tests/[type]/[type]_account_setup.robot ← WRITE this file
4. test/suite/pipeline_tests/[type]/ACCOUNT_SETUP_README.md     ← WRITE this file

If you did not call the Write tool exactly 4 times (once per file), you have NOT completed the task. Never say "file already exists" — always write it.

1. test/suite/test_data/accounts_payload/acc_[type].json       ← 必须创建此文件
2. env_files/[category]_accounts/.env.[type]                   ← 必须创建此文件
3. test/suite/pipeline_tests/[type]/[type]_account_setup.robot ← 必须创建此文件
4. test/suite/pipeline_tests/[type]/ACCOUNT_SETUP_README.md     ← 必须创建此文件

如果未调用Write工具恰好4次（每个文件一次），则任务未完成。永远不要说“文件已存在”——始终重新写入。

COMPLETE EXAMPLE: Snowflake Account (All 4 Files)

完整示例：Snowflake账户（全部4个文件）

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

当用户请求“Create a Snowflake account test case”时，必须创建以下全部文件：

File 1: Payload File —

test/suite/test_data/accounts_payload/acc_snowflake_s3_db.json

文件1：Payload文件 ——

test/suite/test_data/accounts_payload/acc_snowflake_s3_db.json

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}}"
          }
        }
      }
    }
  }
}

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

文件2：环境配置文件 ——

env_files/database_accounts/.env.snowflake

bash

undefined

bash

undefined

============================================================================

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

undefined

SNOWFLAKE_DATABASE=YOUR_DB SNOWFLAKE_WAREHOUSE=YOUR_WH SNOWFLAKE_SCHEMA=PUBLIC SNOWFLAKE_ROLE=SYSADMIN

undefined

File 3: Robot Test File —

test/suite/pipeline_tests/snowflake/snowflake_account_setup.robot

文件3：Robot测试文件 ——

test/suite/pipeline_tests/snowflake/snowflake_account_setup.robot

robotframework

*** 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}

robotframework

*** 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

文件4：README ——

test/suite/pipeline_tests/snowflake/ACCOUNT_SETUP_README.md

markdown

undefined

markdown

undefined

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

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

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

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.**

---

bash

make robot-run-all-tests TAGS="snowflake" PROJECT_SPACE_SETUP=True


**Claude说明：以上是完整示例。为任意账户类型创建测试用例时，请遵循相同模式——始终创建全部4个文件，不要仅创建.robot文件。**

---

Example: Reading the Snowflake Key Pair Env File

示例：读取Snowflake密钥对环境配置文件

When user asks for Snowflake Key Pair account, first read

env_files/database_accounts/.env.snowflake_s3_keypair

bash

undefined

当用户请求Snowflake密钥对账户时，先读取

env_files/database_accounts/.env.snowflake_s3_keypair

：

bash

undefined

============================================================================

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

---

SNOWFLAKE_KEYPAIR_S3_BUCKET= SNOWFLAKE_KEYPAIR_S3_ACCESS_KEY_ID= SNOWFLAKE_KEYPAIR_S3_SECRET_KEY=


从该文件中可以了解到：
- 使用`${SNOWFLAKE_ACCOUNT_PAYLOAD_KEY_PAIR_FILE_NAME}`作为Payload文件名
- 使用`${SNOWFLAKE_KEYPAIR_ACCOUNT_NAME}`作为账户名
- 用户需要更新：主机名、用户名、私钥、数据库、仓库，以及可选的S3配置

---

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      │
                                └─────────────────────┘

┌─────────────────────┐     ┌─────────────────────┐     ┌─────────────────────┐
│   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

支持的账户类型

Account Type	Payload File	Env File	JAR Required
PostgreSQL	`acc_postgres.json`	`.env.postgres`	No
MySQL	`acc_mysql.json`	`.env.mysql`	Yes
Oracle	`acc_oracle.json`	`.env.oracle`	No
SQL Server	`acc_sqlserver.json`	`.env.sqlserver`	No
Snowflake	`acc_snowflake_s3_db.json`	`.env.snowflake`	No
Snowflake (Key Pair)	`acc_snowflake_s3_keypair.json`	`.env.snowflake_s3_keypair`	No
DB2	`acc_db2.json`	`.env.db2`	Yes
Teradata	`acc_teradata.json`	`.env.teradata`	Yes
Kafka	`acc_kafka.json`	`.env.kafka`	No
JMS	`acc_jms.json`	`.env.jms`	Yes
S3 / MinIO	`acc_s3.json`	`.env.s3`	No
Email	`acc_email.json`	`.env.email`	No
Salesforce	`acc_salesforce.json`	`.env.salesforce`	No

账户类型	Payload文件	环境配置文件	是否需要JAR包
PostgreSQL	`acc_postgres.json`	`.env.postgres`	否
MySQL	`acc_mysql.json`	`.env.mysql`	是
Oracle	`acc_oracle.json`	`.env.oracle`	否
SQL Server	`acc_sqlserver.json`	`.env.sqlserver`	否
Snowflake	`acc_snowflake_s3_db.json`	`.env.snowflake`	否
Snowflake（密钥对）	`acc_snowflake_s3_keypair.json`	`.env.snowflake_s3_keypair`	否
DB2	`acc_db2.json`	`.env.db2`	是
Teradata	`acc_teradata.json`	`.env.teradata`	是
Kafka	`acc_kafka.json`	`.env.kafka`	否
JMS	`acc_jms.json`	`.env.jms`	是
S3 / MinIO	`acc_s3.json`	`.env.s3`	否
Email	`acc_email.json`	`.env.email`	否
Salesforce	`acc_salesforce.json`	`.env.salesforce`	否

File Locations

文件位置

Account Payload Files

账户Payload文件

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/

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

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

Oracle账户

robotframework

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}

robotframework

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

PostgreSQL账户

robotframework

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}

robotframework

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

MySQL账户

robotframework

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}

robotframework

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

SQL Server账户

robotframework

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}

robotframework

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)

Snowflake账户（密码认证）

robotframework

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}

robotframework

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)

Snowflake账户（密钥对认证）

robotframework

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}

robotframework

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

Kafka账户

robotframework

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}

robotframework

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

JMS账户

robotframework

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}

robotframework

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

S3 / MinIO账户

robotframework

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}

robotframework

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

Email账户

robotframework

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}

robotframework

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

Salesforce账户

robotframework

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}

robotframework

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

模板关键字参数

Argument	Description	Example
`${ACCOUNT_LOCATION_PATH}`	SnapLogic path where account will be created	`/org/project/shared`
`Payload File Name`	JSON template file from accounts_payload/	`acc_postgres.json`
`Account Name`	Name displayed in SnapLogic Manager	`postgres_acc`
`overwrite_if_exists`	Replace existing account with same name	`${TRUE}` or `${FALSE}`

参数	描述	示例
`${ACCOUNT_LOCATION_PATH}`	账户在SnapLogic中的创建路径	`/org/project/shared`
`Payload File Name`	来自accounts_payload/的JSON模板文件名	`acc_postgres.json`
`Account Name`	在SnapLogic Manager中显示的账户名	`postgres_acc`
`overwrite_if_exists`	是否覆盖已存在的同名账户	`${TRUE}` 或 `${FALSE}`

Creating Multiple Accounts in One Test Suite

在一个测试套件中创建多个账户

robotframework

*** 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}

robotframework

*** 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)

场景1：使用Docker化服务（默认）

No changes needed - credentials in

env_files/

are pre-configured for local Docker containers.

bash

undefined

无需修改——

env_files/

目录下的凭据已针对本地Docker容器预配置。

bash

undefined

Start Docker services

启动Docker服务

make start-services

Run tests - uses default Docker credentials

运行测试——使用默认Docker凭据

make robot-run-all-tests TAGS="oracle"

undefined

make robot-run-all-tests TAGS="oracle"

undefined

Scenario 2: Using Your Own External Credentials

场景2：使用自有外部凭据

Copy variables to root

.env

file and update with your values:

bash

undefined

将变量复制到根目录

.env

文件并更新为自有值：

bash

undefined

Copy from env_files/database_accounts/.env.snowflake to root .env:

从env_files/database_accounts/.env.snowflake复制到根目录.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.


**注意：** 无需复制`*_PAYLOAD_FILE_NAME`变量——Payload模板结构不会改变。

Adding a New Account Type

添加新账户类型

Step 1: Create Payload Template

步骤1：创建Payload模板

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

在
```
test/suite/test_data/accounts_payload/
```
目录下创建新的JSON文件
使用SnapLogic的账户导出功能获取基础结构
将硬编码值替换为Jinja变量：
```
{{VARIABLE_NAME}}
```
命名文件：
```
acc_[account_type].json
```

Step 2: Create Environment File

步骤2：创建环境配置文件

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

在对应
```
env_files/
```
子目录下创建
```
.env.[account_type]
```
文件
定义Payload模板中使用的所有变量
添加Payload文件名的引用

Step 3: Add JAR Files (if needed)

步骤3：添加JAR文件（如需要）

Create subdirectory in
```
accounts_jar_files/
```
Add required JDBC driver JAR files
Update payload template to reference the JAR location

在
```
accounts_jar_files/
```
目录下创建子目录
添加所需的JDBC驱动JAR文件
更新Payload模板以引用JAR文件位置

Step 4: Create Test Case

步骤4：创建测试用例

robotframework

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}

robotframework

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

强制要求：带文件结构的ACCOUNT_SETUP_README.md

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.

重要说明：每次创建账户测试用例时，必须在同一目录下创建ACCOUNT_SETUP_README.md，包含文件结构示意图。

此要求适用于所有账户类型——包括已支持的（Oracle、Snowflake、PostgreSQL等）和新增/未支持的类型，无例外情况。

What to Include in the README

README文件需包含的内容

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

用途 —— 测试套件功能的简要描述
文件结构 —— 展示所有相关文件的树状图（测试文件、Payload文件、环境配置文件，如需要还包括JAR文件）
前置条件 —— 需要配置的环境变量
运行方式 —— 执行测试的make命令

README Template

README模板

markdown

undefined

markdown

undefined

[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

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

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)

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

undefined

bash

make robot-run-all-tests TAGS="[account_type]" PROJECT_SPACE_SETUP=True

undefined

Example: Snowflake README

示例：Snowflake README

markdown

undefined

markdown

undefined

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

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               ← Password auth payload
│               └── acc_snowflake_s3_keypair.json          ← Key pair auth payload
├── env_files/
│   └── database_accounts/
│       ├── .env.snowflake                                 ← Password auth env vars
│       └── .env.snowflake_s3_keypair                      ← Key pair auth env vars
└── .env                                                   ← Override credentials here

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               ← Password auth payload
│               └── acc_snowflake_s3_keypair.json          ← Key pair auth payload
├── env_files/
│   └── database_accounts/
│       ├── .env.snowflake                                 ← Password auth env vars
│       └── .env.snowflake_s3_keypair                      ← Key pair auth env vars
└── .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

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

---

bash

make robot-run-all-tests TAGS="snowflake" PROJECT_SPACE_SETUP=True

---

Checklist Before Committing

提交前检查清单

Payload file exists in
```
accounts_payload/
```
Environment file exists in
```
env_files/
```
All Jinja variables in payload have corresponding env variables
JAR files added if required (MySQL, DB2, Teradata, JMS)
Test has appropriate tags
Documentation describes the account type
No sensitive credentials are hardcoded
ACCOUNT_SETUP_README.md created with file structure diagram

Payload文件存在于
```
accounts_payload/
```
目录
环境配置文件存在于
```
env_files/
```
目录
Payload中的所有Jinja变量都有对应的环境变量
已添加所需的JAR文件（MySQL、DB2、Teradata、JMS）
测试用例已添加合适的标签
文档已描述账户类型
无硬编码的敏感凭据
已创建包含文件结构示意图的ACCOUNT_SETUP_README.md