fix: Fix datasource acceptance tests setup part2

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)
 

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

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,
     })
 }
 

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()),
+			}),
+		)
+}

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