Infisical is the open-source platform for securing secrets, certificates, access, and AI Agents.
TypeScript acmeagentsai-agentscertificate-managementdevsecopsenvironment-variableskubernetesopen-sourcepampkipostgresprivate-caprivileged-access-managementsecret-managementsecret-managersecretssecrets-managementsecuritysecurity-toolsvault
//go:build integration
package infra
import (
"context"
"crypto/rand"
"fmt"
"log"
"testing"
"time"
"github.com/go-resty/resty/v2"
"github.com/google/uuid"
"github.com/testcontainers/testcontainers-go"
"github.com/testcontainers/testcontainers-go/wait"
"github.com/infisical/api/internal/database/pg"
)
// ProjectSeed contains IDs for a project created via the Node.js API.
type ProjectSeed struct {
ID string
Slug string
EnvSlug string
}
// IdentitySeed contains IDs for a machine identity created via the Node.js API.
type IdentitySeed struct {
ID string
Name string
}
// CustomRoleSeed contains metadata for a custom project role created via the Node.js API.
type CustomRoleSeed struct {
ID string
Slug string
Name string
}
// GroupSeed contains metadata for an org group created via the Node.js API.
type GroupSeed struct {
ID string
Name string
Slug string
}
// UserSeed contains IDs for a user created via the Node.js API.
type UserSeed struct {
ID string
Email string
Token string // JWT access token for authentication
}
// NodeJSService provides access to a running Node.js backend container
// and the bootstrapped credentials (admin user, org, machine identity).
type NodeJSService struct {
container testcontainers.Container
url string
client *resty.Client
db pg.DB
orgID string
userID string
userEmail string
identityToken string
userToken string
}
func (n *NodeJSService) URL() string { return n.url }
func (n *NodeJSService) OrgID() string { return n.orgID }
func (n *NodeJSService) UserID() string { return n.userID }
func (n *NodeJSService) UserEmail() string { return n.userEmail }
func (n *NodeJSService) IdentityToken() string { return n.identityToken }
func (n *NodeJSService) UserToken() string { return n.userToken }
func (n *NodeJSService) Client() *resty.Client { return n.client }
func startNodeJS(ctx context.Context, networkName string, files []testcontainers.ContainerFile, cmd []string) (*NodeJSService, error) {
// When a custom Cmd is provided (e.g. for patching files via sed), we need
// to run as root because the container image sets USER non-root-user which
// cannot write to root-owned paths like /backend/dist/.
user := ""
if len(cmd) > 0 {
user = "root"
}
req := testcontainers.ContainerRequest{
Image: "infisical/infisical:latest",
ExposedPorts: []string{"8080/tcp"},
Networks: []string{networkName},
NetworkAliases: map[string][]string{
networkName: {"backend-nodejs"},
},
User: user,
Env: map[string]string{
"NODE_ENV": "development",
"DB_CONNECTION_URI": fmt.Sprintf("postgres://%s:%s@db:5432/%s?sslmode=disable", pgUser, pgPassword, pgDB),
"REDIS_URL": "redis://redis:6379",
"ENCRYPTION_KEY": EncryptionKey,
"AUTH_SECRET": AuthSecret,
"SITE_URL": "http://localhost:8080",
"TELEMETRY_ENABLED": "false",
"SMTP_HOST": "",
},
Files: files,
Cmd: cmd,
WaitingFor: wait.ForHTTP("/api/status").WithPort("8080/tcp").WithStartupTimeout(120 * time.Second),
}
container, err := testcontainers.GenericContainer(ctx, testcontainers.GenericContainerRequest{
ContainerRequest: req,
Started: true,
})
if err != nil {
return nil, fmt.Errorf("starting nodejs: %w", err)
}
host, err := container.Host(ctx)
if err != nil {
return nil, fmt.Errorf("getting nodejs host: %w", err)
}
mappedPort, err := container.MappedPort(ctx, "8080/tcp")
if err != nil {
return nil, fmt.Errorf("getting nodejs port: %w", err)
}
baseURL := fmt.Sprintf("http://%s:%d", host, mappedPort.Int())
return &NodeJSService{
container: container,
url: baseURL,
client: resty.New().SetBaseURL(baseURL),
}, nil
}
// bootstrap creates the initial admin user, org, and machine identity, logs in
// to obtain a user JWT, then mints the identity access token used by the infra
// helpers. Uses log.Fatalf since it runs in TestMain.
func (n *NodeJSService) bootstrap() {
var bootstrapResp BootstrapResponse
resp, err := n.client.R().
SetBody(BootstrapRequest{
Email: "[email protected]",
Password: "testpassword123",
Organization: "test-org",
}).
SetResult(&bootstrapResp).
Post("/api/v1/admin/bootstrap")
if err != nil {
log.Fatalf("infra.bootstrap: request failed: %v", err)
}
if resp.IsError() {
log.Fatalf("infra.bootstrap: returned %d: %s", resp.StatusCode(), resp.String())
}
n.orgID = bootstrapResp.Organization.ID
n.userEmail = bootstrapResp.User.Email
n.userID = bootstrapResp.User.ID
var loginResp LoginResponse
resp, err = n.client.R().
SetBody(LoginRequest{
Email: n.userEmail,
Password: "testpassword123",
}).
SetResult(&loginResp).
Post("/api/v3/auth/login")
if err != nil {
log.Fatalf("infra.bootstrap: login request failed: %v", err)
}
if resp.IsError() {
log.Fatalf("infra.bootstrap: login returned %d: %s", resp.StatusCode(), resp.String())
}
// Select organization to get an org-scoped JWT (required for org-level API calls).
var selectOrgResp SelectOrgResponse
resp, err = n.client.R().
SetHeader("Authorization", "Bearer "+loginResp.AccessToken).
SetBody(SelectOrgRequest{
OrganizationID: n.orgID,
}).
SetResult(&selectOrgResp).
Post("/api/v3/auth/select-organization")
if err != nil {
log.Fatalf("infra.bootstrap: select-org request failed: %v", err)
}
if resp.IsError() {
log.Fatalf("infra.bootstrap: select-org returned %d: %s", resp.StatusCode(), resp.String())
}
n.userToken = selectOrgResp.Token
// The bootstrap response token is signed without an exp claim, which the
// backend rejects as over max age once past the legacy no-exp token cutoff
// (2026-08-02 on default config). Mint a standard Token Auth access token
// for the instance admin identity and use that for all infra calls.
var tokenResp CreateTokenAuthTokenResponse
resp, err = n.client.R().
SetHeader("Authorization", "Bearer "+n.userToken).
SetBody(CreateTokenAuthTokenRequest{Name: "test-infra"}).
SetResult(&tokenResp).
Post("/api/v1/auth/token-auth/identities/" + bootstrapResp.Identity.ID + "/tokens")
if err != nil {
log.Fatalf("infra.bootstrap: create token-auth token request failed: %v", err)
}
if resp.IsError() {
log.Fatalf("infra.bootstrap: create token-auth token returned %d: %s", resp.StatusCode(), resp.String())
}
n.identityToken = tokenResp.AccessToken
}
// MustCreateProject creates a new project via the Node.js API.
// Safe to call from TestMain — uses log.Fatalf on error.
func (n *NodeJSService) MustCreateProject(name string) *ProjectSeed {
var projectResp CreateProjectResponse
resp, err := n.client.R().
SetAuthToken(n.identityToken).
SetBody(CreateProjectRequest{
ProjectName: name,
Slug: fmt.Sprintf("test-%s", name),
Type: "secret-manager",
}).
SetResult(&projectResp).
Post("/api/v1/projects")
if err != nil {
log.Fatalf("infra.MustCreateProject: request failed: %v", err)
}
if resp.IsError() {
log.Fatalf("infra.MustCreateProject: returned %d: %s", resp.StatusCode(), resp.String())
}
return &ProjectSeed{
ID: projectResp.Project.ID,
Slug: projectResp.Project.Slug,
EnvSlug: "dev",
}
}
// CreateProject creates a new project via the Node.js API and returns its metadata.
// The bootstrap identity creates the project (automatically becoming admin), then the
// bootstrap user is also added as admin so both can be used for API calls.
func (n *NodeJSService) CreateProject(t *testing.T, name string) *ProjectSeed {
t.Helper()
b := make([]byte, 4)
rand.Read(b)
slug := fmt.Sprintf("t-%s-%x", name, b)
if len(slug) > 36 {
slug = slug[:36]
}
var projectResp CreateProjectResponse
resp, err := n.client.R().
SetAuthToken(n.identityToken).
SetBody(CreateProjectRequest{
ProjectName: name,
Slug: slug,
Type: "secret-manager",
}).
SetResult(&projectResp).
Post("/api/v1/projects")
if err != nil {
t.Fatalf("infra.CreateProject: request failed: %v", err)
}
if resp.IsError() {
t.Fatalf("infra.CreateProject: returned %d: %s", resp.StatusCode(), resp.String())
}
projectID := projectResp.Project.ID
// Add bootstrap user to project as admin (identity is already admin as creator)
r, err := n.client.R().
SetAuthToken(n.identityToken).
SetBody(AddUserToProjectRequest{
Usernames: []string{n.userEmail},
RoleSlugs: []string{"admin"},
}).
Post(fmt.Sprintf("/api/v1/projects/%s/memberships", projectID))
if err != nil {
t.Fatalf("infra.CreateProject: add user failed: %v", err)
}
if r.IsError() {
t.Fatalf("infra.CreateProject: add user returned %d: %s", r.StatusCode(), r.String())
}
return &ProjectSeed{
ID: projectID,
Slug: projectResp.Project.Slug,
EnvSlug: "dev",
}
}
// DeleteProject deletes a project via the Node.js API.
func (n *NodeJSService) DeleteProject(t *testing.T, projectID string) {
t.Helper()
resp, err := n.client.R().
SetAuthToken(n.identityToken).
Delete("/api/v1/projects/" + projectID)
if err != nil {
t.Fatalf("infra.DeleteProject: request failed: %v", err)
}
if resp.IsError() {
t.Fatalf("infra.DeleteProject: returned %d: %s", resp.StatusCode(), resp.String())
}
}
// CreateIdentity creates a new machine identity in the bootstrap org.
func (n *NodeJSService) CreateIdentity(t *testing.T, name string) *IdentitySeed {
t.Helper()
var resp CreateIdentityResponse
r, err := n.client.R().
SetAuthToken(n.identityToken).
SetBody(CreateIdentityRequest{
Name: name,
OrganizationID: n.orgID,
Role: "no-access",
}).
SetResult(&resp).
Post("/api/v1/identities")
if err != nil {
t.Fatalf("infra.CreateIdentity: request failed: %v", err)
}
if r.IsError() {
t.Fatalf("infra.CreateIdentity: returned %d: %s", r.StatusCode(), r.String())
}
return &IdentitySeed{
ID: resp.Identity.ID,
Name: name,
}
}
// DeleteIdentity deletes a machine identity. This also revokes all tokens for the identity.
func (n *NodeJSService) DeleteIdentity(t *testing.T, identityID string) {
t.Helper()
r, err := n.client.R().
SetAuthToken(n.identityToken).
Delete("/api/v1/identities/" + identityID)
if err != nil {
t.Fatalf("infra.DeleteIdentity: request failed: %v", err)
}
if r.IsError() {
t.Fatalf("infra.DeleteIdentity: returned %d: %s", r.StatusCode(), r.String())
}
}
// AddIdentityToProject adds a machine identity to a project with the given roles.
// Each role entry can include temporary access fields (isTemporary, temporaryMode, temporaryRange,
// temporaryAccessStartTime). For simple cases, use infra.Role("admin") helper.
func (n *NodeJSService) AddIdentityToProject(t *testing.T, projectID, identityID string, roles []RoleAssignment) {
t.Helper()
r, err := n.client.R().
SetAuthToken(n.identityToken).
SetBody(AddIdentityToProjectWithRolesRequest{
Roles: roles,
}).
Post(fmt.Sprintf("/api/v1/projects/%s/memberships/identities/%s", projectID, identityID))
if err != nil {
t.Fatalf("infra.AddIdentityToProject: request failed: %v", err)
}
if r.IsError() {
t.Fatalf("infra.AddIdentityToProject: returned %d: %s", r.StatusCode(), r.String())
}
}
// Role is a helper to create a simple RoleAssignment for AddIdentityToProject.
func Role(slug string) []RoleAssignment {
return []RoleAssignment{{Role: slug}}
}
// InviteAndCreateUser invites a user to the org and returns their seed.
// The invite creates a user record + org membership in the DB.
// The user ID is queried from the DB since the invite response doesn't include it.
func (n *NodeJSService) InviteAndCreateUser(t *testing.T, email string) *UserSeed {
t.Helper()
// 1. Invite user to org (requires user JWT auth with org context)
r, err := n.client.R().
SetAuthToken(n.userToken).
SetBody(InviteToOrgRequest{
InviteeEmails: []string{email},
OrganizationID: n.orgID,
}).
Post("/api/v1/invite-org/signup")
if err != nil {
t.Fatalf("infra.InviteAndCreateUser: invite failed: %v", err)
}
if r.IsError() {
t.Fatalf("infra.InviteAndCreateUser: invite returned %d: %s", r.StatusCode(), r.String())
}
// 2. Query user ID from DB (invite creates a user record with the email as username)
if n.db == nil {
t.Fatal("infra.InviteAndCreateUser: db is nil, cannot query user ID")
}
var userID string
err = n.db.Primary().QueryRow(context.Background(),
`SELECT id FROM users WHERE username = $1`, email).Scan(&userID)
if err != nil {
t.Fatalf("infra.InviteAndCreateUser: query user ID: %v", err)
}
return &UserSeed{
ID: userID,
Email: email,
}
}
// AddUserToProject adds a user (by email) to a project with the given role slugs.
func (n *NodeJSService) AddUserToProject(t *testing.T, projectID, email string, roleSlugs []string) {
t.Helper()
r, err := n.client.R().
SetAuthToken(n.identityToken).
SetBody(AddUserToProjectRequest{
Usernames: []string{email},
RoleSlugs: roleSlugs,
}).
Post(fmt.Sprintf("/api/v1/projects/%s/memberships", projectID))
if err != nil {
t.Fatalf("infra.AddUserToProject: request failed: %v", err)
}
if r.IsError() {
t.Fatalf("infra.AddUserToProject: returned %d: %s", r.StatusCode(), r.String())
}
}
// CreateCustomProjectRole creates a custom project role with the given permissions.
// Requires the "rbac" EE feature to be enabled (see WithEEFeatures).
func (n *NodeJSService) CreateCustomProjectRole(t *testing.T, projectID, slug, name string, permissions []Permission) *CustomRoleSeed {
t.Helper()
var resp CreateCustomRoleResponse
r, err := n.client.R().
SetAuthToken(n.identityToken).
SetBody(CreateCustomRoleRequest{
Slug: slug,
Name: name,
Permissions: permissions,
}).
SetResult(&resp).
Post(fmt.Sprintf("/api/v1/projects/%s/roles", projectID))
if err != nil {
t.Fatalf("infra.CreateCustomProjectRole: request failed: %v", err)
}
if r.IsError() {
t.Fatalf("infra.CreateCustomProjectRole: returned %d: %s", r.StatusCode(), r.String())
}
return &CustomRoleSeed{
ID: resp.Role.ID,
Slug: resp.Role.Slug,
Name: resp.Role.Name,
}
}
// CreateGroup creates an org-level group via the Node.js API.
// Requires the "groups" EE feature to be enabled (see WithEEFeatures).
func (n *NodeJSService) CreateGroup(t *testing.T, name string) *GroupSeed {
t.Helper()
var resp CreateGroupResponse
r, err := n.client.R().
SetAuthToken(n.identityToken).
SetBody(CreateGroupRequest{
Name: name,
Role: "no-access",
}).
SetResult(&resp).
Post("/api/v1/groups")
if err != nil {
t.Fatalf("infra.CreateGroup: request failed: %v", err)
}
if r.IsError() {
t.Fatalf("infra.CreateGroup: returned %d: %s", r.StatusCode(), r.String())
}
return &GroupSeed{
ID: resp.ID,
Name: resp.Name,
Slug: resp.Slug,
}
}
// AddUserToGroup adds a user (by username/email) to a group.
// Uses the admin user JWT (not identity token) because group member management
// requires org-level group permissions with privilege boundary checks.
func (n *NodeJSService) AddUserToGroup(t *testing.T, groupID, username string) {
t.Helper()
r, err := n.client.R().
SetAuthToken(n.userToken).
SetHeader("Content-Type", "application/json").
SetBody(struct{}{}).
Post(fmt.Sprintf("/api/v1/groups/%s/users/%s", groupID, username))
if err != nil {
t.Fatalf("infra.AddUserToGroup: request failed: %v", err)
}
if r.IsError() {
t.Fatalf("infra.AddUserToGroup: returned %d: %s", r.StatusCode(), r.String())
}
}
// AddGroupToProject adds a group to a project with the given role.
func (n *NodeJSService) AddGroupToProject(t *testing.T, projectID, groupID, role string) {
t.Helper()
r, err := n.client.R().
SetAuthToken(n.identityToken).
SetBody(AddGroupToProjectRequest{
Role: role,
}).
Post(fmt.Sprintf("/api/v1/projects/%s/memberships/groups/%s", projectID, groupID))
if err != nil {
t.Fatalf("infra.AddGroupToProject: request failed: %v", err)
}
if r.IsError() {
t.Fatalf("infra.AddGroupToProject: returned %d: %s", r.StatusCode(), r.String())
}
}
// IdentityPrivilegeOpts holds optional temporal parameters for CreateIdentityAdditionalPrivilege.
type IdentityPrivilegeOpts struct {
TemporaryRange string // Duration string (e.g. "1h", "30s")
TemporaryAccessStartTime string // ISO-8601 datetime string
}
// CreateIdentityAdditionalPrivilege creates an additional privilege for an identity in a project.
// Pass nil opts for permanent privilege, or provide temporal fields for temporary privilege.
func (n *NodeJSService) CreateIdentityAdditionalPrivilege(t *testing.T, identityID, projectID string, permissions []Permission, opts *IdentityPrivilegeOpts) {
t.Helper()
privType := PrivilegeType{IsTemporary: false}
if opts != nil && opts.TemporaryRange != "" {
privType = PrivilegeType{
IsTemporary: true,
TemporaryMode: "relative",
TemporaryRange: opts.TemporaryRange,
TemporaryAccessStartTime: opts.TemporaryAccessStartTime,
}
}
r, err := n.client.R().
SetAuthToken(n.identityToken).
SetBody(CreateIdentityPrivilegeRequest{
IdentityID: identityID,
ProjectID: projectID,
Permissions: permissions,
Type: privType,
}).
Post("/api/v2/identity-project-additional-privilege/")
if err != nil {
t.Fatalf("infra.CreateIdentityAdditionalPrivilege: request failed: %v", err)
}
if r.IsError() {
t.Fatalf("infra.CreateIdentityAdditionalPrivilege: returned %d: %s", r.StatusCode(), r.String())
}
}
// CreateUserAdditionalPrivilege creates a permanent additional privilege
// for a user in a project via the Node.js API.
// Requires looking up the project membership ID from the DB.
func (n *NodeJSService) CreateUserAdditionalPrivilege(t *testing.T, userID, projectID string, permissions []Permission) {
t.Helper()
if n.db == nil {
t.Fatal("infra.CreateUserAdditionalPrivilege: db is nil")
}
// Look up the user's project membership ID from the unified memberships table.
var membershipID string
err := n.db.Primary().QueryRow(context.Background(),
`SELECT id FROM memberships WHERE "actorUserId" = $1 AND "scopeProjectId" = $2 AND scope = 'project'`,
userID, projectID).Scan(&membershipID)
if err != nil {
t.Fatalf("infra.CreateUserAdditionalPrivilege: query membership ID: %v", err)
}
r, err := n.client.R().
SetAuthToken(n.userToken).
SetBody(CreateUserPrivilegeRequest{
ProjectMembershipID: membershipID,
Permissions: permissions,
Type: PrivilegeType{IsTemporary: false},
}).
Post("/api/v1/user-project-additional-privilege/")
if err != nil {
t.Fatalf("infra.CreateUserAdditionalPrivilege: request failed: %v", err)
}
if r.IsError() {
t.Fatalf("infra.CreateUserAdditionalPrivilege: returned %d: %s", r.StatusCode(), r.String())
}
}
// SecretSeed contains metadata for a secret created via the Node.js API.
type SecretSeed struct {
ID string
Key string
Value string
Version int
}
// CreateSecretOpts holds optional parameters for CreateSecret.
type CreateSecretOpts struct {
Comment string
Metadata []SecretMetadataEntry
TagIDs []string
Type string // "shared" or "personal", defaults to "shared"
ReminderNote string
ReminderRepeatDays *int
}
// CreateSecret creates a secret via the Node.js API.
// Pass nil opts for a basic shared secret, or provide opts for tags, comment, metadata, or personal type.
func (n *NodeJSService) CreateSecret(t *testing.T, projectID, environment, secretPath, key, value string, opts *CreateSecretOpts) *SecretSeed {
t.Helper()
var comment string
var metadata []SecretMetadataEntry
var tagIDs []string
var reminderNote string
var reminderRepeatDays *int
secretType := "shared"
if opts != nil {
comment = opts.Comment
metadata = opts.Metadata
tagIDs = opts.TagIDs
reminderNote = opts.ReminderNote
reminderRepeatDays = opts.ReminderRepeatDays
if opts.Type != "" {
secretType = opts.Type
}
}
token := n.identityToken
if secretType == "personal" {
token = n.userToken
}
var resp CreateSecretResponse
r, err := n.client.R().
SetAuthToken(token).
SetBody(CreateSecretRequest{
ProjectID: projectID,
Environment: environment,
SecretPath: secretPath,
SecretValue: value,
SecretComment: comment,
SecretMetadata: metadata,
Type: secretType,
TagIDs: tagIDs,
SecretReminderNote: reminderNote,
SecretReminderRepeatDays: reminderRepeatDays,
}).
SetResult(&resp).
Post(fmt.Sprintf("/api/v4/secrets/%s", key))
if err != nil {
t.Fatalf("infra.CreateSecret: request failed: %v", err)
}
if r.IsError() {
t.Fatalf("infra.CreateSecret: returned %d: %s", r.StatusCode(), r.String())
}
return &SecretSeed{
ID: resp.Secret.ID,
Key: key,
Value: value,
Version: 1,
}
}
// FolderSeed contains metadata for a folder created via the Node.js API.
type FolderSeed struct {
ID string
Name string
}
// CreateFolder creates a secret folder via the Node.js API.
func (n *NodeJSService) CreateFolder(t *testing.T, projectID, environment, path, name string) *FolderSeed {
t.Helper()
var resp CreateFolderResponse
r, err := n.client.R().
SetAuthToken(n.identityToken).
SetBody(CreateFolderRequest{
ProjectID: projectID,
Environment: environment,
Path: path,
Name: name,
}).
SetResult(&resp).
Post("/api/v2/folders")
if err != nil {
t.Fatalf("infra.CreateFolder: request failed: %v", err)
}
if r.IsError() {
t.Fatalf("infra.CreateFolder: returned %d: %s", r.StatusCode(), r.String())
}
return &FolderSeed{
ID: resp.Folder.ID,
Name: name,
}
}
// SecretImportSeed contains metadata for a secret import created via the Node.js API.
type SecretImportSeed struct {
ID string
}
// CreateSecretImport creates a secret import via the Node.js API.
func (n *NodeJSService) CreateSecretImport(t *testing.T, projectID, environment, path, importEnv, importPath string) *SecretImportSeed {
t.Helper()
var resp CreateSecretImportResponse
r, err := n.client.R().
SetAuthToken(n.identityToken).
SetBody(CreateSecretImportRequest{
ProjectID: projectID,
Environment: environment,
Path: path,
Import: SecretImportTarget{
Environment: importEnv,
Path: importPath,
},
}).
SetResult(&resp).
Post("/api/v2/secret-imports")
if err != nil {
t.Fatalf("infra.CreateSecretImport: request failed: %v", err)
}
if r.IsError() {
t.Fatalf("infra.CreateSecretImport: returned %d: %s", r.StatusCode(), r.String())
}
return &SecretImportSeed{
ID: resp.SecretImport.ID,
}
}
// EnvironmentSeed contains metadata for an environment created via the Node.js API.
type EnvironmentSeed struct {
ID string
Slug string
Name string
}
// CreateEnvironment creates an environment in a project via the Node.js API.
func (n *NodeJSService) CreateEnvironment(t *testing.T, projectID, slug, name string) *EnvironmentSeed {
t.Helper()
var resp CreateEnvironmentResponse
r, err := n.client.R().
SetAuthToken(n.identityToken).
SetBody(CreateEnvironmentRequest{
Slug: slug,
Name: name,
}).
SetResult(&resp).
Post(fmt.Sprintf("/api/v1/projects/%s/environments", projectID))
if err != nil {
t.Fatalf("infra.CreateEnvironment: request failed: %v", err)
}
if r.IsError() {
t.Fatalf("infra.CreateEnvironment: returned %d: %s", r.StatusCode(), r.String())
}
return &EnvironmentSeed{
ID: resp.Environment.ID,
Slug: slug,
Name: name,
}
}
// SoftDeleteEnvironment soft-deletes an environment in a project via the Node.js API.
// The environment is marked for deletion but not immediately removed, allowing for restore.
func (n *NodeJSService) SoftDeleteEnvironment(t *testing.T, projectID, envID string) {
t.Helper()
r, err := n.client.R().
SetAuthToken(n.identityToken).
Delete(fmt.Sprintf("/api/v1/projects/%s/environments/%s", projectID, envID))
if err != nil {
t.Fatalf("infra.SoftDeleteEnvironment: request failed: %v", err)
}
if r.IsError() {
t.Fatalf("infra.SoftDeleteEnvironment: returned %d: %s", r.StatusCode(), r.String())
}
}
// TagSeed contains metadata for a tag created via the Node.js API.
type TagSeed struct {
ID string
Slug string
Name string
}
// CreateTag creates a project tag via the Node.js API.
func (n *NodeJSService) CreateTag(t *testing.T, projectID, slug, name, color string) *TagSeed {
t.Helper()
var resp CreateTagResponse
r, err := n.client.R().
SetAuthToken(n.identityToken).
SetBody(CreateTagRequest{
Slug: slug,
Name: name,
Color: color,
}).
SetResult(&resp).
Post(fmt.Sprintf("/api/v1/projects/%s/tags", projectID))
if err != nil {
t.Fatalf("infra.CreateTag: request failed: %v", err)
}
if r.IsError() {
t.Fatalf("infra.CreateTag: returned %d: %s", r.StatusCode(), r.String())
}
return &TagSeed{
ID: resp.Tag.ID,
Slug: slug,
Name: name,
}
}
// GetIdentityAccessToken creates and returns an access token for an identity.
// This is useful for testing API calls as that specific identity.
func (n *NodeJSService) GetIdentityAccessToken(t *testing.T, identityID string) string {
t.Helper()
// First, create a universal auth method for the identity
// This response contains the clientId
var universalAuthResp CreateUniversalAuthResponse
r, err := n.client.R().
SetAuthToken(n.identityToken).
SetBody(CreateUniversalAuthRequest{
IdentityID: identityID,
AccessTokenTrustedIPs: []IPAddress{{IPAddress: "0.0.0.0/0"}},
AccessTokenTTL: 3600,
AccessTokenMaxTTL: 7200,
AccessTokenNumUsesLimit: 0,
ClientSecretTrustedIPs: []IPAddress{{IPAddress: "0.0.0.0/0"}},
ClientSecretNumUsesLimit: 0,
IsClientSecretRotationEnabled: false,
}).
SetResult(&universalAuthResp).
Post("/api/v1/auth/universal-auth/identities/" + identityID)
if err != nil {
t.Fatalf("infra.GetIdentityAccessToken: create auth failed: %v", err)
}
if r.IsError() {
t.Fatalf("infra.GetIdentityAccessToken: create auth returned %d: %s", r.StatusCode(), r.String())
}
clientID := universalAuthResp.IdentityUniversalAuth.ClientID
// Then create a client secret
var clientSecretResp CreateClientSecretResponse
r, err = n.client.R().
SetAuthToken(n.identityToken).
SetBody(CreateClientSecretRequest{
Description: "test-client-secret",
TTL: 0,
NumUsesLimit: 0,
}).
SetResult(&clientSecretResp).
Post("/api/v1/auth/universal-auth/identities/" + identityID + "/client-secrets")
if err != nil {
t.Fatalf("infra.GetIdentityAccessToken: create client secret failed: %v", err)
}
if r.IsError() {
t.Fatalf("infra.GetIdentityAccessToken: create client secret returned %d: %s", r.StatusCode(), r.String())
}
clientSecret := clientSecretResp.ClientSecret
// Finally, login to get the access token
var loginResp UniversalAuthLoginResponse
r, err = n.client.R().
SetBody(UniversalAuthLoginRequest{
ClientID: clientID,
ClientSecret: clientSecret,
}).
SetResult(&loginResp).
Post("/api/v1/auth/universal-auth/login")
if err != nil {
t.Fatalf("infra.GetIdentityAccessToken: login failed: %v", err)
}
if r.IsError() {
t.Fatalf("infra.GetIdentityAccessToken: login returned %d: %s", r.StatusCode(), r.String())
}
return loginResp.AccessToken
}
// RevokeAccessToken revokes an identity access token via the Node.js API.
func (n *NodeJSService) RevokeAccessToken(t *testing.T, accessToken string) {
t.Helper()
r, err := n.client.R().
SetBody(map[string]string{"accessToken": accessToken}).
Post("/api/v1/auth/token/revoke")
if err != nil {
t.Fatalf("infra.RevokeAccessToken: request failed: %v", err)
}
if r.IsError() {
t.Fatalf("infra.RevokeAccessToken: returned %d: %s", r.StatusCode(), r.String())
}
}
// ServiceTokenScope defines the scope for a service token.
type ServiceTokenScope struct {
Environment string `json:"environment"`
SecretPath string `json:"secretPath"`
}
// CreateServiceTokenRequest is the request body for creating a service token.
type CreateServiceTokenRequest struct {
Name string `json:"name"`
WorkspaceID string `json:"workspaceId"`
Scopes []ServiceTokenScope `json:"scopes"`
EncryptedKey string `json:"encryptedKey"`
IV string `json:"iv"`
Tag string `json:"tag"`
ExpiresIn *int `json:"expiresIn"`
Permissions []string `json:"permissions"`
}
// CreateServiceTokenResponse is the response from creating a service token.
type CreateServiceTokenResponse struct {
ServiceToken string `json:"serviceToken"`
ServiceTokenData struct {
ID string `json:"id"`
Name string `json:"name"`
} `json:"serviceTokenData"`
}
// ServiceTokenSeed holds the created service token info.
type ServiceTokenSeed struct {
ID string
Name string
Token string
}
// CreateServiceTokenOpts contains options for creating a service token.
type CreateServiceTokenOpts struct {
Scopes []ServiceTokenScope
Permissions []string
ExpiresIn *int
}
// CreateServiceToken creates a service token for a project.
func (n *NodeJSService) CreateServiceToken(t *testing.T, projectID string, opts *CreateServiceTokenOpts) *ServiceTokenSeed {
t.Helper()
scopes := []ServiceTokenScope{{Environment: "dev", SecretPath: "/"}}
permissions := []string{"read", "write"}
if opts != nil {
if len(opts.Scopes) > 0 {
scopes = opts.Scopes
}
if len(opts.Permissions) > 0 {
permissions = opts.Permissions
}
}
var expiresIn *int
if opts != nil {
expiresIn = opts.ExpiresIn
}
var resp CreateServiceTokenResponse
r, err := n.client.R().
SetAuthToken(n.userToken).
SetBody(CreateServiceTokenRequest{
Name: "test-service-token-" + uuid.New().String()[:8],
WorkspaceID: projectID,
Scopes: scopes,
EncryptedKey: "",
IV: "",
Tag: "",
ExpiresIn: expiresIn,
Permissions: permissions,
}).
SetResult(&resp).
Post("/api/v2/service-token")
if err != nil {
t.Fatalf("infra.CreateServiceToken: request failed: %v", err)
}
if r.IsError() {
t.Fatalf("infra.CreateServiceToken: returned %d: %s", r.StatusCode(), r.String())
}
return &ServiceTokenSeed{
ID: resp.ServiceTokenData.ID,
Name: resp.ServiceTokenData.Name,
Token: resp.ServiceToken,
}
}
// DeleteServiceToken deletes a service token.
func (n *NodeJSService) DeleteServiceToken(t *testing.T, serviceTokenID string) {
t.Helper()
r, err := n.client.R().
SetAuthToken(n.userToken).
Delete("/api/v2/service-token/" + serviceTokenID)
if err != nil {
t.Fatalf("infra.DeleteServiceToken: request failed: %v", err)
}
if r.IsError() {
t.Fatalf("infra.DeleteServiceToken: returned %d: %s", r.StatusCode(), r.String())
}
}
// GetSecretByKey reads a secret by key via the Node.js API.
func (n *NodeJSService) GetSecretByKey(t *testing.T, projectID, environment, secretPath, key string) *SecretSeed {
t.Helper()
var resp GetSecretResponse
r, err := n.client.R().
SetAuthToken(n.identityToken).
SetQueryParams(map[string]string{
"projectId": projectID,
"environment": environment,
"secretPath": secretPath,
}).
SetResult(&resp).
Get(fmt.Sprintf("/api/v4/secrets/%s", key))
if err != nil {
t.Fatalf("infra.GetSecretByKey: request failed: %v", err)
}
if r.IsError() {
t.Fatalf("infra.GetSecretByKey: returned %d: %s", r.StatusCode(), r.String())
}
return &SecretSeed{
ID: resp.Secret.ID,
Key: resp.Secret.Key,
Value: resp.Secret.Value,
Version: resp.Secret.Version,
}
}