diff --git a/pkg/acceptance/bettertestspoc/config/config_test.go b/pkg/acceptance/bettertestspoc/config/config_test.go index e9f4a3ec059..92e18b2b148 100644 --- a/pkg/acceptance/bettertestspoc/config/config_test.go +++ b/pkg/acceptance/bettertestspoc/config/config_test.go @@ -97,7 +97,8 @@ func Test_DatasourceFromModelPoc(t *testing.T) { t.Run("test basic", func(t *testing.T) { datasourceModel := datasourcemodel.Databases("test") expectedOutput := strings.TrimPrefix(` -data "snowflake_databases" "test" {} +data "snowflake_databases" "test" { +} `, "\n") result := config.DatasourceFromModel(t, datasourceModel) diff --git a/pkg/acceptance/bettertestspoc/config/datasourcemodel/accounts_model_gen.go b/pkg/acceptance/bettertestspoc/config/datasourcemodel/accounts_model_gen.go index f21a456df80..efd04d6c4bc 100644 --- a/pkg/acceptance/bettertestspoc/config/datasourcemodel/accounts_model_gen.go +++ b/pkg/acceptance/bettertestspoc/config/datasourcemodel/accounts_model_gen.go @@ -43,10 +43,12 @@ func (a *AccountsModel) MarshalJSON() ([]byte, error) { type Alias AccountsModel return json.Marshal(&struct { *Alias - DependsOn []string `json:"depends_on,omitempty"` + DependsOn []string `json:"depends_on,omitempty"` + SingleAttributeWorkaround config.ReplacementPlaceholder `json:"single_attribute_workaround,omitempty"` }{ - Alias: (*Alias)(a), - DependsOn: a.DependsOn(), + Alias: (*Alias)(a), + DependsOn: a.DependsOn(), + SingleAttributeWorkaround: config.SnowflakeProviderConfigSingleAttributeWorkaround, }) } diff --git a/pkg/acceptance/bettertestspoc/config/datasourcemodel/database_model_gen.go b/pkg/acceptance/bettertestspoc/config/datasourcemodel/database_model_gen.go index 7ecb98bf7d3..91affc0458b 100644 --- a/pkg/acceptance/bettertestspoc/config/datasourcemodel/database_model_gen.go +++ b/pkg/acceptance/bettertestspoc/config/datasourcemodel/database_model_gen.go @@ -54,10 +54,12 @@ func (d *DatabaseModel) MarshalJSON() ([]byte, error) { type Alias DatabaseModel return json.Marshal(&struct { *Alias - DependsOn []string `json:"depends_on,omitempty"` + DependsOn []string `json:"depends_on,omitempty"` + SingleAttributeWorkaround config.ReplacementPlaceholder `json:"single_attribute_workaround,omitempty"` }{ - Alias: (*Alias)(d), - DependsOn: d.DependsOn(), + Alias: (*Alias)(d), + DependsOn: d.DependsOn(), + SingleAttributeWorkaround: config.SnowflakeProviderConfigSingleAttributeWorkaround, }) } diff --git a/pkg/acceptance/bettertestspoc/config/datasourcemodel/database_role_model_gen.go b/pkg/acceptance/bettertestspoc/config/datasourcemodel/database_role_model_gen.go index 053f0f5376d..164fd6b8944 100644 --- a/pkg/acceptance/bettertestspoc/config/datasourcemodel/database_role_model_gen.go +++ b/pkg/acceptance/bettertestspoc/config/datasourcemodel/database_role_model_gen.go @@ -53,10 +53,12 @@ func (d *DatabaseRoleModel) MarshalJSON() ([]byte, error) { type Alias DatabaseRoleModel return json.Marshal(&struct { *Alias - DependsOn []string `json:"depends_on,omitempty"` + DependsOn []string `json:"depends_on,omitempty"` + SingleAttributeWorkaround config.ReplacementPlaceholder `json:"single_attribute_workaround,omitempty"` }{ - Alias: (*Alias)(d), - DependsOn: d.DependsOn(), + Alias: (*Alias)(d), + DependsOn: d.DependsOn(), + SingleAttributeWorkaround: config.SnowflakeProviderConfigSingleAttributeWorkaround, }) } diff --git a/pkg/acceptance/bettertestspoc/config/datasourcemodel/database_roles_model_gen.go b/pkg/acceptance/bettertestspoc/config/datasourcemodel/database_roles_model_gen.go index 74d3435fe55..0d82048e02d 100644 --- a/pkg/acceptance/bettertestspoc/config/datasourcemodel/database_roles_model_gen.go +++ b/pkg/acceptance/bettertestspoc/config/datasourcemodel/database_roles_model_gen.go @@ -49,10 +49,12 @@ func (d *DatabaseRolesModel) MarshalJSON() ([]byte, error) { type Alias DatabaseRolesModel return json.Marshal(&struct { *Alias - DependsOn []string `json:"depends_on,omitempty"` + DependsOn []string `json:"depends_on,omitempty"` + SingleAttributeWorkaround config.ReplacementPlaceholder `json:"single_attribute_workaround,omitempty"` }{ - Alias: (*Alias)(d), - DependsOn: d.DependsOn(), + Alias: (*Alias)(d), + DependsOn: d.DependsOn(), + SingleAttributeWorkaround: config.SnowflakeProviderConfigSingleAttributeWorkaround, }) } diff --git a/pkg/acceptance/bettertestspoc/config/datasourcemodel/databases_model_gen.go b/pkg/acceptance/bettertestspoc/config/datasourcemodel/databases_model_gen.go index bab46b9750e..b6ff8e12572 100644 --- a/pkg/acceptance/bettertestspoc/config/datasourcemodel/databases_model_gen.go +++ b/pkg/acceptance/bettertestspoc/config/datasourcemodel/databases_model_gen.go @@ -46,10 +46,12 @@ func (d *DatabasesModel) MarshalJSON() ([]byte, error) { type Alias DatabasesModel return json.Marshal(&struct { *Alias - DependsOn []string `json:"depends_on,omitempty"` + DependsOn []string `json:"depends_on,omitempty"` + SingleAttributeWorkaround config.ReplacementPlaceholder `json:"single_attribute_workaround,omitempty"` }{ - Alias: (*Alias)(d), - DependsOn: d.DependsOn(), + Alias: (*Alias)(d), + DependsOn: d.DependsOn(), + SingleAttributeWorkaround: config.SnowflakeProviderConfigSingleAttributeWorkaround, }) } diff --git a/pkg/acceptance/bettertestspoc/config/datasourcemodel/gen/datasource_schema_def.go b/pkg/acceptance/bettertestspoc/config/datasourcemodel/gen/datasource_schema_def.go index 4841a41e3db..2674d03810e 100644 --- a/pkg/acceptance/bettertestspoc/config/datasourcemodel/gen/datasource_schema_def.go +++ b/pkg/acceptance/bettertestspoc/config/datasourcemodel/gen/datasource_schema_def.go @@ -22,6 +22,10 @@ func GetDatasourceSchemaDetails() []genhelpers.ResourceSchemaDetails { } var allDatasourcesSchemaDefs = []DatasourceSchemaDef{ + { + name: "Accounts", + schema: datasources.Accounts().Schema, + }, { name: "Database", schema: datasources.Database().Schema, @@ -39,7 +43,7 @@ var allDatasourcesSchemaDefs = []DatasourceSchemaDef{ schema: datasources.Databases().Schema, }, { - name: "Accounts", - schema: datasources.Accounts().Schema, + name: "Grants", + schema: datasources.Grants().Schema, }, } diff --git a/pkg/acceptance/bettertestspoc/config/datasourcemodel/gen/templates/marshal_json.tmpl b/pkg/acceptance/bettertestspoc/config/datasourcemodel/gen/templates/marshal_json.tmpl index 96c00d6e1bc..0de389fe128 100644 --- a/pkg/acceptance/bettertestspoc/config/datasourcemodel/gen/templates/marshal_json.tmpl +++ b/pkg/acceptance/bettertestspoc/config/datasourcemodel/gen/templates/marshal_json.tmpl @@ -11,10 +11,12 @@ func ({{ $modelVar }} *{{ $modelName }}) MarshalJSON() ([]byte, error) { type Alias {{ $modelName }} return json.Marshal(&struct { *Alias - DependsOn []string `json:"depends_on,omitempty"` + DependsOn []string `json:"depends_on,omitempty"` + SingleAttributeWorkaround config.ReplacementPlaceholder `json:"single_attribute_workaround,omitempty"` }{ - Alias: (*Alias)({{ $modelVar }}), - DependsOn: {{ $modelVar }}.DependsOn(), + Alias: (*Alias)({{ $modelVar }}), + DependsOn: {{ $modelVar }}.DependsOn(), + SingleAttributeWorkaround: config.SnowflakeProviderConfigSingleAttributeWorkaround, }) } diff --git a/pkg/acceptance/bettertestspoc/config/datasourcemodel/grants_model_ext.go b/pkg/acceptance/bettertestspoc/config/datasourcemodel/grants_model_ext.go new file mode 100644 index 00000000000..1adf9d95882 --- /dev/null +++ b/pkg/acceptance/bettertestspoc/config/datasourcemodel/grants_model_ext.go @@ -0,0 +1,124 @@ +package datasourcemodel + +import ( + "fmt" + + tfconfig "github.com/hashicorp/terraform-plugin-testing/config" + + "github.com/Snowflake-Labs/terraform-provider-snowflake/pkg/acceptance/bettertestspoc/config" + "github.com/Snowflake-Labs/terraform-provider-snowflake/pkg/sdk" +) + +func GrantsOnAccount( + datasourceName string, +) *GrantsModel { + return Grants(datasourceName). + WithGrantsOnValue( + tfconfig.ObjectVariable(map[string]tfconfig.Variable{ + "account": tfconfig.BoolVariable(true), + }), + ) +} + +func GrantsOnAccountObject( + datasourceName string, + id sdk.AccountObjectIdentifier, + objectType sdk.ObjectType, +) *GrantsModel { + return Grants(datasourceName). + WithGrantsOnValue( + tfconfig.ObjectVariable(map[string]tfconfig.Variable{ + "object_name": tfconfig.StringVariable(id.Name()), + "object_type": tfconfig.StringVariable(fmt.Sprintf("%s", objectType)), + }), + ) +} + +func GrantsOnDatabaseObject( + datasourceName string, + id sdk.DatabaseObjectIdentifier, + objectType sdk.ObjectType, +) *GrantsModel { + return Grants(datasourceName). + WithGrantsOnValue( + tfconfig.ObjectVariable(map[string]tfconfig.Variable{ + "object_name": tfconfig.StringVariable(id.FullyQualifiedName()), + "object_type": tfconfig.StringVariable(fmt.Sprintf("%s", objectType)), + }), + ) +} + +func GrantsOnSchemaObject( + datasourceName string, + id sdk.SchemaObjectIdentifier, + objectType sdk.ObjectType, +) *GrantsModel { + return Grants(datasourceName). + WithGrantsOnValue( + tfconfig.ObjectVariable(map[string]tfconfig.Variable{ + "object_name": tfconfig.StringVariable(id.FullyQualifiedName()), + "object_type": tfconfig.StringVariable(fmt.Sprintf("%s", objectType)), + }), + ) +} + +func GrantsOnSchemaObjectWithArguments( + datasourceName string, + id sdk.SchemaObjectIdentifierWithArguments, + objectType sdk.ObjectType, +) *GrantsModel { + return Grants(datasourceName). + WithGrantsOnValue( + tfconfig.ObjectVariable(map[string]tfconfig.Variable{ + "object_name": tfconfig.StringVariable(id.FullyQualifiedName()), + "object_type": tfconfig.StringVariable(fmt.Sprintf("%s", objectType)), + }), + ) +} + +func GrantsOnMissingObjectType( + datasourceName string, +) *GrantsModel { + return Grants(datasourceName). + WithGrantsOnValue( + tfconfig.ObjectVariable(map[string]tfconfig.Variable{ + "object_name": tfconfig.StringVariable("DATABASE"), + }), + ) +} + +func GrantsOnEmpty( + datasourceName string, +) *GrantsModel { + placeholder := fmt.Sprintf("%s", config.SnowflakeProviderConfigSingleAttributeWorkaround) + return Grants(datasourceName). + WithGrantsOnValue( + tfconfig.ObjectVariable(map[string]tfconfig.Variable{ + "placeholder": tfconfig.StringVariable(placeholder), + }), + ) +} + +func GrantsToDatabaseRole( + datasourceName string, + id sdk.DatabaseObjectIdentifier, +) *GrantsModel { + return Grants(datasourceName). + WithGrantsToValue( + tfconfig.ObjectVariable(map[string]tfconfig.Variable{ + "database_role": tfconfig.StringVariable(id.FullyQualifiedName()), + }), + ) +} + +func GrantsToUser( + datasourceName string, + id sdk.AccountObjectIdentifier, +) *GrantsModel { + return Grants(datasourceName). + WithGrantsToValue( + tfconfig.ObjectVariable(map[string]tfconfig.Variable{ + "user": tfconfig.StringVariable(id.Name()), + }), + ) +} diff --git a/pkg/acceptance/bettertestspoc/config/datasourcemodel/grants_model_ext_test.go b/pkg/acceptance/bettertestspoc/config/datasourcemodel/grants_model_ext_test.go new file mode 100644 index 00000000000..400362b7eda --- /dev/null +++ b/pkg/acceptance/bettertestspoc/config/datasourcemodel/grants_model_ext_test.go @@ -0,0 +1,115 @@ +package datasourcemodel_test + +import ( + "fmt" + "testing" + + "github.com/Snowflake-Labs/terraform-provider-snowflake/pkg/acceptance/bettertestspoc/config" + "github.com/Snowflake-Labs/terraform-provider-snowflake/pkg/acceptance/bettertestspoc/config/datasourcemodel" + "github.com/Snowflake-Labs/terraform-provider-snowflake/pkg/acceptance/helpers/random" + "github.com/Snowflake-Labs/terraform-provider-snowflake/pkg/sdk" + "github.com/stretchr/testify/require" +) + +func Test_GrantsModel(t *testing.T) { + t.Run("on account", func(t *testing.T) { + expected := `data "snowflake_grants" "test" { + grants_on { + account = true + } +} +` + + result := config.FromModels(t, datasourcemodel.GrantsOnAccount("test")) + + require.Equal(t, expected, result) + }) + + t.Run("on account object", func(t *testing.T) { + id := randomAccountObjectIdentifier() + expected := fmt.Sprintf(`data "snowflake_grants" "test" { + grants_on { + object_name = "%s" + object_type = "DATABASE" + } +} +`, id.Name()) + + result := config.FromModels(t, datasourcemodel.GrantsOnAccountObject("test", id, sdk.ObjectTypeDatabase)) + + require.Equal(t, expected, result) + }) + + t.Run("on database object", func(t *testing.T) { + id := randomDatabaseObjectIdentifier() + expected := fmt.Sprintf(`data "snowflake_grants" "test" { + grants_on { + object_name = "\"%s\".\"%s\"" + object_type = "SCHEMA" + } +} +`, id.DatabaseName(), id.Name()) + + result := config.FromModels(t, datasourcemodel.GrantsOnDatabaseObject("test", id, sdk.ObjectTypeSchema)) + + require.Equal(t, expected, result) + }) + + t.Run("on schema object", func(t *testing.T) { + id := randomSchemaObjectIdentifier() + expected := fmt.Sprintf(`data "snowflake_grants" "test" { + grants_on { + object_name = "\"%s\".\"%s\".\"%s\"" + object_type = "VIEW" + } +} +`, id.DatabaseName(), id.SchemaName(), id.Name()) + + result := config.FromModels(t, datasourcemodel.GrantsOnSchemaObject("test", id, sdk.ObjectTypeView)) + + require.Equal(t, expected, result) + }) + + t.Run("on schema object with arguments", func(t *testing.T) { + id := randomSchemaObjectIdentifierWithArguments(sdk.DataTypeVARCHAR) + expected := fmt.Sprintf(`data "snowflake_grants" "test" { + grants_on { + object_name = "\"%s\".\"%s\".\"%s\"(%s)" + object_type = "FUNCTION" + } +} +`, id.DatabaseName(), id.SchemaName(), id.Name(), sdk.DataTypeVARCHAR) + + result := config.FromModels(t, datasourcemodel.GrantsOnSchemaObjectWithArguments("test", id, sdk.ObjectTypeFunction)) + + require.Equal(t, expected, result) + }) + + t.Run("on empty", func(t *testing.T) { + expected := `data "snowflake_grants" "test" { + grants_on { + } +} +` + + result := config.FromModels(t, datasourcemodel.GrantsOnEmpty("test")) + + require.Equal(t, expected, result) + }) +} + +func randomAccountObjectIdentifier() sdk.AccountObjectIdentifier { + return sdk.NewAccountObjectIdentifier(random.AlphaN(12)) +} + +func randomDatabaseObjectIdentifier() sdk.DatabaseObjectIdentifier { + return sdk.NewDatabaseObjectIdentifier(random.AlphaN(12), random.AlphaN(12)) +} + +func randomSchemaObjectIdentifier() sdk.SchemaObjectIdentifier { + return sdk.NewSchemaObjectIdentifier(random.AlphaN(12), random.AlphaN(12), random.AlphaN(12)) +} + +func randomSchemaObjectIdentifierWithArguments(argumentDataTypes ...sdk.DataType) sdk.SchemaObjectIdentifierWithArguments { + return sdk.NewSchemaObjectIdentifierWithArguments(random.AlphaN(12), random.AlphaN(12), random.AlphaN(12), argumentDataTypes...) +} diff --git a/pkg/acceptance/bettertestspoc/config/datasourcemodel/grants_model_gen.go b/pkg/acceptance/bettertestspoc/config/datasourcemodel/grants_model_gen.go new file mode 100644 index 00000000000..39e483254be --- /dev/null +++ b/pkg/acceptance/bettertestspoc/config/datasourcemodel/grants_model_gen.go @@ -0,0 +1,111 @@ +// Code generated by config model builder generator; DO NOT EDIT. + +package datasourcemodel + +import ( + "encoding/json" + + tfconfig "github.com/hashicorp/terraform-plugin-testing/config" + + "github.com/Snowflake-Labs/terraform-provider-snowflake/pkg/acceptance/bettertestspoc/config" + "github.com/Snowflake-Labs/terraform-provider-snowflake/pkg/provider/datasources" +) + +type GrantsModel struct { + FutureGrantsIn tfconfig.Variable `json:"future_grants_in,omitempty"` + FutureGrantsTo tfconfig.Variable `json:"future_grants_to,omitempty"` + Grants tfconfig.Variable `json:"grants,omitempty"` + GrantsOf tfconfig.Variable `json:"grants_of,omitempty"` + GrantsOn tfconfig.Variable `json:"grants_on,omitempty"` + GrantsTo tfconfig.Variable `json:"grants_to,omitempty"` + + *config.DatasourceModelMeta +} + +///////////////////////////////////////////////// +// Basic builders (resource name and required) // +///////////////////////////////////////////////// + +func Grants( + datasourceName string, +) *GrantsModel { + g := &GrantsModel{DatasourceModelMeta: config.DatasourceMeta(datasourceName, datasources.Grants)} + return g +} + +func GrantsWithDefaultMeta() *GrantsModel { + g := &GrantsModel{DatasourceModelMeta: config.DatasourceDefaultMeta(datasources.Grants)} + return g +} + +/////////////////////////////////////////////////////// +// set proper json marshalling and handle depends on // +/////////////////////////////////////////////////////// + +func (g *GrantsModel) MarshalJSON() ([]byte, error) { + type Alias GrantsModel + return json.Marshal(&struct { + *Alias + DependsOn []string `json:"depends_on,omitempty"` + SingleAttributeWorkaround config.ReplacementPlaceholder `json:"single_attribute_workaround,omitempty"` + }{ + Alias: (*Alias)(g), + DependsOn: g.DependsOn(), + SingleAttributeWorkaround: config.SnowflakeProviderConfigSingleAttributeWorkaround, + }) +} + +func (g *GrantsModel) WithDependsOn(values ...string) *GrantsModel { + g.SetDependsOn(values...) + return g +} + +///////////////////////////////// +// below all the proper values // +///////////////////////////////// + +// future_grants_in attribute type is not yet supported, so WithFutureGrantsIn can't be generated + +// future_grants_to attribute type is not yet supported, so WithFutureGrantsTo can't be generated + +// grants attribute type is not yet supported, so WithGrants can't be generated + +// grants_of attribute type is not yet supported, so WithGrantsOf can't be generated + +// grants_on attribute type is not yet supported, so WithGrantsOn can't be generated + +// grants_to attribute type is not yet supported, so WithGrantsTo can't be generated + +////////////////////////////////////////// +// below it's possible to set any value // +////////////////////////////////////////// + +func (g *GrantsModel) WithFutureGrantsInValue(value tfconfig.Variable) *GrantsModel { + g.FutureGrantsIn = value + return g +} + +func (g *GrantsModel) WithFutureGrantsToValue(value tfconfig.Variable) *GrantsModel { + g.FutureGrantsTo = value + return g +} + +func (g *GrantsModel) WithGrantsValue(value tfconfig.Variable) *GrantsModel { + g.Grants = value + return g +} + +func (g *GrantsModel) WithGrantsOfValue(value tfconfig.Variable) *GrantsModel { + g.GrantsOf = value + return g +} + +func (g *GrantsModel) WithGrantsOnValue(value tfconfig.Variable) *GrantsModel { + g.GrantsOn = value + return g +} + +func (g *GrantsModel) WithGrantsToValue(value tfconfig.Variable) *GrantsModel { + g.GrantsTo = value + return g +} diff --git a/pkg/acceptance/bettertestspoc/config/hcl_config_provider.go b/pkg/acceptance/bettertestspoc/config/hcl_config_provider.go index e96fe57d166..78d20a83d35 100644 --- a/pkg/acceptance/bettertestspoc/config/hcl_config_provider.go +++ b/pkg/acceptance/bettertestspoc/config/hcl_config_provider.go @@ -10,7 +10,7 @@ import ( hclv1parser "github.com/hashicorp/hcl/json/parser" ) -var DefaultHclConfigProvider = NewHclV1ConfigProvider(replaceNullPlaceholders, unquoteBlockType, fixBlockArguments, replaceMultilinePlaceholders, unquoteArguments, unquoteArguments, removeDoubleNewlines, unquoteDependsOnReferences) +var DefaultHclConfigProvider = NewHclV1ConfigProvider(replaceNullPlaceholders, removeSingleAttributeWorkaroundLines, unquoteBlockType, fixBlockArguments, replaceMultilinePlaceholders, unquoteArguments, removeDoubleNewlines, unquoteDependsOnReferences) // HclConfigProvider defines methods to generate .tf config from .tf.json configs. type HclConfigProvider interface { @@ -98,6 +98,13 @@ EOT`), `\n`, ` `), nil } +// Conversion to HCL using hcl v1 has problem with nested jsons where there is only one child value. +// Current workaround used is to add the placeholder attribute which is later removed from the resulting HCL. +func removeSingleAttributeWorkaroundLines(s string) (string, error) { + lineToRemoveRegex := regexp.MustCompile(fmt.Sprintf(`( +)"(.*)"( += +)"%s"\n`, SnowflakeProviderConfigSingleAttributeWorkaround)) + return lineToRemoveRegex.ReplaceAllString(s, ""), nil +} + // Conversion to HCL using hcl v1 does not unquote arguments. // Check experiments subpackage for details. func unquoteArguments(s string) (string, error) { diff --git a/pkg/acceptance/bettertestspoc/config/hcl_config_provider_test.go b/pkg/acceptance/bettertestspoc/config/hcl_config_provider_test.go index 431e6c36811..97f4502c1ee 100644 --- a/pkg/acceptance/bettertestspoc/config/hcl_config_provider_test.go +++ b/pkg/acceptance/bettertestspoc/config/hcl_config_provider_test.go @@ -103,4 +103,53 @@ EOT _, err := config.DefaultHclConfigProvider.HclFromJson([]byte(resourceJson)) require.ErrorContains(t, err, "object expected closing RBRACE got: EOF") }) + + t.Run("document improper handling when there is only one value inside", func(t *testing.T) { + datasourceJson := `{ + "data": { + "snowflake_grants": { + "test": { + "grants_on": { + "account": true + } + } + } + } + }` + expectedResult := `"data" "snowflake_grants" "test" "grants_on" { + account = true +} +` + + result, err := config.DefaultHclConfigProvider.HclFromJson([]byte(datasourceJson)) + + require.NoError(t, err) + require.Equal(t, expectedResult, result) + }) + + t.Run("only one value inside - working with special formatter", func(t *testing.T) { + datasourceJson := `{ + "data": { + "snowflake_grants": { + "test": { + "grants_on": { + "account": true + }, + "any_name": "SF_TF_TEST_SINGLE_ATTRIBUTE_WORKAROUND" + } + } + } + }` + expectedResult := `data "snowflake_grants" "test" { + grants_on { + account = true + } +} +` + + result, err := config.DefaultHclConfigProvider.HclFromJson([]byte(datasourceJson)) + + require.NoError(t, err) + require.Equal(t, expectedResult, result) + }) } diff --git a/pkg/acceptance/bettertestspoc/config/json_config_provider_test.go b/pkg/acceptance/bettertestspoc/config/json_config_provider_test.go index 0d8850dc203..7c467eb38dd 100644 --- a/pkg/acceptance/bettertestspoc/config/json_config_provider_test.go +++ b/pkg/acceptance/bettertestspoc/config/json_config_provider_test.go @@ -91,7 +91,9 @@ func Test_JsonConfigProvider(t *testing.T) { expectedResult := `{ "data": { "snowflake_databases": { - "some_name": {} + "some_name": { + "single_attribute_workaround": "SF_TF_TEST_SINGLE_ATTRIBUTE_WORKAROUND" + } } } }` diff --git a/pkg/acceptance/bettertestspoc/config/placeholders.go b/pkg/acceptance/bettertestspoc/config/placeholders.go index c54e892d79e..e3b3914a4f8 100644 --- a/pkg/acceptance/bettertestspoc/config/placeholders.go +++ b/pkg/acceptance/bettertestspoc/config/placeholders.go @@ -3,6 +3,7 @@ package config type ReplacementPlaceholder string const ( - SnowflakeProviderConfigNull ReplacementPlaceholder = "SF_TF_TEST_NULL_PLACEHOLDER" - SnowflakeProviderConfigMultilineMarker ReplacementPlaceholder = "SF_TF_TEST_MULTILINE_MARKER_PLACEHOLDER" + SnowflakeProviderConfigNull ReplacementPlaceholder = "SF_TF_TEST_NULL_PLACEHOLDER" + SnowflakeProviderConfigMultilineMarker ReplacementPlaceholder = "SF_TF_TEST_MULTILINE_MARKER_PLACEHOLDER" + SnowflakeProviderConfigSingleAttributeWorkaround ReplacementPlaceholder = "SF_TF_TEST_SINGLE_ATTRIBUTE_WORKAROUND" ) diff --git a/pkg/datasources/databases_acceptance_test.go b/pkg/datasources/databases_acceptance_test.go index 6f294030ffd..223ebe82265 100644 --- a/pkg/datasources/databases_acceptance_test.go +++ b/pkg/datasources/databases_acceptance_test.go @@ -17,7 +17,7 @@ import ( ) func TestAcc_Databases_Complete(t *testing.T) { - _ = testenvs.GetOrSkipTest(t, testenvs.ConfigureClientOnce) + _ = testenvs.GetOrSkipTest(t, testenvs.EnableAcceptance) acc.TestAccPreCheck(t) databaseId := acc.TestClient().Ids.RandomAccountObjectIdentifier() @@ -117,7 +117,7 @@ func TestAcc_Databases_Complete(t *testing.T) { } func TestAcc_Databases_DifferentFiltering(t *testing.T) { - _ = testenvs.GetOrSkipTest(t, testenvs.ConfigureClientOnce) + _ = testenvs.GetOrSkipTest(t, testenvs.EnableAcceptance) acc.TestAccPreCheck(t) prefix := random.AlphaN(4) diff --git a/pkg/datasources/dynamic_tables_acceptance_test.go b/pkg/datasources/dynamic_tables_acceptance_test.go index 828bed57675..3c5eb68b0f2 100644 --- a/pkg/datasources/dynamic_tables_acceptance_test.go +++ b/pkg/datasources/dynamic_tables_acceptance_test.go @@ -7,28 +7,32 @@ import ( acc "github.com/Snowflake-Labs/terraform-provider-snowflake/pkg/acceptance" + "github.com/Snowflake-Labs/terraform-provider-snowflake/pkg/acceptance/testenvs" "github.com/hashicorp/terraform-plugin-testing/config" "github.com/hashicorp/terraform-plugin-testing/helper/resource" "github.com/hashicorp/terraform-plugin-testing/tfversion" ) func TestAcc_DynamicTables_complete(t *testing.T) { - name := acc.TestClient().Ids.Alpha() - dataSourceName := "data.snowflake_dynamic_tables.dts" - tableName := name + "_table" + _ = testenvs.GetOrSkipTest(t, testenvs.EnableAcceptance) + acc.TestAccPreCheck(t) + + tableId := acc.TestClient().Ids.RandomSchemaObjectIdentifier() + dynamicTableId := acc.TestClient().Ids.RandomSchemaObjectIdentifier() m := func() map[string]config.Variable { return map[string]config.Variable{ - "name": config.StringVariable(name), + "name": config.StringVariable(dynamicTableId.Name()), "database": config.StringVariable(acc.TestDatabaseName), "schema": config.StringVariable(acc.TestSchemaName), "warehouse": config.StringVariable(acc.TestWarehouseName), - "query": config.StringVariable(fmt.Sprintf("select \"id\" from \"%v\".\"%v\".\"%v\"", acc.TestDatabaseName, acc.TestSchemaName, tableName)), + "query": config.StringVariable(fmt.Sprintf("select \"id\" from %v", tableId.FullyQualifiedName())), "comment": config.StringVariable("Terraform acceptance test"), - "table_name": config.StringVariable(tableName), + "table_name": config.StringVariable(tableId.Name()), } } variableSet1 := m() + dataSourceName := "data.snowflake_dynamic_tables.dts" resource.Test(t, resource.TestCase{ ProtoV6ProviderFactories: acc.TestAccProtoV6ProviderFactories, PreCheck: func() { acc.TestAccPreCheck(t) }, @@ -42,10 +46,10 @@ func TestAcc_DynamicTables_complete(t *testing.T) { ConfigVariables: variableSet1, Check: resource.ComposeTestCheckFunc( resource.TestCheckResourceAttr(dataSourceName, "like.#", "1"), - resource.TestCheckResourceAttr(dataSourceName, "like.0.pattern", name), + resource.TestCheckResourceAttr(dataSourceName, "like.0.pattern", dynamicTableId.Name()), resource.TestCheckResourceAttr(dataSourceName, "in.#", "1"), - resource.TestCheckResourceAttr(dataSourceName, "in.0.database", acc.TestDatabaseName), - resource.TestCheckResourceAttr(dataSourceName, "starts_with", name), + resource.TestCheckResourceAttr(dataSourceName, "in.0.database", dynamicTableId.DatabaseName()), + resource.TestCheckResourceAttr(dataSourceName, "starts_with", dynamicTableId.Name()), resource.TestCheckResourceAttr(dataSourceName, "limit.#", "1"), resource.TestCheckResourceAttr(dataSourceName, "limit.0.rows", "1"), diff --git a/pkg/datasources/external_functions_acceptance_test.go b/pkg/datasources/external_functions_acceptance_test.go index 016b26eac70..9e9cbf9ce12 100644 --- a/pkg/datasources/external_functions_acceptance_test.go +++ b/pkg/datasources/external_functions_acceptance_test.go @@ -5,27 +5,33 @@ import ( acc "github.com/Snowflake-Labs/terraform-provider-snowflake/pkg/acceptance" + "github.com/Snowflake-Labs/terraform-provider-snowflake/pkg/acceptance/helpers/random" + "github.com/Snowflake-Labs/terraform-provider-snowflake/pkg/acceptance/testenvs" "github.com/hashicorp/terraform-plugin-testing/config" "github.com/hashicorp/terraform-plugin-testing/helper/resource" "github.com/hashicorp/terraform-plugin-testing/tfversion" ) func TestAcc_ExternalFunctions_basic(t *testing.T) { - accName := acc.TestClient().Ids.Alpha() + _ = testenvs.GetOrSkipTest(t, testenvs.EnableAcceptance) + acc.TestAccPreCheck(t) + + id := acc.TestClient().Ids.RandomSchemaObjectIdentifier() + comment := random.Comment() + m := func() map[string]config.Variable { return map[string]config.Variable{ "database": config.StringVariable(acc.TestDatabaseName), "schema": config.StringVariable(acc.TestSchemaName), - "name": config.StringVariable(accName), + "name": config.StringVariable(id.Name()), "api_allowed_prefixes": config.ListVariable(config.StringVariable("https://123456.execute-api.us-west-2.amazonaws.com/prod/")), "url_of_proxy_and_resource": config.StringVariable("https://123456.execute-api.us-west-2.amazonaws.com/prod/test_func"), - "comment": config.StringVariable("Terraform acceptance test"), + "comment": config.StringVariable(comment), } } - - dataSourceName := "data.snowflake_external_functions.external_functions" configVariables := m() + dataSourceName := "data.snowflake_external_functions.external_functions" resource.Test(t, resource.TestCase{ ProtoV6ProviderFactories: acc.TestAccProtoV6ProviderFactories, PreCheck: func() { acc.TestAccPreCheck(t) }, @@ -40,11 +46,11 @@ func TestAcc_ExternalFunctions_basic(t *testing.T) { Check: resource.ComposeTestCheckFunc( resource.TestCheckResourceAttr(dataSourceName, "database", acc.TestDatabaseName), resource.TestCheckResourceAttr(dataSourceName, "schema", acc.TestSchemaName), - resource.TestCheckResourceAttrSet(dataSourceName, "external_functions.#"), - resource.TestCheckResourceAttrSet(dataSourceName, "external_functions.0.name"), - resource.TestCheckResourceAttrSet(dataSourceName, "external_functions.0.database"), - resource.TestCheckResourceAttrSet(dataSourceName, "external_functions.0.schema"), - resource.TestCheckResourceAttrSet(dataSourceName, "external_functions.0.comment"), + resource.TestCheckResourceAttr(dataSourceName, "external_functions.#", "1"), + resource.TestCheckResourceAttr(dataSourceName, "external_functions.0.name", id.Name()), + resource.TestCheckResourceAttr(dataSourceName, "external_functions.0.database", id.DatabaseName()), + resource.TestCheckResourceAttr(dataSourceName, "external_functions.0.schema", id.SchemaName()), + resource.TestCheckResourceAttr(dataSourceName, "external_functions.0.comment", comment), resource.TestCheckResourceAttrSet(dataSourceName, "external_functions.0.language"), ), }, @@ -53,15 +59,20 @@ func TestAcc_ExternalFunctions_basic(t *testing.T) { } func TestAcc_ExternalFunctions_no_database(t *testing.T) { - accName := acc.TestClient().Ids.Alpha() + _ = testenvs.GetOrSkipTest(t, testenvs.EnableAcceptance) + acc.TestAccPreCheck(t) + + id := acc.TestClient().Ids.RandomSchemaObjectIdentifier() + comment := random.Comment() + m := func() map[string]config.Variable { return map[string]config.Variable{ "database": config.StringVariable(acc.TestDatabaseName), "schema": config.StringVariable(acc.TestSchemaName), - "name": config.StringVariable(accName), + "name": config.StringVariable(id.Name()), "api_allowed_prefixes": config.ListVariable(config.StringVariable("https://123456.execute-api.us-west-2.amazonaws.com/prod/")), "url_of_proxy_and_resource": config.StringVariable("https://123456.execute-api.us-west-2.amazonaws.com/prod/test_func"), - "comment": config.StringVariable("Terraform acceptance test"), + "comment": config.StringVariable(comment), } } diff --git a/pkg/datasources/external_tables_acceptance_test.go b/pkg/datasources/external_tables_acceptance_test.go index 7deff130475..6bb68af9088 100644 --- a/pkg/datasources/external_tables_acceptance_test.go +++ b/pkg/datasources/external_tables_acceptance_test.go @@ -6,15 +6,19 @@ import ( acc "github.com/Snowflake-Labs/terraform-provider-snowflake/pkg/acceptance" + "github.com/Snowflake-Labs/terraform-provider-snowflake/pkg/acceptance/testenvs" + "github.com/Snowflake-Labs/terraform-provider-snowflake/pkg/sdk" "github.com/hashicorp/terraform-plugin-testing/helper/resource" "github.com/hashicorp/terraform-plugin-testing/tfversion" ) func TestAcc_ExternalTables(t *testing.T) { - databaseName := acc.TestClient().Ids.Alpha() - schemaName := acc.TestClient().Ids.Alpha() - stageName := acc.TestClient().Ids.Alpha() - externalTableName := acc.TestClient().Ids.Alpha() + _ = testenvs.GetOrSkipTest(t, testenvs.EnableAcceptance) + acc.TestAccPreCheck(t) + + stageId := acc.TestClient().Ids.RandomSchemaObjectIdentifier() + externalTableId := acc.TestClient().Ids.RandomSchemaObjectIdentifier() + resource.Test(t, resource.TestCase{ ProtoV6ProviderFactories: acc.TestAccProtoV6ProviderFactories, PreCheck: func() { acc.TestAccPreCheck(t) }, @@ -24,43 +28,33 @@ func TestAcc_ExternalTables(t *testing.T) { CheckDestroy: nil, Steps: []resource.TestStep{ { - Config: externalTables(databaseName, schemaName, stageName, externalTableName), + Config: externalTables(stageId, externalTableId), Check: resource.ComposeTestCheckFunc( - resource.TestCheckResourceAttr("data.snowflake_external_tables.t", "database", databaseName), - resource.TestCheckResourceAttr("data.snowflake_external_tables.t", "schema", schemaName), + resource.TestCheckResourceAttr("data.snowflake_external_tables.t", "database", stageId.DatabaseName()), + resource.TestCheckResourceAttr("data.snowflake_external_tables.t", "schema", stageId.SchemaName()), resource.TestCheckResourceAttrSet("data.snowflake_external_tables.t", "external_tables.#"), resource.TestCheckResourceAttr("data.snowflake_external_tables.t", "external_tables.#", "1"), - resource.TestCheckResourceAttr("data.snowflake_external_tables.t", "external_tables.0.name", externalTableName), + resource.TestCheckResourceAttr("data.snowflake_external_tables.t", "external_tables.0.name", externalTableId.Name()), ), }, }, }) } -func externalTables(databaseName string, schemaName string, stageName string, externalTableName string) string { +func externalTables(stageId sdk.SchemaObjectIdentifier, externalTableId sdk.SchemaObjectIdentifier) string { return fmt.Sprintf(` - - resource snowflake_database "test" { - name = "%v" - } - - resource snowflake_schema "test"{ - name = "%v" - database = snowflake_database.test.name - } - resource "snowflake_stage" "test" { - name = "%v" + name = "%[3]s" url = "s3://snowflake-workshop-lab/weather-nyc" - database = snowflake_database.test.name - schema = snowflake_schema.test.name + database = "%[1]s" + schema = "%[2]s" comment = "Terraform acceptance test" } resource "snowflake_external_table" "test_table" { - database = snowflake_database.test.name - schema = snowflake_schema.test.name - name = "%v" + database = "%[1]s" + schema = "%[2]s" + name = "%[4]s" comment = "Terraform acceptance test" column { name = "column1" @@ -68,13 +62,13 @@ func externalTables(databaseName string, schemaName string, stageName string, ex as = "TO_VARCHAR(TO_TIMESTAMP_NTZ(value:unix_timestamp_property::NUMBER, 3), 'yyyy-mm-dd-hh')" } file_format = "TYPE = CSV" - location = "@${snowflake_database.test.name}.${snowflake_schema.test.name}.${snowflake_stage.test.name}" + location = "@${snowflake_stage.test.fully_qualified_name}" } data snowflake_external_tables "t" { - database = snowflake_external_table.test_table.database - schema = snowflake_external_table.test_table.schema + database = "%[1]s" + schema = "%[2]s" depends_on = [snowflake_external_table.test_table] } - `, databaseName, schemaName, stageName, externalTableName) + `, stageId.DatabaseName(), stageId.SchemaName(), stageId.Name(), externalTableId.Name()) } diff --git a/pkg/datasources/failover_groups_acceptance_test.go b/pkg/datasources/failover_groups_acceptance_test.go index 2944cdca4a0..8d6a53675df 100644 --- a/pkg/datasources/failover_groups_acceptance_test.go +++ b/pkg/datasources/failover_groups_acceptance_test.go @@ -7,6 +7,7 @@ import ( acc "github.com/Snowflake-Labs/terraform-provider-snowflake/pkg/acceptance" "github.com/Snowflake-Labs/terraform-provider-snowflake/pkg/acceptance/testenvs" + "github.com/Snowflake-Labs/terraform-provider-snowflake/pkg/sdk" "github.com/hashicorp/terraform-plugin-testing/helper/resource" "github.com/hashicorp/terraform-plugin-testing/tfversion" ) @@ -15,9 +16,12 @@ func TestAcc_FailoverGroups(t *testing.T) { // TODO [SNOW-1002023]: Unskip; Business Critical Snowflake Edition needed _ = testenvs.GetOrSkipTest(t, testenvs.TestFailoverGroups) + _ = testenvs.GetOrSkipTest(t, testenvs.EnableAcceptance) + acc.TestAccPreCheck(t) + + failoverGroupId := acc.TestClient().Ids.RandomAccountObjectIdentifier() accountName := testenvs.GetOrSkipTest(t, testenvs.BusinessCriticalAccount) - name := acc.TestClient().Ids.Alpha() resource.Test(t, resource.TestCase{ ProtoV6ProviderFactories: acc.TestAccProtoV6ProviderFactories, PreCheck: func() { acc.TestAccPreCheck(t) }, @@ -27,8 +31,9 @@ func TestAcc_FailoverGroups(t *testing.T) { CheckDestroy: nil, Steps: []resource.TestStep{ { - Config: failoverGroupsConfig(name, accountName), + Config: failoverGroupsConfig(failoverGroupId, accountName), Check: resource.ComposeTestCheckFunc( + // TODO [SNOW-1348343]: fix these assertions - there might be multiple failover groups if we run tests in parallel resource.TestCheckResourceAttr("data.snowflake_failover_groups.d", "failover_groups.#", "1"), resource.TestCheckResourceAttr("data.snowflake_failover_groups.d", "failover_groups.0.object_types.#", "1"), resource.TestCheckResourceAttr("data.snowflake_failover_groups.d", "failover_groups.0.object_types.0", "ROLES"), @@ -40,7 +45,7 @@ func TestAcc_FailoverGroups(t *testing.T) { }) } -func failoverGroupsConfig(failoverGroupName string, allowedAccount string) string { +func failoverGroupsConfig(failoverGroupId sdk.AccountObjectIdentifier, allowedAccount string) string { return fmt.Sprintf(` resource "snowflake_failover_group" "source_failover_group" { name = "%s" @@ -51,5 +56,5 @@ func failoverGroupsConfig(failoverGroupName string, allowedAccount string) strin data "snowflake_failover_groups" "d" { depends_on = [snowflake_failover_group.source_failover_group] } - `, failoverGroupName, allowedAccount) + `, failoverGroupId.Name(), allowedAccount) } diff --git a/pkg/datasources/file_formats_acceptance_test.go b/pkg/datasources/file_formats_acceptance_test.go index 9fc3c2c52f5..eca32a01d2f 100644 --- a/pkg/datasources/file_formats_acceptance_test.go +++ b/pkg/datasources/file_formats_acceptance_test.go @@ -6,14 +6,18 @@ import ( acc "github.com/Snowflake-Labs/terraform-provider-snowflake/pkg/acceptance" + "github.com/Snowflake-Labs/terraform-provider-snowflake/pkg/acceptance/testenvs" + "github.com/Snowflake-Labs/terraform-provider-snowflake/pkg/sdk" "github.com/hashicorp/terraform-plugin-testing/helper/resource" "github.com/hashicorp/terraform-plugin-testing/tfversion" ) func TestAcc_FileFormats(t *testing.T) { - databaseName := acc.TestClient().Ids.Alpha() - schemaName := acc.TestClient().Ids.Alpha() - fileFormatName := acc.TestClient().Ids.Alpha() + _ = testenvs.GetOrSkipTest(t, testenvs.EnableAcceptance) + acc.TestAccPreCheck(t) + + fileFormatId := acc.TestClient().Ids.RandomSchemaObjectIdentifier() + resource.Test(t, resource.TestCase{ ProtoV6ProviderFactories: acc.TestAccProtoV6ProviderFactories, PreCheck: func() { acc.TestAccPreCheck(t) }, @@ -23,13 +27,13 @@ func TestAcc_FileFormats(t *testing.T) { CheckDestroy: nil, Steps: []resource.TestStep{ { - Config: fileFormats(databaseName, schemaName, fileFormatName), + Config: fileFormats(fileFormatId), Check: resource.ComposeTestCheckFunc( - resource.TestCheckResourceAttr("data.snowflake_file_formats.t", "database", databaseName), - resource.TestCheckResourceAttr("data.snowflake_file_formats.t", "schema", schemaName), + resource.TestCheckResourceAttr("data.snowflake_file_formats.t", "database", fileFormatId.DatabaseName()), + resource.TestCheckResourceAttr("data.snowflake_file_formats.t", "schema", fileFormatId.SchemaName()), resource.TestCheckResourceAttrSet("data.snowflake_file_formats.t", "file_formats.#"), resource.TestCheckResourceAttr("data.snowflake_file_formats.t", "file_formats.#", "1"), - resource.TestCheckResourceAttr("data.snowflake_file_formats.t", "file_formats.0.name", fileFormatName), + resource.TestCheckResourceAttr("data.snowflake_file_formats.t", "file_formats.0.name", fileFormatId.Name()), ), }, }, @@ -37,8 +41,9 @@ func TestAcc_FileFormats(t *testing.T) { } func TestAcc_FileFormatsEmpty(t *testing.T) { - databaseName := acc.TestClient().Ids.Alpha() - schemaName := acc.TestClient().Ids.Alpha() + _ = testenvs.GetOrSkipTest(t, testenvs.EnableAcceptance) + acc.TestAccPreCheck(t) + resource.Test(t, resource.TestCase{ ProtoV6ProviderFactories: acc.TestAccProtoV6ProviderFactories, PreCheck: func() { acc.TestAccPreCheck(t) }, @@ -48,10 +53,10 @@ func TestAcc_FileFormatsEmpty(t *testing.T) { CheckDestroy: nil, Steps: []resource.TestStep{ { - Config: zeroFileFormats(databaseName, schemaName), + Config: zeroFileFormats(), Check: resource.ComposeTestCheckFunc( - resource.TestCheckResourceAttr("data.snowflake_file_formats.t", "database", databaseName), - resource.TestCheckResourceAttr("data.snowflake_file_formats.t", "schema", schemaName), + resource.TestCheckResourceAttr("data.snowflake_file_formats.t", "database", acc.TestDatabaseName), + resource.TestCheckResourceAttr("data.snowflake_file_formats.t", "schema", acc.TestSchemaName), resource.TestCheckResourceAttrSet("data.snowflake_file_formats.t", "file_formats.#"), resource.TestCheckResourceAttr("data.snowflake_file_formats.t", "file_formats.#", "0"), ), @@ -60,22 +65,12 @@ func TestAcc_FileFormatsEmpty(t *testing.T) { }) } -func fileFormats(databaseName string, schemaName string, fileFormatName string) string { +func fileFormats(fileFormatId sdk.SchemaObjectIdentifier) string { return fmt.Sprintf(` - - resource snowflake_database "d" { - name = "%v" - } - - resource snowflake_schema "s"{ - name = "%v" - database = snowflake_database.d.name - } - resource snowflake_file_format "t"{ - name = "%v" - database = snowflake_schema.s.database - schema = snowflake_schema.s.name + name = "%[3]s" + database = "%[1]s" + schema = "%[2]s" format_type = "CSV" compression = "GZIP" record_delimiter = "\r" @@ -101,28 +96,18 @@ func fileFormats(databaseName string, schemaName string, fileFormatName string) } data snowflake_file_formats "t" { - database = snowflake_file_format.t.database - schema = snowflake_file_format.t.schema + database = "%[1]s" + schema = "%[2]s" depends_on = [snowflake_file_format.t] } - `, databaseName, schemaName, fileFormatName) + `, fileFormatId.DatabaseName(), fileFormatId.SchemaName(), fileFormatId.Name()) } -func zeroFileFormats(databaseName string, schemaName string) string { +func zeroFileFormats() string { return fmt.Sprintf(` - - resource snowflake_database "d" { - name = "%v" - } - - resource snowflake_schema "s"{ - name = "%v" - database = snowflake_database.d.name - } - data snowflake_file_formats "t" { - database = snowflake_schema.s.database - schema = snowflake_schema.s.name + database = "%[1]s" + schema = "%[2]s" } - `, databaseName, schemaName) + `, acc.TestDatabaseName, acc.TestSchemaName) } diff --git a/pkg/datasources/functions_acceptance_test.go b/pkg/datasources/functions_acceptance_test.go index 4ac49882fea..ca53707f1f9 100644 --- a/pkg/datasources/functions_acceptance_test.go +++ b/pkg/datasources/functions_acceptance_test.go @@ -21,7 +21,6 @@ func TestAcc_Functions(t *testing.T) { t.Setenv(string(testenvs.ConfigureClientOnce), "") dataSourceName := "data.snowflake_functions.functions" - resource.Test(t, resource.TestCase{ ProtoV6ProviderFactories: acc.TestAccProtoV6ProviderFactories, PreCheck: func() { acc.TestAccPreCheck(t) }, diff --git a/pkg/datasources/grants_acceptance_test.go b/pkg/datasources/grants_acceptance_test.go index ec2e06d553f..a6ca7191ef9 100644 --- a/pkg/datasources/grants_acceptance_test.go +++ b/pkg/datasources/grants_acceptance_test.go @@ -5,7 +5,10 @@ import ( "testing" acc "github.com/Snowflake-Labs/terraform-provider-snowflake/pkg/acceptance" + accconfig "github.com/Snowflake-Labs/terraform-provider-snowflake/pkg/acceptance/bettertestspoc/config" + "github.com/Snowflake-Labs/terraform-provider-snowflake/pkg/acceptance/bettertestspoc/config/datasourcemodel" + "github.com/Snowflake-Labs/terraform-provider-snowflake/pkg/acceptance/bettertestspoc/config/model" "github.com/Snowflake-Labs/terraform-provider-snowflake/pkg/acceptance/testenvs" "github.com/Snowflake-Labs/terraform-provider-snowflake/pkg/sdk" "github.com/hashicorp/terraform-plugin-testing/config" @@ -15,6 +18,8 @@ import ( ) func TestAcc_Grants_On_Account(t *testing.T) { + grantsModel := datasourcemodel.GrantsOnAccount("test") + resource.Test(t, resource.TestCase{ ProtoV6ProviderFactories: acc.TestAccProtoV6ProviderFactories, PreCheck: func() { acc.TestAccPreCheck(t) }, @@ -24,17 +29,18 @@ func TestAcc_Grants_On_Account(t *testing.T) { CheckDestroy: nil, Steps: []resource.TestStep{ { - ConfigDirectory: acc.ConfigurationDirectory("TestAcc_Grants/On/Account"), - Check: checkAtLeastOneGrantPresent(), + Config: accconfig.FromModels(t, grantsModel), + Check: checkAtLeastOneGrantPresent(), }, }, }) } func TestAcc_Grants_On_AccountObject(t *testing.T) { - configVariables := config.Variables{ - "database": config.StringVariable(acc.TestDatabaseName), - } + _ = testenvs.GetOrSkipTest(t, testenvs.EnableAcceptance) + acc.TestAccPreCheck(t) + + grantsModel := datasourcemodel.GrantsOnAccountObject("test", acc.TestClient().Ids.DatabaseId(), sdk.ObjectTypeDatabase) resource.Test(t, resource.TestCase{ ProtoV6ProviderFactories: acc.TestAccProtoV6ProviderFactories, @@ -45,19 +51,18 @@ func TestAcc_Grants_On_AccountObject(t *testing.T) { CheckDestroy: nil, Steps: []resource.TestStep{ { - ConfigDirectory: acc.ConfigurationDirectory("TestAcc_Grants/On/AccountObject"), - ConfigVariables: configVariables, - Check: checkAtLeastOneGrantPresent(), + Config: accconfig.FromModels(t, grantsModel), + Check: checkAtLeastOneGrantPresent(), }, }, }) } func TestAcc_Grants_On_DatabaseObject(t *testing.T) { - configVariables := config.Variables{ - "database": config.StringVariable(acc.TestDatabaseName), - "schema": config.StringVariable(acc.TestSchemaName), - } + _ = testenvs.GetOrSkipTest(t, testenvs.EnableAcceptance) + acc.TestAccPreCheck(t) + + grantsModel := datasourcemodel.GrantsOnDatabaseObject("test", acc.TestClient().Ids.SchemaId(), sdk.ObjectTypeSchema) resource.Test(t, resource.TestCase{ ProtoV6ProviderFactories: acc.TestAccProtoV6ProviderFactories, @@ -68,21 +73,24 @@ func TestAcc_Grants_On_DatabaseObject(t *testing.T) { CheckDestroy: nil, Steps: []resource.TestStep{ { - ConfigDirectory: acc.ConfigurationDirectory("TestAcc_Grants/On/DatabaseObject"), - ConfigVariables: configVariables, - Check: checkAtLeastOneGrantPresent(), + Config: accconfig.FromModels(t, grantsModel), + Check: checkAtLeastOneGrantPresent(), }, }, }) } func TestAcc_Grants_On_SchemaObject(t *testing.T) { - tableName := acc.TestClient().Ids.Alpha() - configVariables := config.Variables{ - "database": config.StringVariable(acc.TestDatabaseName), - "schema": config.StringVariable(acc.TestSchemaName), - "table": config.StringVariable(tableName), - } + _ = testenvs.GetOrSkipTest(t, testenvs.EnableAcceptance) + acc.TestAccPreCheck(t) + + viewId := acc.TestClient().Ids.RandomSchemaObjectIdentifier() + statement := "SELECT ROLE_NAME FROM INFORMATION_SCHEMA.APPLICABLE_ROLES" + columnNames := []string{"ROLE_NAME"} + + viewModel := model.View("test", viewId.DatabaseName(), viewId.Name(), viewId.SchemaName(), statement).WithColumnNames(columnNames...) + grantsModel := datasourcemodel.GrantsOnSchemaObject("test", viewId, sdk.ObjectTypeView). + WithDependsOn(viewModel.ResourceReference()) resource.Test(t, resource.TestCase{ ProtoV6ProviderFactories: acc.TestAccProtoV6ProviderFactories, @@ -93,9 +101,8 @@ func TestAcc_Grants_On_SchemaObject(t *testing.T) { CheckDestroy: nil, Steps: []resource.TestStep{ { - ConfigDirectory: acc.ConfigurationDirectory("TestAcc_Grants/On/SchemaObject"), - ConfigVariables: configVariables, - Check: checkAtLeastOneGrantPresent(), + Config: accconfig.FromModels(t, viewModel, grantsModel), + Check: checkAtLeastOneGrantPresent(), }, }, }) @@ -106,9 +113,7 @@ func TestAcc_Grants_On_SchemaObject_WithArguments(t *testing.T) { acc.TestAccPreCheck(t) function := acc.TestClient().Function.Create(t, sdk.DataTypeVARCHAR) - configVariables := config.Variables{ - "fully_qualified_function_name": config.StringVariable(function.ID().FullyQualifiedName()), - } + grantsModel := datasourcemodel.GrantsOnSchemaObjectWithArguments("test", function.ID(), sdk.ObjectTypeFunction) resource.Test(t, resource.TestCase{ ProtoV6ProviderFactories: acc.TestAccProtoV6ProviderFactories, @@ -119,15 +124,16 @@ func TestAcc_Grants_On_SchemaObject_WithArguments(t *testing.T) { CheckDestroy: nil, Steps: []resource.TestStep{ { - ConfigDirectory: acc.ConfigurationDirectory("TestAcc_Grants/On/SchemaObject_WithArguments"), - ConfigVariables: configVariables, - Check: checkAtLeastOneGrantPresent(), + Config: accconfig.FromModels(t, grantsModel), + Check: checkAtLeastOneGrantPresent(), }, }, }) } func TestAcc_Grants_On_Invalid_NoAttribute(t *testing.T) { + grantsModel := datasourcemodel.GrantsOnEmpty("test") + resource.Test(t, resource.TestCase{ ProtoV6ProviderFactories: acc.TestAccProtoV6ProviderFactories, PreCheck: func() { acc.TestAccPreCheck(t) }, @@ -137,15 +143,17 @@ func TestAcc_Grants_On_Invalid_NoAttribute(t *testing.T) { CheckDestroy: nil, Steps: []resource.TestStep{ { - ConfigDirectory: acc.ConfigurationDirectory("TestAcc_Grants/On/Invalid/NoAttribute"), - PlanOnly: true, - ExpectError: regexp.MustCompile("Error: Invalid combination of arguments"), + Config: accconfig.FromModels(t, grantsModel), + PlanOnly: true, + ExpectError: regexp.MustCompile("Error: Invalid combination of arguments"), }, }, }) } func TestAcc_Grants_On_Invalid_MissingObjectType(t *testing.T) { + grantsModel := datasourcemodel.GrantsOnMissingObjectType("test") + resource.Test(t, resource.TestCase{ ProtoV6ProviderFactories: acc.TestAccProtoV6ProviderFactories, PreCheck: func() { acc.TestAccPreCheck(t) }, @@ -155,9 +163,9 @@ func TestAcc_Grants_On_Invalid_MissingObjectType(t *testing.T) { CheckDestroy: nil, Steps: []resource.TestStep{ { - ConfigDirectory: acc.ConfigurationDirectory("TestAcc_Grants/On/Invalid/MissingObjectType"), - PlanOnly: true, - ExpectError: regexp.MustCompile("Error: Missing required argument"), + Config: accconfig.FromModels(t, grantsModel), + PlanOnly: true, + ExpectError: regexp.MustCompile("Error: Missing required argument"), }, }, }) @@ -194,12 +202,13 @@ func TestAcc_Grants_To_AccountRole(t *testing.T) { } func TestAcc_Grants_To_DatabaseRole(t *testing.T) { - databaseName := acc.TestClient().Ids.Alpha() - databaseRoleName := acc.TestClient().Ids.Alpha() - configVariables := config.Variables{ - "database": config.StringVariable(databaseName), - "database_role": config.StringVariable(databaseRoleName), - } + _ = testenvs.GetOrSkipTest(t, testenvs.EnableAcceptance) + acc.TestAccPreCheck(t) + + databaseRoleId := acc.TestClient().Ids.RandomDatabaseObjectIdentifier() + databaseRoleModel := model.DatabaseRole("test", databaseRoleId.DatabaseName(), databaseRoleId.Name()) + grantsModel := datasourcemodel.GrantsToDatabaseRole("test", databaseRoleId). + WithDependsOn(databaseRoleModel.ResourceReference()) resource.Test(t, resource.TestCase{ ProtoV6ProviderFactories: acc.TestAccProtoV6ProviderFactories, @@ -210,19 +219,19 @@ func TestAcc_Grants_To_DatabaseRole(t *testing.T) { CheckDestroy: nil, Steps: []resource.TestStep{ { - ConfigDirectory: acc.ConfigurationDirectory("TestAcc_Grants/To/DatabaseRole"), - ConfigVariables: configVariables, - Check: checkAtLeastOneGrantPresent(), + Config: accconfig.FromModels(t, databaseRoleModel, grantsModel), + Check: checkAtLeastOneGrantPresent(), }, }, }) } func TestAcc_Grants_To_User(t *testing.T) { + _ = testenvs.GetOrSkipTest(t, testenvs.EnableAcceptance) + acc.TestAccPreCheck(t) + userId := acc.TestClient().Context.CurrentUser(t) - configVariables := config.Variables{ - "user": config.StringVariable(userId.Name()), - } + grantsModel := datasourcemodel.GrantsToUser("test", userId) resource.Test(t, resource.TestCase{ ProtoV6ProviderFactories: acc.TestAccProtoV6ProviderFactories, @@ -233,20 +242,21 @@ func TestAcc_Grants_To_User(t *testing.T) { CheckDestroy: nil, Steps: []resource.TestStep{ { - ConfigDirectory: acc.ConfigurationDirectory("TestAcc_Grants/To/User"), - ConfigVariables: configVariables, - Check: checkAtLeastOneGrantPresentLimited(), + Config: accconfig.FromModels(t, grantsModel), + Check: checkAtLeastOneGrantPresentLimited(), }, }, }) } func TestAcc_Grants_To_Share(t *testing.T) { - databaseName := acc.TestClient().Ids.Alpha() - shareName := acc.TestClient().Ids.Alpha() + _ = testenvs.GetOrSkipTest(t, testenvs.EnableAcceptance) + acc.TestAccPreCheck(t) + + shareId := acc.TestClient().Ids.RandomAccountObjectIdentifier() configVariables := config.Variables{ - "database": config.StringVariable(databaseName), - "share": config.StringVariable(shareName), + "database": config.StringVariable(acc.TestDatabaseName), + "share": config.StringVariable(shareId.Name()), } resource.Test(t, resource.TestCase{ @@ -361,11 +371,13 @@ func TestAcc_Grants_Of_AccountRole(t *testing.T) { } func TestAcc_Grants_Of_DatabaseRole(t *testing.T) { - databaseName := acc.TestClient().Ids.Alpha() - databaseRoleName := acc.TestClient().Ids.Alpha() + _ = testenvs.GetOrSkipTest(t, testenvs.EnableAcceptance) + acc.TestAccPreCheck(t) + + databaseRoleId := acc.TestClient().Ids.RandomDatabaseObjectIdentifier() configVariables := config.Variables{ - "database": config.StringVariable(databaseName), - "database_role": config.StringVariable(databaseRoleName), + "database": config.StringVariable(acc.TestDatabaseName), + "database_role": config.StringVariable(databaseRoleId.Name()), } resource.Test(t, resource.TestCase{ @@ -393,19 +405,21 @@ func TestAcc_Grants_Of_ApplicationRole(t *testing.T) { // TODO [SNOW-1284394]: Unskip the test func TestAcc_Grants_Of_Share(t *testing.T) { t.Skip("TestAcc_Share are skipped") - databaseName := acc.TestClient().Ids.Alpha() - shareName := acc.TestClient().Ids.Alpha() + _ = testenvs.GetOrSkipTest(t, testenvs.EnableAcceptance) + acc.TestAccPreCheck(t) + + shareId := acc.TestClient().Ids.RandomAccountObjectIdentifier() accountId := acc.SecondaryTestClient().Account.GetAccountIdentifier(t) require.NotNil(t, accountId) configVariables := config.Variables{ - "database": config.StringVariable(databaseName), - "share": config.StringVariable(shareName), + "database": config.StringVariable(acc.TestDatabaseName), + "share": config.StringVariable(shareId.Name()), "account": config.StringVariable(accountId.FullyQualifiedName()), } - datasourceName := "data.snowflake_grants.test" + datasourceName := "data.snowflake_grants.test" resource.Test(t, resource.TestCase{ ProtoV6ProviderFactories: acc.TestAccProtoV6ProviderFactories, PreCheck: func() { acc.TestAccPreCheck(t) }, @@ -481,9 +495,11 @@ func TestAcc_Grants_Of_Invalid_ApplicationRoleIdInvalid(t *testing.T) { } func TestAcc_Grants_FutureIn_Database(t *testing.T) { - databaseName := acc.TestClient().Ids.Alpha() + _ = testenvs.GetOrSkipTest(t, testenvs.EnableAcceptance) + acc.TestAccPreCheck(t) + configVariables := config.Variables{ - "database": config.StringVariable(databaseName), + "database": config.StringVariable(acc.TestDatabaseName), } resource.Test(t, resource.TestCase{ @@ -504,11 +520,12 @@ func TestAcc_Grants_FutureIn_Database(t *testing.T) { } func TestAcc_Grants_FutureIn_Schema(t *testing.T) { - databaseName := acc.TestClient().Ids.Alpha() - schemaName := acc.TestClient().Ids.Alpha() + _ = testenvs.GetOrSkipTest(t, testenvs.EnableAcceptance) + acc.TestAccPreCheck(t) + configVariables := config.Variables{ - "database": config.StringVariable(databaseName), - "schema": config.StringVariable(schemaName), + "database": config.StringVariable(acc.TestDatabaseName), + "schema": config.StringVariable(acc.TestSchemaName), } resource.Test(t, resource.TestCase{ @@ -565,9 +582,11 @@ func TestAcc_Grants_FutureIn_Invalid_SchemaNameNotFullyQualified(t *testing.T) { } func TestAcc_Grants_FutureTo_AccountRole(t *testing.T) { - databaseName := acc.TestClient().Ids.Alpha() + _ = testenvs.GetOrSkipTest(t, testenvs.EnableAcceptance) + acc.TestAccPreCheck(t) + configVariables := config.Variables{ - "database": config.StringVariable(databaseName), + "database": config.StringVariable(acc.TestDatabaseName), } resource.Test(t, resource.TestCase{ @@ -588,11 +607,13 @@ func TestAcc_Grants_FutureTo_AccountRole(t *testing.T) { } func TestAcc_Grants_FutureTo_DatabaseRole(t *testing.T) { - databaseName := acc.TestClient().Ids.Alpha() - databaseRoleName := acc.TestClient().Ids.Alpha() + _ = testenvs.GetOrSkipTest(t, testenvs.EnableAcceptance) + acc.TestAccPreCheck(t) + + databaseRoleId := acc.TestClient().Ids.RandomDatabaseObjectIdentifier() configVariables := config.Variables{ - "database": config.StringVariable(databaseName), - "database_role": config.StringVariable(databaseRoleName), + "database": config.StringVariable(acc.TestDatabaseName), + "database_role": config.StringVariable(databaseRoleId.Name()), } resource.Test(t, resource.TestCase{ diff --git a/pkg/datasources/testdata/TestAcc_Grants/FutureIn/Database/snowflake_grants_future_in_database.tf b/pkg/datasources/testdata/TestAcc_Grants/FutureIn/Database/snowflake_grants_future_in_database.tf index 5a7b657f0e1..fe4ef6a1255 100644 --- a/pkg/datasources/testdata/TestAcc_Grants/FutureIn/Database/snowflake_grants_future_in_database.tf +++ b/pkg/datasources/testdata/TestAcc_Grants/FutureIn/Database/snowflake_grants_future_in_database.tf @@ -1,15 +1,11 @@ data "snowflake_current_role" "test" {} -resource "snowflake_database" "test" { - name = var.database -} - resource "snowflake_grant_privileges_to_account_role" "test" { account_role_name = data.snowflake_current_role.test.name privileges = ["CREATE TABLE"] on_schema { - future_schemas_in_database = snowflake_database.test.name + future_schemas_in_database = var.database } } @@ -17,6 +13,6 @@ data "snowflake_grants" "test" { depends_on = [snowflake_grant_privileges_to_account_role.test] future_grants_in { - database = snowflake_database.test.name + database = var.database } } diff --git a/pkg/datasources/testdata/TestAcc_Grants/FutureIn/Schema/snowflake_grants_future_in_schema.tf b/pkg/datasources/testdata/TestAcc_Grants/FutureIn/Schema/snowflake_grants_future_in_schema.tf index 5da13766973..747219ace6c 100644 --- a/pkg/datasources/testdata/TestAcc_Grants/FutureIn/Schema/snowflake_grants_future_in_schema.tf +++ b/pkg/datasources/testdata/TestAcc_Grants/FutureIn/Schema/snowflake_grants_future_in_schema.tf @@ -1,14 +1,5 @@ data "snowflake_current_role" "test" {} -resource "snowflake_database" "test" { - name = var.database -} - -resource "snowflake_schema" "test" { - name = var.schema - database = snowflake_database.test.name -} - resource "snowflake_grant_privileges_to_account_role" "test" { account_role_name = data.snowflake_current_role.test.name privileges = ["INSERT"] @@ -16,7 +7,7 @@ resource "snowflake_grant_privileges_to_account_role" "test" { on_schema_object { future { object_type_plural = "TABLES" - in_schema = "\"${snowflake_database.test.name}\".\"${snowflake_schema.test.name}\"" + in_schema = "\"${var.database}\".\"${var.schema}\"" } } } @@ -25,6 +16,6 @@ data "snowflake_grants" "test" { depends_on = [snowflake_grant_privileges_to_account_role.test] future_grants_in { - schema = "\"${snowflake_database.test.name}\".\"${snowflake_schema.test.name}\"" + schema = "\"${var.database}\".\"${var.schema}\"" } } diff --git a/pkg/datasources/testdata/TestAcc_Grants/FutureTo/AccountRole/snowflake_grants_future_to_account_role.tf b/pkg/datasources/testdata/TestAcc_Grants/FutureTo/AccountRole/snowflake_grants_future_to_account_role.tf index 51959e6ff9a..6345b21e2d0 100644 --- a/pkg/datasources/testdata/TestAcc_Grants/FutureTo/AccountRole/snowflake_grants_future_to_account_role.tf +++ b/pkg/datasources/testdata/TestAcc_Grants/FutureTo/AccountRole/snowflake_grants_future_to_account_role.tf @@ -1,15 +1,11 @@ data "snowflake_current_role" "test" {} -resource "snowflake_database" "test" { - name = var.database -} - resource "snowflake_grant_privileges_to_account_role" "test" { account_role_name = data.snowflake_current_role.test.name privileges = ["CREATE TABLE"] on_schema { - future_schemas_in_database = snowflake_database.test.name + future_schemas_in_database = var.database } } diff --git a/pkg/datasources/testdata/TestAcc_Grants/FutureTo/DatabaseRole/snowflake_grants_future_to_database_role.tf b/pkg/datasources/testdata/TestAcc_Grants/FutureTo/DatabaseRole/snowflake_grants_future_to_database_role.tf index e194007f222..0c18f629e15 100644 --- a/pkg/datasources/testdata/TestAcc_Grants/FutureTo/DatabaseRole/snowflake_grants_future_to_database_role.tf +++ b/pkg/datasources/testdata/TestAcc_Grants/FutureTo/DatabaseRole/snowflake_grants_future_to_database_role.tf @@ -1,18 +1,14 @@ -resource "snowflake_database" "test" { - name = var.database -} - resource "snowflake_database_role" "test" { name = var.database_role - database = snowflake_database.test.name + database = var.database } resource "snowflake_grant_privileges_to_database_role" "test" { - database_role_name = "\"${snowflake_database.test.name}\".\"${snowflake_database_role.test.name}\"" + database_role_name = snowflake_database_role.test.fully_qualified_name privileges = ["CREATE TABLE"] on_schema { - future_schemas_in_database = snowflake_database.test.name + future_schemas_in_database = var.database } } @@ -20,6 +16,6 @@ data "snowflake_grants" "test" { depends_on = [snowflake_grant_privileges_to_database_role.test] future_grants_to { - database_role = "\"${snowflake_database.test.name}\".\"${snowflake_database_role.test.name}\"" + database_role = snowflake_database_role.test.fully_qualified_name } } diff --git a/pkg/datasources/testdata/TestAcc_Grants/Of/DatabaseRole/snowflake_grants_of_database_role.tf b/pkg/datasources/testdata/TestAcc_Grants/Of/DatabaseRole/snowflake_grants_of_database_role.tf index 2495cee7f99..4fbd0a850ca 100644 --- a/pkg/datasources/testdata/TestAcc_Grants/Of/DatabaseRole/snowflake_grants_of_database_role.tf +++ b/pkg/datasources/testdata/TestAcc_Grants/Of/DatabaseRole/snowflake_grants_of_database_role.tf @@ -1,16 +1,12 @@ data "snowflake_current_role" "test" {} -resource "snowflake_database" "test" { - name = var.database -} - resource "snowflake_database_role" "test" { name = var.database_role - database = snowflake_database.test.name + database = var.database } resource "snowflake_grant_database_role" "test" { - database_role_name = "\"${snowflake_database.test.name}\".\"${snowflake_database_role.test.name}\"" + database_role_name = snowflake_database_role.test.fully_qualified_name parent_role_name = data.snowflake_current_role.test.name } @@ -18,6 +14,6 @@ data "snowflake_grants" "test" { depends_on = [snowflake_grant_database_role.test] grants_of { - database_role = "\"${snowflake_database.test.name}\".\"${snowflake_database_role.test.name}\"" + database_role = snowflake_database_role.test.fully_qualified_name } } diff --git a/pkg/datasources/testdata/TestAcc_Grants/Of/Share/snowflake_grants_of_share.tf b/pkg/datasources/testdata/TestAcc_Grants/Of/Share/snowflake_grants_of_share.tf index 001bb832d5b..bcaf674df58 100644 --- a/pkg/datasources/testdata/TestAcc_Grants/Of/Share/snowflake_grants_of_share.tf +++ b/pkg/datasources/testdata/TestAcc_Grants/Of/Share/snowflake_grants_of_share.tf @@ -1,10 +1,4 @@ -resource "snowflake_database" "test" { - name = var.database -} - resource "snowflake_share" "test" { - depends_on = [snowflake_database.test] - name = var.share accounts = [var.account] } @@ -12,7 +6,7 @@ resource "snowflake_share" "test" { resource "snowflake_grant_privileges_to_share" "test" { to_share = snowflake_share.test.name privileges = ["USAGE"] - on_database = snowflake_database.test.name + on_database = var.database } data "snowflake_grants" "test" { diff --git a/pkg/datasources/testdata/TestAcc_Grants/On/Account/snowflake_grants_on_account.tf b/pkg/datasources/testdata/TestAcc_Grants/On/Account/snowflake_grants_on_account.tf deleted file mode 100644 index 4c66d5a46e4..00000000000 --- a/pkg/datasources/testdata/TestAcc_Grants/On/Account/snowflake_grants_on_account.tf +++ /dev/null @@ -1,5 +0,0 @@ -data "snowflake_grants" "test" { - grants_on { - account = true - } -} diff --git a/pkg/datasources/testdata/TestAcc_Grants/On/AccountObject/snowflake_grants_on_account_object.tf b/pkg/datasources/testdata/TestAcc_Grants/On/AccountObject/snowflake_grants_on_account_object.tf deleted file mode 100644 index cd936923665..00000000000 --- a/pkg/datasources/testdata/TestAcc_Grants/On/AccountObject/snowflake_grants_on_account_object.tf +++ /dev/null @@ -1,6 +0,0 @@ -data "snowflake_grants" "test" { - grants_on { - object_name = var.database - object_type = "DATABASE" - } -} diff --git a/pkg/datasources/testdata/TestAcc_Grants/On/AccountObject/variables.tf b/pkg/datasources/testdata/TestAcc_Grants/On/AccountObject/variables.tf deleted file mode 100644 index bfdd9eeb3c1..00000000000 --- a/pkg/datasources/testdata/TestAcc_Grants/On/AccountObject/variables.tf +++ /dev/null @@ -1,3 +0,0 @@ -variable "database" { - type = string -} diff --git a/pkg/datasources/testdata/TestAcc_Grants/On/DatabaseObject/snowflake_grants_on_database_object.tf b/pkg/datasources/testdata/TestAcc_Grants/On/DatabaseObject/snowflake_grants_on_database_object.tf deleted file mode 100644 index ffb7081367a..00000000000 --- a/pkg/datasources/testdata/TestAcc_Grants/On/DatabaseObject/snowflake_grants_on_database_object.tf +++ /dev/null @@ -1,6 +0,0 @@ -data "snowflake_grants" "test" { - grants_on { - object_name = "\"${var.database}\".\"${var.schema}\"" - object_type = "SCHEMA" - } -} diff --git a/pkg/datasources/testdata/TestAcc_Grants/On/DatabaseObject/variables.tf b/pkg/datasources/testdata/TestAcc_Grants/On/DatabaseObject/variables.tf deleted file mode 100644 index 626dbab534f..00000000000 --- a/pkg/datasources/testdata/TestAcc_Grants/On/DatabaseObject/variables.tf +++ /dev/null @@ -1,7 +0,0 @@ -variable "database" { - type = string -} - -variable "schema" { - type = string -} diff --git a/pkg/datasources/testdata/TestAcc_Grants/On/Invalid/MissingObjectType/snowflake_grants_on_invalid_missing_object_type.tf b/pkg/datasources/testdata/TestAcc_Grants/On/Invalid/MissingObjectType/snowflake_grants_on_invalid_missing_object_type.tf deleted file mode 100644 index d94be962db7..00000000000 --- a/pkg/datasources/testdata/TestAcc_Grants/On/Invalid/MissingObjectType/snowflake_grants_on_invalid_missing_object_type.tf +++ /dev/null @@ -1,5 +0,0 @@ -data "snowflake_grants" "test" { - grants_on { - object_name = "some_object" - } -} diff --git a/pkg/datasources/testdata/TestAcc_Grants/On/Invalid/NoAttribute/snowflake_grants_on_invalid_no_attribute.tf b/pkg/datasources/testdata/TestAcc_Grants/On/Invalid/NoAttribute/snowflake_grants_on_invalid_no_attribute.tf deleted file mode 100644 index 4ec09a6115e..00000000000 --- a/pkg/datasources/testdata/TestAcc_Grants/On/Invalid/NoAttribute/snowflake_grants_on_invalid_no_attribute.tf +++ /dev/null @@ -1,4 +0,0 @@ -data "snowflake_grants" "test" { - grants_on { - } -} diff --git a/pkg/datasources/testdata/TestAcc_Grants/On/SchemaObject/snowflake_grants_on_schema_object.tf b/pkg/datasources/testdata/TestAcc_Grants/On/SchemaObject/snowflake_grants_on_schema_object.tf deleted file mode 100644 index f64d445a33d..00000000000 --- a/pkg/datasources/testdata/TestAcc_Grants/On/SchemaObject/snowflake_grants_on_schema_object.tf +++ /dev/null @@ -1,17 +0,0 @@ -resource "snowflake_table" "test" { - database = var.database - schema = var.schema - name = var.table - - column { - name = "id" - type = "NUMBER(38,0)" - } -} - -data "snowflake_grants" "test" { - grants_on { - object_name = snowflake_table.test.fully_qualified_name - object_type = "TABLE" - } -} diff --git a/pkg/datasources/testdata/TestAcc_Grants/On/SchemaObject/variables.tf b/pkg/datasources/testdata/TestAcc_Grants/On/SchemaObject/variables.tf deleted file mode 100644 index 92e06a8848c..00000000000 --- a/pkg/datasources/testdata/TestAcc_Grants/On/SchemaObject/variables.tf +++ /dev/null @@ -1,11 +0,0 @@ -variable "database" { - type = string -} - -variable "schema" { - type = string -} - -variable "table" { - type = string -} diff --git a/pkg/datasources/testdata/TestAcc_Grants/On/SchemaObject_WithArguments/snowflake_grants_on_schema_object.tf b/pkg/datasources/testdata/TestAcc_Grants/On/SchemaObject_WithArguments/snowflake_grants_on_schema_object.tf deleted file mode 100644 index 80d7df5fad7..00000000000 --- a/pkg/datasources/testdata/TestAcc_Grants/On/SchemaObject_WithArguments/snowflake_grants_on_schema_object.tf +++ /dev/null @@ -1,6 +0,0 @@ -data "snowflake_grants" "test" { - grants_on { - object_name = var.fully_qualified_function_name - object_type = "FUNCTION" - } -} diff --git a/pkg/datasources/testdata/TestAcc_Grants/On/SchemaObject_WithArguments/variables.tf b/pkg/datasources/testdata/TestAcc_Grants/On/SchemaObject_WithArguments/variables.tf deleted file mode 100644 index 8a903b6d62c..00000000000 --- a/pkg/datasources/testdata/TestAcc_Grants/On/SchemaObject_WithArguments/variables.tf +++ /dev/null @@ -1,3 +0,0 @@ -variable "fully_qualified_function_name" { - type = string -} diff --git a/pkg/datasources/testdata/TestAcc_Grants/To/DatabaseRole/snowflake_grants_to_database_role.tf b/pkg/datasources/testdata/TestAcc_Grants/To/DatabaseRole/snowflake_grants_to_database_role.tf deleted file mode 100644 index 87183c9a9b8..00000000000 --- a/pkg/datasources/testdata/TestAcc_Grants/To/DatabaseRole/snowflake_grants_to_database_role.tf +++ /dev/null @@ -1,14 +0,0 @@ -resource "snowflake_database" "test" { - name = var.database -} - -resource "snowflake_database_role" "test" { - name = var.database_role - database = snowflake_database.test.name -} - -data "snowflake_grants" "test" { - grants_to { - database_role = "\"${snowflake_database.test.name}\".\"${snowflake_database_role.test.name}\"" - } -} diff --git a/pkg/datasources/testdata/TestAcc_Grants/To/DatabaseRole/variables.tf b/pkg/datasources/testdata/TestAcc_Grants/To/DatabaseRole/variables.tf deleted file mode 100644 index 447fa919c0a..00000000000 --- a/pkg/datasources/testdata/TestAcc_Grants/To/DatabaseRole/variables.tf +++ /dev/null @@ -1,7 +0,0 @@ -variable "database" { - type = string -} - -variable "database_role" { - type = string -} diff --git a/pkg/datasources/testdata/TestAcc_Grants/To/Share/snowflake_grants_to_share.tf b/pkg/datasources/testdata/TestAcc_Grants/To/Share/snowflake_grants_to_share.tf index 5fa9e344244..8e3c2de7443 100644 --- a/pkg/datasources/testdata/TestAcc_Grants/To/Share/snowflake_grants_to_share.tf +++ b/pkg/datasources/testdata/TestAcc_Grants/To/Share/snowflake_grants_to_share.tf @@ -1,17 +1,11 @@ -resource "snowflake_database" "test" { - name = var.database -} - resource "snowflake_share" "test" { - depends_on = [snowflake_database.test] - name = var.share } resource "snowflake_grant_privileges_to_share" "test" { to_share = snowflake_share.test.name privileges = ["USAGE"] - on_database = snowflake_database.test.name + on_database = var.database } data "snowflake_grants" "test" { diff --git a/pkg/datasources/testdata/TestAcc_Grants/To/User/snowflake_grants_to_user.tf b/pkg/datasources/testdata/TestAcc_Grants/To/User/snowflake_grants_to_user.tf deleted file mode 100644 index fa2cffc3ac2..00000000000 --- a/pkg/datasources/testdata/TestAcc_Grants/To/User/snowflake_grants_to_user.tf +++ /dev/null @@ -1,5 +0,0 @@ -data "snowflake_grants" "test" { - grants_to { - user = var.user - } -} diff --git a/pkg/datasources/testdata/TestAcc_Grants/To/User/variables.tf b/pkg/datasources/testdata/TestAcc_Grants/To/User/variables.tf deleted file mode 100644 index be0022a44a8..00000000000 --- a/pkg/datasources/testdata/TestAcc_Grants/To/User/variables.tf +++ /dev/null @@ -1,3 +0,0 @@ -variable "user" { - type = string -} diff --git a/pkg/provider/provider_acceptance_test.go b/pkg/provider/provider_acceptance_test.go index 7eacda0f4fd..950e94f6458 100644 --- a/pkg/provider/provider_acceptance_test.go +++ b/pkg/provider/provider_acceptance_test.go @@ -886,15 +886,6 @@ data %[2]s t {} `, profile, feature) } -func providerConfigWithDatasourcePreviewFeature(profile, feature string) string { - return fmt.Sprintf(` -provider "snowflake" { - profile = "%[1]s" -} -data %[2]s t {} -`, profile, feature) -} - func datasourceModel() config.DatasourceModel { return datasourcemodel.Database("t", acc.TestDatabaseName) } diff --git a/pkg/sdk/helper_test.go b/pkg/sdk/helper_test.go index 57421942d98..7a46a66db71 100644 --- a/pkg/sdk/helper_test.go +++ b/pkg/sdk/helper_test.go @@ -1,11 +1,9 @@ package sdk import ( - "strings" "testing" "github.com/Snowflake-Labs/terraform-provider-snowflake/pkg/acceptance/testprofiles" - "github.com/snowflakedb/gosnowflake" ) func defaultTestClient(t *testing.T) *Client { @@ -48,10 +46,3 @@ func testClient(t *testing.T, profile string) *Client { return client } - -func configAccountId(t *testing.T, cfg *gosnowflake.Config) AccountIdentifier { - t.Helper() - accountIdRaw := cfg.Account - parts := strings.SplitN(accountIdRaw, "-", 2) - return NewAccountIdentifier(parts[0], parts[1]) -}