Skip to content

Infisical is the open-source platform for securing secrets, certificates, access, and AI Agents.

feat: completed simple test cases for secrets

=d1bd0fede4a5
diff --git a/tests/fixture/secretmanager/secret.go b/tests/fixture/secretmanager/secret.go
index adabb76eb9..0369ca93b7 100644
--- a/tests/fixture/secretmanager/secret.go
+++ b/tests/fixture/secretmanager/secret.go
@@ -2,6 +2,7 @@
package secretmanager
import (
+ "path"
"testing"
"github.com/Infisical/infisical/tests/clients/api"
@@ -14,6 +15,8 @@ import (
// Secret is a narrowed read, since the generated response is a union. ValueHidden
// matters: a hidden value reads as empty rather than as an error.
type Secret struct {
+ ID string
+ Key string
Value string
ValueHidden bool
Path string
@@ -23,8 +26,9 @@ type Secret struct {
type SecretOption func(*secretConfig)
type secretConfig struct {
- path string
- as *harness.Principal
+ path string
+ as *harness.Principal
+ personal bool
}
// WithPath places the secret somewhere other than the project root.
@@ -34,6 +38,10 @@ func WithPath(p string) SecretOption { return func(c *secretConfig) { c.path = p
// what a member may do needs.
func As(p *harness.Principal) SecretOption { return func(c *secretConfig) { c.as = p } }
+// WithPersonal targets the actor's personal override instead of the shared secret.
+// On ListSecrets it asks for the actor's overrides to be included.
+func WithPersonal() SecretOption { return func(c *secretConfig) { c.personal = true } }
+
func resolve(p *fixture.Project, opts []SecretOption) (secretConfig, *api.ClientWithResponses) {
cfg := secretConfig{path: "/"}
for _, o := range opts {
@@ -50,36 +58,148 @@ func CreateSecret(tt *testing.T, p *fixture.Project, env, name, value string, op
tt.Helper()
cfg, client := resolve(p, opts)
+ secretType := api.CreateSecretV4JSONBodyTypeShared
+ if cfg.personal {
+ secretType = api.CreateSecretV4JSONBodyTypePersonal
+ }
+
res, err := client.CreateSecretV4WithResponse(tt.Context(), name, api.CreateSecretV4JSONRequestBody{
ProjectId: p.ID,
Environment: env,
SecretPath: &cfg.path,
SecretValue: value,
+ Type: &secretType,
})
require.NoErrorf(tt, err, "creating secret %s", name)
require.NotNilf(tt, res.JSON200, "creating secret %s returned %d: %s", name, res.StatusCode(), apierr.Body(res.Body))
- // A union with an approval request; a tenant has no change policy unless a test
- // adds one, so that branch means an unintended path.
+ // The generated unwrap only unmarshals, so an approval reply decodes into an
+ // empty secret without error; a missing id is how a held write shows.
created, err := res.JSON200.AsCreateSecretV4200JSONResponseBody0()
- require.NoErrorf(tt, err, "creating secret %s returned an approval request: %s", name, res.Body)
+ require.NoError(tt, err)
+ require.NotEmptyf(tt, created.Secret.Id, "creating secret %s was not applied (held for approval?): %s", name, res.Body)
+
+ return Secret{
+ ID: created.Secret.Id,
+ Key: created.Secret.SecretKey,
+ Value: created.Secret.SecretValue,
+ Path: cfg.path,
+ Version: created.Secret.Version,
+ }
+}
+
+func UpdateSecret(tt *testing.T, p *fixture.Project, env, name, value string, opts ...SecretOption) Secret {
+ tt.Helper()
+ cfg, client := resolve(p, opts)
+
+ secretType := api.UpdateSecretV4JSONBodyTypeShared
+ if cfg.personal {
+ secretType = api.UpdateSecretV4JSONBodyTypePersonal
+ }
+
+ res, err := client.UpdateSecretV4WithResponse(tt.Context(), name, api.UpdateSecretV4JSONRequestBody{
+ ProjectId: p.ID,
+ Environment: env,
+ SecretPath: &cfg.path,
+ SecretValue: &value,
+ Type: &secretType,
+ })
+ require.NoErrorf(tt, err, "updating secret %s", name)
+ require.NotNilf(tt, res.JSON200, "updating secret %s returned %d: %s", name, res.StatusCode(), apierr.Body(res.Body))
+
+ updated, err := res.JSON200.AsUpdateSecretV4200JSONResponseBody0()
+ require.NoError(tt, err)
+ require.NotEmptyf(tt, updated.Secret.Id, "updating secret %s was not applied (held for approval?): %s", name, res.Body)
+
+ return Secret{
+ ID: updated.Secret.Id,
+ Key: updated.Secret.SecretKey,
+ Value: updated.Secret.SecretValue,
+ ValueHidden: updated.Secret.SecretValueHidden,
+ Path: cfg.path,
+ Version: updated.Secret.Version,
+ }
+}
+
+// ListSecrets reads one folder with references expanded, which is what an
+// application pulling its secrets sees.
+func ListSecrets(tt *testing.T, p *fixture.Project, env string, opts ...SecretOption) []Secret {
+ tt.Helper()
+ cfg, client := resolve(p, opts)
+
+ includePersonal := api.ListSecretsV4ParamsIncludePersonalOverridesFalse
+ if cfg.personal {
+ includePersonal = api.ListSecretsV4ParamsIncludePersonalOverridesTrue
+ }
+
+ res, err := client.ListSecretsV4WithResponse(tt.Context(), &api.ListSecretsV4Params{
+ ProjectId: &p.ID,
+ Environment: &env,
+ SecretPath: &cfg.path,
+ ViewSecretValue: new(api.ListSecretsV4ParamsViewSecretValueTrue),
+ IncludePersonalOverrides: &includePersonal,
+ })
+ require.NoError(tt, err)
+ require.NotNilf(tt, res.JSON200, "listing secrets in %s:%s returned %d: %s",
+ env, cfg.path, res.StatusCode(), apierr.Body(res.Body))
+
+ secrets := make([]Secret, 0, len(res.JSON200.Secrets))
+ for _, s := range res.JSON200.Secrets {
+ secretPath := cfg.path
+ if s.SecretPath != nil {
+ secretPath = *s.SecretPath
+ }
+ secrets = append(secrets, Secret{
+ ID: s.Id,
+ Key: s.SecretKey,
+ Value: s.SecretValue,
+ ValueHidden: s.SecretValueHidden,
+ Path: secretPath,
+ Version: s.Version,
+ })
+ }
+ return secrets
+}
+
+// CreateFolder creates a folder at an absolute path such as "/app/api". Missing
+// parents are created by the server.
+func CreateFolder(tt *testing.T, p *fixture.Project, env, folderPath string, opts ...SecretOption) {
+ tt.Helper()
+ _, client := resolve(p, opts)
- return Secret{Value: created.Secret.SecretValue, Path: cfg.path, Version: created.Secret.Version}
+ parent, name := path.Split(path.Clean(folderPath))
+ res, err := client.CreateSecretFolderWithResponse(tt.Context(), api.CreateSecretFolderJSONRequestBody{
+ ProjectId: p.ID,
+ Environment: env,
+ Name: name,
+ Path: &parent,
+ })
+ require.NoErrorf(tt, err, "creating folder %s", folderPath)
+ require.NotNilf(tt, res.JSON200, "creating folder %s in %s returned %d: %s",
+ folderPath, env, res.StatusCode(), apierr.Body(res.Body))
}
func GetSecret(tt *testing.T, p *fixture.Project, env, name string, opts ...SecretOption) Secret {
tt.Helper()
cfg, client := resolve(p, opts)
+ secretType := api.GetSecretByNameV4ParamsTypeShared
+ if cfg.personal {
+ secretType = api.GetSecretByNameV4ParamsTypePersonal
+ }
+
res, err := client.GetSecretByNameV4WithResponse(tt.Context(), name, &api.GetSecretByNameV4Params{
ProjectId: p.ID,
Environment: &env,
SecretPath: &cfg.path,
+ Type: &secretType,
ViewSecretValue: new(api.GetSecretByNameV4ParamsViewSecretValue("true")),
})
require.NoError(tt, err)
require.NotNilf(tt, res.JSON200, "reading secret %s returned %d: %s", name, res.StatusCode(), apierr.Body(res.Body))
return Secret{
+ ID: res.JSON200.Secret.Id,
+ Key: res.JSON200.Secret.SecretKey,
Value: res.JSON200.Secret.SecretValue,
ValueHidden: res.JSON200.Secret.SecretValueHidden,
Path: res.JSON200.Secret.SecretPath,
@@ -91,11 +211,20 @@ func DeleteSecret(tt *testing.T, p *fixture.Project, env, name string, opts ...S
tt.Helper()
cfg, client := resolve(p, opts)
+ secretType := api.DeleteSecretV4JSONBodyTypeShared
+ if cfg.personal {
+ secretType = api.DeleteSecretV4JSONBodyTypePersonal
+ }
+
res, err := client.DeleteSecretV4WithResponse(tt.Context(), name, api.DeleteSecretV4JSONRequestBody{
ProjectId: p.ID,
Environment: env,
SecretPath: &cfg.path,
+ Type: &secretType,
})
require.NoErrorf(tt, err, "deleting secret %s", name)
require.NotNilf(tt, res.JSON200, "deleting secret %s returned %d: %s", name, res.StatusCode(), apierr.Body(res.Body))
+ deleted, err := res.JSON200.AsDeleteSecretV4200JSONResponseBody0()
+ require.NoError(tt, err)
+ require.NotEmptyf(tt, deleted.Secret.Id, "deleting secret %s was not applied (held for approval?): %s", name, res.Body)
}
diff --git a/tests/suites/secretmanager/secrets/create_test.go b/tests/suites/secretmanager/secrets/create_test.go
index 629531674f..af898372bc 100644
--- a/tests/suites/secretmanager/secrets/create_test.go
+++ b/tests/suites/secretmanager/secrets/create_test.go
@@ -113,4 +113,147 @@ func TestSecret_Create(t *testing.T) {
require.NotEqualf(t, http.StatusOK, res.StatusCode(),
"tenant %s wrote a secret into tenant %s's project", mine.OrgSlug, theirs.OrgSlug)
})
+
+ t.Run("should place the secret in the nested folder and not at the root when a path is given", func(t *testing.T) {
+ t.Parallel()
+
+ // Setup
+ proj := fixture.NewProject(t, h.NewTenant(t), fixture.WithProjectType("secret-manager"))
+ secretmanager.CreateFolder(t, proj, "dev", "/app/api")
+
+ // Action
+ secretmanager.CreateSecret(t, proj, "dev", "DB_URL", "nested", secretmanager.WithPath("/app/api"))
+
+ // Assert
+ require.Equal(t, "nested", secretmanager.GetSecret(t, proj, "dev", "DB_URL", secretmanager.WithPath("/app/api")).Value)
+ require.Empty(t, secretmanager.ListSecrets(t, proj, "dev"), "the nested secret also landed at the root")
+ })
+
+ t.Run("should refuse and create nothing when the folder does not exist", func(t *testing.T) {
+ t.Parallel()
+
+ // Setup
+ tn := h.NewTenant(t)
+ proj := fixture.NewProject(t, tn, fixture.WithProjectType("secret-manager"))
+
+ // Action
+ res, err := tn.Admin.API.CreateSecretV4WithResponse(t.Context(), "STRAY",
+ api.CreateSecretV4JSONRequestBody{
+ ProjectId: proj.ID,
+ Environment: "dev",
+ SecretPath: new("/missing"),
+ SecretValue: "value",
+ })
+
+ // Assert
+ require.NoError(t, err)
+ require.Equal(t, http.StatusNotFound, res.StatusCode())
+ require.Equal(t, "Folder with path '/missing' in environment with slug 'dev' not found", res.JSON404.Message)
+ require.Empty(t, secretmanager.ListSecrets(t, proj, "dev"))
+ })
+
+ t.Run("should keep a trailing newline and trim the rest of the surrounding whitespace", func(t *testing.T) {
+ t.Parallel()
+
+ // Setup
+ proj := fixture.NewProject(t, h.NewTenant(t), fixture.WithProjectType("secret-manager"))
+
+ // Action
+ secretmanager.CreateSecret(t, proj, "dev", "PEM", " -----BEGIN KEY-----\n")
+ secretmanager.CreateSecret(t, proj, "dev", "TOKEN", " padded ")
+
+ // Assert
+ require.Equal(t, "-----BEGIN KEY-----\n", secretmanager.GetSecret(t, proj, "dev", "PEM").Value)
+ require.Equal(t, "padded", secretmanager.GetSecret(t, proj, "dev", "TOKEN").Value)
+ })
+
+ t.Run("should return the tags and metadata the secret was created with", func(t *testing.T) {
+ t.Parallel()
+
+ // Setup
+ tn := h.NewTenant(t)
+ proj := fixture.NewProject(t, tn, fixture.WithProjectType("secret-manager"))
+ tagID := newTag(t, proj, "billing")
+
+ // Action
+ res, err := tn.Admin.API.CreateSecretV4WithResponse(t.Context(), "STRIPE_KEY",
+ api.CreateSecretV4JSONRequestBody{
+ ProjectId: proj.ID,
+ Environment: "dev",
+ SecretValue: "sk_test",
+ TagIds: &[]string{tagID},
+ SecretMetadata: &[]secretMetadataEntry{{Key: "team", Value: new("payments")}},
+ })
+ require.NoError(t, err)
+ require.Equalf(t, http.StatusOK, res.StatusCode(), "creating returned %s", res.Body)
+
+ // Assert
+ got, err := tn.Admin.API.GetSecretByNameV4WithResponse(t.Context(), "STRIPE_KEY",
+ &api.GetSecretByNameV4Params{ProjectId: proj.ID, Environment: new("dev")})
+ require.NoError(t, err)
+ require.NotNilf(t, got.JSON200, "reading returned %d: %s", got.StatusCode(), got.Body)
+ require.NotNil(t, got.JSON200.Secret.Tags)
+ require.Len(t, *got.JSON200.Secret.Tags, 1)
+ require.Equal(t, "billing", (*got.JSON200.Secret.Tags)[0].Slug)
+ require.NotNil(t, got.JSON200.Secret.SecretMetadata)
+ require.Len(t, *got.JSON200.Secret.SecretMetadata, 1)
+ require.Equal(t, "team", (*got.JSON200.Secret.SecretMetadata)[0].Key)
+ })
+
+ t.Run("should refuse and create nothing when the tag belongs to another project", func(t *testing.T) {
+ t.Parallel()
+
+ // Setup
+ tn := h.NewTenant(t)
+ proj := fixture.NewProject(t, tn, fixture.WithProjectType("secret-manager"))
+ other := fixture.NewProject(t, tn, fixture.WithProjectType("secret-manager"))
+ foreignTagID := newTag(t, other, "foreign")
+
+ // Action
+ res, err := tn.Admin.API.CreateSecretV4WithResponse(t.Context(), "TAGGED",
+ api.CreateSecretV4JSONRequestBody{
+ ProjectId: proj.ID,
+ Environment: "dev",
+ SecretValue: "value",
+ TagIds: &[]string{foreignTagID},
+ })
+
+ // Assert
+ require.NoError(t, err)
+ require.Equal(t, http.StatusNotFound, res.StatusCode())
+ require.Contains(t, res.JSON404.Message, "Tag not found")
+ require.Empty(t, secretmanager.ListSecrets(t, proj, "dev"))
+ })
+
+ t.Run("should refuse and create nothing when the actor is a project viewer", func(t *testing.T) {
+ t.Parallel()
+
+ // Setup
+ proj := fixture.NewProject(t, h.NewTenant(t), fixture.WithProjectType("secret-manager"))
+ viewer := proj.NewMachineIdentity(t, fixture.WithRoles("viewer"))
+
+ // Action
+ res, err := viewer.API.CreateSecretV4WithResponse(t.Context(), "BLOCKED",
+ api.CreateSecretV4JSONRequestBody{ProjectId: proj.ID, Environment: "dev", SecretValue: "value"})
+
+ // Assert
+ require.NoError(t, err)
+ require.Equal(t, http.StatusForbidden, res.StatusCode())
+ require.Equal(t, "You are not allowed to create on secrets", res.JSON403.Message)
+ require.Empty(t, secretmanager.ListSecrets(t, proj, "dev"))
+ })
+
+ t.Run("should let a machine identity with the member role create and read a secret", func(t *testing.T) {
+ t.Parallel()
+
+ // Setup
+ proj := fixture.NewProject(t, h.NewTenant(t), fixture.WithProjectType("secret-manager"))
+ member := proj.NewMachineIdentity(t, fixture.WithRoles("member"))
+
+ // Action
+ secretmanager.CreateSecret(t, proj, "dev", "CI_TOKEN", "from-ci", secretmanager.As(member))
+
+ // Assert
+ require.Equal(t, "from-ci", secretmanager.GetSecret(t, proj, "dev", "CI_TOKEN", secretmanager.As(member)).Value)
+ })
}
diff --git a/tests/suites/secretmanager/secrets/delete_test.go b/tests/suites/secretmanager/secrets/delete_test.go
new file mode 100644
index 0000000000..2dfbf1a3ab
--- /dev/null
+++ b/tests/suites/secretmanager/secrets/delete_test.go
@@ -0,0 +1,75 @@
+package secrets_test
+
+import (
+ "net/http"
+ "testing"
+
+ "github.com/Infisical/infisical/tests/clients/api"
+ "github.com/Infisical/infisical/tests/fixture"
+ "github.com/Infisical/infisical/tests/fixture/secretmanager"
+ "github.com/Infisical/infisical/tests/harness"
+ "github.com/stretchr/testify/require"
+)
+
+func TestSecret_Delete(t *testing.T) {
+ t.Parallel()
+ h := harness.From(t)
+
+ t.Run("should no longer list or return a secret once it is deleted", func(t *testing.T) {
+ t.Parallel()
+
+ // Setup
+ tn := h.NewTenant(t)
+ proj := fixture.NewProject(t, tn, fixture.WithProjectType("secret-manager"))
+ secretmanager.CreateSecret(t, proj, "dev", "GONE", "value")
+ secretmanager.CreateSecret(t, proj, "dev", "KEPT", "value")
+
+ // Action
+ secretmanager.DeleteSecret(t, proj, "dev", "GONE")
+
+ // Assert
+ res, err := tn.Admin.API.GetSecretByNameV4WithResponse(t.Context(), "GONE",
+ &api.GetSecretByNameV4Params{ProjectId: proj.ID, Environment: new("dev")})
+ require.NoError(t, err)
+ require.Equal(t, http.StatusNotFound, res.StatusCode())
+ secrets := secretmanager.ListSecrets(t, proj, "dev")
+ require.Len(t, secrets, 1)
+ require.Equal(t, "KEPT", secrets[0].Key)
+ })
+
+ t.Run("should return not found when the secret does not exist", func(t *testing.T) {
+ t.Parallel()
+
+ // Setup
+ tn := h.NewTenant(t)
+ proj := fixture.NewProject(t, tn, fixture.WithProjectType("secret-manager"))
+
+ // Action
+ res, err := tn.Admin.API.DeleteSecretV4WithResponse(t.Context(), "NOPE",
+ api.DeleteSecretV4JSONRequestBody{ProjectId: proj.ID, Environment: "dev"})
+
+ // Assert
+ require.NoError(t, err)
+ require.Equal(t, http.StatusNotFound, res.StatusCode())
+ require.Equal(t, "Secret not found", res.JSON404.Message)
+ })
+
+ t.Run("should refuse and keep the secret when the actor is a project viewer", func(t *testing.T) {
+ t.Parallel()
+
+ // Setup
+ proj := fixture.NewProject(t, h.NewTenant(t), fixture.WithProjectType("secret-manager"))
+ viewer := proj.NewMachineIdentity(t, fixture.WithRoles("viewer"))
+ secretmanager.CreateSecret(t, proj, "dev", "API_KEY", "original")
+
+ // Action
+ res, err := viewer.API.DeleteSecretV4WithResponse(t.Context(), "API_KEY",
+ api.DeleteSecretV4JSONRequestBody{ProjectId: proj.ID, Environment: "dev"})
+
+ // Assert
+ require.NoError(t, err)
+ require.Equal(t, http.StatusForbidden, res.StatusCode())
+ require.Equal(t, "You are not allowed to delete on secrets", res.JSON403.Message)
+ require.Equal(t, "original", secretmanager.GetSecret(t, proj, "dev", "API_KEY").Value)
+ })
+}
diff --git a/tests/suites/secretmanager/secrets/get_test.go b/tests/suites/secretmanager/secrets/get_test.go
new file mode 100644
index 0000000000..f22df1f363
--- /dev/null
+++ b/tests/suites/secretmanager/secrets/get_test.go
@@ -0,0 +1,136 @@
+package secrets_test
+
+import (
+ "net/http"
+ "testing"
+
+ "github.com/Infisical/infisical/tests/clients/api"
+ "github.com/Infisical/infisical/tests/fixture"
+ "github.com/Infisical/infisical/tests/fixture/secretmanager"
+ "github.com/Infisical/infisical/tests/harness"
+ "github.com/stretchr/testify/require"
+)
+
+func TestSecret_Get(t *testing.T) {
+ t.Parallel()
+ h := harness.From(t)
+
+ t.Run("should return the earlier value when an earlier version is requested", func(t *testing.T) {
+ t.Parallel()
+
+ // Setup
+ tn := h.NewTenant(t)
+ proj := fixture.NewProject(t, tn, fixture.WithProjectType("secret-manager"))
+ secretmanager.CreateSecret(t, proj, "dev", "API_KEY", "first")
+ secretmanager.UpdateSecret(t, proj, "dev", "API_KEY", "second")
+
+ // Action
+ res, err := tn.Admin.API.GetSecretByNameV4WithResponse(t.Context(), "API_KEY",
+ &api.GetSecretByNameV4Params{ProjectId: proj.ID, Environment: new("dev"), Version: new(float32(1))})
+
+ // Assert
+ require.NoError(t, err)
+ require.NotNilf(t, res.JSON200, "reading version 1 returned %d: %s", res.StatusCode(), res.Body)
+ require.Equal(t, "first", res.JSON200.Secret.SecretValue)
+ require.EqualValues(t, 1, res.JSON200.Secret.Version)
+ })
+
+ t.Run("should hide the value when the caller asks not to see it", func(t *testing.T) {
+ t.Parallel()
+
+ // Setup
+ tn := h.NewTenant(t)
+ proj := fixture.NewProject(t, tn, fixture.WithProjectType("secret-manager"))
+ secretmanager.CreateSecret(t, proj, "dev", "API_KEY", "plaintext")
+
+ // Action
+ res, err := tn.Admin.API.GetSecretByNameV4WithResponse(t.Context(), "API_KEY",
+ &api.GetSecretByNameV4Params{
+ ProjectId: proj.ID,
+ Environment: new("dev"),
+ ViewSecretValue: new(api.GetSecretByNameV4ParamsViewSecretValueFalse),
+ })
+
+ // Assert
+ require.NoError(t, err)
+ require.NotNilf(t, res.JSON200, "reading returned %d: %s", res.StatusCode(), res.Body)
+ require.True(t, res.JSON200.Secret.SecretValueHidden)
+ require.NotContains(t, string(res.Body), "plaintext")
+ })
+
+ t.Run("should return not found when the secret does not exist", func(t *testing.T) {
+ t.Parallel()
+
+ // Setup
+ tn := h.NewTenant(t)
+ proj := fixture.NewProject(t, tn, fixture.WithProjectType("secret-manager"))
+
+ // Action
+ res, err := tn.Admin.API.GetSecretByNameV4WithResponse(t.Context(), "NOPE",
+ &api.GetSecretByNameV4Params{ProjectId: proj.ID, Environment: new("dev")})
+
+ // Assert
+ require.NoError(t, err)
+ require.Equal(t, http.StatusNotFound, res.StatusCode())
+ require.Equal(t, "Secret with name 'NOPE' not found", res.JSON404.Message)
+ })
+
+ t.Run("should return the same secret by id as by name, with its path", func(t *testing.T) {
+ t.Parallel()
+
+ // Setup
+ tn := h.NewTenant(t)
+ proj := fixture.NewProject(t, tn, fixture.WithProjectType("secret-manager"))
+ secretmanager.CreateFolder(t, proj, "dev", "/app")
+ created := secretmanager.CreateSecret(t, proj, "dev", "DB_URL", "postgres://app", secretmanager.WithPath("/app"))
+
+ // Action
+ res, err := tn.Admin.API.GetSecretByIdV4WithResponse(t.Context(), created.ID)
+
+ // Assert
+ require.NoError(t, err)
+ require.NotNilf(t, res.JSON200, "reading by id returned %d: %s", res.StatusCode(), res.Body)
+ require.Equal(t, "DB_URL", res.JSON200.Secret.SecretKey)
+ require.Equal(t, "postgres://app", res.JSON200.Secret.SecretValue)
+ require.Equal(t, "/app", res.JSON200.Secret.SecretPath)
+ })
+
+ t.Run("should refuse and reveal nothing for a secret id from another tenant's project", func(t *testing.T) {
+ t.Parallel()
+
+ // Setup
+ mine, theirs := h.NewTenant(t), h.NewTenant(t)
+ target := fixture.NewProject(t, theirs, fixture.WithProjectType("secret-manager"))
+ created := secretmanager.CreateSecret(t, target, "dev", "THEIRS", "their-value")
+
+ // Action
+ res, err := mine.Admin.API.GetSecretByIdV4WithResponse(t.Context(), created.ID)
+
+ // Assert
+ require.NoError(t, err)
+ require.NotEqualf(t, http.StatusOK, res.StatusCode(),
+ "tenant %s read a secret from tenant %s's project", mine.OrgSlug, theirs.OrgSlug)
+ require.NotContains(t, string(res.Body), "their-value")
+ })
+
+ t.Run("should refuse another member reading the owner's personal override by id", func(t *testing.T) {
+ t.Parallel()
+
+ // Setup
+ proj := fixture.NewProject(t, h.NewTenant(t), fixture.WithProjectType("secret-manager"))
+ owner := proj.NewUser(t, fixture.WithPrincipalName("owner"))
+ other := proj.NewUser(t, fixture.WithPrincipalName("other"))
+ secretmanager.CreateSecret(t, proj, "dev", "DB_PASS", "shared")
+ personal := secretmanager.CreateSecret(t, proj, "dev", "DB_PASS", "owner-only",
+ secretmanager.As(owner), secretmanager.WithPersonal())
+
+ // Action
+ res, err := other.API.GetSecretByIdV4WithResponse(t.Context(), personal.ID)
+
+ // Assert
+ require.NoError(t, err)
+ require.Equal(t, http.StatusForbidden, res.StatusCode())
+ require.Equal(t, "You are not allowed to access this secret", res.JSON403.Message)
+ require.NotContains(t, string(res.Body), "owner-only")
+ })
+}
diff --git a/tests/suites/secretmanager/secrets/helpers_test.go b/tests/suites/secretmanager/secrets/helpers_test.go
new file mode 100644
index 0000000000..d57ebdedcb
--- /dev/null
+++ b/tests/suites/secretmanager/secrets/helpers_test.go
@@ -0,0 +1,27 @@
+package secrets_test
+
+import (
+ "testing"
+
+ "github.com/Infisical/infisical/tests/clients/api"
+ "github.com/Infisical/infisical/tests/fixture"
+ "github.com/Infisical/infisical/tests/internal/apierr"
+ "github.com/stretchr/testify/require"
+)
+
+// The generated bodies declare metadata as an anonymous struct; an identical alias is
+// assignable to it.
+type secretMetadataEntry = struct {
+ IsEncrypted *bool `json:"isEncrypted,omitempty"`
+ Key string `json:"key"`
+ Value *string `json:"value,omitempty"`
+}
+
+func newTag(t *testing.T, proj *fixture.Project, slug string) string {
+ t.Helper()
+ res, err := proj.Tenant().Admin.API.CreateSecretTagWithResponse(t.Context(), proj.ID,
+ api.CreateSecretTagJSONRequestBody{Slug: slug, Color: "#2563eb"})
+ require.NoError(t, err)
+ require.NotNilf(t, res.JSON200, "creating tag %s returned %d: %s", slug, res.StatusCode(), apierr.Body(res.Body))
+ return res.JSON200.Tag.Id.String()
+}
diff --git a/tests/suites/secretmanager/secrets/list_test.go b/tests/suites/secretmanager/secrets/list_test.go
new file mode 100644
index 0000000000..dafef7c9d2
--- /dev/null
+++ b/tests/suites/secretmanager/secrets/list_test.go
@@ -0,0 +1,240 @@
+package secrets_test
+
+import (
+ "context"
+ "net/http"
+ "testing"
+
+ "github.com/Infisical/infisical/tests/clients/api"
+ "github.com/Infisical/infisical/tests/fixture"
+ "github.com/Infisical/infisical/tests/fixture/secretmanager"
+ "github.com/Infisical/infisical/tests/harness"
+ "github.com/Infisical/infisical/tests/internal/apierr"
+ "github.com/stretchr/testify/require"
+)
+
+func TestSecret_List(t *testing.T) {
+ t.Parallel()
+ h := harness.From(t)
+
+ t.Run("should list only the secrets in the requested environment and path", func(t *testing.T) {
+ t.Parallel()
+
+ // Setup
+ proj := fixture.NewProject(t, h.NewTenant(t), fixture.WithProjectType("secret-manager"))
+ secretmanager.CreateFolder(t, proj, "dev", "/app")
+ secretmanager.CreateSecret(t, proj, "dev", "ROOT_KEY", "root")
+ secretmanager.CreateSecret(t, proj, "dev", "APP_KEY", "app", secretmanager.WithPath("/app"))
+ secretmanager.CreateSecret(t, proj, "prod", "ROOT_KEY", "prod")
+
+ // Action
+ secrets := secretmanager.ListSecrets(t, proj, "dev")
+
+ // Assert
+ require.Len(t, secrets, 1)
+ require.Equal(t, "ROOT_KEY", secrets[0].Key)
+ require.Equal(t, "root", secrets[0].Value)
+ })
+
+ t.Run("should include subfolder secrets with their paths when listing recursively", func(t *testing.T) {
+ t.Parallel()
+
+ // Setup
+ tn := h.NewTenant(t)
+ proj := fixture.NewProject(t, tn, fixture.WithProjectType("secret-manager"))
+ secretmanager.CreateFolder(t, proj, "dev", "/app/api")
+ secretmanager.CreateSecret(t, proj, "dev", "ROOT_KEY", "root")
+ secretmanager.CreateSecret(t, proj, "dev", "API_KEY", "api", secretmanager.WithPath("/app/api"))
+
+ // Action
+ res, err := tn.Admin.API.ListSecretsV4WithResponse(t.Context(), &api.ListSecretsV4Params{
+ ProjectId: &proj.ID,
+ Environment: new("dev"),
+ Recursive: new(api.ListSecretsV4ParamsRecursiveTrue),
+ })
+
+ // Assert
+ require.NoError(t, err)
+ require.NotNilf(t, res.JSON200, "listing returned %d: %s", res.StatusCode(), res.Body)
+ paths := map[string]string{}
+ for _, s := range res.JSON200.Secrets {
+ require.NotNil(t, s.SecretPath)
+ paths[s.SecretKey] = *s.SecretPath
+ }
+ require.Equal(t, map[string]string{"ROOT_KEY": "/", "API_KEY": "/app/api"}, paths)
+ })
+
+ t.Run("should return the secrets carrying any requested tag and leave out the rest", func(t *testing.T) {
+ t.Parallel()
+
+ // Setup
+ tn := h.NewTenant(t)
+ proj := fixture.NewProject(t, tn, fixture.WithProjectType("secret-manager"))
+ backend, billing, search := newTag(t, proj, "backend"), newTag(t, proj, "billing"), newTag(t, proj, "search")
+ for name, tags := range map[string][]string{
+ "BACKEND_KEY": {backend}, "BILLING_KEY": {billing}, "SEARCH_KEY": {search}, "UNTAGGED": {},
+ } {
+ res, err := tn.Admin.API.CreateSecretV4WithResponse(t.Context(), name,
+ api.CreateSecretV4JSONRequestBody{ProjectId: proj.ID, Environment: "dev", SecretValue: "v", TagIds: &tags})
+ require.NoError(t, err)
+ require.Equalf(t, http.StatusOK, res.StatusCode(), "creating %s returned %s", name, res.Body)
+ }
+
+ // Action
+ res, err := tn.Admin.API.ListSecretsV4WithResponse(t.Context(), &api.ListSecretsV4Params{
+ ProjectId: &proj.ID,
+ Environment: new("dev"),
+ TagSlugs: new("backend,billing"),
+ })
+
+ // Assert
+ require.NoError(t, err)
+ require.NotNilf(t, res.JSON200, "listing returned %d: %s", res.StatusCode(), res.Body)
+ keys := make([]string, 0, len(res.JSON200.Secrets))
+ for _, s := range res.JSON200.Secrets {
+ keys = append(keys, s.SecretKey)
+ }
+ require.ElementsMatch(t, []string{"BACKEND_KEY", "BILLING_KEY"}, keys)
+ })
+
+ t.Run("should return only the secrets whose metadata matches the filter", func(t *testing.T) {
+ t.Parallel()
+
+ // Setup
+ tn := h.NewTenant(t)
+ proj := fixture.NewProject(t, tn, fixture.WithProjectType("secret-manager"))
+ for name, team := range map[string]string{"PAYMENTS_KEY": "payments", "SEARCH_KEY": "search"} {
+ res, err := tn.Admin.API.CreateSecretV4WithResponse(t.Context(), name, api.CreateSecretV4JSONRequestBody{
+ ProjectId: proj.ID,
+ Environment: "dev",
+ SecretValue: "v",
+ SecretMetadata: &[]secretMetadataEntry{{Key: "team", Value: new(team)}},
+ })
+ require.NoError(t, err)
+ require.Equalf(t, http.StatusOK, res.StatusCode(), "creating %s returned %s", name, res.Body)
+ }
+
+ // Action
+ res, err := tn.Admin.API.ListSecretsV4WithResponse(t.Context(), &api.ListSecretsV4Params{
+ ProjectId: &proj.ID,
+ Environment: new("dev"),
+ MetadataFilter: new("key=team,value=payments"),
+ })
+
+ // Assert
+ require.NoError(t, err)
+ require.NotNilf(t, res.JSON200, "listing returned %d: %s", res.StatusCode(), res.Body)
+ require.Len(t, res.JSON200.Secrets, 1)
+ require.Equal(t, "PAYMENTS_KEY", res.JSON200.Secrets[0].SecretKey)
+ })
+
+ t.Run("should return imported secrets only when imports are included", func(t *testing.T) {
+ t.Parallel()
+
+ // Setup
+ tn := h.NewTenant(t)
+ proj := fixture.NewProject(t, tn, fixture.WithProjectType("secret-manager"))
+ secretmanager.CreateSecret(t, proj, "prod", "SHARED_KEY", "from-prod")
+ imp, err := tn.Admin.API.CreateSecretImportWithResponse(t.Context(), api.CreateSecretImportJSONRequestBody{
+ ProjectId: proj.ID,
+ Environment: "dev",
+ Path: new("/"),
+ Import: struct {
+ Environment string `json:"environment"`
+ Path string `json:"path"`
+ SourceProjectId *string `json:"sourceProjectId,omitempty"`
+ }{Environment: "prod", Path: "/"},
+ })
+ require.NoError(t, err)
+ require.NotNilf(t, imp.JSON200, "creating the import returned %d: %s", imp.StatusCode(), apierr.Body(imp.Body))
+
+ // Action
+ included, err := tn.Admin.API.ListSecretsV4WithResponse(t.Context(), &api.ListSecretsV4Params{
+ ProjectId: &proj.ID, Environment: new("dev"),
+ })
+ require.NoError(t, err)
+ excluded, err := tn.Admin.API.ListSecretsV4WithResponse(t.Context(), &api.ListSecretsV4Params{
+ ProjectId: &proj.ID, Environment: new("dev"), IncludeImports: new(api.ListSecretsV4ParamsIncludeImportsFalse),
+ })
+ require.NoError(t, err)
+
+ // Assert
+ require.NotNilf(t, included.JSON200, "listing returned %d: %s", included.StatusCode(), included.Body)
+ require.NotNil(t, included.JSON200.Imports)
+ require.Len(t, *included.JSON200.Imports, 1)
+ imported := (*included.JSON200.Imports)[0]
+ require.Equal(t, "prod", imported.Environment)
+ require.Len(t, imported.Secrets, 1)
+ require.Equal(t, "from-prod", imported.Secrets[0].SecretValue)
+
+ require.NotNilf(t, excluded.JSON200, "listing returned %d: %s", excluded.StatusCode(), excluded.Body)
+ require.True(t, excluded.JSON200.Imports == nil || len(*excluded.JSON200.Imports) == 0,
+ "imports were returned although they were excluded: %s", excluded.Body)
+ })
+
+ t.Run("should answer not modified for a matching etag and a new body after a write", func(t *testing.T) {
+ t.Parallel()
+
+ // Setup
+ tn := h.NewTenant(t)
+ proj := fixture.NewProject(t, tn, fixture.WithProjectType("secret-manager"))
+ secretmanager.CreateSecret(t, proj, "dev", "API_KEY", "old")
+ params := &api.ListSecretsV4Params{ProjectId: &proj.ID, Environment: new("dev")}
+ first, err := tn.Admin.API.ListSecretsV4WithResponse(t.Context(), params)
+ require.NoError(t, err)
+ etag := first.HTTPResponse.Header.Get("ETag")
+ require.NotEmpty(t, etag, "the list response carried no ETag")
+ ifNoneMatch := func(_ context.Context, req *http.Request) error {
+ req.Header.Set("If-None-Match", etag)
+ return nil
+ }
+
+ // Action
+ unchanged, err := tn.Admin.API.ListSecretsV4WithResponse(t.Context(), params, ifNoneMatch)
+ require.NoError(t, err)
+ secretmanager.UpdateSecret(t, proj, "dev", "API_KEY", "new")
+ changed, err := tn.Admin.API.ListSecretsV4WithResponse(t.Context(), params, ifNoneMatch)
+ require.NoError(t, err)
+
+ // Assert
+ require.Equal(t, http.StatusNotModified, unchanged.StatusCode())
+ require.NotNilf(t, changed.JSON200, "listing after a write returned %d: %s", changed.StatusCode(), changed.Body)
+ require.Equal(t, "new", changed.JSON200.Secrets[0].SecretValue)
+ })
+
+ t.Run("should refuse a list without an environment", func(t *testing.T) {
+ t.Parallel()
+
+ // Setup
+ tn := h.NewTenant(t)
+ proj := fixture.NewProject(t, tn, fixture.WithProjectType("secret-manager"))
+
+ // Action
+ res, err := tn.Admin.API.ListSecretsV4WithResponse(t.Context(), &api.ListSecretsV4Params{ProjectId: &proj.ID})
+
+ // Assert
+ require.NoError(t, err)
+ require.Equal(t, http.StatusBadRequest, res.StatusCode())
+ require.Equal(t, "Missing project id or environment", res.JSON400.Message)
+ })
+
+ t.Run("should return not found for a path that does not exist", func(t *testing.T) {
+ t.Parallel()
+
+ // Setup
+ tn := h.NewTenant(t)
+ proj := fixture.NewProject(t, tn, fixture.WithProjectType("secret-manager"))
+
+ // Action
+ res, err := tn.Admin.API.ListSecretsV4WithResponse(t.Context(), &api.ListSecretsV4Params{
+ ProjectId: &proj.ID, Environment: new("dev"), SecretPath: new("/nope"),
+ })
+
+ // Assert
+ require.NoError(t, err)
+ require.Equal(t, http.StatusNotFound, res.StatusCode())
+ require.Equal(t,
+ "Folder with path '/nope' in environment 'dev' was not found. Please ensure the environment slug and secret path is correct.",
+ res.JSON404.Message)
+ })
+}
diff --git a/tests/suites/secretmanager/secrets/update_test.go b/tests/suites/secretmanager/secrets/update_test.go
new file mode 100644
index 0000000000..286afb35af
--- /dev/null
+++ b/tests/suites/secretmanager/secrets/update_test.go
@@ -0,0 +1,139 @@
+package secrets_test
+
+import (
+ "net/http"
+ "testing"
+
+ "github.com/Infisical/infisical/tests/clients/api"
+ "github.com/Infisical/infisical/tests/fixture"
+ "github.com/Infisical/infisical/tests/fixture/secretmanager"
+ "github.com/Infisical/infisical/tests/harness"
+ "github.com/stretchr/testify/require"
+)
+
+func TestSecret_Update(t *testing.T) {
+ t.Parallel()
+ h := harness.From(t)
+
+ t.Run("should return the new value and move to version 2", func(t *testing.T) {
+ t.Parallel()
+
+ // Setup
+ proj := fixture.NewProject(t, h.NewTenant(t), fixture.WithProjectType("secret-manager"))
+ secretmanager.CreateSecret(t, proj, "dev", "API_KEY", "old")
+
+ // Action
+ updated := secretmanager.UpdateSecret(t, proj, "dev", "API_KEY", "new")
+
+ // Assert
+ require.EqualValues(t, 2, updated.Version)
+ require.Equal(t, "new", secretmanager.GetSecret(t, proj, "dev", "API_KEY").Value)
+ })
+
+ t.Run("should move the value to the new name and free the old one when renamed", func(t *testing.T) {
+ t.Parallel()
+
+ // Setup
+ tn := h.NewTenant(t)
+ proj := fixture.NewProject(t, tn, fixture.WithProjectType("secret-manager"))
+ secretmanager.CreateSecret(t, proj, "dev", "OLD_NAME", "value")
+
+ // Action
+ res, err := tn.Admin.API.UpdateSecretV4WithResponse(t.Context(), "OLD_NAME",
+ api.UpdateSecretV4JSONRequestBody{ProjectId: proj.ID, Environment: "dev", NewSecretName: new("NEW_NAME")})
+
+ // Assert
+ require.NoError(t, err)
+ require.Equalf(t, http.StatusOK, res.StatusCode(), "renaming returned %s", res.Body)
+ require.Equal(t, "value", secretmanager.GetSecret(t, proj, "dev", "NEW_NAME").Value)
+ secrets := secretmanager.ListSecrets(t, proj, "dev")
+ require.Len(t, secrets, 1)
+ require.Equal(t, "NEW_NAME", secrets[0].Key)
+ })
+
+ t.Run("should refuse a rename onto an existing name and keep both secrets", func(t *testing.T) {
+ t.Parallel()
+
+ // Setup
+ tn := h.NewTenant(t)
+ proj := fixture.NewProject(t, tn, fixture.WithProjectType("secret-manager"))
+ secretmanager.CreateSecret(t, proj, "dev", "FIRST", "one")
+ secretmanager.CreateSecret(t, proj, "dev", "SECOND", "two")
+
+ // Action
+ res, err := tn.Admin.API.UpdateSecretV4WithResponse(t.Context(), "FIRST",
+ api.UpdateSecretV4JSONRequestBody{ProjectId: proj.ID, Environment: "dev", NewSecretName: new("SECOND")})
+
+ // Assert
+ require.NoError(t, err)
+ require.Equal(t, http.StatusBadRequest, res.StatusCode())
+ require.Equal(t, "Secret with the new name already exists", res.JSON400.Message)
+ require.Equal(t, "one", secretmanager.GetSecret(t, proj, "dev", "FIRST").Value)
+ require.Equal(t, "two", secretmanager.GetSecret(t, proj, "dev", "SECOND").Value)
+ })
+
+ t.Run("should replace the tags and keep the value when only tags are sent", func(t *testing.T) {
+ t.Parallel()
+
+ // Setup
+ tn := h.NewTenant(t)
+ proj := fixture.NewProject(t, tn, fixture.WithProjectType("secret-manager"))
+ oldTag, newTagID := newTag(t, proj, "old-tag"), newTag(t, proj, "new-tag")
+ _, err := tn.Admin.API.CreateSecretV4WithResponse(t.Context(), "TAGGED",
+ api.CreateSecretV4JSONRequestBody{ProjectId: proj.ID, Environment: "dev", SecretValue: "value", TagIds: &[]string{oldTag}})
+ require.NoError(t, err)
+
+ // Action
+ res, err := tn.Admin.API.UpdateSecretV4WithResponse(t.Context(), "TAGGED",
+ api.UpdateSecretV4JSONRequestBody{ProjectId: proj.ID, Environment: "dev", TagIds: &[]string{newTagID}})
+ require.NoError(t, err)
+ require.Equalf(t, http.StatusOK, res.StatusCode(), "retagging returned %s", res.Body)
+
+ // Assert
+ got, err := tn.Admin.API.GetSecretByNameV4WithResponse(t.Context(), "TAGGED",
+ &api.GetSecretByNameV4Params{ProjectId: proj.ID, Environment: new("dev")})
+ require.NoError(t, err)
+ require.NotNilf(t, got.JSON200, "reading returned %d: %s", got.StatusCode(), got.Body)
+ require.Equal(t, "value", got.JSON200.Secret.SecretValue)
+ require.NotNil(t, got.JSON200.Secret.Tags)
+ require.Len(t, *got.JSON200.Secret.Tags, 1)
+ require.Equal(t, "new-tag", (*got.JSON200.Secret.Tags)[0].Slug)
+ })
+
+ t.Run("should return not found and create nothing when the secret does not exist", func(t *testing.T) {
+ t.Parallel()
+
+ // Setup
+ tn := h.NewTenant(t)
+ proj := fixture.NewProject(t, tn, fixture.WithProjectType("secret-manager"))
+
+ // Action
+ res, err := tn.Admin.API.UpdateSecretV4WithResponse(t.Context(), "NOPE",
+ api.UpdateSecretV4JSONRequestBody{ProjectId: proj.ID, Environment: "dev", SecretValue: new("value")})
+
+ // Assert
+ require.NoError(t, err)
+ require.Equal(t, http.StatusNotFound, res.StatusCode())
+ require.Equal(t, "Secret with name NOPE not found", res.JSON404.Message)
+ require.Empty(t, secretmanager.ListSecrets(t, proj, "dev"))
+ })
+
+ t.Run("should refuse and keep the value when the actor is a project viewer", func(t *testing.T) {
+ t.Parallel()
+
+ // Setup
+ proj := fixture.NewProject(t, h.NewTenant(t), fixture.WithProjectType("secret-manager"))
+ viewer := proj.NewMachineIdentity(t, fixture.WithRoles("viewer"))
+ secretmanager.CreateSecret(t, proj, "dev", "API_KEY", "original")
+
+ // Action
+ res, err := viewer.API.UpdateSecretV4WithResponse(t.Context(), "API_KEY",
+ api.UpdateSecretV4JSONRequestBody{ProjectId: proj.ID, Environment: "dev", SecretValue: new("changed")})
+
+ // Assert
+ require.NoError(t, err)
+ require.Equal(t, http.StatusForbidden, res.StatusCode())
+ require.Equal(t, "You are not allowed to edit on secrets", res.JSON403.Message)
+ require.Equal(t, "original", secretmanager.GetSecret(t, proj, "dev", "API_KEY").Value)
+ })
+}