From 425787c5938e88895af1157f505889611bdef398 Mon Sep 17 00:00:00 2001
From: Artur Sawicki <artur.sawicki@snowflake.com>
Date: Fri, 29 Nov 2024 10:50:59 +0100
Subject: [PATCH] chore: Improve config builders (#3207)

Improve how we build config models:
- explore HCL v1 lib
- generate provider config builder
- generate datasource config builder
- generate config using hcl v1 lib
- support objects, lists, and sets
- use provider config in provider setup tests
- use datasource generated config in one test for databases datasource
- use support for objects and lists in one view resource acceptance test
- extract nullVariable to own file
- cleanup in bettertestspoc/config directory
- add all datasources to provider/datasources
- ~deprecate old config builder and config variables from config
methods~ - undeprecated for now because of linter (and I could not
quickly find how to disable it; will do in a follow-up)
- multiline values (using <<EOT...EOT) are handled far from ideally but
work for now

References:
- https://developer.hashicorp.com/terraform/language/syntax/json
-
https://github.com/hashicorp/hcl/blob/56a9aee5207dbaed7f061cd926b96fc159d26ea0/json/spec.md

TODOs (next PRs - soon):
- rename package model to resourcemodel
- add generating MarshalJSON() function
- migrate resources to new config generation method (above needed first)
- improve unquoteDependsOnReferences method

TODOs (next PRs - later, left as next steps in readme):
- add config builders for other block types (Variable, Output, Localsl,
Module, Terraform)
- add provider to resource/datasource models (use in the
grant_ownership_acceptance_test)
- explore HCL v2 in more detail (especially struct tags generation;
probably with migration to plugin framework because of schema models)
- introduce some common interface for all three existing models
(ResourceModel, DatasourceModel, and ProviderModel)
- rename ResourceSchemaDetails (because it is used for the datasources
and provider too)
- consider duplicating the builders template from resource (currently
same template used for datasources and provider)
- consider merging ResourceModel with DatasourceModel (currently the
implementation is really similar)
---
 Makefile                                      |  16 +-
 go.mod                                        |   1 +
 go.sum                                        |   2 +
 pkg/acceptance/bettertestspoc/README.md       |  82 ++-
 .../bettertestspoc/config/config.go           | 126 ++--
 .../bettertestspoc/config/config_test.go      | 189 ++++++
 .../bettertestspoc/config/custom_variables.go |  15 +
 .../bettertestspoc/config/datasource_model.go |  60 ++
 .../datasourcemodel/database_model_ext.go     |  17 +
 .../datasourcemodel/database_model_gen.go     | 143 +++++
 .../datasourcemodel/databases_model_ext.go    |  32 +
 .../datasourcemodel/databases_model_gen.go    |  99 +++
 .../gen/datasource_schema_def.go              |  33 +
 .../config/datasourcemodel/gen/main/main.go   |  22 +
 .../config/datasourcemodel/gen/templates.go   |  28 +
 .../gen/templates/definition.tmpl             |  53 ++
 .../gen/templates/preamble.tmpl               |  16 +
 .../config/datasourcemodel/generate.go        |   3 +
 .../config/experiments/hcl_v1_test.go         | 126 ++++
 .../config/hcl_config_provider.go             | 128 ++++
 .../config/hcl_config_provider_test.go        |  83 +++
 .../config/json_config_provider.go            |  67 ++
 .../config/json_config_provider_test.go       |  78 +++
 .../config/model/database_model_ext.go        |  23 +
 .../bettertestspoc/config/model/generate.go   |   2 +
 .../config/model/view_model_ext.go            |  75 +++
 .../bettertestspoc/config/placeholders.go     |   5 +
 .../bettertestspoc/config/provider_model.go   |  29 +
 .../config/providermodel/gen/main/main.go     |  22 +
 .../providermodel/gen/provider_schema_def.go  |  29 +
 .../config/providermodel/gen/templates.go     |  28 +
 .../gen/templates/definition.tmpl             |  53 ++
 .../providermodel/gen/templates/preamble.tmpl |  15 +
 .../config/providermodel/generate.go          |   3 +
 .../providermodel/snowflake_model_ext.go      |  91 +++
 .../providermodel/snowflake_model_gen.go      | 590 ++++++++++++++++++
 .../bettertestspoc/config/resource_model.go   |  64 ++
 .../config/resource_model_test.go             | 138 ++++
 pkg/datasources/databases_acceptance_test.go  | 140 +++--
 .../TestAcc_Databases/optionals_set/test.tf   |  20 -
 .../optionals_set/variables.tf                |  11 -
 .../TestAcc_Databases/optionals_unset/test.tf |  22 -
 .../optionals_unset/variables.tf              |  11 -
 .../authentication_methods/auth_test.go       |  34 +-
 pkg/provider/provider_acceptance_test.go      | 335 +++-------
 .../grant_ownership_acceptance_test.go        |   1 +
 .../object_renaming_acceptance_test.go        |   8 +-
 .../TestAcc_View/basic_update/test.tf         |  31 -
 .../TestAcc_View/basic_update/variables.tf    |  55 --
 pkg/resources/view_acceptance_test.go         | 268 ++++----
 .../LIST_OF_PREVIEW_FEATURES_FOR_V1.md        |   2 +-
 51 files changed, 2817 insertions(+), 707 deletions(-)
 create mode 100644 pkg/acceptance/bettertestspoc/config/config_test.go
 create mode 100644 pkg/acceptance/bettertestspoc/config/custom_variables.go
 create mode 100644 pkg/acceptance/bettertestspoc/config/datasource_model.go
 create mode 100644 pkg/acceptance/bettertestspoc/config/datasourcemodel/database_model_ext.go
 create mode 100644 pkg/acceptance/bettertestspoc/config/datasourcemodel/database_model_gen.go
 create mode 100644 pkg/acceptance/bettertestspoc/config/datasourcemodel/databases_model_ext.go
 create mode 100644 pkg/acceptance/bettertestspoc/config/datasourcemodel/databases_model_gen.go
 create mode 100644 pkg/acceptance/bettertestspoc/config/datasourcemodel/gen/datasource_schema_def.go
 create mode 100644 pkg/acceptance/bettertestspoc/config/datasourcemodel/gen/main/main.go
 create mode 100644 pkg/acceptance/bettertestspoc/config/datasourcemodel/gen/templates.go
 create mode 100644 pkg/acceptance/bettertestspoc/config/datasourcemodel/gen/templates/definition.tmpl
 create mode 100644 pkg/acceptance/bettertestspoc/config/datasourcemodel/gen/templates/preamble.tmpl
 create mode 100644 pkg/acceptance/bettertestspoc/config/datasourcemodel/generate.go
 create mode 100644 pkg/acceptance/bettertestspoc/config/experiments/hcl_v1_test.go
 create mode 100644 pkg/acceptance/bettertestspoc/config/hcl_config_provider.go
 create mode 100644 pkg/acceptance/bettertestspoc/config/hcl_config_provider_test.go
 create mode 100644 pkg/acceptance/bettertestspoc/config/json_config_provider.go
 create mode 100644 pkg/acceptance/bettertestspoc/config/json_config_provider_test.go
 create mode 100644 pkg/acceptance/bettertestspoc/config/model/database_model_ext.go
 create mode 100644 pkg/acceptance/bettertestspoc/config/placeholders.go
 create mode 100644 pkg/acceptance/bettertestspoc/config/provider_model.go
 create mode 100644 pkg/acceptance/bettertestspoc/config/providermodel/gen/main/main.go
 create mode 100644 pkg/acceptance/bettertestspoc/config/providermodel/gen/provider_schema_def.go
 create mode 100644 pkg/acceptance/bettertestspoc/config/providermodel/gen/templates.go
 create mode 100644 pkg/acceptance/bettertestspoc/config/providermodel/gen/templates/definition.tmpl
 create mode 100644 pkg/acceptance/bettertestspoc/config/providermodel/gen/templates/preamble.tmpl
 create mode 100644 pkg/acceptance/bettertestspoc/config/providermodel/generate.go
 create mode 100644 pkg/acceptance/bettertestspoc/config/providermodel/snowflake_model_ext.go
 create mode 100644 pkg/acceptance/bettertestspoc/config/providermodel/snowflake_model_gen.go
 create mode 100644 pkg/acceptance/bettertestspoc/config/resource_model.go
 create mode 100644 pkg/acceptance/bettertestspoc/config/resource_model_test.go
 delete mode 100644 pkg/datasources/testdata/TestAcc_Databases/optionals_set/test.tf
 delete mode 100644 pkg/datasources/testdata/TestAcc_Databases/optionals_set/variables.tf
 delete mode 100644 pkg/datasources/testdata/TestAcc_Databases/optionals_unset/test.tf
 delete mode 100644 pkg/datasources/testdata/TestAcc_Databases/optionals_unset/variables.tf
 delete mode 100644 pkg/resources/testdata/TestAcc_View/basic_update/test.tf
 delete mode 100644 pkg/resources/testdata/TestAcc_View/basic_update/variables.tf

diff --git a/Makefile b/Makefile
index fa1448adef..1f914dc5d9 100644
--- a/Makefile
+++ b/Makefile
@@ -162,8 +162,20 @@ generate-resource-model-builders: ## Generate resource model builders
 clean-resource-model-builders: ## Clean resource model builders
 	rm -f ./pkg/acceptance/bettertestspoc/config/model/*_gen.go
 
-clean-all-assertions-and-config-models: clean-snowflake-object-assertions clean-snowflake-object-parameters-assertions clean-resource-assertions clean-resource-parameters-assertions clean-resource-show-output-assertions clean-resource-model-builders ## clean all generated assertions and config models
+generate-provider-model-builders: ## Generate provider model builders
+	go generate ./pkg/acceptance/bettertestspoc/config/providermodel/generate.go
 
-generate-all-assertions-and-config-models: generate-snowflake-object-assertions generate-snowflake-object-parameters-assertions generate-resource-assertions generate-resource-parameters-assertions generate-resource-show-output-assertions generate-resource-model-builders ## generate all assertions and config models
+clean-provider-model-builders: ## Clean provider model builders
+	rm -f ./pkg/acceptance/bettertestspoc/config/providermodel/*_gen.go
+
+generate-datasource-model-builders: ## Generate datasource model builders
+	go generate ./pkg/acceptance/bettertestspoc/config/datasourcemodel/generate.go
+
+clean-datasource-model-builders: ## Clean datasource model builders
+	rm -f ./pkg/acceptance/bettertestspoc/config/datasourcemodel/*_gen.go
+
+clean-all-assertions-and-config-models: clean-snowflake-object-assertions clean-snowflake-object-parameters-assertions clean-resource-assertions clean-resource-parameters-assertions clean-resource-show-output-assertions clean-resource-model-builders clean-provider-model-builders clean-datasource-model-builders ## clean all generated assertions and config models
+
+generate-all-assertions-and-config-models: generate-snowflake-object-assertions generate-snowflake-object-parameters-assertions generate-resource-assertions generate-resource-parameters-assertions generate-resource-show-output-assertions generate-resource-model-builders generate-provider-model-builders generate-datasource-model-builders ## generate all assertions and config models
 
 .PHONY: build-local clean-generator-poc dev-setup dev-cleanup docs docs-check fmt fmt-check fumpt help install lint lint-fix mod mod-check pre-push pre-push-check sweep test test-acceptance uninstall-tf
diff --git a/go.mod b/go.mod
index 7f42d3fbd8..d599d2ef2c 100644
--- a/go.mod
+++ b/go.mod
@@ -9,6 +9,7 @@ require (
 	github.com/gookit/color v1.5.4
 	github.com/hashicorp/go-cty v1.4.1-0.20200414143053-d3edf31b6320
 	github.com/hashicorp/go-uuid v1.0.3
+	github.com/hashicorp/hcl v1.0.0
 	github.com/hashicorp/terraform-json v0.21.0
 	github.com/hashicorp/terraform-plugin-framework v1.8.0
 	github.com/hashicorp/terraform-plugin-framework-validators v0.12.0
diff --git a/go.sum b/go.sum
index f73906bfd7..7693a11e05 100644
--- a/go.sum
+++ b/go.sum
@@ -157,6 +157,8 @@ github.com/hashicorp/go-version v1.6.0 h1:feTTfFNnjP967rlCxM/I9g701jU+RN74YKx2mO
 github.com/hashicorp/go-version v1.6.0/go.mod h1:fltr4n8CU8Ke44wwGCBoEymUuxUHl09ZGVZPK5anwXA=
 github.com/hashicorp/hc-install v0.6.3 h1:yE/r1yJvWbtrJ0STwScgEnCanb0U9v7zp0Gbkmcoxqs=
 github.com/hashicorp/hc-install v0.6.3/go.mod h1:KamGdbodYzlufbWh4r9NRo8y6GLHWZP2GBtdnms1Ln0=
+github.com/hashicorp/hcl v1.0.0 h1:0Anlzjpi4vEasTeNFn2mLJgTSwt0+6sfsiTG8qcWGx4=
+github.com/hashicorp/hcl v1.0.0/go.mod h1:E5yfLk+7swimpb2L/Alb/PJmXilQ/rhwaUYs4T20WEQ=
 github.com/hashicorp/hcl/v2 v2.19.1 h1://i05Jqznmb2EXqa39Nsvyan2o5XyMowW5fnCKW5RPI=
 github.com/hashicorp/hcl/v2 v2.19.1/go.mod h1:ThLC89FV4p9MPW804KVbe/cEXoQ8NZEh+JtMeeGErHE=
 github.com/hashicorp/logutils v1.0.0 h1:dLEQVugN8vlakKOUE3ihGLTZJRB4j+M2cdTm/ORI65Y=
diff --git a/pkg/acceptance/bettertestspoc/README.md b/pkg/acceptance/bettertestspoc/README.md
index 7b96af6362..82a7b98f17 100644
--- a/pkg/acceptance/bettertestspoc/README.md
+++ b/pkg/acceptance/bettertestspoc/README.md
@@ -23,7 +23,7 @@ It contains the following packages:
   - resource parameters assertions (generated in subpackage `resourceparametersassert`)
   - show output assertions (generated in subpackage `resourceshowoutputassert`)
 
-- `config` - the new `ResourceModel` abstraction resides here. It provides models for objects and the builder methods allowing better config preparation in the acceptance tests.
+- `config` - the new model abstractions (`ResourceModel`, `DatasourceModel`, and `ProviderModel`) reside here. They provide models for objects and the builder methods allowing better config preparation in the acceptance tests.
 It aims to be more readable than using `Config:` with hardcoded string or `ConfigFile:` for file that is not directly reachable from the test body. Also, it should be easier to reuse the models and prepare convenience extension methods. The models are already generated.
 
 ## How it works
@@ -97,18 +97,58 @@ Resource config model builders can be generated automatically. For object `abc`
 - add object you want to generate to `allResourceSchemaDefs` slice in the `assert/resourceassert/gen/resource_schema_def.go`
 - to add custom (not generated) config builder methods create file `warehouse_model_ext` in the `config/model` package. Example would be:
 ```go
-func BasicWarehouseModel(
+func BasicAbcModel(
 	name string,
 	comment string,
-) *WarehouseModel {
-	return WarehouseWithDefaultMeta(name).WithComment(comment)
+) *AbcModel {
+	return AbcWithDefaultMeta(name).WithComment(comment)
 }
 
-func (w *WarehouseModel) WithWarehouseSizeEnum(warehouseSize sdk.WarehouseSize) *WarehouseModel {
+func (w *AbcModel) WithWarehouseSizeEnum(warehouseSize sdk.WarehouseSize) *AbcModel {
 	return w.WithWarehouseSize(string(warehouseSize))
 }
 ```
 
+### Adding new datasource config model builders
+Data source config model builders can be generated automatically. For object `abc` do the following:
+- add object you want to generate to `allDatasourcesSchemaDefs` slice in the `config/datasourcemodel/gen/datasource_schema_def.go`
+- to add custom (not generated) config builder methods create file `abc_model_ext` in the `config/datasourcemodel` package. Example would be:
+```go
+func BasicAbcModel(
+	name string,
+	comment string,
+) *AbcModel {
+	return AbcWithDefaultMeta(name).WithComment(comment)
+}
+
+func (d *AbcModel) WithLimit(rows int) *AbcModel {
+    return d.WithLimitValue(
+        tfconfig.ObjectVariable(map[string]tfconfig.Variable{
+            "rows": tfconfig.IntegerVariable(rows),
+        }),
+    )
+}
+```
+
+### Adding new provider config model builders
+Provider config model builders can be generated automatically. For object `abc` do the following:
+- add object you want to generate to `allProviderSchemaDefs` slice in the `config/providermodel/gen/provider_schema_def.go`
+- to add custom (not generated) config builder methods create file `abc_model_ext` in the `config/providermodel` package. Example would be:
+```go
+func BasicAbcModel(
+	name string,
+	comment string,
+) *AbcModel {
+	return AbcWithDefaultMeta(name).WithComment(comment)
+}
+
+func (w *AbcModel) WithWarehouseSizeEnum(warehouseSize sdk.WarehouseSize) *AbcModel {
+	return w.WithWarehouseSize(string(warehouseSize))
+}
+```
+
+*Note*: our provider's config is already generated, so there should not be a need to generate any more providers (the regeneration or adding custom methods are still expected).
+
 ### Running the generators
 Each of the above assertion types/config models has its own generator and cleanup entry in our Makefile.
 You can generate config models with:
@@ -310,12 +350,12 @@ it will result in:
         	Test:       	TestInt_Warehouses/create:_complete
 ```
 
-## Known limitations/planned improvements
+## Planned improvements
 - Test all the utilities for assertion/model construction (public interfaces, methods, functions).
 - Verify if all the config types are supported.
 - Consider a better implementation for the model conversion to config (TODO left in `config/config.go`).
 - Support additional methods for references in models (TODO left in `config/config.go`).
-- Support depends_on in models so that it can be chained like other resource fields (TODO left in `config/config.go`).
+- Generate depends_on for all compatible models. Consider exporting it in meta (discussion: https://github.com/Snowflake-Labs/terraform-provider-snowflake/pull/3207#discussion_r1850053618).
 - Add a convenience function to concatenate multiple models (TODO left in `config/config.go`).
 - Add function to support using `ConfigFile:` in the acceptance tests (TODO left in `config/config.go`).
 - Replace `acceptance/snowflakechecks` with the new proposed Snowflake objects assertions.
@@ -354,3 +394,31 @@ func (w *WarehouseDatasourceShowOutputAssert) IsEmpty() {
 - utilize `ContainsExactlyInAnyOrder` function in `pkg/acceptance/bettertestspoc/assert/commons.go` to create asserts on collections that are order independent
 - Additional asserts for sets and lists that wouldn't rely on the order of items saved to the state (SNOW-1706544)
 - support generating provider config and use generated configs in `pkg/provider/provider_acceptance_test.go`
+- add config builders for other block types (Variable, Output, Locals, Module, Terraform)
+- add provider to resource/datasource models (use in the grant_ownership_acceptance_test)
+- explore HCL v2 in more detail (especially struct tags generation; probably with migration to plugin framework because of schema models); ref: https://github.com/hashicorp/hcl/blob/bee2dc2e75f7528ad85777b7a013c13796426bd6/gohcl/encode_test.go#L48
+- introduce some common interface for all three existing models (ResourceModel, DatasourceModel, and ProviderModel)
+- rename ResourceSchemaDetails (because it is used for the datasources and provider too)
+- consider duplicating the builders template from resource (currently same template used for datasources and provider which limits the customization possibilities for just one block type)
+- consider merging ResourceModel with DatasourceModel (currently the implementation is really similar)
+- remove schema.TypeMap workaround or make it wiser (e.g. during generation we could programmatically gather all schema.TypeMap and use this workaround only for them)
+
+## Known limitations
+- generating provider config may misbehave when used only with one object/map paramter (like `params`), e.g.:
+```json
+{
+  "provider": {
+    "snowflake": {
+      "params": {
+        "statement_timeout_in_seconds": 31337
+      }
+    }
+  }
+}
+```
+will be converted to HCL:
+```hcl
+provider "snowflake" "params" {
+  statement_timeout_in_seconds = 31337
+}
+```
diff --git a/pkg/acceptance/bettertestspoc/config/config.go b/pkg/acceptance/bettertestspoc/config/config.go
index 1e256a811c..3174d20fca 100644
--- a/pkg/acceptance/bettertestspoc/config/config.go
+++ b/pkg/acceptance/bettertestspoc/config/config.go
@@ -9,70 +9,95 @@ import (
 
 	tfconfig "github.com/hashicorp/terraform-plugin-testing/config"
 
-	"github.com/Snowflake-Labs/terraform-provider-snowflake/pkg/provider/resources"
 	"github.com/stretchr/testify/require"
 )
 
-// TODO [SNOW-1501905]: add possibility to have reference to another object (e.g. WithResourceMonitorReference); new config.Variable impl?
-// TODO [SNOW-1501905]: generate With/SetDependsOn for the resources to preserve builder pattern
-// TODO [SNOW-1501905]: add a convenience method to use multiple configs from multiple models
-
-// ResourceModel is the base interface all of our config models will implement.
-// To allow easy implementation, ResourceModelMeta can be embedded inside the struct (and the struct will automatically implement it).
-type ResourceModel interface {
-	Resource() resources.Resource
-	ResourceName() string
-	SetResourceName(name string)
-	ResourceReference() string
-	DependsOn() []string
-	SetDependsOn(values ...string)
-}
+// ResourceFromModel should be used in terraform acceptance tests for Config attribute to get string config from ResourceModel.
+// Current implementation is an improved implementation using two steps:
+// - .tf.json generation
+// - conversion to HCL using hcl v1 lib
+// It is still not ideal. HCL v2 should be considered.
+func ResourceFromModel(t *testing.T, model ResourceModel) string {
+	t.Helper()
 
-type ResourceModelMeta struct {
-	name      string
-	resource  resources.Resource
-	dependsOn []string
-}
+	resourceJson, err := DefaultJsonConfigProvider.ResourceJsonFromModel(model)
+	require.NoError(t, err)
 
-func (m *ResourceModelMeta) Resource() resources.Resource {
-	return m.resource
-}
+	hcl, err := DefaultHclConfigProvider.HclFromJson(resourceJson)
+	require.NoError(t, err)
+	t.Logf("Generated config:\n%s", hcl)
 
-func (m *ResourceModelMeta) ResourceName() string {
-	return m.name
+	return hcl
 }
 
-func (m *ResourceModelMeta) SetResourceName(name string) {
-	m.name = name
-}
+// DatasourceFromModel should be used in terraform acceptance tests for Config attribute to get string config from DatasourceModel.
+// Current implementation is an improved implementation using two steps:
+// - .tf.json generation
+// - conversion to HCL using hcl v1 lib
+// It is still not ideal. HCL v2 should be considered.
+func DatasourceFromModel(t *testing.T, model DatasourceModel) string {
+	t.Helper()
 
-func (m *ResourceModelMeta) ResourceReference() string {
-	return fmt.Sprintf(`%s.%s`, m.resource, m.name)
-}
+	datasourceJson, err := DefaultJsonConfigProvider.DatasourceJsonFromModel(model)
+	require.NoError(t, err)
 
-func (m *ResourceModelMeta) DependsOn() []string {
-	return m.dependsOn
-}
+	hcl, err := DefaultHclConfigProvider.HclFromJson(datasourceJson)
+	require.NoError(t, err)
+	t.Logf("Generated config:\n%s", hcl)
 
-func (m *ResourceModelMeta) SetDependsOn(values ...string) {
-	m.dependsOn = values
+	return hcl
 }
 
-// DefaultResourceName is exported to allow assertions against the resources using the default name.
-const DefaultResourceName = "test"
+// ProviderFromModel should be used in terraform acceptance tests for Config attribute to get string config from ProviderModel.
+// Current implementation is an improved implementation using two steps:
+// - .tf.json generation
+// - conversion to HCL using hcl v1 lib
+// It is still not ideal. HCL v2 should be considered.
+func ProviderFromModel(t *testing.T, model ProviderModel) string {
+	t.Helper()
+
+	providerJson, err := DefaultJsonConfigProvider.ProviderJsonFromModel(model)
+	require.NoError(t, err)
+
+	hcl, err := DefaultHclConfigProvider.HclFromJson(providerJson)
+	require.NoError(t, err)
+	hcl, err = revertEqualSignForMapTypeAttributes(hcl)
+	require.NoError(t, err)
 
-func DefaultMeta(resource resources.Resource) *ResourceModelMeta {
-	return &ResourceModelMeta{name: DefaultResourceName, resource: resource}
+	return hcl
 }
 
-func Meta(resourceName string, resource resources.Resource) *ResourceModelMeta {
-	return &ResourceModelMeta{name: resourceName, resource: resource}
+// FromModels allows to combine multiple models.
+// TODO [SNOW-1501905]: introduce some common interface for all three existing models (ResourceModel, DatasourceModel, and ProviderModel)
+func FromModels(t *testing.T, models ...any) string {
+	t.Helper()
+
+	var sb strings.Builder
+	for i, model := range models {
+		switch m := model.(type) {
+		case ResourceModel:
+			sb.WriteString(ResourceFromModel(t, m))
+		case DatasourceModel:
+			sb.WriteString(DatasourceFromModel(t, m))
+		case ProviderModel:
+			sb.WriteString(ProviderFromModel(t, m))
+		default:
+			t.Fatalf("unknown model: %T", model)
+		}
+		if i < len(models)-1 {
+			sb.WriteString("\n")
+		}
+	}
+	return sb.String()
 }
 
 // FromModel should be used in terraform acceptance tests for Config attribute to get string config from ResourceModel.
 // Current implementation is really straightforward but it could be improved and tested. It may not handle all cases (like objects, lists, sets) correctly.
 // TODO [SNOW-1501905]: use reflection to build config directly from model struct (or some other different way)
 // TODO [SNOW-1501905]: add support for config.TestStepConfigFunc (to use as ConfigFile); the naive implementation would be to just create a tmp directory and save file there
+// TODO [SNOW-1501905]: add generating MarshalJSON() function
+// TODO [SNOW-1501905]: migrate resources to new config generation method (above needed first)
+// Use ResourceFromModel, DatasourceFromModel, ProviderFromModel, and FromModels instead.
 func FromModel(t *testing.T, model ResourceModel) string {
 	t.Helper()
 
@@ -99,7 +124,9 @@ func FromModel(t *testing.T, model ResourceModel) string {
 	return s
 }
 
-func FromModels(t *testing.T, models ...ResourceModel) string {
+// FromModelsDeprecated allows to combine multiple resource models.
+// Use FromModels instead.
+func FromModelsDeprecated(t *testing.T, models ...ResourceModel) string {
 	t.Helper()
 	var sb strings.Builder
 	for _, model := range models {
@@ -110,6 +137,7 @@ func FromModels(t *testing.T, models ...ResourceModel) string {
 
 // ConfigVariablesFromModel constructs config.Variables needed in acceptance tests that are using ConfigVariables in
 // combination with ConfigDirectory. It's necessary for cases not supported by FromModel, like lists of objects.
+// Use ResourceFromModel, DatasourceFromModel, ProviderFromModel, and FromModels instead.
 func ConfigVariablesFromModel(t *testing.T, model ResourceModel) tfconfig.Variables {
 	t.Helper()
 	variables := make(tfconfig.Variables)
@@ -139,15 +167,3 @@ func ConfigVariablesFromModels(t *testing.T, variableName string, models ...Reso
 		variableName: tfconfig.ListVariable(allVariables...),
 	}
 }
-
-type nullVariable struct{}
-
-// MarshalJSON returns the JSON encoding of nullVariable.
-func (v nullVariable) MarshalJSON() ([]byte, error) {
-	return json.Marshal(nil)
-}
-
-// NullVariable returns nullVariable which implements Variable.
-func NullVariable() nullVariable {
-	return nullVariable{}
-}
diff --git a/pkg/acceptance/bettertestspoc/config/config_test.go b/pkg/acceptance/bettertestspoc/config/config_test.go
new file mode 100644
index 0000000000..f061058adc
--- /dev/null
+++ b/pkg/acceptance/bettertestspoc/config/config_test.go
@@ -0,0 +1,189 @@
+package config_test
+
+import (
+	"strings"
+	"testing"
+
+	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/acceptance/bettertestspoc/config/datasourcemodel"
+	"github.com/Snowflake-Labs/terraform-provider-snowflake/pkg/acceptance/bettertestspoc/config/providermodel"
+	"github.com/stretchr/testify/require"
+)
+
+func Test_ResourceFromModelPoc(t *testing.T) {
+	t.Run("test basic", func(t *testing.T) {
+		someModel := Some("test", "Some Name")
+		expectedOutput := strings.TrimPrefix(`
+resource "snowflake_share" "test" {
+  name = "Some Name"
+}
+`, "\n")
+		result := config.ResourceFromModel(t, someModel)
+
+		require.Equal(t, expectedOutput, result)
+	})
+
+	t.Run("test full", func(t *testing.T) {
+		someModel := Some("test", "Some Name").
+			WithComment("Some Comment").
+			WithStringList("a", "b", "a").
+			WithStringSet("a", "b", "c").
+			WithObjectList(
+				Item{IntField: 1, StringField: "first item"},
+				Item{IntField: 2, StringField: "second item"},
+			).
+			WithSingleObject("one", 2).
+			WithDependsOn("some_other_resource.some_name", "other_resource.some_other_name", "third_resource.third_name")
+		expectedOutput := strings.TrimPrefix(`
+resource "snowflake_share" "test" {
+  comment = "Some Comment"
+  name = "Some Name"
+  string_list = ["a", "b", "a"]
+  string_set = ["a", "b", "c"]
+  object_list {
+    int_field = 1
+    string_field = "first item"
+  }
+  object_list {
+    int_field = 2
+    string_field = "second item"
+  }
+  single_object {
+    a = "one"
+    b = 2
+  }
+  depends_on = [some_other_resource.some_name, other_resource.some_other_name, third_resource.third_name]
+}
+`, "\n")
+
+		result := config.ResourceFromModel(t, someModel)
+
+		require.Equal(t, expectedOutput, result)
+	})
+}
+
+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" {}
+`, "\n")
+		result := config.DatasourceFromModel(t, datasourceModel)
+
+		require.Equal(t, expectedOutput, result)
+	})
+
+	t.Run("test with some arguments", func(t *testing.T) {
+		datasourceModel := datasourcemodel.Databases("test").WithLike("some").WithLimit(1)
+		expectedOutput := strings.TrimPrefix(`
+data "snowflake_databases" "test" {
+  like = "some"
+  limit {
+    rows = 1
+  }
+}
+`, "\n")
+		result := config.DatasourceFromModel(t, datasourceModel)
+
+		require.Equal(t, expectedOutput, result)
+	})
+
+	t.Run("test with depends on", func(t *testing.T) {
+		datasourceModel := datasourcemodel.Databases("test").
+			WithDependsOn("some_other_resource.some_name", "other_resource.some_other_name", "third_resource.third_name")
+		expectedOutput := strings.TrimPrefix(`
+data "snowflake_databases" "test" {
+  depends_on = [some_other_resource.some_name, other_resource.some_other_name, third_resource.third_name]
+}
+`, "\n")
+		result := config.DatasourceFromModel(t, datasourceModel)
+
+		require.Equal(t, expectedOutput, result)
+	})
+}
+
+func Test_ProviderFromModelPoc(t *testing.T) {
+	t.Run("test basic", func(t *testing.T) {
+		providerModel := providermodel.SnowflakeProvider()
+		expectedOutput := strings.TrimPrefix(`
+provider "snowflake" {}
+`, "\n")
+		result := config.ProviderFromModel(t, providerModel)
+
+		require.Equal(t, expectedOutput, result)
+	})
+
+	t.Run("test with alias", func(t *testing.T) {
+		providerModel := providermodel.SnowflakeProviderAlias("other_name")
+		expectedOutput := strings.TrimPrefix(`
+provider "snowflake" {
+  alias = "other_name"
+}
+`, "\n")
+		result := config.ProviderFromModel(t, providerModel)
+
+		require.Equal(t, expectedOutput, result)
+	})
+
+	t.Run("test with some attributes", func(t *testing.T) {
+		providerModel := providermodel.SnowflakeProvider().WithProfile("some_profile").WithUser("some user")
+		expectedOutput := strings.TrimPrefix(`
+provider "snowflake" {
+  profile = "some_profile"
+  user = "some user"
+}
+`, "\n")
+		result := config.ProviderFromModel(t, providerModel)
+
+		require.Equal(t, expectedOutput, result)
+	})
+
+	t.Run("test with parameters map", func(t *testing.T) {
+		providerModel := providermodel.SnowflakeProvider().WithProfile("some_profile").WithParamsValue(
+			tfconfig.MapVariable(map[string]tfconfig.Variable{
+				"statement_timeout_in_seconds": tfconfig.IntegerVariable(31337),
+			}),
+		)
+		expectedOutput := strings.TrimPrefix(`
+provider "snowflake" {
+  params = {
+    statement_timeout_in_seconds = 31337
+  }
+  profile = "some_profile"
+}
+`, "\n")
+		result := config.ProviderFromModel(t, providerModel)
+
+		require.Equal(t, expectedOutput, result)
+	})
+}
+
+func Test_ConfigFromModelsPoc(t *testing.T) {
+	t.Run("test basic", func(t *testing.T) {
+		providerModel := providermodel.SnowflakeProvider()
+		someModel := Some("test", "Some Name")
+		datasourceModel := datasourcemodel.Databases("test").WithDependsOn(someModel.ResourceReference())
+		someOtherModel := Some("test2", "Some Name 2").WithDependsOn(datasourceModel.DatasourceReference())
+		expectedOutput := strings.TrimPrefix(`
+provider "snowflake" {}
+
+resource "snowflake_share" "test" {
+  name = "Some Name"
+}
+
+data "snowflake_databases" "test" {
+  depends_on = [snowflake_share.test]
+}
+
+resource "snowflake_share" "test2" {
+  name = "Some Name 2"
+  depends_on = [data.snowflake_databases.test]
+}
+`, "\n")
+		result := config.FromModels(t, providerModel, someModel, datasourceModel, someOtherModel)
+
+		require.Equal(t, expectedOutput, result)
+	})
+}
diff --git a/pkg/acceptance/bettertestspoc/config/custom_variables.go b/pkg/acceptance/bettertestspoc/config/custom_variables.go
new file mode 100644
index 0000000000..4fb26cc040
--- /dev/null
+++ b/pkg/acceptance/bettertestspoc/config/custom_variables.go
@@ -0,0 +1,15 @@
+package config
+
+import "encoding/json"
+
+type nullVariable struct{}
+
+// MarshalJSON returns the JSON encoding of nullVariable.
+func (v nullVariable) MarshalJSON() ([]byte, error) {
+	return json.Marshal(nil)
+}
+
+// NullVariable returns nullVariable which implements Variable.
+func NullVariable() nullVariable {
+	return nullVariable{}
+}
diff --git a/pkg/acceptance/bettertestspoc/config/datasource_model.go b/pkg/acceptance/bettertestspoc/config/datasource_model.go
new file mode 100644
index 0000000000..4fada6ae84
--- /dev/null
+++ b/pkg/acceptance/bettertestspoc/config/datasource_model.go
@@ -0,0 +1,60 @@
+package config
+
+import (
+	"fmt"
+
+	"github.com/Snowflake-Labs/terraform-provider-snowflake/pkg/provider/datasources"
+)
+
+// DatasourceModel is the base interface all of our datasource config models will implement.
+// To allow easy implementation, DatasourceModelMeta can be embedded inside the struct (and the struct will automatically implement it).
+// TODO [SNOW-1501905]: consider merging ResourceModel with DatasourceModel (currently the implementation is really similar)
+type DatasourceModel interface {
+	Datasource() datasources.Datasource
+	DatasourceName() string
+	SetDatasourceName(name string)
+	DatasourceReference() string
+	DependsOn() []string
+	SetDependsOn(values ...string)
+}
+
+type DatasourceModelMeta struct {
+	name       string
+	datasource datasources.Datasource
+	dependsOn  []string
+}
+
+func (m *DatasourceModelMeta) Datasource() datasources.Datasource {
+	return m.datasource
+}
+
+func (m *DatasourceModelMeta) DatasourceName() string {
+	return m.name
+}
+
+func (m *DatasourceModelMeta) SetDatasourceName(name string) {
+	m.name = name
+}
+
+func (m *DatasourceModelMeta) DatasourceReference() string {
+	return fmt.Sprintf(`data.%s.%s`, m.datasource, m.name)
+}
+
+func (m *DatasourceModelMeta) DependsOn() []string {
+	return m.dependsOn
+}
+
+func (m *DatasourceModelMeta) SetDependsOn(values ...string) {
+	m.dependsOn = values
+}
+
+// DefaultDatasourceName is exported to allow assertions against the resources using the default name.
+const DefaultDatasourceName = "test"
+
+func DatasourceDefaultMeta(datasource datasources.Datasource) *DatasourceModelMeta {
+	return &DatasourceModelMeta{name: DefaultDatasourceName, datasource: datasource}
+}
+
+func DatasourceMeta(resourceName string, datasource datasources.Datasource) *DatasourceModelMeta {
+	return &DatasourceModelMeta{name: resourceName, datasource: datasource}
+}
diff --git a/pkg/acceptance/bettertestspoc/config/datasourcemodel/database_model_ext.go b/pkg/acceptance/bettertestspoc/config/datasourcemodel/database_model_ext.go
new file mode 100644
index 0000000000..96e4ec2d28
--- /dev/null
+++ b/pkg/acceptance/bettertestspoc/config/datasourcemodel/database_model_ext.go
@@ -0,0 +1,17 @@
+package datasourcemodel
+
+import (
+	"encoding/json"
+)
+
+// Based on https://medium.com/picus-security-engineering/custom-json-marshaller-in-go-and-common-pitfalls-c43fa774db05.
+func (d *DatabaseModel) MarshalJSON() ([]byte, error) {
+	type Alias DatabaseModel
+	return json.Marshal(&struct {
+		*Alias
+		DependsOn []string `json:"depends_on,omitempty"`
+	}{
+		Alias:     (*Alias)(d),
+		DependsOn: d.DependsOn(),
+	})
+}
diff --git a/pkg/acceptance/bettertestspoc/config/datasourcemodel/database_model_gen.go b/pkg/acceptance/bettertestspoc/config/datasourcemodel/database_model_gen.go
new file mode 100644
index 0000000000..dd99002397
--- /dev/null
+++ b/pkg/acceptance/bettertestspoc/config/datasourcemodel/database_model_gen.go
@@ -0,0 +1,143 @@
+// Code generated by config model builder generator; DO NOT EDIT.
+
+package datasourcemodel
+
+import (
+	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 DatabaseModel struct {
+	Comment       tfconfig.Variable `json:"comment,omitempty"`
+	CreatedOn     tfconfig.Variable `json:"created_on,omitempty"`
+	IsCurrent     tfconfig.Variable `json:"is_current,omitempty"`
+	IsDefault     tfconfig.Variable `json:"is_default,omitempty"`
+	Name          tfconfig.Variable `json:"name,omitempty"`
+	Options       tfconfig.Variable `json:"options,omitempty"`
+	Origin        tfconfig.Variable `json:"origin,omitempty"`
+	Owner         tfconfig.Variable `json:"owner,omitempty"`
+	RetentionTime tfconfig.Variable `json:"retention_time,omitempty"`
+
+	*config.DatasourceModelMeta
+}
+
+/////////////////////////////////////////////////
+// Basic builders (resource name and required) //
+/////////////////////////////////////////////////
+
+func Database(
+	datasourceName string,
+	name string,
+) *DatabaseModel {
+	d := &DatabaseModel{DatasourceModelMeta: config.DatasourceMeta(datasourceName, datasources.Database)}
+	d.WithName(name)
+	return d
+}
+
+func DatabaseWithDefaultMeta(
+	name string,
+) *DatabaseModel {
+	d := &DatabaseModel{DatasourceModelMeta: config.DatasourceDefaultMeta(datasources.Database)}
+	d.WithName(name)
+	return d
+}
+
+/////////////////////////////////
+// below all the proper values //
+/////////////////////////////////
+
+func (d *DatabaseModel) WithComment(comment string) *DatabaseModel {
+	d.Comment = tfconfig.StringVariable(comment)
+	return d
+}
+
+func (d *DatabaseModel) WithCreatedOn(createdOn string) *DatabaseModel {
+	d.CreatedOn = tfconfig.StringVariable(createdOn)
+	return d
+}
+
+func (d *DatabaseModel) WithIsCurrent(isCurrent bool) *DatabaseModel {
+	d.IsCurrent = tfconfig.BoolVariable(isCurrent)
+	return d
+}
+
+func (d *DatabaseModel) WithIsDefault(isDefault bool) *DatabaseModel {
+	d.IsDefault = tfconfig.BoolVariable(isDefault)
+	return d
+}
+
+func (d *DatabaseModel) WithName(name string) *DatabaseModel {
+	d.Name = tfconfig.StringVariable(name)
+	return d
+}
+
+func (d *DatabaseModel) WithOptions(options string) *DatabaseModel {
+	d.Options = tfconfig.StringVariable(options)
+	return d
+}
+
+func (d *DatabaseModel) WithOrigin(origin string) *DatabaseModel {
+	d.Origin = tfconfig.StringVariable(origin)
+	return d
+}
+
+func (d *DatabaseModel) WithOwner(owner string) *DatabaseModel {
+	d.Owner = tfconfig.StringVariable(owner)
+	return d
+}
+
+func (d *DatabaseModel) WithRetentionTime(retentionTime int) *DatabaseModel {
+	d.RetentionTime = tfconfig.IntegerVariable(retentionTime)
+	return d
+}
+
+//////////////////////////////////////////
+// below it's possible to set any value //
+//////////////////////////////////////////
+
+func (d *DatabaseModel) WithCommentValue(value tfconfig.Variable) *DatabaseModel {
+	d.Comment = value
+	return d
+}
+
+func (d *DatabaseModel) WithCreatedOnValue(value tfconfig.Variable) *DatabaseModel {
+	d.CreatedOn = value
+	return d
+}
+
+func (d *DatabaseModel) WithIsCurrentValue(value tfconfig.Variable) *DatabaseModel {
+	d.IsCurrent = value
+	return d
+}
+
+func (d *DatabaseModel) WithIsDefaultValue(value tfconfig.Variable) *DatabaseModel {
+	d.IsDefault = value
+	return d
+}
+
+func (d *DatabaseModel) WithNameValue(value tfconfig.Variable) *DatabaseModel {
+	d.Name = value
+	return d
+}
+
+func (d *DatabaseModel) WithOptionsValue(value tfconfig.Variable) *DatabaseModel {
+	d.Options = value
+	return d
+}
+
+func (d *DatabaseModel) WithOriginValue(value tfconfig.Variable) *DatabaseModel {
+	d.Origin = value
+	return d
+}
+
+func (d *DatabaseModel) WithOwnerValue(value tfconfig.Variable) *DatabaseModel {
+	d.Owner = value
+	return d
+}
+
+func (d *DatabaseModel) WithRetentionTimeValue(value tfconfig.Variable) *DatabaseModel {
+	d.RetentionTime = value
+	return d
+}
diff --git a/pkg/acceptance/bettertestspoc/config/datasourcemodel/databases_model_ext.go b/pkg/acceptance/bettertestspoc/config/datasourcemodel/databases_model_ext.go
new file mode 100644
index 0000000000..1e19163087
--- /dev/null
+++ b/pkg/acceptance/bettertestspoc/config/datasourcemodel/databases_model_ext.go
@@ -0,0 +1,32 @@
+package datasourcemodel
+
+import (
+	"encoding/json"
+
+	tfconfig "github.com/hashicorp/terraform-plugin-testing/config"
+)
+
+// Based on https://medium.com/picus-security-engineering/custom-json-marshaller-in-go-and-common-pitfalls-c43fa774db05.
+func (d *DatabasesModel) MarshalJSON() ([]byte, error) {
+	type Alias DatabasesModel
+	return json.Marshal(&struct {
+		*Alias
+		DependsOn []string `json:"depends_on,omitempty"`
+	}{
+		Alias:     (*Alias)(d),
+		DependsOn: d.DependsOn(),
+	})
+}
+
+func (d *DatabasesModel) WithDependsOn(values ...string) *DatabasesModel {
+	d.SetDependsOn(values...)
+	return d
+}
+
+func (d *DatabasesModel) WithLimit(rows int) *DatabasesModel {
+	return d.WithLimitValue(
+		tfconfig.ObjectVariable(map[string]tfconfig.Variable{
+			"rows": tfconfig.IntegerVariable(rows),
+		}),
+	)
+}
diff --git a/pkg/acceptance/bettertestspoc/config/datasourcemodel/databases_model_gen.go b/pkg/acceptance/bettertestspoc/config/datasourcemodel/databases_model_gen.go
new file mode 100644
index 0000000000..f2adf41b91
--- /dev/null
+++ b/pkg/acceptance/bettertestspoc/config/datasourcemodel/databases_model_gen.go
@@ -0,0 +1,99 @@
+// Code generated by config model builder generator; DO NOT EDIT.
+
+package datasourcemodel
+
+import (
+	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 DatabasesModel struct {
+	Databases      tfconfig.Variable `json:"databases,omitempty"`
+	Like           tfconfig.Variable `json:"like,omitempty"`
+	Limit          tfconfig.Variable `json:"limit,omitempty"`
+	StartsWith     tfconfig.Variable `json:"starts_with,omitempty"`
+	WithDescribe   tfconfig.Variable `json:"with_describe,omitempty"`
+	WithParameters tfconfig.Variable `json:"with_parameters,omitempty"`
+
+	*config.DatasourceModelMeta
+}
+
+/////////////////////////////////////////////////
+// Basic builders (resource name and required) //
+/////////////////////////////////////////////////
+
+func Databases(
+	datasourceName string,
+) *DatabasesModel {
+	d := &DatabasesModel{DatasourceModelMeta: config.DatasourceMeta(datasourceName, datasources.Databases)}
+	return d
+}
+
+func DatabasesWithDefaultMeta() *DatabasesModel {
+	d := &DatabasesModel{DatasourceModelMeta: config.DatasourceDefaultMeta(datasources.Databases)}
+	return d
+}
+
+/////////////////////////////////
+// below all the proper values //
+/////////////////////////////////
+
+// databases attribute type is not yet supported, so WithDatabases can't be generated
+
+func (d *DatabasesModel) WithLike(like string) *DatabasesModel {
+	d.Like = tfconfig.StringVariable(like)
+	return d
+}
+
+// limit attribute type is not yet supported, so WithLimit can't be generated
+
+func (d *DatabasesModel) WithStartsWith(startsWith string) *DatabasesModel {
+	d.StartsWith = tfconfig.StringVariable(startsWith)
+	return d
+}
+
+func (d *DatabasesModel) WithWithDescribe(withDescribe bool) *DatabasesModel {
+	d.WithDescribe = tfconfig.BoolVariable(withDescribe)
+	return d
+}
+
+func (d *DatabasesModel) WithWithParameters(withParameters bool) *DatabasesModel {
+	d.WithParameters = tfconfig.BoolVariable(withParameters)
+	return d
+}
+
+//////////////////////////////////////////
+// below it's possible to set any value //
+//////////////////////////////////////////
+
+func (d *DatabasesModel) WithDatabasesValue(value tfconfig.Variable) *DatabasesModel {
+	d.Databases = value
+	return d
+}
+
+func (d *DatabasesModel) WithLikeValue(value tfconfig.Variable) *DatabasesModel {
+	d.Like = value
+	return d
+}
+
+func (d *DatabasesModel) WithLimitValue(value tfconfig.Variable) *DatabasesModel {
+	d.Limit = value
+	return d
+}
+
+func (d *DatabasesModel) WithStartsWithValue(value tfconfig.Variable) *DatabasesModel {
+	d.StartsWith = value
+	return d
+}
+
+func (d *DatabasesModel) WithWithDescribeValue(value tfconfig.Variable) *DatabasesModel {
+	d.WithDescribe = value
+	return d
+}
+
+func (d *DatabasesModel) WithWithParametersValue(value tfconfig.Variable) *DatabasesModel {
+	d.WithParameters = value
+	return d
+}
diff --git a/pkg/acceptance/bettertestspoc/config/datasourcemodel/gen/datasource_schema_def.go b/pkg/acceptance/bettertestspoc/config/datasourcemodel/gen/datasource_schema_def.go
new file mode 100644
index 0000000000..e507ea2800
--- /dev/null
+++ b/pkg/acceptance/bettertestspoc/config/datasourcemodel/gen/datasource_schema_def.go
@@ -0,0 +1,33 @@
+package gen
+
+import (
+	"github.com/Snowflake-Labs/terraform-provider-snowflake/pkg/datasources"
+	"github.com/Snowflake-Labs/terraform-provider-snowflake/pkg/internal/genhelpers"
+	"github.com/hashicorp/terraform-plugin-sdk/v2/helper/schema"
+)
+
+type DatasourceSchemaDef struct {
+	name   string
+	schema map[string]*schema.Schema
+}
+
+// TODO [SNOW-1501905]: rename ResourceSchemaDetails (because it is used for the datasources and provider too)
+func GetDatasourceSchemaDetails() []genhelpers.ResourceSchemaDetails {
+	allDatasourcesSchemas := allDatasourcesSchemaDefs
+	allDatasourcesSchemasDetails := make([]genhelpers.ResourceSchemaDetails, len(allDatasourcesSchemas))
+	for idx, s := range allDatasourcesSchemas {
+		allDatasourcesSchemasDetails[idx] = genhelpers.ExtractResourceSchemaDetails(s.name, s.schema)
+	}
+	return allDatasourcesSchemasDetails
+}
+
+var allDatasourcesSchemaDefs = []DatasourceSchemaDef{
+	{
+		name:   "Database",
+		schema: datasources.Database().Schema,
+	},
+	{
+		name:   "Databases",
+		schema: datasources.Databases().Schema,
+	},
+}
diff --git a/pkg/acceptance/bettertestspoc/config/datasourcemodel/gen/main/main.go b/pkg/acceptance/bettertestspoc/config/datasourcemodel/gen/main/main.go
new file mode 100644
index 0000000000..0099d8a413
--- /dev/null
+++ b/pkg/acceptance/bettertestspoc/config/datasourcemodel/gen/main/main.go
@@ -0,0 +1,22 @@
+package main
+
+import (
+	resourcemodelgen "github.com/Snowflake-Labs/terraform-provider-snowflake/pkg/acceptance/bettertestspoc/config/model/gen"
+
+	"github.com/Snowflake-Labs/terraform-provider-snowflake/pkg/acceptance/bettertestspoc/config/datasourcemodel/gen"
+	"github.com/Snowflake-Labs/terraform-provider-snowflake/pkg/internal/genhelpers"
+)
+
+func main() {
+	genhelpers.NewGenerator(
+		gen.GetDatasourceSchemaDetails,
+		resourcemodelgen.ModelFromResourceSchemaDetails,
+		getFilename,
+		gen.AllTemplates,
+	).
+		RunAndHandleOsReturn()
+}
+
+func getFilename(_ genhelpers.ResourceSchemaDetails, model resourcemodelgen.ResourceConfigBuilderModel) string {
+	return genhelpers.ToSnakeCase(model.Name) + "_model" + "_gen.go"
+}
diff --git a/pkg/acceptance/bettertestspoc/config/datasourcemodel/gen/templates.go b/pkg/acceptance/bettertestspoc/config/datasourcemodel/gen/templates.go
new file mode 100644
index 0000000000..0c0da8794d
--- /dev/null
+++ b/pkg/acceptance/bettertestspoc/config/datasourcemodel/gen/templates.go
@@ -0,0 +1,28 @@
+package gen
+
+import (
+	"text/template"
+
+	_ "embed"
+
+	resourcemodel "github.com/Snowflake-Labs/terraform-provider-snowflake/pkg/acceptance/bettertestspoc/config/model/gen"
+
+	"github.com/Snowflake-Labs/terraform-provider-snowflake/pkg/internal/genhelpers"
+)
+
+var (
+	//go:embed templates/preamble.tmpl
+	preambleTemplateContent string
+	PreambleTemplate, _     = template.New("preambleTemplate").Parse(preambleTemplateContent)
+
+	//go:embed templates/definition.tmpl
+	definitionTemplateContent string
+	DefinitionTemplate, _     = template.New("definitionTemplate").Funcs(genhelpers.BuildTemplateFuncMap(
+		genhelpers.FirstLetterLowercase,
+		genhelpers.FirstLetter,
+		genhelpers.SnakeCaseToCamel,
+	)).Parse(definitionTemplateContent)
+
+	// TODO [SNOW-1501905]: consider duplicating the builders template from resource (currently same template used for datasources and provider which limits the customization possibilities for just one block type)
+	AllTemplates = []*template.Template{PreambleTemplate, DefinitionTemplate, resourcemodel.BuildersTemplate}
+)
diff --git a/pkg/acceptance/bettertestspoc/config/datasourcemodel/gen/templates/definition.tmpl b/pkg/acceptance/bettertestspoc/config/datasourcemodel/gen/templates/definition.tmpl
new file mode 100644
index 0000000000..0eff2ab707
--- /dev/null
+++ b/pkg/acceptance/bettertestspoc/config/datasourcemodel/gen/templates/definition.tmpl
@@ -0,0 +1,53 @@
+{{- /*gotype: github.com/Snowflake-Labs/terraform-provider-snowflake/pkg/acceptance/bettertestspoc/config/model/gen.ResourceConfigBuilderModel*/ -}}
+
+{{- $modelName := .Name | printf "%sModel" -}}
+{{- $nameLowerCase := FirstLetterLowercase .Name -}}
+{{- $modelVar := FirstLetter $nameLowerCase }}
+
+type {{ $modelName }} struct {
+    {{ range .Attributes -}}
+        {{ SnakeCaseToCamel .Name }} tfconfig.Variable `json:"{{ .Name }},omitempty"`
+    {{ end }}
+    *config.DatasourceModelMeta
+}
+
+/////////////////////////////////////////////////
+// Basic builders (resource name and required) //
+/////////////////////////////////////////////////
+
+func {{ .Name }}(
+    datasourceName string,
+    {{ range .Attributes -}}
+        {{- $attributeNameCamel := SnakeCaseToCamel .Name -}}
+        {{ if .Required -}}
+            {{ FirstLetterLowercase $attributeNameCamel }} {{ .AttributeType }},
+        {{ end }}
+    {{- end -}}
+) *{{ $modelName }} {
+    {{ $modelVar }} := &{{ $modelName }}{DatasourceModelMeta: config.DatasourceMeta(datasourceName, datasources.{{ .Name }})}
+    {{ range .Attributes -}}
+        {{- $attributeNameCamel := SnakeCaseToCamel .Name -}}
+        {{ if .Required -}}
+            {{ $modelVar }}.With{{ $attributeNameCamel }}({{ FirstLetterLowercase $attributeNameCamel }})
+        {{ end }}
+    {{- end -}}
+    return {{ $modelVar }}
+}
+
+func {{ .Name }}WithDefaultMeta(
+    {{ range .Attributes -}}
+        {{- $attributeNameCamel := SnakeCaseToCamel .Name -}}
+        {{ if .Required -}}
+            {{ FirstLetterLowercase $attributeNameCamel }} {{ .AttributeType }},
+        {{ end }}
+    {{- end -}}
+) *{{ $modelName }} {
+    {{ $modelVar }} := &{{ $modelName }}{DatasourceModelMeta: config.DatasourceDefaultMeta(datasources.{{ .Name }})}
+    {{ range .Attributes -}}
+        {{- $attributeNameCamel := SnakeCaseToCamel .Name -}}
+        {{ if .Required -}}
+            {{ $modelVar }}.With{{ $attributeNameCamel }}({{ FirstLetterLowercase $attributeNameCamel }})
+        {{ end }}
+    {{- end -}}
+    return {{ $modelVar }}
+}
diff --git a/pkg/acceptance/bettertestspoc/config/datasourcemodel/gen/templates/preamble.tmpl b/pkg/acceptance/bettertestspoc/config/datasourcemodel/gen/templates/preamble.tmpl
new file mode 100644
index 0000000000..ebd7566570
--- /dev/null
+++ b/pkg/acceptance/bettertestspoc/config/datasourcemodel/gen/templates/preamble.tmpl
@@ -0,0 +1,16 @@
+{{- /*gotype: github.com/Snowflake-Labs/terraform-provider-snowflake/pkg/acceptance/bettertestspoc/config/model/gen.PreambleModel*/ -}}
+
+// Code generated by config model builder generator; DO NOT EDIT.
+
+package {{ .PackageName }}
+
+import (
+    {{- range .AdditionalStandardImports }}
+    "{{- . }}"
+    {{- end }}
+
+    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"
+)
diff --git a/pkg/acceptance/bettertestspoc/config/datasourcemodel/generate.go b/pkg/acceptance/bettertestspoc/config/datasourcemodel/generate.go
new file mode 100644
index 0000000000..383a77c127
--- /dev/null
+++ b/pkg/acceptance/bettertestspoc/config/datasourcemodel/generate.go
@@ -0,0 +1,3 @@
+package datasourcemodel
+
+//go:generate go run ./gen/main/main.go $SF_TF_GENERATOR_ARGS
diff --git a/pkg/acceptance/bettertestspoc/config/experiments/hcl_v1_test.go b/pkg/acceptance/bettertestspoc/config/experiments/hcl_v1_test.go
new file mode 100644
index 0000000000..c01280c5cb
--- /dev/null
+++ b/pkg/acceptance/bettertestspoc/config/experiments/hcl_v1_test.go
@@ -0,0 +1,126 @@
+package experiments_test
+
+import (
+	"bytes"
+	"fmt"
+	"testing"
+
+	hclv1printer "github.com/hashicorp/hcl/hcl/printer"
+	hclv1parser "github.com/hashicorp/hcl/json/parser"
+
+	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/require"
+)
+
+// Test_exploreHclV1 shows conversion from .tf.json to .tf using HCL v1 lib.
+// The main takes:
+// - block types (e.g. resource) stay quoted (while they should be unquoted)
+// - attribute names stay quoted (while they should be unquoted)
+// - objects and object lists have equal sign (what should not be there)
+// - references in depends_on stay quoted (while they should be unquoted)
+// - there are two newlines between every attribute
+//
+// Because of the above, the current implementation using json generation and later conversion to HCL using hcl v1
+// introduces formatters tackling the issues above. This is not the perfect solution but it's fast and will work in the meantime.
+// Check: config.DefaultHclConfigProvider.
+//
+// References:
+// - https://developer.hashicorp.com/terraform/language/syntax/json
+// - https://github.com/hashicorp/hcl/blob/56a9aee5207dbaed7f061cd926b96fc159d26ea0/json/spec.md
+// - https://developer.hashicorp.com/terraform/language/resources/syntax
+// - https://developer.hashicorp.com/terraform/language/meta-arguments/depends_on
+// TODO [SNOW-1501905]: explore HCL v2 in more detail (especially struct tags generation; probably with migration to plugin framework because of schema models); ref: https://github.com/hashicorp/hcl/blob/bee2dc2e75f7528ad85777b7a013c13796426bd6/gohcl/encode_test.go#L48
+func Test_exploreHclV1(t *testing.T) {
+	convertJsonToHclStringV1 := func(json string) (string, error) {
+		parsed, err := hclv1parser.Parse([]byte(json))
+		if err != nil {
+			return "", err
+		}
+
+		var buffer bytes.Buffer
+		err = hclv1printer.Fprint(&buffer, parsed)
+		if err != nil {
+			return "", err
+		}
+
+		formatted, err := hclv1printer.Format(buffer.Bytes())
+		if err != nil {
+			return "", err
+		}
+
+		return string(formatted), nil
+	}
+
+	t.Run("test HCL v1", func(t *testing.T) {
+		resourceJson := `{
+            "resource": {
+                "snowflake_share": {
+                    "test": {
+						"attribute_int": 1,
+						"attribute_bool": true,
+						"attribute_string": "some string",
+						"string_template": "${resource.name.attribute}",
+                        "string_list": ["a", "b", "a"],
+                        "object_list": [
+                            {
+                                "int_field": 1,
+                                "string_field": "first item"
+                            },
+                            {
+                                "int_field": 2,
+                                "string_field": "second item"
+                            }
+                        ],
+                        "single_object": {
+							"prop1": 1,
+							"prop2": "two"
+						},
+                        "depends_on": [
+                            "some_other_resource.some_name",
+                            "other_resource.some_other_name",
+							"data.some_datasource.some_fancy_datasource"
+                        ]
+                    }
+                }
+            }
+        }`
+		expectedResult := `"resource" "snowflake_share" "test" {
+  "attribute_int" = 1
+
+  "attribute_bool" = true
+
+  "attribute_string" = "some string"
+
+  "string_template" = "${resource.name.attribute}"
+
+  "string_list" = ["a", "b", "a"]
+
+  "object_list" = {
+    "int_field" = 1
+
+    "string_field" = "first item"
+  }
+
+  "object_list" = {
+    "int_field" = 2
+
+    "string_field" = "second item"
+  }
+
+  "single_object" = {
+    "prop1" = 1
+
+    "prop2" = "two"
+  }
+
+  "depends_on" = ["some_other_resource.some_name", "other_resource.some_other_name", "data.some_datasource.some_fancy_datasource"]
+}
+`
+
+		result, err := convertJsonToHclStringV1(resourceJson)
+		require.NoError(t, err)
+		assert.Equal(t, expectedResult, result)
+
+		fmt.Printf("%s", result)
+	})
+}
diff --git a/pkg/acceptance/bettertestspoc/config/hcl_config_provider.go b/pkg/acceptance/bettertestspoc/config/hcl_config_provider.go
new file mode 100644
index 0000000000..632e2d502e
--- /dev/null
+++ b/pkg/acceptance/bettertestspoc/config/hcl_config_provider.go
@@ -0,0 +1,128 @@
+package config
+
+import (
+	"bytes"
+	"fmt"
+	"regexp"
+	"strings"
+
+	hclv1printer "github.com/hashicorp/hcl/hcl/printer"
+	hclv1parser "github.com/hashicorp/hcl/json/parser"
+)
+
+var DefaultHclConfigProvider = NewHclV1ConfigProvider(unquoteBlockType, fixBlockArguments, fixMultilinePrivateKey, unquoteArguments, unquoteArguments, removeDoubleNewlines, unquoteDependsOnReferences)
+
+// HclConfigProvider defines methods to generate .tf config from .tf.json configs.
+type HclConfigProvider interface {
+	HclFromJson(json []byte) (string, error)
+}
+
+type HclFormatter func(string) (string, error)
+
+type hclV1ConfigProvider struct {
+	formatters []HclFormatter
+}
+
+func NewHclV1ConfigProvider(formatters ...HclFormatter) HclConfigProvider {
+	return &hclV1ConfigProvider{
+		formatters: formatters,
+	}
+}
+
+func (h *hclV1ConfigProvider) HclFromJson(json []byte) (string, error) {
+	hcl, err := convertJsonToHclStringV1(json)
+	if err != nil {
+		return "", err
+	}
+
+	for _, formatter := range h.formatters {
+		hcl, err = formatter(hcl)
+		if err != nil {
+			return "", err
+		}
+	}
+
+	return hcl, nil
+}
+
+func convertJsonToHclStringV1(jsonBytes []byte) (string, error) {
+	parsed, err := hclv1parser.Parse(jsonBytes)
+	if err != nil {
+		return "", err
+	}
+
+	var buffer bytes.Buffer
+	err = hclv1printer.Fprint(&buffer, parsed)
+	if err != nil {
+		return "", err
+	}
+
+	formatted, err := hclv1printer.Format(buffer.Bytes())
+	if err != nil {
+		return "", err
+	}
+
+	return string(formatted), nil
+}
+
+// Conversion to HCL using hcl v1 does not unquote block types (i.e. `"resource"` instead of expected `resource`).
+// Check experiments subpackage for details.
+func unquoteBlockType(s string) (string, error) {
+	blockTypeRegex := regexp.MustCompile(`"(resource|data|provider)"(( "\w+"){1,2} {)`)
+	return blockTypeRegex.ReplaceAllString(s, `$1$2`), nil
+}
+
+// Conversion to HCL using hcl v1 uses `=` sign for objects and lists of objects.
+// Check experiments subpackage for details.
+func fixBlockArguments(s string) (string, error) {
+	argumentRegex := regexp.MustCompile(`( +)"(\w+)"( +)= ({\n)`)
+	return argumentRegex.ReplaceAllString(s, `$1$2$3$4`), nil
+}
+
+// TODO [SNOW-1501905]: fix new lines replacement totally in this method, consider better placeholders (now there can't be multilinekeys for private key)
+func fixMultilinePrivateKey(s string) (string, error) {
+	argumentRegex := regexp.MustCompile(fmt.Sprintf(`"%[1]s(.*)%[1]s"`, SnowflakeProviderConfigPrivateKey))
+	submatches := argumentRegex.FindStringSubmatch(s)
+	if len(submatches) < 1 {
+		return s, nil
+	} else {
+		return argumentRegex.ReplaceAllString(s, fmt.Sprintf(`<<EOT
+%s
+EOT`, strings.ReplaceAll(submatches[1], `\n`, `
+`))), nil
+	}
+}
+
+// Conversion to HCL using hcl v1  does not unquote arguments.
+// Check experiments subpackage for details.
+func unquoteArguments(s string) (string, error) {
+	argumentRegex := regexp.MustCompile(`( +)"(\w+)"( +=)`)
+	return argumentRegex.ReplaceAllString(s, `$1$2$3`), nil
+}
+
+// Conversion to HCL using hcl v1 leaves double newlines between each attribute.
+// Check experiments subpackage for details.
+func removeDoubleNewlines(input string) (string, error) {
+	return strings.ReplaceAll(input, "\n\n", "\n"), nil
+}
+
+// Based on https://developer.hashicorp.com/terraform/language/syntax/json#depends_on should be processed in a special way, but it isn't.
+// Check experiments subpackage for details.
+// TODO [SNOW-1501905]: use FindAllStringSubmatch or fix this method in other way
+func unquoteDependsOnReferences(s string) (string, error) {
+	dependsOnRegex := regexp.MustCompile(`("?depends_on"? = )(\["\w+\.\w+(.\w+)?"(, "\w+\.\w+(.\w+)?")*])`)
+	submatches := dependsOnRegex.FindStringSubmatch(s)
+	if len(submatches) < 2 {
+		return s, nil
+	} else {
+		withoutQuotes := strings.ReplaceAll(submatches[2], `"`, "")
+		return dependsOnRegex.ReplaceAllString(s, fmt.Sprintf(`$1%s`, withoutQuotes)), nil
+	}
+}
+
+// fixBlockArguments messes with schema.TypeMap. We use it only in the provider (will be replaced) and in the old resources.
+// TODO [SNOW-1501905]: remove this workaround after replacing schema.TypeMap everywhere or make it wiser (e.g. during generation we could programmatically gather all schema.TypeMap and use this workaround only for them)
+func revertEqualSignForMapTypeAttributes(s string) (string, error) {
+	argumentRegex := regexp.MustCompile(`( +)(params|sessions_params)( +)({\n)`)
+	return argumentRegex.ReplaceAllString(s, `$1$2$3= $4`), nil
+}
diff --git a/pkg/acceptance/bettertestspoc/config/hcl_config_provider_test.go b/pkg/acceptance/bettertestspoc/config/hcl_config_provider_test.go
new file mode 100644
index 0000000000..ddd1187d32
--- /dev/null
+++ b/pkg/acceptance/bettertestspoc/config/hcl_config_provider_test.go
@@ -0,0 +1,83 @@
+package config_test
+
+import (
+	"fmt"
+	"testing"
+
+	"github.com/Snowflake-Labs/terraform-provider-snowflake/pkg/acceptance/bettertestspoc/config"
+	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/require"
+)
+
+func Test_HclProvider(t *testing.T) {
+	// This test shows that all issues from the experiments package were resolved using formatters.
+	t.Run("test default hcl provider", func(t *testing.T) {
+		resourceJson := `{
+            "resource": {
+                "snowflake_share": {
+                    "test": {
+                        "attribute_int": 1,
+                        "attribute_bool": true,
+                        "attribute_string": "some string",
+                        "string_template": "${resource.name.attribute}",
+                        "string_list": ["a", "b", "a"],
+                        "object_list": [
+                            {
+                                "int_field": 1,
+                                "string_field": "first item"
+                            },
+                            {
+                                "int_field": 2,
+                                "string_field": "second item"
+                            }
+                        ],
+                        "single_object": {
+                            "prop1": 1,
+                            "prop2": "two"
+                        },
+						"multiline_string": "SF_TF_TEST_MULTILINE_PLACEHOLDER_PRIVATE_KEY-----BEGIN PRIVATE KEY-----\nabc\ndef\nghj\n-----END PRIVATE KEY-----\nSF_TF_TEST_MULTILINE_PLACEHOLDER_PRIVATE_KEY",
+                        "depends_on": [
+                            "some_other_resource.some_name",
+                            "other_resource.some_other_name",
+							"data.some_datasource.some_fancy_datasource"
+                        ]
+                    }
+                }
+            }
+        }`
+		expectedResult := `resource "snowflake_share" "test" {
+  attribute_int = 1
+  attribute_bool = true
+  attribute_string = "some string"
+  string_template = "${resource.name.attribute}"
+  string_list = ["a", "b", "a"]
+  object_list {
+    int_field = 1
+    string_field = "first item"
+  }
+  object_list {
+    int_field = 2
+    string_field = "second item"
+  }
+  single_object {
+    prop1 = 1
+    prop2 = "two"
+  }
+  multiline_string = <<EOT
+-----BEGIN PRIVATE KEY-----
+abc
+def
+ghj
+-----END PRIVATE KEY-----
+EOT
+  depends_on = [some_other_resource.some_name, other_resource.some_other_name, data.some_datasource.some_fancy_datasource]
+}
+`
+
+		result, err := config.DefaultHclConfigProvider.HclFromJson([]byte(resourceJson))
+		require.NoError(t, err)
+		assert.Equal(t, expectedResult, result)
+
+		fmt.Printf("%s", result)
+	})
+}
diff --git a/pkg/acceptance/bettertestspoc/config/json_config_provider.go b/pkg/acceptance/bettertestspoc/config/json_config_provider.go
new file mode 100644
index 0000000000..9d80c09cf6
--- /dev/null
+++ b/pkg/acceptance/bettertestspoc/config/json_config_provider.go
@@ -0,0 +1,67 @@
+package config
+
+import (
+	"encoding/json"
+)
+
+var DefaultJsonConfigProvider = NewBasicJsonConfigProvider()
+
+// JsonConfigProvider defines methods to generate .tf.json configs.
+// TODO [SNOW-1501905]: add config builders for other block types (Variable, Output, Localsl, Module, Terraform)
+type JsonConfigProvider interface {
+	ResourceJsonFromModel(model ResourceModel) ([]byte, error)
+	DatasourceJsonFromModel(model DatasourceModel) ([]byte, error)
+	ProviderJsonFromModel(model ProviderModel) ([]byte, error)
+}
+
+type basicJsonConfigProvider struct{}
+
+func NewBasicJsonConfigProvider() JsonConfigProvider {
+	return &basicJsonConfigProvider{}
+}
+
+func (p *basicJsonConfigProvider) ResourceJsonFromModel(model ResourceModel) ([]byte, error) {
+	modelJson := resourceJson{
+		Resource: map[string]map[string]ResourceModel{
+			model.Resource().String(): {
+				model.ResourceName(): model,
+			},
+		},
+	}
+
+	return json.MarshalIndent(modelJson, "", "    ")
+}
+
+type resourceJson struct {
+	Resource map[string]map[string]ResourceModel `json:"resource"`
+}
+
+func (p *basicJsonConfigProvider) DatasourceJsonFromModel(model DatasourceModel) ([]byte, error) {
+	modelJson := datasourceJson{
+		Datasource: map[string]map[string]DatasourceModel{
+			model.Datasource().String(): {
+				model.DatasourceName(): model,
+			},
+		},
+	}
+
+	return json.MarshalIndent(modelJson, "", "    ")
+}
+
+type datasourceJson struct {
+	Datasource map[string]map[string]DatasourceModel `json:"data"`
+}
+
+func (p *basicJsonConfigProvider) ProviderJsonFromModel(model ProviderModel) ([]byte, error) {
+	modelJson := providerJson{
+		Provider: map[string]ProviderModel{
+			model.ProviderName(): model,
+		},
+	}
+
+	return json.MarshalIndent(modelJson, "", "    ")
+}
+
+type providerJson struct {
+	Provider map[string]ProviderModel `json:"provider"`
+}
diff --git a/pkg/acceptance/bettertestspoc/config/json_config_provider_test.go b/pkg/acceptance/bettertestspoc/config/json_config_provider_test.go
new file mode 100644
index 0000000000..a5584008df
--- /dev/null
+++ b/pkg/acceptance/bettertestspoc/config/json_config_provider_test.go
@@ -0,0 +1,78 @@
+package config_test
+
+import (
+	"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/bettertestspoc/config/providermodel"
+	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/require"
+)
+
+func Test_JsonConfigProvider(t *testing.T) {
+	t.Run("test resource json config", func(t *testing.T) {
+		model := Some("some_name", "abc").WithDependsOn("abc.def")
+		expectedResult := `{
+    "resource": {
+        "snowflake_share": {
+            "some_name": {
+                "name": "abc",
+                "depends_on": [
+                    "abc.def"
+                ]
+            }
+        }
+    }
+}`
+
+		result, err := config.DefaultJsonConfigProvider.ResourceJsonFromModel(model)
+		require.NoError(t, err)
+		assert.Equal(t, expectedResult, string(result))
+	})
+
+	t.Run("test resource json config when proper marshaller is absent", func(t *testing.T) {
+		model := SomeOther("some_name", "abc").WithDependsOn("abc.def")
+		expectedResult := `{
+    "resource": {
+        "snowflake_share": {
+            "some_name": {
+                "name": "abc"
+            }
+        }
+    }
+}`
+
+		result, err := config.DefaultJsonConfigProvider.ResourceJsonFromModel(model)
+		require.NoError(t, err)
+		assert.Equal(t, expectedResult, string(result))
+	})
+
+	t.Run("test datasource json config", func(t *testing.T) {
+		model := datasourcemodel.Databases("some_name")
+		expectedResult := `{
+    "data": {
+        "snowflake_databases": {
+            "some_name": {}
+        }
+    }
+}`
+
+		result, err := config.DefaultJsonConfigProvider.DatasourceJsonFromModel(model)
+		require.NoError(t, err)
+		assert.Equal(t, expectedResult, string(result))
+	})
+
+	t.Run("test provider json config", func(t *testing.T) {
+		model := providermodel.SnowflakeProvider()
+		expectedResult := `{
+    "provider": {
+        "snowflake": {}
+    }
+}`
+
+		result, err := config.DefaultJsonConfigProvider.ProviderJsonFromModel(model)
+		require.NoError(t, err)
+		assert.Equal(t, expectedResult, string(result))
+	})
+}
diff --git a/pkg/acceptance/bettertestspoc/config/model/database_model_ext.go b/pkg/acceptance/bettertestspoc/config/model/database_model_ext.go
new file mode 100644
index 0000000000..de2d420039
--- /dev/null
+++ b/pkg/acceptance/bettertestspoc/config/model/database_model_ext.go
@@ -0,0 +1,23 @@
+package model
+
+import (
+	tfconfig "github.com/hashicorp/terraform-plugin-testing/config"
+
+	"github.com/Snowflake-Labs/terraform-provider-snowflake/pkg/sdk"
+)
+
+func (d *DatabaseModel) WithReplication(accountIdentifier sdk.AccountIdentifier, withFailover bool, ignoreEditionCheck bool) *DatabaseModel {
+	return d.WithReplicationValue(
+		tfconfig.ObjectVariable(
+			map[string]tfconfig.Variable{
+				"enable_to_account": tfconfig.ObjectVariable(
+					map[string]tfconfig.Variable{
+						"account_identifier": tfconfig.StringVariable(accountIdentifier.FullyQualifiedName()),
+						"with_failover":      tfconfig.BoolVariable(withFailover),
+					},
+				),
+				"ignore_edition_check": tfconfig.BoolVariable(ignoreEditionCheck),
+			},
+		),
+	)
+}
diff --git a/pkg/acceptance/bettertestspoc/config/model/generate.go b/pkg/acceptance/bettertestspoc/config/model/generate.go
index a4a6f090b8..ff5dbe2afb 100644
--- a/pkg/acceptance/bettertestspoc/config/model/generate.go
+++ b/pkg/acceptance/bettertestspoc/config/model/generate.go
@@ -1,3 +1,5 @@
 package model
 
 //go:generate go run ./gen/main/main.go $SF_TF_GENERATOR_ARGS
+
+// TODO [SNOW-1501905]: rename package model to resourcemodel
diff --git a/pkg/acceptance/bettertestspoc/config/model/view_model_ext.go b/pkg/acceptance/bettertestspoc/config/model/view_model_ext.go
index db546a67f6..3d213bf0b8 100644
--- a/pkg/acceptance/bettertestspoc/config/model/view_model_ext.go
+++ b/pkg/acceptance/bettertestspoc/config/model/view_model_ext.go
@@ -1,6 +1,81 @@
 package model
 
+import (
+	"encoding/json"
+
+	"github.com/Snowflake-Labs/terraform-provider-snowflake/pkg/internal/collections"
+	"github.com/Snowflake-Labs/terraform-provider-snowflake/pkg/sdk"
+	"github.com/hashicorp/terraform-plugin-testing/config"
+)
+
+func (v *ViewModel) MarshalJSON() ([]byte, error) {
+	type Alias ViewModel
+	return json.Marshal(&struct {
+		*Alias
+		DependsOn []string `json:"depends_on,omitempty"`
+	}{
+		Alias:     (*Alias)(v),
+		DependsOn: v.DependsOn(),
+	})
+}
+
 func (v *ViewModel) WithDependsOn(values ...string) *ViewModel {
 	v.SetDependsOn(values...)
 	return v
 }
+
+func (v *ViewModel) WithColumnNames(columnNames ...string) *ViewModel {
+	return v.WithColumnValue(config.TupleVariable(
+		collections.Map(columnNames, func(columnName string) config.Variable {
+			return config.ObjectVariable(
+				map[string]config.Variable{
+					"column_name": config.StringVariable(columnName),
+				},
+			)
+		})...,
+	))
+}
+
+func (v *ViewModel) WithRowAccessPolicy(rap sdk.SchemaObjectIdentifier, on string) *ViewModel {
+	return v.WithRowAccessPolicyValue(
+		config.ObjectVariable(
+			map[string]config.Variable{
+				"policy_name": config.StringVariable(rap.FullyQualifiedName()),
+				"on":          config.ListVariable(config.StringVariable(on)),
+			},
+		),
+	)
+}
+
+func (v *ViewModel) WithAggregationPolicy(ap sdk.SchemaObjectIdentifier, key string) *ViewModel {
+	return v.WithAggregationPolicyValue(
+		config.ObjectVariable(
+			map[string]config.Variable{
+				"policy_name": config.StringVariable(ap.FullyQualifiedName()),
+				"entity_key":  config.ListVariable(config.StringVariable(key)),
+			},
+		),
+	)
+}
+
+func (v *ViewModel) WithDataMetricFunction(functionId sdk.SchemaObjectIdentifier, on string, scheduleStatus sdk.DataMetricScheduleStatusOption) *ViewModel {
+	return v.WithDataMetricFunctionValue(
+		config.ObjectVariable(
+			map[string]config.Variable{
+				"function_name":   config.StringVariable(functionId.FullyQualifiedName()),
+				"on":              config.ListVariable(config.StringVariable(on)),
+				"schedule_status": config.StringVariable(string(scheduleStatus)),
+			},
+		),
+	)
+}
+
+func (v *ViewModel) WithDataMetricSchedule(cron string) *ViewModel {
+	return v.WithDataMetricScheduleValue(
+		config.ObjectVariable(
+			map[string]config.Variable{
+				"using_cron": config.StringVariable(cron),
+			},
+		),
+	)
+}
diff --git a/pkg/acceptance/bettertestspoc/config/placeholders.go b/pkg/acceptance/bettertestspoc/config/placeholders.go
new file mode 100644
index 0000000000..21b5fe10e6
--- /dev/null
+++ b/pkg/acceptance/bettertestspoc/config/placeholders.go
@@ -0,0 +1,5 @@
+package config
+
+type ReplacementPlaceholder string
+
+const SnowflakeProviderConfigPrivateKey ReplacementPlaceholder = "SF_TF_TEST_MULTILINE_PLACEHOLDER_PRIVATE_KEY"
diff --git a/pkg/acceptance/bettertestspoc/config/provider_model.go b/pkg/acceptance/bettertestspoc/config/provider_model.go
new file mode 100644
index 0000000000..78f34a0401
--- /dev/null
+++ b/pkg/acceptance/bettertestspoc/config/provider_model.go
@@ -0,0 +1,29 @@
+package config
+
+// ProviderModel is the base interface all of our provider config models will implement.
+// To allow easy implementation, ProviderModelMeta can be embedded inside the struct (and the struct will automatically implement it).
+type ProviderModel interface {
+	ProviderName() string
+	Alias() string
+}
+
+type ProviderModelMeta struct {
+	name  string
+	alias string
+}
+
+func DefaultProviderMeta(name string) *ProviderModelMeta {
+	return &ProviderModelMeta{name: name}
+}
+
+func ProviderMeta(name string, alias string) *ProviderModelMeta {
+	return &ProviderModelMeta{name: name, alias: alias}
+}
+
+func (m *ProviderModelMeta) ProviderName() string {
+	return m.name
+}
+
+func (m *ProviderModelMeta) Alias() string {
+	return m.alias
+}
diff --git a/pkg/acceptance/bettertestspoc/config/providermodel/gen/main/main.go b/pkg/acceptance/bettertestspoc/config/providermodel/gen/main/main.go
new file mode 100644
index 0000000000..69f014a321
--- /dev/null
+++ b/pkg/acceptance/bettertestspoc/config/providermodel/gen/main/main.go
@@ -0,0 +1,22 @@
+package main
+
+import (
+	resourcemodelgen "github.com/Snowflake-Labs/terraform-provider-snowflake/pkg/acceptance/bettertestspoc/config/model/gen"
+
+	"github.com/Snowflake-Labs/terraform-provider-snowflake/pkg/acceptance/bettertestspoc/config/providermodel/gen"
+	"github.com/Snowflake-Labs/terraform-provider-snowflake/pkg/internal/genhelpers"
+)
+
+func main() {
+	genhelpers.NewGenerator(
+		gen.GetProviderSchemaDetails,
+		resourcemodelgen.ModelFromResourceSchemaDetails,
+		getFilename,
+		gen.AllTemplates,
+	).
+		RunAndHandleOsReturn()
+}
+
+func getFilename(_ genhelpers.ResourceSchemaDetails, model resourcemodelgen.ResourceConfigBuilderModel) string {
+	return genhelpers.ToSnakeCase(model.Name) + "_model" + "_gen.go"
+}
diff --git a/pkg/acceptance/bettertestspoc/config/providermodel/gen/provider_schema_def.go b/pkg/acceptance/bettertestspoc/config/providermodel/gen/provider_schema_def.go
new file mode 100644
index 0000000000..51ccb7726d
--- /dev/null
+++ b/pkg/acceptance/bettertestspoc/config/providermodel/gen/provider_schema_def.go
@@ -0,0 +1,29 @@
+package gen
+
+import (
+	"github.com/Snowflake-Labs/terraform-provider-snowflake/pkg/internal/genhelpers"
+	"github.com/Snowflake-Labs/terraform-provider-snowflake/pkg/provider"
+	"github.com/hashicorp/terraform-plugin-sdk/v2/helper/schema"
+)
+
+type ProviderSchemaDef struct {
+	name   string
+	schema map[string]*schema.Schema
+}
+
+// TODO [SNOW-1501905]: rename ResourceSchemaDetails (because it is used for the datasources and provider too)
+func GetProviderSchemaDetails() []genhelpers.ResourceSchemaDetails {
+	allProvidersSchemas := allProviderSchemaDefs
+	allProvidersSchemasDetails := make([]genhelpers.ResourceSchemaDetails, len(allProvidersSchemas))
+	for idx, s := range allProvidersSchemas {
+		allProvidersSchemasDetails[idx] = genhelpers.ExtractResourceSchemaDetails(s.name, s.schema)
+	}
+	return allProvidersSchemasDetails
+}
+
+var allProviderSchemaDefs = []ProviderSchemaDef{
+	{
+		name:   "Snowflake",
+		schema: provider.Provider().Schema,
+	},
+}
diff --git a/pkg/acceptance/bettertestspoc/config/providermodel/gen/templates.go b/pkg/acceptance/bettertestspoc/config/providermodel/gen/templates.go
new file mode 100644
index 0000000000..0c0da8794d
--- /dev/null
+++ b/pkg/acceptance/bettertestspoc/config/providermodel/gen/templates.go
@@ -0,0 +1,28 @@
+package gen
+
+import (
+	"text/template"
+
+	_ "embed"
+
+	resourcemodel "github.com/Snowflake-Labs/terraform-provider-snowflake/pkg/acceptance/bettertestspoc/config/model/gen"
+
+	"github.com/Snowflake-Labs/terraform-provider-snowflake/pkg/internal/genhelpers"
+)
+
+var (
+	//go:embed templates/preamble.tmpl
+	preambleTemplateContent string
+	PreambleTemplate, _     = template.New("preambleTemplate").Parse(preambleTemplateContent)
+
+	//go:embed templates/definition.tmpl
+	definitionTemplateContent string
+	DefinitionTemplate, _     = template.New("definitionTemplate").Funcs(genhelpers.BuildTemplateFuncMap(
+		genhelpers.FirstLetterLowercase,
+		genhelpers.FirstLetter,
+		genhelpers.SnakeCaseToCamel,
+	)).Parse(definitionTemplateContent)
+
+	// TODO [SNOW-1501905]: consider duplicating the builders template from resource (currently same template used for datasources and provider which limits the customization possibilities for just one block type)
+	AllTemplates = []*template.Template{PreambleTemplate, DefinitionTemplate, resourcemodel.BuildersTemplate}
+)
diff --git a/pkg/acceptance/bettertestspoc/config/providermodel/gen/templates/definition.tmpl b/pkg/acceptance/bettertestspoc/config/providermodel/gen/templates/definition.tmpl
new file mode 100644
index 0000000000..03e9da86ae
--- /dev/null
+++ b/pkg/acceptance/bettertestspoc/config/providermodel/gen/templates/definition.tmpl
@@ -0,0 +1,53 @@
+{{- /*gotype: github.com/Snowflake-Labs/terraform-provider-snowflake/pkg/acceptance/bettertestspoc/config/model/gen.ResourceConfigBuilderModel*/ -}}
+
+{{- $modelName := .Name | printf "%sModel" -}}
+{{- $nameLowerCase := FirstLetterLowercase .Name -}}
+{{- $modelVar := FirstLetter $nameLowerCase }}
+
+type {{ $modelName }} struct {
+    {{ range .Attributes -}}
+        {{ SnakeCaseToCamel .Name }} tfconfig.Variable `json:"{{ .Name }},omitempty"`
+    {{ end }}
+    *config.ProviderModelMeta
+}
+
+/////////////////////////////////////////////////
+// Basic builders (resource name and required) //
+/////////////////////////////////////////////////
+
+func {{ .Name }}Provider(
+    {{ range .Attributes -}}
+        {{- $attributeNameCamel := SnakeCaseToCamel .Name -}}
+        {{ if .Required -}}
+            {{ FirstLetterLowercase $attributeNameCamel }} {{ .AttributeType }},
+        {{ end }}
+    {{- end -}}
+) *{{ $modelName }} {
+    {{ $modelVar }} := &{{ $modelName }}{ProviderModelMeta: config.DefaultProviderMeta("{{ $nameLowerCase }}")}
+    {{ range .Attributes -}}
+        {{- $attributeNameCamel := SnakeCaseToCamel .Name -}}
+        {{ if .Required -}}
+            {{ $modelVar }}.With{{ $attributeNameCamel }}({{ FirstLetterLowercase $attributeNameCamel }})
+        {{ end }}
+    {{- end -}}
+    return {{ $modelVar }}
+}
+
+func {{ .Name }}ProviderAlias(
+    alias string,
+    {{ range .Attributes -}}
+        {{- $attributeNameCamel := SnakeCaseToCamel .Name -}}
+        {{ if .Required -}}
+            {{ FirstLetterLowercase $attributeNameCamel }} {{ .AttributeType }},
+        {{ end }}
+    {{- end -}}
+) *{{ $modelName }} {
+    {{ $modelVar }} := &{{ $modelName }}{ProviderModelMeta: config.ProviderMeta("{{ $nameLowerCase }}", alias)}
+    {{ range .Attributes -}}
+        {{- $attributeNameCamel := SnakeCaseToCamel .Name -}}
+        {{ if .Required -}}
+            {{ $modelVar }}.With{{ $attributeNameCamel }}({{ FirstLetterLowercase $attributeNameCamel }})
+        {{ end }}
+    {{- end -}}
+    return {{ $modelVar }}
+}
diff --git a/pkg/acceptance/bettertestspoc/config/providermodel/gen/templates/preamble.tmpl b/pkg/acceptance/bettertestspoc/config/providermodel/gen/templates/preamble.tmpl
new file mode 100644
index 0000000000..8d260e74c2
--- /dev/null
+++ b/pkg/acceptance/bettertestspoc/config/providermodel/gen/templates/preamble.tmpl
@@ -0,0 +1,15 @@
+{{- /*gotype: github.com/Snowflake-Labs/terraform-provider-snowflake/pkg/acceptance/bettertestspoc/config/model/gen.PreambleModel*/ -}}
+
+// Code generated by config model builder generator; DO NOT EDIT.
+
+package {{ .PackageName }}
+
+import (
+    {{- range .AdditionalStandardImports }}
+    "{{- . }}"
+    {{- end }}
+
+    tfconfig "github.com/hashicorp/terraform-plugin-testing/config"
+
+    "github.com/Snowflake-Labs/terraform-provider-snowflake/pkg/acceptance/bettertestspoc/config"
+)
diff --git a/pkg/acceptance/bettertestspoc/config/providermodel/generate.go b/pkg/acceptance/bettertestspoc/config/providermodel/generate.go
new file mode 100644
index 0000000000..7b6f20e05e
--- /dev/null
+++ b/pkg/acceptance/bettertestspoc/config/providermodel/generate.go
@@ -0,0 +1,3 @@
+package providermodel
+
+//go:generate go run ./gen/main/main.go $SF_TF_GENERATOR_ARGS
diff --git a/pkg/acceptance/bettertestspoc/config/providermodel/snowflake_model_ext.go b/pkg/acceptance/bettertestspoc/config/providermodel/snowflake_model_ext.go
new file mode 100644
index 0000000000..a3947d4a11
--- /dev/null
+++ b/pkg/acceptance/bettertestspoc/config/providermodel/snowflake_model_ext.go
@@ -0,0 +1,91 @@
+package providermodel
+
+import (
+	"encoding/json"
+	"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/acceptance/helpers"
+	"github.com/Snowflake-Labs/terraform-provider-snowflake/pkg/sdk"
+)
+
+// Based on https://medium.com/picus-security-engineering/custom-json-marshaller-in-go-and-common-pitfalls-c43fa774db05.
+func (m *SnowflakeModel) MarshalJSON() ([]byte, error) {
+	type AliasModelType SnowflakeModel
+	return json.Marshal(&struct {
+		*AliasModelType
+		Alias string `json:"alias,omitempty"`
+	}{
+		AliasModelType: (*AliasModelType)(m),
+		Alias:          m.Alias(),
+	})
+}
+
+func (m *SnowflakeModel) WithUserId(userId sdk.AccountObjectIdentifier) *SnowflakeModel {
+	return m.WithUser(userId.Name())
+}
+
+func (m *SnowflakeModel) WithRoleId(roleId sdk.AccountObjectIdentifier) *SnowflakeModel {
+	return m.WithRole(roleId.Name())
+}
+
+func (m *SnowflakeModel) WithWarehouseId(warehouseId sdk.AccountObjectIdentifier) *SnowflakeModel {
+	return m.WithWarehouse(warehouseId.Name())
+}
+
+func (m *SnowflakeModel) WithAuthenticatorType(authenticationType sdk.AuthenticationType) *SnowflakeModel {
+	return m.WithAuthenticator(string(authenticationType))
+}
+
+func (m *SnowflakeModel) WithPrivateKeyMultiline(privateKey string) *SnowflakeModel {
+	return m.WithPrivateKey(fmt.Sprintf(`%[1]s%[2]s%[1]s`, config.SnowflakeProviderConfigPrivateKey, privateKey))
+}
+
+func (m *SnowflakeModel) WithClientStoreTemporaryCredentialBool(clientStoreTemporaryCredential bool) *SnowflakeModel {
+	m.ClientStoreTemporaryCredential = tfconfig.BoolVariable(clientStoreTemporaryCredential)
+	return m
+}
+
+func (m *SnowflakeModel) AllFields(tmpConfig *helpers.TmpTomlConfig, tmpUser *helpers.TmpServiceUser) *SnowflakeModel {
+	return SnowflakeProvider().
+		WithProfile(tmpConfig.Profile).
+		WithOrganizationName(tmpUser.AccountId.OrganizationName()).
+		WithAccountName(tmpUser.AccountId.AccountName()).
+		WithUserId(tmpUser.UserId).
+		WithPrivateKeyMultiline(tmpUser.PrivateKey).
+		WithWarehouseId(tmpUser.WarehouseId).
+		WithProtocol("https").
+		WithPort(443).
+		WithRoleId(tmpUser.RoleId).
+		WithValidateDefaultParameters("true").
+		WithClientIp("3.3.3.3").
+		WithAuthenticatorType(sdk.AuthenticationTypeJwt).
+		WithOktaUrl("https://example-tf.com").
+		WithLoginTimeout(101).
+		WithRequestTimeout(201).
+		WithJwtExpireTimeout(301).
+		WithClientTimeout(401).
+		WithJwtClientTimeout(501).
+		WithExternalBrowserTimeout(601).
+		WithInsecureMode(true).
+		WithOcspFailOpen("true").
+		WithKeepSessionAlive(true).
+		WithDisableTelemetry(true).
+		WithClientRequestMfaToken("true").
+		WithClientStoreTemporaryCredential("true").
+		WithDisableQueryContextCache(true).
+		WithIncludeRetryReason("true").
+		WithMaxRetryCount(3).
+		WithDriverTracing("warning").
+		WithTmpDirectoryPath("../../").
+		WithDisableConsoleLogin("true").
+		WithParamsValue(
+			tfconfig.ObjectVariable(
+				map[string]tfconfig.Variable{
+					"foo": tfconfig.StringVariable("piyo"),
+				},
+			),
+		)
+}
diff --git a/pkg/acceptance/bettertestspoc/config/providermodel/snowflake_model_gen.go b/pkg/acceptance/bettertestspoc/config/providermodel/snowflake_model_gen.go
new file mode 100644
index 0000000000..28ee44bd6b
--- /dev/null
+++ b/pkg/acceptance/bettertestspoc/config/providermodel/snowflake_model_gen.go
@@ -0,0 +1,590 @@
+// Code generated by config model builder generator; DO NOT EDIT.
+
+package providermodel
+
+import (
+	tfconfig "github.com/hashicorp/terraform-plugin-testing/config"
+
+	"github.com/Snowflake-Labs/terraform-provider-snowflake/pkg/acceptance/bettertestspoc/config"
+)
+
+type SnowflakeModel struct {
+	Account                        tfconfig.Variable `json:"account,omitempty"`
+	AccountName                    tfconfig.Variable `json:"account_name,omitempty"`
+	Authenticator                  tfconfig.Variable `json:"authenticator,omitempty"`
+	BrowserAuth                    tfconfig.Variable `json:"browser_auth,omitempty"`
+	ClientIp                       tfconfig.Variable `json:"client_ip,omitempty"`
+	ClientRequestMfaToken          tfconfig.Variable `json:"client_request_mfa_token,omitempty"`
+	ClientStoreTemporaryCredential tfconfig.Variable `json:"client_store_temporary_credential,omitempty"`
+	ClientTimeout                  tfconfig.Variable `json:"client_timeout,omitempty"`
+	DisableConsoleLogin            tfconfig.Variable `json:"disable_console_login,omitempty"`
+	DisableQueryContextCache       tfconfig.Variable `json:"disable_query_context_cache,omitempty"`
+	DisableTelemetry               tfconfig.Variable `json:"disable_telemetry,omitempty"`
+	DriverTracing                  tfconfig.Variable `json:"driver_tracing,omitempty"`
+	ExternalBrowserTimeout         tfconfig.Variable `json:"external_browser_timeout,omitempty"`
+	Host                           tfconfig.Variable `json:"host,omitempty"`
+	IncludeRetryReason             tfconfig.Variable `json:"include_retry_reason,omitempty"`
+	InsecureMode                   tfconfig.Variable `json:"insecure_mode,omitempty"`
+	JwtClientTimeout               tfconfig.Variable `json:"jwt_client_timeout,omitempty"`
+	JwtExpireTimeout               tfconfig.Variable `json:"jwt_expire_timeout,omitempty"`
+	KeepSessionAlive               tfconfig.Variable `json:"keep_session_alive,omitempty"`
+	LoginTimeout                   tfconfig.Variable `json:"login_timeout,omitempty"`
+	MaxRetryCount                  tfconfig.Variable `json:"max_retry_count,omitempty"`
+	OauthAccessToken               tfconfig.Variable `json:"oauth_access_token,omitempty"`
+	OauthClientId                  tfconfig.Variable `json:"oauth_client_id,omitempty"`
+	OauthClientSecret              tfconfig.Variable `json:"oauth_client_secret,omitempty"`
+	OauthEndpoint                  tfconfig.Variable `json:"oauth_endpoint,omitempty"`
+	OauthRedirectUrl               tfconfig.Variable `json:"oauth_redirect_url,omitempty"`
+	OauthRefreshToken              tfconfig.Variable `json:"oauth_refresh_token,omitempty"`
+	OcspFailOpen                   tfconfig.Variable `json:"ocsp_fail_open,omitempty"`
+	OktaUrl                        tfconfig.Variable `json:"okta_url,omitempty"`
+	OrganizationName               tfconfig.Variable `json:"organization_name,omitempty"`
+	Params                         tfconfig.Variable `json:"params,omitempty"`
+	Passcode                       tfconfig.Variable `json:"passcode,omitempty"`
+	PasscodeInPassword             tfconfig.Variable `json:"passcode_in_password,omitempty"`
+	Password                       tfconfig.Variable `json:"password,omitempty"`
+	Port                           tfconfig.Variable `json:"port,omitempty"`
+	PrivateKey                     tfconfig.Variable `json:"private_key,omitempty"`
+	PrivateKeyPassphrase           tfconfig.Variable `json:"private_key_passphrase,omitempty"`
+	PrivateKeyPath                 tfconfig.Variable `json:"private_key_path,omitempty"`
+	Profile                        tfconfig.Variable `json:"profile,omitempty"`
+	Protocol                       tfconfig.Variable `json:"protocol,omitempty"`
+	Region                         tfconfig.Variable `json:"region,omitempty"`
+	RequestTimeout                 tfconfig.Variable `json:"request_timeout,omitempty"`
+	Role                           tfconfig.Variable `json:"role,omitempty"`
+	SessionParams                  tfconfig.Variable `json:"session_params,omitempty"`
+	TmpDirectoryPath               tfconfig.Variable `json:"tmp_directory_path,omitempty"`
+	Token                          tfconfig.Variable `json:"token,omitempty"`
+	TokenAccessor                  tfconfig.Variable `json:"token_accessor,omitempty"`
+	User                           tfconfig.Variable `json:"user,omitempty"`
+	Username                       tfconfig.Variable `json:"username,omitempty"`
+	ValidateDefaultParameters      tfconfig.Variable `json:"validate_default_parameters,omitempty"`
+	Warehouse                      tfconfig.Variable `json:"warehouse,omitempty"`
+
+	*config.ProviderModelMeta
+}
+
+/////////////////////////////////////////////////
+// Basic builders (resource name and required) //
+/////////////////////////////////////////////////
+
+func SnowflakeProvider() *SnowflakeModel {
+	s := &SnowflakeModel{ProviderModelMeta: config.DefaultProviderMeta("snowflake")}
+	return s
+}
+
+func SnowflakeProviderAlias(
+	alias string,
+) *SnowflakeModel {
+	s := &SnowflakeModel{ProviderModelMeta: config.ProviderMeta("snowflake", alias)}
+	return s
+}
+
+/////////////////////////////////
+// below all the proper values //
+/////////////////////////////////
+
+func (s *SnowflakeModel) WithAccount(account string) *SnowflakeModel {
+	s.Account = tfconfig.StringVariable(account)
+	return s
+}
+
+func (s *SnowflakeModel) WithAccountName(accountName string) *SnowflakeModel {
+	s.AccountName = tfconfig.StringVariable(accountName)
+	return s
+}
+
+func (s *SnowflakeModel) WithAuthenticator(authenticator string) *SnowflakeModel {
+	s.Authenticator = tfconfig.StringVariable(authenticator)
+	return s
+}
+
+func (s *SnowflakeModel) WithBrowserAuth(browserAuth bool) *SnowflakeModel {
+	s.BrowserAuth = tfconfig.BoolVariable(browserAuth)
+	return s
+}
+
+func (s *SnowflakeModel) WithClientIp(clientIp string) *SnowflakeModel {
+	s.ClientIp = tfconfig.StringVariable(clientIp)
+	return s
+}
+
+func (s *SnowflakeModel) WithClientRequestMfaToken(clientRequestMfaToken string) *SnowflakeModel {
+	s.ClientRequestMfaToken = tfconfig.StringVariable(clientRequestMfaToken)
+	return s
+}
+
+func (s *SnowflakeModel) WithClientStoreTemporaryCredential(clientStoreTemporaryCredential string) *SnowflakeModel {
+	s.ClientStoreTemporaryCredential = tfconfig.StringVariable(clientStoreTemporaryCredential)
+	return s
+}
+
+func (s *SnowflakeModel) WithClientTimeout(clientTimeout int) *SnowflakeModel {
+	s.ClientTimeout = tfconfig.IntegerVariable(clientTimeout)
+	return s
+}
+
+func (s *SnowflakeModel) WithDisableConsoleLogin(disableConsoleLogin string) *SnowflakeModel {
+	s.DisableConsoleLogin = tfconfig.StringVariable(disableConsoleLogin)
+	return s
+}
+
+func (s *SnowflakeModel) WithDisableQueryContextCache(disableQueryContextCache bool) *SnowflakeModel {
+	s.DisableQueryContextCache = tfconfig.BoolVariable(disableQueryContextCache)
+	return s
+}
+
+func (s *SnowflakeModel) WithDisableTelemetry(disableTelemetry bool) *SnowflakeModel {
+	s.DisableTelemetry = tfconfig.BoolVariable(disableTelemetry)
+	return s
+}
+
+func (s *SnowflakeModel) WithDriverTracing(driverTracing string) *SnowflakeModel {
+	s.DriverTracing = tfconfig.StringVariable(driverTracing)
+	return s
+}
+
+func (s *SnowflakeModel) WithExternalBrowserTimeout(externalBrowserTimeout int) *SnowflakeModel {
+	s.ExternalBrowserTimeout = tfconfig.IntegerVariable(externalBrowserTimeout)
+	return s
+}
+
+func (s *SnowflakeModel) WithHost(host string) *SnowflakeModel {
+	s.Host = tfconfig.StringVariable(host)
+	return s
+}
+
+func (s *SnowflakeModel) WithIncludeRetryReason(includeRetryReason string) *SnowflakeModel {
+	s.IncludeRetryReason = tfconfig.StringVariable(includeRetryReason)
+	return s
+}
+
+func (s *SnowflakeModel) WithInsecureMode(insecureMode bool) *SnowflakeModel {
+	s.InsecureMode = tfconfig.BoolVariable(insecureMode)
+	return s
+}
+
+func (s *SnowflakeModel) WithJwtClientTimeout(jwtClientTimeout int) *SnowflakeModel {
+	s.JwtClientTimeout = tfconfig.IntegerVariable(jwtClientTimeout)
+	return s
+}
+
+func (s *SnowflakeModel) WithJwtExpireTimeout(jwtExpireTimeout int) *SnowflakeModel {
+	s.JwtExpireTimeout = tfconfig.IntegerVariable(jwtExpireTimeout)
+	return s
+}
+
+func (s *SnowflakeModel) WithKeepSessionAlive(keepSessionAlive bool) *SnowflakeModel {
+	s.KeepSessionAlive = tfconfig.BoolVariable(keepSessionAlive)
+	return s
+}
+
+func (s *SnowflakeModel) WithLoginTimeout(loginTimeout int) *SnowflakeModel {
+	s.LoginTimeout = tfconfig.IntegerVariable(loginTimeout)
+	return s
+}
+
+func (s *SnowflakeModel) WithMaxRetryCount(maxRetryCount int) *SnowflakeModel {
+	s.MaxRetryCount = tfconfig.IntegerVariable(maxRetryCount)
+	return s
+}
+
+func (s *SnowflakeModel) WithOauthAccessToken(oauthAccessToken string) *SnowflakeModel {
+	s.OauthAccessToken = tfconfig.StringVariable(oauthAccessToken)
+	return s
+}
+
+func (s *SnowflakeModel) WithOauthClientId(oauthClientId string) *SnowflakeModel {
+	s.OauthClientId = tfconfig.StringVariable(oauthClientId)
+	return s
+}
+
+func (s *SnowflakeModel) WithOauthClientSecret(oauthClientSecret string) *SnowflakeModel {
+	s.OauthClientSecret = tfconfig.StringVariable(oauthClientSecret)
+	return s
+}
+
+func (s *SnowflakeModel) WithOauthEndpoint(oauthEndpoint string) *SnowflakeModel {
+	s.OauthEndpoint = tfconfig.StringVariable(oauthEndpoint)
+	return s
+}
+
+func (s *SnowflakeModel) WithOauthRedirectUrl(oauthRedirectUrl string) *SnowflakeModel {
+	s.OauthRedirectUrl = tfconfig.StringVariable(oauthRedirectUrl)
+	return s
+}
+
+func (s *SnowflakeModel) WithOauthRefreshToken(oauthRefreshToken string) *SnowflakeModel {
+	s.OauthRefreshToken = tfconfig.StringVariable(oauthRefreshToken)
+	return s
+}
+
+func (s *SnowflakeModel) WithOcspFailOpen(ocspFailOpen string) *SnowflakeModel {
+	s.OcspFailOpen = tfconfig.StringVariable(ocspFailOpen)
+	return s
+}
+
+func (s *SnowflakeModel) WithOktaUrl(oktaUrl string) *SnowflakeModel {
+	s.OktaUrl = tfconfig.StringVariable(oktaUrl)
+	return s
+}
+
+func (s *SnowflakeModel) WithOrganizationName(organizationName string) *SnowflakeModel {
+	s.OrganizationName = tfconfig.StringVariable(organizationName)
+	return s
+}
+
+// params attribute type is not yet supported, so WithParams can't be generated
+
+func (s *SnowflakeModel) WithPasscode(passcode string) *SnowflakeModel {
+	s.Passcode = tfconfig.StringVariable(passcode)
+	return s
+}
+
+func (s *SnowflakeModel) WithPasscodeInPassword(passcodeInPassword bool) *SnowflakeModel {
+	s.PasscodeInPassword = tfconfig.BoolVariable(passcodeInPassword)
+	return s
+}
+
+func (s *SnowflakeModel) WithPassword(password string) *SnowflakeModel {
+	s.Password = tfconfig.StringVariable(password)
+	return s
+}
+
+func (s *SnowflakeModel) WithPort(port int) *SnowflakeModel {
+	s.Port = tfconfig.IntegerVariable(port)
+	return s
+}
+
+func (s *SnowflakeModel) WithPrivateKey(privateKey string) *SnowflakeModel {
+	s.PrivateKey = tfconfig.StringVariable(privateKey)
+	return s
+}
+
+func (s *SnowflakeModel) WithPrivateKeyPassphrase(privateKeyPassphrase string) *SnowflakeModel {
+	s.PrivateKeyPassphrase = tfconfig.StringVariable(privateKeyPassphrase)
+	return s
+}
+
+func (s *SnowflakeModel) WithPrivateKeyPath(privateKeyPath string) *SnowflakeModel {
+	s.PrivateKeyPath = tfconfig.StringVariable(privateKeyPath)
+	return s
+}
+
+func (s *SnowflakeModel) WithProfile(profile string) *SnowflakeModel {
+	s.Profile = tfconfig.StringVariable(profile)
+	return s
+}
+
+func (s *SnowflakeModel) WithProtocol(protocol string) *SnowflakeModel {
+	s.Protocol = tfconfig.StringVariable(protocol)
+	return s
+}
+
+func (s *SnowflakeModel) WithRegion(region string) *SnowflakeModel {
+	s.Region = tfconfig.StringVariable(region)
+	return s
+}
+
+func (s *SnowflakeModel) WithRequestTimeout(requestTimeout int) *SnowflakeModel {
+	s.RequestTimeout = tfconfig.IntegerVariable(requestTimeout)
+	return s
+}
+
+func (s *SnowflakeModel) WithRole(role string) *SnowflakeModel {
+	s.Role = tfconfig.StringVariable(role)
+	return s
+}
+
+// session_params attribute type is not yet supported, so WithSessionParams can't be generated
+
+func (s *SnowflakeModel) WithTmpDirectoryPath(tmpDirectoryPath string) *SnowflakeModel {
+	s.TmpDirectoryPath = tfconfig.StringVariable(tmpDirectoryPath)
+	return s
+}
+
+func (s *SnowflakeModel) WithToken(token string) *SnowflakeModel {
+	s.Token = tfconfig.StringVariable(token)
+	return s
+}
+
+// token_accessor attribute type is not yet supported, so WithTokenAccessor can't be generated
+
+func (s *SnowflakeModel) WithUser(user string) *SnowflakeModel {
+	s.User = tfconfig.StringVariable(user)
+	return s
+}
+
+func (s *SnowflakeModel) WithUsername(username string) *SnowflakeModel {
+	s.Username = tfconfig.StringVariable(username)
+	return s
+}
+
+func (s *SnowflakeModel) WithValidateDefaultParameters(validateDefaultParameters string) *SnowflakeModel {
+	s.ValidateDefaultParameters = tfconfig.StringVariable(validateDefaultParameters)
+	return s
+}
+
+func (s *SnowflakeModel) WithWarehouse(warehouse string) *SnowflakeModel {
+	s.Warehouse = tfconfig.StringVariable(warehouse)
+	return s
+}
+
+//////////////////////////////////////////
+// below it's possible to set any value //
+//////////////////////////////////////////
+
+func (s *SnowflakeModel) WithAccountValue(value tfconfig.Variable) *SnowflakeModel {
+	s.Account = value
+	return s
+}
+
+func (s *SnowflakeModel) WithAccountNameValue(value tfconfig.Variable) *SnowflakeModel {
+	s.AccountName = value
+	return s
+}
+
+func (s *SnowflakeModel) WithAuthenticatorValue(value tfconfig.Variable) *SnowflakeModel {
+	s.Authenticator = value
+	return s
+}
+
+func (s *SnowflakeModel) WithBrowserAuthValue(value tfconfig.Variable) *SnowflakeModel {
+	s.BrowserAuth = value
+	return s
+}
+
+func (s *SnowflakeModel) WithClientIpValue(value tfconfig.Variable) *SnowflakeModel {
+	s.ClientIp = value
+	return s
+}
+
+func (s *SnowflakeModel) WithClientRequestMfaTokenValue(value tfconfig.Variable) *SnowflakeModel {
+	s.ClientRequestMfaToken = value
+	return s
+}
+
+func (s *SnowflakeModel) WithClientStoreTemporaryCredentialValue(value tfconfig.Variable) *SnowflakeModel {
+	s.ClientStoreTemporaryCredential = value
+	return s
+}
+
+func (s *SnowflakeModel) WithClientTimeoutValue(value tfconfig.Variable) *SnowflakeModel {
+	s.ClientTimeout = value
+	return s
+}
+
+func (s *SnowflakeModel) WithDisableConsoleLoginValue(value tfconfig.Variable) *SnowflakeModel {
+	s.DisableConsoleLogin = value
+	return s
+}
+
+func (s *SnowflakeModel) WithDisableQueryContextCacheValue(value tfconfig.Variable) *SnowflakeModel {
+	s.DisableQueryContextCache = value
+	return s
+}
+
+func (s *SnowflakeModel) WithDisableTelemetryValue(value tfconfig.Variable) *SnowflakeModel {
+	s.DisableTelemetry = value
+	return s
+}
+
+func (s *SnowflakeModel) WithDriverTracingValue(value tfconfig.Variable) *SnowflakeModel {
+	s.DriverTracing = value
+	return s
+}
+
+func (s *SnowflakeModel) WithExternalBrowserTimeoutValue(value tfconfig.Variable) *SnowflakeModel {
+	s.ExternalBrowserTimeout = value
+	return s
+}
+
+func (s *SnowflakeModel) WithHostValue(value tfconfig.Variable) *SnowflakeModel {
+	s.Host = value
+	return s
+}
+
+func (s *SnowflakeModel) WithIncludeRetryReasonValue(value tfconfig.Variable) *SnowflakeModel {
+	s.IncludeRetryReason = value
+	return s
+}
+
+func (s *SnowflakeModel) WithInsecureModeValue(value tfconfig.Variable) *SnowflakeModel {
+	s.InsecureMode = value
+	return s
+}
+
+func (s *SnowflakeModel) WithJwtClientTimeoutValue(value tfconfig.Variable) *SnowflakeModel {
+	s.JwtClientTimeout = value
+	return s
+}
+
+func (s *SnowflakeModel) WithJwtExpireTimeoutValue(value tfconfig.Variable) *SnowflakeModel {
+	s.JwtExpireTimeout = value
+	return s
+}
+
+func (s *SnowflakeModel) WithKeepSessionAliveValue(value tfconfig.Variable) *SnowflakeModel {
+	s.KeepSessionAlive = value
+	return s
+}
+
+func (s *SnowflakeModel) WithLoginTimeoutValue(value tfconfig.Variable) *SnowflakeModel {
+	s.LoginTimeout = value
+	return s
+}
+
+func (s *SnowflakeModel) WithMaxRetryCountValue(value tfconfig.Variable) *SnowflakeModel {
+	s.MaxRetryCount = value
+	return s
+}
+
+func (s *SnowflakeModel) WithOauthAccessTokenValue(value tfconfig.Variable) *SnowflakeModel {
+	s.OauthAccessToken = value
+	return s
+}
+
+func (s *SnowflakeModel) WithOauthClientIdValue(value tfconfig.Variable) *SnowflakeModel {
+	s.OauthClientId = value
+	return s
+}
+
+func (s *SnowflakeModel) WithOauthClientSecretValue(value tfconfig.Variable) *SnowflakeModel {
+	s.OauthClientSecret = value
+	return s
+}
+
+func (s *SnowflakeModel) WithOauthEndpointValue(value tfconfig.Variable) *SnowflakeModel {
+	s.OauthEndpoint = value
+	return s
+}
+
+func (s *SnowflakeModel) WithOauthRedirectUrlValue(value tfconfig.Variable) *SnowflakeModel {
+	s.OauthRedirectUrl = value
+	return s
+}
+
+func (s *SnowflakeModel) WithOauthRefreshTokenValue(value tfconfig.Variable) *SnowflakeModel {
+	s.OauthRefreshToken = value
+	return s
+}
+
+func (s *SnowflakeModel) WithOcspFailOpenValue(value tfconfig.Variable) *SnowflakeModel {
+	s.OcspFailOpen = value
+	return s
+}
+
+func (s *SnowflakeModel) WithOktaUrlValue(value tfconfig.Variable) *SnowflakeModel {
+	s.OktaUrl = value
+	return s
+}
+
+func (s *SnowflakeModel) WithOrganizationNameValue(value tfconfig.Variable) *SnowflakeModel {
+	s.OrganizationName = value
+	return s
+}
+
+func (s *SnowflakeModel) WithParamsValue(value tfconfig.Variable) *SnowflakeModel {
+	s.Params = value
+	return s
+}
+
+func (s *SnowflakeModel) WithPasscodeValue(value tfconfig.Variable) *SnowflakeModel {
+	s.Passcode = value
+	return s
+}
+
+func (s *SnowflakeModel) WithPasscodeInPasswordValue(value tfconfig.Variable) *SnowflakeModel {
+	s.PasscodeInPassword = value
+	return s
+}
+
+func (s *SnowflakeModel) WithPasswordValue(value tfconfig.Variable) *SnowflakeModel {
+	s.Password = value
+	return s
+}
+
+func (s *SnowflakeModel) WithPortValue(value tfconfig.Variable) *SnowflakeModel {
+	s.Port = value
+	return s
+}
+
+func (s *SnowflakeModel) WithPrivateKeyValue(value tfconfig.Variable) *SnowflakeModel {
+	s.PrivateKey = value
+	return s
+}
+
+func (s *SnowflakeModel) WithPrivateKeyPassphraseValue(value tfconfig.Variable) *SnowflakeModel {
+	s.PrivateKeyPassphrase = value
+	return s
+}
+
+func (s *SnowflakeModel) WithPrivateKeyPathValue(value tfconfig.Variable) *SnowflakeModel {
+	s.PrivateKeyPath = value
+	return s
+}
+
+func (s *SnowflakeModel) WithProfileValue(value tfconfig.Variable) *SnowflakeModel {
+	s.Profile = value
+	return s
+}
+
+func (s *SnowflakeModel) WithProtocolValue(value tfconfig.Variable) *SnowflakeModel {
+	s.Protocol = value
+	return s
+}
+
+func (s *SnowflakeModel) WithRegionValue(value tfconfig.Variable) *SnowflakeModel {
+	s.Region = value
+	return s
+}
+
+func (s *SnowflakeModel) WithRequestTimeoutValue(value tfconfig.Variable) *SnowflakeModel {
+	s.RequestTimeout = value
+	return s
+}
+
+func (s *SnowflakeModel) WithRoleValue(value tfconfig.Variable) *SnowflakeModel {
+	s.Role = value
+	return s
+}
+
+func (s *SnowflakeModel) WithSessionParamsValue(value tfconfig.Variable) *SnowflakeModel {
+	s.SessionParams = value
+	return s
+}
+
+func (s *SnowflakeModel) WithTmpDirectoryPathValue(value tfconfig.Variable) *SnowflakeModel {
+	s.TmpDirectoryPath = value
+	return s
+}
+
+func (s *SnowflakeModel) WithTokenValue(value tfconfig.Variable) *SnowflakeModel {
+	s.Token = value
+	return s
+}
+
+func (s *SnowflakeModel) WithTokenAccessorValue(value tfconfig.Variable) *SnowflakeModel {
+	s.TokenAccessor = value
+	return s
+}
+
+func (s *SnowflakeModel) WithUserValue(value tfconfig.Variable) *SnowflakeModel {
+	s.User = value
+	return s
+}
+
+func (s *SnowflakeModel) WithUsernameValue(value tfconfig.Variable) *SnowflakeModel {
+	s.Username = value
+	return s
+}
+
+func (s *SnowflakeModel) WithValidateDefaultParametersValue(value tfconfig.Variable) *SnowflakeModel {
+	s.ValidateDefaultParameters = value
+	return s
+}
+
+func (s *SnowflakeModel) WithWarehouseValue(value tfconfig.Variable) *SnowflakeModel {
+	s.Warehouse = value
+	return s
+}
diff --git a/pkg/acceptance/bettertestspoc/config/resource_model.go b/pkg/acceptance/bettertestspoc/config/resource_model.go
new file mode 100644
index 0000000000..9aa8e6ff92
--- /dev/null
+++ b/pkg/acceptance/bettertestspoc/config/resource_model.go
@@ -0,0 +1,64 @@
+package config
+
+import (
+	"fmt"
+
+	"github.com/Snowflake-Labs/terraform-provider-snowflake/pkg/provider/resources"
+)
+
+// TODO [SNOW-1501905]: add possibility to have reference to another object (e.g. WithResourceMonitorReference); new config.Variable impl?
+// TODO [SNOW-1501905]: generate With/SetDependsOn for the resources to preserve builder pattern
+// TODO [SNOW-1501905]: add a convenience method to use multiple configs from multiple models
+// TODO [SNOW-1501905]: add provider to resource/datasource models (use in the grant_ownership_acceptance_test)
+
+// ResourceModel is the base interface all of our resource config models will implement.
+// To allow easy implementation, ResourceModelMeta can be embedded inside the struct (and the struct will automatically implement it).
+type ResourceModel interface {
+	Resource() resources.Resource
+	ResourceName() string
+	SetResourceName(name string)
+	ResourceReference() string
+	DependsOn() []string
+	SetDependsOn(values ...string)
+}
+
+type ResourceModelMeta struct {
+	name      string
+	resource  resources.Resource
+	dependsOn []string
+}
+
+func (m *ResourceModelMeta) Resource() resources.Resource {
+	return m.resource
+}
+
+func (m *ResourceModelMeta) ResourceName() string {
+	return m.name
+}
+
+func (m *ResourceModelMeta) SetResourceName(name string) {
+	m.name = name
+}
+
+func (m *ResourceModelMeta) ResourceReference() string {
+	return fmt.Sprintf(`%s.%s`, m.resource, m.name)
+}
+
+func (m *ResourceModelMeta) DependsOn() []string {
+	return m.dependsOn
+}
+
+func (m *ResourceModelMeta) SetDependsOn(values ...string) {
+	m.dependsOn = values
+}
+
+// DefaultResourceName is exported to allow assertions against the resources using the default name.
+const DefaultResourceName = "test"
+
+func DefaultMeta(resource resources.Resource) *ResourceModelMeta {
+	return &ResourceModelMeta{name: DefaultResourceName, resource: resource}
+}
+
+func Meta(resourceName string, resource resources.Resource) *ResourceModelMeta {
+	return &ResourceModelMeta{name: resourceName, resource: resource}
+}
diff --git a/pkg/acceptance/bettertestspoc/config/resource_model_test.go b/pkg/acceptance/bettertestspoc/config/resource_model_test.go
new file mode 100644
index 0000000000..1d30583f6a
--- /dev/null
+++ b/pkg/acceptance/bettertestspoc/config/resource_model_test.go
@@ -0,0 +1,138 @@
+package config_test
+
+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/resources"
+)
+
+type Item struct {
+	IntField    int
+	StringField string
+}
+
+// SomeModel is an example model struct similar to the ones being generated for our resources.
+// It contains all the interesting types of variables.
+type SomeModel struct {
+	Comment tfconfig.Variable `json:"comment,omitempty"`
+	Name    tfconfig.Variable `json:"name,omitempty"`
+
+	StringList tfconfig.Variable `json:"string_list,omitempty"`
+	StringSet  tfconfig.Variable `json:"string_set,omitempty"`
+	// contains list of Item
+	ObjectList   tfconfig.Variable `json:"object_list,omitempty"`
+	SingleObject tfconfig.Variable `json:"single_object,omitempty"`
+
+	*config.ResourceModelMeta
+}
+
+func Some(
+	resourceName string,
+	name string,
+) *SomeModel {
+	// resources enum is closed so using one of the existing ones
+	d := &SomeModel{ResourceModelMeta: config.Meta(resourceName, resources.Share)}
+	d.WithName(name)
+	return d
+}
+
+func (m *SomeModel) WithComment(comment string) *SomeModel {
+	m.Comment = tfconfig.StringVariable(comment)
+	return m
+}
+
+func (m *SomeModel) WithName(name string) *SomeModel {
+	m.Name = tfconfig.StringVariable(name)
+	return m
+}
+
+func (m *SomeModel) WithStringList(items ...string) *SomeModel {
+	variables := make([]tfconfig.Variable, 0)
+	for _, i := range items {
+		variables = append(variables, tfconfig.StringVariable(i))
+	}
+	m.StringList = tfconfig.ListVariable(variables...)
+	return m
+}
+
+func (m *SomeModel) WithStringSet(items ...string) *SomeModel {
+	variables := make([]tfconfig.Variable, 0)
+	for _, i := range items {
+		variables = append(variables, tfconfig.StringVariable(i))
+	}
+	m.StringSet = tfconfig.SetVariable(variables...)
+	return m
+}
+
+func (m *SomeModel) WithObjectList(items ...Item) *SomeModel {
+	variables := make([]tfconfig.Variable, 0)
+	for _, i := range items {
+		variables = append(variables, tfconfig.ObjectVariable(
+			map[string]tfconfig.Variable{
+				"int_field":    tfconfig.IntegerVariable(i.IntField),
+				"string_field": tfconfig.StringVariable(i.StringField),
+			},
+		))
+	}
+	m.ObjectList = tfconfig.TupleVariable(variables...)
+	return m
+}
+
+func (m *SomeModel) WithSingleObject(a string, b int) *SomeModel {
+	m.SingleObject = tfconfig.ObjectVariable(
+		map[string]tfconfig.Variable{
+			"a": tfconfig.StringVariable(a),
+			"b": tfconfig.IntegerVariable(b),
+		},
+	)
+	return m
+}
+
+func (m *SomeModel) WithDependsOn(values ...string) *SomeModel {
+	m.SetDependsOn(values...)
+	return m
+}
+
+// Based on https://medium.com/picus-security-engineering/custom-json-marshaller-in-go-and-common-pitfalls-c43fa774db05.
+func (m *SomeModel) MarshalJSON() ([]byte, error) {
+	type Alias SomeModel
+	return json.Marshal(&struct {
+		*Alias
+		DependsOn []string `json:"depends_on,omitempty"`
+	}{
+		Alias:     (*Alias)(m),
+		DependsOn: m.DependsOn(),
+	})
+}
+
+// SomeOtherModel is an example model struct similar to the ones being generated for our resources.
+// It does not contain a proper marshaller to fail the test with depends_on.
+type SomeOtherModel struct {
+	Comment tfconfig.Variable `json:"comment,omitempty"`
+	Name    tfconfig.Variable `json:"name,omitempty"`
+
+	*config.ResourceModelMeta
+}
+
+func SomeOther(
+	resourceName string,
+	name string,
+) *SomeOtherModel {
+	// resources enum is closed so using one of the existing ones
+	d := &SomeOtherModel{ResourceModelMeta: config.Meta(resourceName, resources.Share)}
+	d.WithName(name)
+	return d
+}
+
+func (m *SomeOtherModel) WithName(name string) *SomeOtherModel {
+	m.Name = tfconfig.StringVariable(name)
+	return m
+}
+
+func (m *SomeOtherModel) WithDependsOn(values ...string) *SomeOtherModel {
+	m.SetDependsOn(values...)
+	return m
+}
diff --git a/pkg/datasources/databases_acceptance_test.go b/pkg/datasources/databases_acceptance_test.go
index 09e7e386ac..b8e53c5de1 100644
--- a/pkg/datasources/databases_acceptance_test.go
+++ b/pkg/datasources/databases_acceptance_test.go
@@ -6,7 +6,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/helpers/random"
 	"github.com/Snowflake-Labs/terraform-provider-snowflake/pkg/acceptance/testenvs"
 	"github.com/Snowflake-Labs/terraform-provider-snowflake/pkg/provider/resources"
@@ -17,14 +20,27 @@ import (
 
 func TestAcc_Databases_Complete(t *testing.T) {
 	_ = testenvs.GetOrSkipTest(t, testenvs.ConfigureClientOnce)
+	acc.TestAccPreCheck(t)
+
 	databaseName := acc.TestClient().Ids.Alpha()
 	comment := random.Comment()
-
-	configVariables := config.Variables{
-		"name":               config.StringVariable(databaseName),
-		"comment":            config.StringVariable(comment),
-		"account_identifier": config.StringVariable(acc.SecondaryTestClient().Account.GetAccountIdentifier(t).FullyQualifiedName()),
-	}
+	secondaryAccountId := acc.SecondaryTestClient().Account.GetAccountIdentifier(t)
+
+	databaseModel := model.Database("test", databaseName).
+		WithComment(comment).
+		WithReplication(secondaryAccountId, true, true)
+	databasesModel := datasourcemodel.Databases("test").
+		WithLike(databaseName).
+		WithStartsWith(databaseName).
+		WithLimit(1).
+		WithDependsOn(databaseModel.ResourceReference())
+	databasesWithoutOptionalsModel := datasourcemodel.Databases("test").
+		WithLike(databaseName).
+		WithStartsWith(databaseName).
+		WithLimit(1).
+		WithDependsOn(databaseModel.ResourceReference()).
+		WithWithDescribe(false).
+		WithWithParameters(false)
 
 	resource.Test(t, resource.TestCase{
 		ProtoV6ProviderFactories: acc.TestAccProtoV6ProviderFactories,
@@ -35,68 +51,66 @@ func TestAcc_Databases_Complete(t *testing.T) {
 		CheckDestroy: acc.CheckDestroy(t, resources.Database),
 		Steps: []resource.TestStep{
 			{
-				ConfigDirectory: acc.ConfigurationDirectory("TestAcc_Databases/optionals_set"),
-				ConfigVariables: configVariables,
+				Config: accconfig.FromModels(t, databaseModel, databasesModel),
 				Check: resource.ComposeTestCheckFunc(
-					resource.TestCheckResourceAttr("data.snowflake_databases.test", "databases.#", "1"),
-					resource.TestCheckResourceAttrSet("data.snowflake_databases.test", "databases.0.show_output.0.created_on"),
-					resource.TestCheckResourceAttr("data.snowflake_databases.test", "databases.0.show_output.0.name", databaseName),
-					resource.TestCheckResourceAttr("data.snowflake_databases.test", "databases.0.show_output.0.kind", "STANDARD"),
-					resource.TestCheckResourceAttr("data.snowflake_databases.test", "databases.0.show_output.0.transient", "false"),
-					resource.TestCheckResourceAttr("data.snowflake_databases.test", "databases.0.show_output.0.is_default", "false"),
-					resource.TestCheckResourceAttr("data.snowflake_databases.test", "databases.0.show_output.0.is_current", "true"),
-					resource.TestCheckResourceAttr("data.snowflake_databases.test", "databases.0.show_output.0.origin", ""),
-					resource.TestCheckResourceAttrSet("data.snowflake_databases.test", "databases.0.show_output.0.owner"),
-					resource.TestCheckResourceAttr("data.snowflake_databases.test", "databases.0.show_output.0.comment", comment),
-					resource.TestCheckResourceAttr("data.snowflake_databases.test", "databases.0.show_output.0.options", ""),
-					resource.TestCheckResourceAttrSet("data.snowflake_databases.test", "databases.0.show_output.0.retention_time"),
-					resource.TestCheckResourceAttr("data.snowflake_databases.test", "databases.0.show_output.0.resource_group", ""),
-					resource.TestCheckResourceAttrSet("data.snowflake_databases.test", "databases.0.show_output.0.owner_role_type"),
-
-					resource.TestCheckResourceAttr("data.snowflake_databases.test", "databases.0.describe_output.#", "2"),
-					resource.TestCheckResourceAttrSet("data.snowflake_databases.test", "databases.0.describe_output.0.created_on"),
-					resource.TestCheckResourceAttrSet("data.snowflake_databases.test", "databases.0.describe_output.0.name"),
-					resource.TestCheckResourceAttr("data.snowflake_databases.test", "databases.0.describe_output.0.kind", "SCHEMA"),
-
-					resource.TestCheckResourceAttr("data.snowflake_databases.test", "databases.0.parameters.#", "1"),
-					resource.TestCheckResourceAttrSet("data.snowflake_databases.test", "databases.0.parameters.0.data_retention_time_in_days.0.value"),
-					resource.TestCheckResourceAttrSet("data.snowflake_databases.test", "databases.0.parameters.0.max_data_extension_time_in_days.0.value"),
-					resource.TestCheckResourceAttr("data.snowflake_databases.test", "databases.0.parameters.0.external_volume.0.value", ""),
-					resource.TestCheckResourceAttr("data.snowflake_databases.test", "databases.0.parameters.0.catalog.0.value", ""),
-					resource.TestCheckResourceAttrSet("data.snowflake_databases.test", "databases.0.parameters.0.replace_invalid_characters.0.value"),
-					resource.TestCheckResourceAttr("data.snowflake_databases.test", "databases.0.parameters.0.default_ddl_collation.0.value", ""),
-					resource.TestCheckResourceAttrSet("data.snowflake_databases.test", "databases.0.parameters.0.storage_serialization_policy.0.value"),
-					resource.TestCheckResourceAttrSet("data.snowflake_databases.test", "databases.0.parameters.0.log_level.0.value"),
-					resource.TestCheckResourceAttrSet("data.snowflake_databases.test", "databases.0.parameters.0.trace_level.0.value"),
-					resource.TestCheckResourceAttrSet("data.snowflake_databases.test", "databases.0.parameters.0.suspend_task_after_num_failures.0.value"),
-					resource.TestCheckResourceAttrSet("data.snowflake_databases.test", "databases.0.parameters.0.task_auto_retry_attempts.0.value"),
-					resource.TestCheckResourceAttrSet("data.snowflake_databases.test", "databases.0.parameters.0.user_task_managed_initial_warehouse_size.0.value"),
-					resource.TestCheckResourceAttrSet("data.snowflake_databases.test", "databases.0.parameters.0.user_task_minimum_trigger_interval_in_seconds.0.value"),
-					resource.TestCheckResourceAttrSet("data.snowflake_databases.test", "databases.0.parameters.0.quoted_identifiers_ignore_case.0.value"),
-					resource.TestCheckResourceAttrSet("data.snowflake_databases.test", "databases.0.parameters.0.enable_console_output.0.value"),
+					resource.TestCheckResourceAttr(databasesModel.DatasourceReference(), "databases.#", "1"),
+					resource.TestCheckResourceAttrSet(databasesModel.DatasourceReference(), "databases.0.show_output.0.created_on"),
+					resource.TestCheckResourceAttr(databasesModel.DatasourceReference(), "databases.0.show_output.0.name", databaseName),
+					resource.TestCheckResourceAttr(databasesModel.DatasourceReference(), "databases.0.show_output.0.kind", "STANDARD"),
+					resource.TestCheckResourceAttr(databasesModel.DatasourceReference(), "databases.0.show_output.0.transient", "false"),
+					resource.TestCheckResourceAttr(databasesModel.DatasourceReference(), "databases.0.show_output.0.is_default", "false"),
+					resource.TestCheckResourceAttr(databasesModel.DatasourceReference(), "databases.0.show_output.0.is_current", "true"),
+					resource.TestCheckResourceAttr(databasesModel.DatasourceReference(), "databases.0.show_output.0.origin", ""),
+					resource.TestCheckResourceAttrSet(databasesModel.DatasourceReference(), "databases.0.show_output.0.owner"),
+					resource.TestCheckResourceAttr(databasesModel.DatasourceReference(), "databases.0.show_output.0.comment", comment),
+					resource.TestCheckResourceAttr(databasesModel.DatasourceReference(), "databases.0.show_output.0.options", ""),
+					resource.TestCheckResourceAttrSet(databasesModel.DatasourceReference(), "databases.0.show_output.0.retention_time"),
+					resource.TestCheckResourceAttr(databasesModel.DatasourceReference(), "databases.0.show_output.0.resource_group", ""),
+					resource.TestCheckResourceAttrSet(databasesModel.DatasourceReference(), "databases.0.show_output.0.owner_role_type"),
+
+					resource.TestCheckResourceAttr(databasesModel.DatasourceReference(), "databases.0.describe_output.#", "2"),
+					resource.TestCheckResourceAttrSet(databasesModel.DatasourceReference(), "databases.0.describe_output.0.created_on"),
+					resource.TestCheckResourceAttrSet(databasesModel.DatasourceReference(), "databases.0.describe_output.0.name"),
+					resource.TestCheckResourceAttr(databasesModel.DatasourceReference(), "databases.0.describe_output.0.kind", "SCHEMA"),
+
+					resource.TestCheckResourceAttr(databasesModel.DatasourceReference(), "databases.0.parameters.#", "1"),
+					resource.TestCheckResourceAttrSet(databasesModel.DatasourceReference(), "databases.0.parameters.0.data_retention_time_in_days.0.value"),
+					resource.TestCheckResourceAttrSet(databasesModel.DatasourceReference(), "databases.0.parameters.0.max_data_extension_time_in_days.0.value"),
+					resource.TestCheckResourceAttr(databasesModel.DatasourceReference(), "databases.0.parameters.0.external_volume.0.value", ""),
+					resource.TestCheckResourceAttr(databasesModel.DatasourceReference(), "databases.0.parameters.0.catalog.0.value", ""),
+					resource.TestCheckResourceAttrSet(databasesModel.DatasourceReference(), "databases.0.parameters.0.replace_invalid_characters.0.value"),
+					resource.TestCheckResourceAttr(databasesModel.DatasourceReference(), "databases.0.parameters.0.default_ddl_collation.0.value", ""),
+					resource.TestCheckResourceAttrSet(databasesModel.DatasourceReference(), "databases.0.parameters.0.storage_serialization_policy.0.value"),
+					resource.TestCheckResourceAttrSet(databasesModel.DatasourceReference(), "databases.0.parameters.0.log_level.0.value"),
+					resource.TestCheckResourceAttrSet(databasesModel.DatasourceReference(), "databases.0.parameters.0.trace_level.0.value"),
+					resource.TestCheckResourceAttrSet(databasesModel.DatasourceReference(), "databases.0.parameters.0.suspend_task_after_num_failures.0.value"),
+					resource.TestCheckResourceAttrSet(databasesModel.DatasourceReference(), "databases.0.parameters.0.task_auto_retry_attempts.0.value"),
+					resource.TestCheckResourceAttrSet(databasesModel.DatasourceReference(), "databases.0.parameters.0.user_task_managed_initial_warehouse_size.0.value"),
+					resource.TestCheckResourceAttrSet(databasesModel.DatasourceReference(), "databases.0.parameters.0.user_task_minimum_trigger_interval_in_seconds.0.value"),
+					resource.TestCheckResourceAttrSet(databasesModel.DatasourceReference(), "databases.0.parameters.0.quoted_identifiers_ignore_case.0.value"),
+					resource.TestCheckResourceAttrSet(databasesModel.DatasourceReference(), "databases.0.parameters.0.enable_console_output.0.value"),
 				),
 			},
 			{
-				ConfigDirectory: acc.ConfigurationDirectory("TestAcc_Databases/optionals_unset"),
-				ConfigVariables: configVariables,
+				Config: accconfig.FromModels(t, databaseModel, databasesWithoutOptionalsModel),
 				Check: resource.ComposeTestCheckFunc(
-					resource.TestCheckResourceAttr("data.snowflake_databases.test", "databases.#", "1"),
-					resource.TestCheckResourceAttrSet("data.snowflake_databases.test", "databases.0.show_output.0.created_on"),
-					resource.TestCheckResourceAttr("data.snowflake_databases.test", "databases.0.show_output.0.name", databaseName),
-					resource.TestCheckResourceAttr("data.snowflake_databases.test", "databases.0.show_output.0.kind", "STANDARD"),
-					resource.TestCheckResourceAttr("data.snowflake_databases.test", "databases.0.show_output.0.transient", "false"),
-					resource.TestCheckResourceAttr("data.snowflake_databases.test", "databases.0.show_output.0.is_default", "false"),
-					resource.TestCheckResourceAttr("data.snowflake_databases.test", "databases.0.show_output.0.is_current", "true"),
-					resource.TestCheckResourceAttr("data.snowflake_databases.test", "databases.0.show_output.0.origin", ""),
-					resource.TestCheckResourceAttrSet("data.snowflake_databases.test", "databases.0.show_output.0.owner"),
-					resource.TestCheckResourceAttr("data.snowflake_databases.test", "databases.0.show_output.0.comment", comment),
-					resource.TestCheckResourceAttr("data.snowflake_databases.test", "databases.0.show_output.0.options", ""),
-					resource.TestCheckResourceAttrSet("data.snowflake_databases.test", "databases.0.show_output.0.retention_time"),
-					resource.TestCheckResourceAttr("data.snowflake_databases.test", "databases.0.show_output.0.resource_group", ""),
-					resource.TestCheckResourceAttrSet("data.snowflake_databases.test", "databases.0.show_output.0.owner_role_type"),
-
-					resource.TestCheckResourceAttr("data.snowflake_databases.test", "databases.0.describe_output.#", "0"),
-					resource.TestCheckResourceAttr("data.snowflake_databases.test", "databases.0.parameters.#", "0"),
+					resource.TestCheckResourceAttr(databasesModel.DatasourceReference(), "databases.#", "1"),
+					resource.TestCheckResourceAttrSet(databasesModel.DatasourceReference(), "databases.0.show_output.0.created_on"),
+					resource.TestCheckResourceAttr(databasesModel.DatasourceReference(), "databases.0.show_output.0.name", databaseName),
+					resource.TestCheckResourceAttr(databasesModel.DatasourceReference(), "databases.0.show_output.0.kind", "STANDARD"),
+					resource.TestCheckResourceAttr(databasesModel.DatasourceReference(), "databases.0.show_output.0.transient", "false"),
+					resource.TestCheckResourceAttr(databasesModel.DatasourceReference(), "databases.0.show_output.0.is_default", "false"),
+					resource.TestCheckResourceAttr(databasesModel.DatasourceReference(), "databases.0.show_output.0.is_current", "true"),
+					resource.TestCheckResourceAttr(databasesModel.DatasourceReference(), "databases.0.show_output.0.origin", ""),
+					resource.TestCheckResourceAttrSet(databasesModel.DatasourceReference(), "databases.0.show_output.0.owner"),
+					resource.TestCheckResourceAttr(databasesModel.DatasourceReference(), "databases.0.show_output.0.comment", comment),
+					resource.TestCheckResourceAttr(databasesModel.DatasourceReference(), "databases.0.show_output.0.options", ""),
+					resource.TestCheckResourceAttrSet(databasesModel.DatasourceReference(), "databases.0.show_output.0.retention_time"),
+					resource.TestCheckResourceAttr(databasesModel.DatasourceReference(), "databases.0.show_output.0.resource_group", ""),
+					resource.TestCheckResourceAttrSet(databasesModel.DatasourceReference(), "databases.0.show_output.0.owner_role_type"),
+
+					resource.TestCheckResourceAttr(databasesModel.DatasourceReference(), "databases.0.describe_output.#", "0"),
+					resource.TestCheckResourceAttr(databasesModel.DatasourceReference(), "databases.0.parameters.#", "0"),
 				),
 			},
 		},
diff --git a/pkg/datasources/testdata/TestAcc_Databases/optionals_set/test.tf b/pkg/datasources/testdata/TestAcc_Databases/optionals_set/test.tf
deleted file mode 100644
index c7b1aa7069..0000000000
--- a/pkg/datasources/testdata/TestAcc_Databases/optionals_set/test.tf
+++ /dev/null
@@ -1,20 +0,0 @@
-resource "snowflake_database" "test" {
-  name    = var.name
-  comment = var.comment
-  replication {
-    enable_to_account {
-      account_identifier = var.account_identifier
-      with_failover      = true
-    }
-    ignore_edition_check = true
-  }
-}
-
-data "snowflake_databases" "test" {
-  depends_on  = [snowflake_database.test]
-  like        = var.name
-  starts_with = var.name
-  limit {
-    rows = 1
-  }
-}
diff --git a/pkg/datasources/testdata/TestAcc_Databases/optionals_set/variables.tf b/pkg/datasources/testdata/TestAcc_Databases/optionals_set/variables.tf
deleted file mode 100644
index ea75b95f23..0000000000
--- a/pkg/datasources/testdata/TestAcc_Databases/optionals_set/variables.tf
+++ /dev/null
@@ -1,11 +0,0 @@
-variable "name" {
-  type = string
-}
-
-variable "account_identifier" {
-  type = string
-}
-
-variable "comment" {
-  type = string
-}
diff --git a/pkg/datasources/testdata/TestAcc_Databases/optionals_unset/test.tf b/pkg/datasources/testdata/TestAcc_Databases/optionals_unset/test.tf
deleted file mode 100644
index c640dcafc0..0000000000
--- a/pkg/datasources/testdata/TestAcc_Databases/optionals_unset/test.tf
+++ /dev/null
@@ -1,22 +0,0 @@
-resource "snowflake_database" "test" {
-  name    = var.name
-  comment = var.comment
-  replication {
-    enable_to_account {
-      account_identifier = var.account_identifier
-      with_failover      = true
-    }
-    ignore_edition_check = true
-  }
-}
-
-data "snowflake_databases" "test" {
-  with_describe   = false
-  with_parameters = false
-  depends_on      = [snowflake_database.test]
-  like            = var.name
-  starts_with     = var.name
-  limit {
-    rows = 1
-  }
-}
diff --git a/pkg/datasources/testdata/TestAcc_Databases/optionals_unset/variables.tf b/pkg/datasources/testdata/TestAcc_Databases/optionals_unset/variables.tf
deleted file mode 100644
index ea75b95f23..0000000000
--- a/pkg/datasources/testdata/TestAcc_Databases/optionals_unset/variables.tf
+++ /dev/null
@@ -1,11 +0,0 @@
-variable "name" {
-  type = string
-}
-
-variable "account_identifier" {
-  type = string
-}
-
-variable "comment" {
-  type = string
-}
diff --git a/pkg/manual_tests/authentication_methods/auth_test.go b/pkg/manual_tests/authentication_methods/auth_test.go
index 48446fbd2a..07f8af0deb 100644
--- a/pkg/manual_tests/authentication_methods/auth_test.go
+++ b/pkg/manual_tests/authentication_methods/auth_test.go
@@ -1,11 +1,13 @@
 package manual
 
 import (
-	"fmt"
 	"testing"
 
 	acc "github.com/Snowflake-Labs/terraform-provider-snowflake/pkg/acceptance"
 
+	"github.com/Snowflake-Labs/terraform-provider-snowflake/pkg/acceptance/bettertestspoc/config"
+	"github.com/Snowflake-Labs/terraform-provider-snowflake/pkg/acceptance/bettertestspoc/config/model"
+	"github.com/Snowflake-Labs/terraform-provider-snowflake/pkg/acceptance/bettertestspoc/config/providermodel"
 	"github.com/Snowflake-Labs/terraform-provider-snowflake/pkg/acceptance/testenvs"
 	"github.com/Snowflake-Labs/terraform-provider-snowflake/pkg/acceptance/testprofiles"
 	"github.com/Snowflake-Labs/terraform-provider-snowflake/pkg/internal/snowflakeenvs"
@@ -31,7 +33,7 @@ func TestAcc_Provider_OktaAuth(t *testing.T) {
 		},
 		Steps: []resource.TestStep{
 			{
-				Config: providerConfigWithAuthenticator(Okta, sdk.AuthenticationTypeOkta),
+				Config: providerConfigWithAuthenticator(t, Okta, sdk.AuthenticationTypeOkta),
 			},
 		},
 	})
@@ -51,11 +53,11 @@ func TestAcc_Provider_UsernamePasswordMfaAuth(t *testing.T) {
 		Steps: []resource.TestStep{
 			// ensure MFA is checked here - accept login on your MFA device
 			{
-				Config: providerConfigWithAuthenticator(testprofiles.Default, sdk.AuthenticationTypeUsernamePasswordMfa),
+				Config: providerConfigWithAuthenticator(t, testprofiles.Default, sdk.AuthenticationTypeUsernamePasswordMfa),
 			},
 			// check that MFA login is cached - this step should not require manual action
 			{
-				Config: providerConfigWithAuthenticator(testprofiles.Default, sdk.AuthenticationTypeUsernamePasswordMfa),
+				Config: providerConfigWithAuthenticator(t, testprofiles.Default, sdk.AuthenticationTypeUsernamePasswordMfa),
 			},
 		},
 	})
@@ -75,28 +77,20 @@ func TestAcc_Provider_UsernamePasswordMfaAuthWithPasscode(t *testing.T) {
 		Steps: []resource.TestStep{
 			// ensure MFA is checked here - accept access to keychain on your device
 			{
-				Config: providerConfigWithAuthenticator(DefaultWithPasscode, sdk.AuthenticationTypeUsernamePasswordMfa),
+				Config: providerConfigWithAuthenticator(t, DefaultWithPasscode, sdk.AuthenticationTypeUsernamePasswordMfa),
 			},
 			// check that MFA login is cached - this step should not require manual action
 			{
-				Config: providerConfigWithAuthenticator(DefaultWithPasscode, sdk.AuthenticationTypeUsernamePasswordMfa),
+				Config: providerConfigWithAuthenticator(t, DefaultWithPasscode, sdk.AuthenticationTypeUsernamePasswordMfa),
 			},
 		},
 	})
 }
 
-func providerConfigWithAuthenticator(profile string, authenticator sdk.AuthenticationType) string {
-	return fmt.Sprintf(`
-provider "snowflake" {
-	profile = "%[1]s"
-	authenticator    = "%[2]s"
-}
-`, profile, authenticator) + datasourceConfig()
-}
-
-func datasourceConfig() string {
-	return `
-data snowflake_database "t" {
-	name = "SNOWFLAKE"
-}`
+func providerConfigWithAuthenticator(t *testing.T, profile string, authenticator sdk.AuthenticationType) string {
+	t.Helper()
+	return config.FromModels(t,
+		providermodel.SnowflakeProvider().WithProfile(profile).WithAuthenticator(string(authenticator)),
+		model.Database("t", "SNOWFLAKE"),
+	)
 }
diff --git a/pkg/provider/provider_acceptance_test.go b/pkg/provider/provider_acceptance_test.go
index f1ac12b158..8d9d5b0666 100644
--- a/pkg/provider/provider_acceptance_test.go
+++ b/pkg/provider/provider_acceptance_test.go
@@ -11,7 +11,11 @@ import (
 
 	acc "github.com/Snowflake-Labs/terraform-provider-snowflake/pkg/acceptance"
 	internalprovider "github.com/Snowflake-Labs/terraform-provider-snowflake/pkg/internal/provider"
+	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/acceptance/bettertestspoc/config/datasourcemodel"
+	"github.com/Snowflake-Labs/terraform-provider-snowflake/pkg/acceptance/bettertestspoc/config/providermodel"
 	"github.com/Snowflake-Labs/terraform-provider-snowflake/pkg/acceptance/helpers"
 	"github.com/Snowflake-Labs/terraform-provider-snowflake/pkg/acceptance/ids"
 	"github.com/Snowflake-Labs/terraform-provider-snowflake/pkg/acceptance/testenvs"
@@ -52,7 +56,7 @@ func TestAcc_Provider_configHierarchy(t *testing.T) {
 				PreConfig: func() {
 					t.Setenv(snowflakeenvs.ConfigPath, incorrectConfig.Path)
 				},
-				Config:      providerConfig(incorrectConfig.Profile),
+				Config:      config.FromModels(t, providermodel.SnowflakeProvider().WithProfile(incorrectConfig.Profile), datasourceModel()),
 				ExpectError: regexp.MustCompile("JWT token is invalid"),
 			},
 			// make sure that we succeed for the correct profile
@@ -60,14 +64,14 @@ func TestAcc_Provider_configHierarchy(t *testing.T) {
 				PreConfig: func() {
 					t.Setenv(snowflakeenvs.ConfigPath, tmpServiceUserConfig.Path)
 				},
-				Config: providerConfig(tmpServiceUserConfig.Profile),
+				Config: config.FromModels(t, providermodel.SnowflakeProvider().WithProfile(tmpServiceUserConfig.Profile), datasourceModel()),
 				Check: resource.ComposeTestCheckFunc(
 					resource.TestCheckResourceAttr("data.snowflake_database.t", "name", acc.TestDatabaseName),
 				),
 			},
 			// incorrect user in provider config should not be rewritten by profile and cause error
 			{
-				Config:      providerConfigWithUserAndProfile(ids.NonExistingAccountObjectIdentifier, tmpServiceUserConfig.Profile),
+				Config:      config.FromModels(t, providermodel.SnowflakeProvider().WithAuthenticatorType(sdk.AuthenticationTypeJwt).WithProfile(tmpServiceUserConfig.Profile).WithUserId(ids.NonExistingAccountObjectIdentifier), datasourceModel()),
 				ExpectError: regexp.MustCompile("JWT token is invalid"),
 			},
 			// correct user and key in provider's config should not be rewritten by a faulty config
@@ -75,7 +79,12 @@ func TestAcc_Provider_configHierarchy(t *testing.T) {
 				PreConfig: func() {
 					t.Setenv(snowflakeenvs.ConfigPath, incorrectConfig.Path)
 				},
-				Config: providerConfigWithUserPrivateKeyAndProfile(tmpServiceUser.UserId, tmpServiceUser.PrivateKey, tmpServiceUser.RoleId.Name(), incorrectConfig.Profile),
+				Config: config.FromModels(t, providermodel.SnowflakeProvider().
+					WithAuthenticatorType(sdk.AuthenticationTypeJwt).
+					WithProfile(incorrectConfig.Profile).
+					WithUserId(tmpServiceUser.UserId).
+					WithRoleId(tmpServiceUser.RoleId).
+					WithPrivateKeyMultiline(tmpServiceUser.PrivateKey), datasourceModel()),
 				Check: resource.ComposeTestCheckFunc(
 					resource.TestCheckResourceAttr("data.snowflake_database.t", "name", acc.TestDatabaseName),
 				),
@@ -86,7 +95,7 @@ func TestAcc_Provider_configHierarchy(t *testing.T) {
 					t.Setenv(snowflakeenvs.User, ids.NonExistingAccountObjectIdentifier.Name())
 					t.Setenv(snowflakeenvs.ConfigPath, tmpServiceUserConfig.Path)
 				},
-				Config:      providerConfig(tmpServiceUserConfig.Profile),
+				Config:      config.FromModels(t, providermodel.SnowflakeProvider().WithProfile(tmpServiceUserConfig.Profile), datasourceModel()),
 				ExpectError: regexp.MustCompile("JWT token is invalid"),
 			},
 			// correct user and private key in env should not be rewritten by a faulty config
@@ -97,7 +106,7 @@ func TestAcc_Provider_configHierarchy(t *testing.T) {
 					t.Setenv(snowflakeenvs.Role, tmpServiceUser.RoleId.Name())
 					t.Setenv(snowflakeenvs.ConfigPath, incorrectConfig.Path)
 				},
-				Config: providerConfigWithProfileAndAuthenticator(incorrectConfig.Profile, sdk.AuthenticationTypeJwt),
+				Config: config.FromModels(t, providermodel.SnowflakeProvider().WithProfile(incorrectConfig.Profile).WithAuthenticatorType(sdk.AuthenticationTypeJwt), datasourceModel()),
 				Check: resource.ComposeTestCheckFunc(
 					resource.TestCheckResourceAttr("data.snowflake_database.t", "name", acc.TestDatabaseName),
 				),
@@ -108,7 +117,12 @@ func TestAcc_Provider_configHierarchy(t *testing.T) {
 					testenvs.AssertEnvSet(t, snowflakeenvs.User)
 					t.Setenv(snowflakeenvs.ConfigPath, tmpServiceUserConfig.Path)
 				},
-				Config:      providerConfigWithUserPrivateKeyAndProfile(ids.NonExistingAccountObjectIdentifier, tmpServiceUser.PrivateKey, tmpServiceUser.RoleId.Name(), tmpServiceUserConfig.Profile),
+				Config: config.FromModels(t, providermodel.SnowflakeProvider().
+					WithAuthenticatorType(sdk.AuthenticationTypeJwt).
+					WithProfile(tmpServiceUserConfig.Profile).
+					WithUserId(ids.NonExistingAccountObjectIdentifier).
+					WithRoleId(tmpServiceUser.RoleId).
+					WithPrivateKeyMultiline(tmpServiceUser.PrivateKey), datasourceModel()),
 				ExpectError: regexp.MustCompile("JWT token is invalid"),
 			},
 			// there is no config (by setting the dir to something different from .snowflake/config)
@@ -118,7 +132,12 @@ func TestAcc_Provider_configHierarchy(t *testing.T) {
 					require.NoError(t, err)
 					t.Setenv(snowflakeenvs.ConfigPath, dir)
 				},
-				Config:      providerConfigWithUserPrivateKeyAndProfile(tmpServiceUser.UserId, tmpServiceUser.PrivateKey, tmpServiceUser.RoleId.Name(), testprofiles.Default),
+				Config: config.FromModels(t, providermodel.SnowflakeProvider().
+					WithAuthenticatorType(sdk.AuthenticationTypeJwt).
+					WithProfile(testprofiles.Default).
+					WithUserId(tmpServiceUser.UserId).
+					WithRoleId(tmpServiceUser.RoleId).
+					WithPrivateKeyMultiline(tmpServiceUser.PrivateKey), datasourceModel()),
 				ExpectError: regexp.MustCompile("account is empty"),
 			},
 			// provider's config should not be rewritten by env when there is no profile (incorrect user in config versus correct one in env) - proves #2242
@@ -131,7 +150,7 @@ func TestAcc_Provider_configHierarchy(t *testing.T) {
 					t.Setenv(snowflakeenvs.OrganizationName, tmpServiceUser.AccountId.OrganizationName())
 					t.Setenv(snowflakeenvs.Role, tmpServiceUser.RoleId.Name())
 				},
-				Config:      providerConfigWithUserAndProfile(ids.NonExistingAccountObjectIdentifier, testprofiles.Default),
+				Config:      config.FromModels(t, providermodel.SnowflakeProvider().WithAuthenticatorType(sdk.AuthenticationTypeJwt).WithProfile(testprofiles.Default).WithUserId(ids.NonExistingAccountObjectIdentifier), datasourceModel()),
 				ExpectError: regexp.MustCompile("JWT token is invalid"),
 			},
 			// make sure the teardown is fine by using a correct env config at the end
@@ -144,7 +163,7 @@ func TestAcc_Provider_configHierarchy(t *testing.T) {
 					testenvs.AssertEnvSet(t, snowflakeenvs.OrganizationName)
 					testenvs.AssertEnvSet(t, snowflakeenvs.Role)
 				},
-				Config: providerConfigWithAuthenticator(sdk.AuthenticationTypeJwt),
+				Config: config.FromModels(t, providermodel.SnowflakeProvider().WithAuthenticatorType(sdk.AuthenticationTypeJwt), datasourceModel()),
 				Check: resource.ComposeTestCheckFunc(
 					resource.TestCheckResourceAttr("data.snowflake_database.t", "name", acc.TestDatabaseName),
 				),
@@ -178,7 +197,7 @@ func TestAcc_Provider_configureClientOnceSwitching(t *testing.T) {
 				PreConfig: func() {
 					t.Setenv(snowflakeenvs.ConfigPath, incorrectConfig.Path)
 				},
-				Config:      providerConfig(incorrectConfig.Profile),
+				Config:      config.FromModels(t, providermodel.SnowflakeProvider().WithProfile(incorrectConfig.Profile), datasourceModel()),
 				ExpectError: regexp.MustCompile("JWT token is invalid"),
 			},
 			// in this step we simulate the situation when we want to use client configured once, but it was faulty last time
@@ -187,7 +206,7 @@ func TestAcc_Provider_configureClientOnceSwitching(t *testing.T) {
 					t.Setenv(string(testenvs.ConfigureClientOnce), "true")
 					t.Setenv(snowflakeenvs.ConfigPath, tmpServiceUserConfig.Path)
 				},
-				Config: providerConfig(tmpServiceUserConfig.Profile),
+				Config: config.FromModels(t, providermodel.SnowflakeProvider().WithProfile(tmpServiceUserConfig.Profile), datasourceModel()),
 				Check: resource.ComposeTestCheckFunc(
 					resource.TestCheckResourceAttr("data.snowflake_database.t", "name", acc.TestDatabaseName),
 				),
@@ -224,7 +243,7 @@ func TestAcc_Provider_tomlConfig(t *testing.T) {
 		},
 		Steps: []resource.TestStep{
 			{
-				Config: providerConfig(tmpServiceUserConfig.Profile),
+				Config: config.FromModels(t, providermodel.SnowflakeProvider().WithProfile(tmpServiceUserConfig.Profile), datasourceModel()),
 				Check: func(s *terraform.State) error {
 					config := acc.TestAccProvider.Meta().(*internalprovider.Context).Client.GetConfig()
 					assert.Equal(t, tmpServiceUser.OrgAndAccount(), config.Account)
@@ -335,7 +354,7 @@ func TestAcc_Provider_envConfig(t *testing.T) {
 					t.Setenv(snowflakeenvs.TmpDirectoryPath, "../")
 					t.Setenv(snowflakeenvs.DisableConsoleLogin, "false")
 				},
-				Config: providerConfig(tmpServiceUserConfig.Profile),
+				Config: config.FromModels(t, providermodel.SnowflakeProvider().WithProfile(tmpServiceUserConfig.Profile), datasourceModel()),
 				Check: func(s *terraform.State) error {
 					config := acc.TestAccProvider.Meta().(*internalprovider.Context).Client.GetConfig()
 
@@ -447,7 +466,7 @@ func TestAcc_Provider_tfConfig(t *testing.T) {
 					t.Setenv(snowflakeenvs.TmpDirectoryPath, "../")
 					t.Setenv(snowflakeenvs.DisableConsoleLogin, "false")
 				},
-				Config: providerConfigAllFields(tmpServiceUserConfig, tmpServiceUser),
+				Config: config.FromModels(t, providermodel.SnowflakeProvider().AllFields(tmpServiceUserConfig, tmpServiceUser), datasourceModel()),
 				Check: func(s *terraform.State) error {
 					config := acc.TestAccProvider.Meta().(*internalprovider.Context).Client.GetConfig()
 
@@ -520,16 +539,16 @@ func TestAcc_Provider_useNonExistentDefaultParams(t *testing.T) {
 		},
 		Steps: []resource.TestStep{
 			{
-				Config:      providerConfigWithExplicitValidationAndRole(tmpServiceUserConfig.Profile, nonExisting, true),
+				Config:      config.FromModels(t, providermodel.SnowflakeProvider().WithProfile(tmpServiceUserConfig.Profile).WithRole(nonExisting).WithValidateDefaultParameters("true"), datasourceModel()),
 				ExpectError: regexp.MustCompile("Role 'NON-EXISTENT' specified in the connect string does not exist or not authorized."),
 			},
 			{
-				Config:      providerConfigWithExplicitValidationAndWarehouse(tmpServiceUserConfig.Profile, nonExisting, true),
+				Config:      config.FromModels(t, providermodel.SnowflakeProvider().WithProfile(tmpServiceUserConfig.Profile).WithWarehouse(nonExisting).WithValidateDefaultParameters("true"), datasourceModel()),
 				ExpectError: regexp.MustCompile("The requested warehouse does not exist or not authorized."),
 			},
 			// check that using a non-existing warehouse with disabled verification succeeds
 			{
-				Config: providerConfigWithExplicitValidationAndWarehouse(tmpServiceUserConfig.Profile, nonExisting, false),
+				Config: config.FromModels(t, providermodel.SnowflakeProvider().WithProfile(tmpServiceUserConfig.Profile).WithWarehouse(nonExisting).WithValidateDefaultParameters("false"), datasourceModel()),
 			},
 		},
 	})
@@ -557,18 +576,18 @@ func TestAcc_Provider_triValueBoolean(t *testing.T) {
 			{
 				PreConfig:         func() { acc.SetV097CompatibleConfigPathEnv(t) },
 				ExternalProviders: acc.ExternalProviderWithExactVersion("0.97.0"),
-				Config:            providerConfigWithClientStoreTemporaryCredential(testprofiles.Default, `true`),
+				Config:            config.FromModels(t, providermodel.SnowflakeProvider().WithProfile(testprofiles.Default).WithClientStoreTemporaryCredentialBool(true), datasourceModel()),
 			},
 			{
 				PreConfig: func() {
 					t.Setenv(snowflakeenvs.ConfigPath, tmpServiceUserConfig.Path)
 				},
 				ProtoV6ProviderFactories: acc.TestAccProtoV6ProviderFactories,
-				Config:                   providerConfigWithClientStoreTemporaryCredential(tmpServiceUserConfig.Profile, `true`),
+				Config:                   config.FromModels(t, providermodel.SnowflakeProvider().WithProfile(tmpServiceUserConfig.Profile).WithClientStoreTemporaryCredentialBool(true), datasourceModel()),
 			},
 			{
 				ProtoV6ProviderFactories: acc.TestAccProtoV6ProviderFactories,
-				Config:                   providerConfigWithClientStoreTemporaryCredential(tmpServiceUserConfig.Profile, `"true"`),
+				Config:                   config.FromModels(t, providermodel.SnowflakeProvider().WithProfile(tmpServiceUserConfig.Profile).WithClientStoreTemporaryCredential("true"), datasourceModel()),
 			},
 		},
 	})
@@ -597,7 +616,14 @@ func TestAcc_Provider_sessionParameters(t *testing.T) {
 				PreConfig: func() {
 					t.Setenv(snowflakeenvs.ConfigPath, tmpServiceUserConfig.Path)
 				},
-				Config: providerWithParamsConfig(tmpServiceUserConfig.Profile, 31337),
+				// TODO [SNOW-1348325]: Use parameter data source with `IN SESSION` filtering.
+				Config: config.FromModels(t, providermodel.SnowflakeProvider().WithProfile(tmpServiceUserConfig.Profile).WithParamsValue(
+					tfconfig.ObjectVariable(
+						map[string]tfconfig.Variable{
+							"statement_timeout_in_seconds": tfconfig.IntegerVariable(31337),
+						},
+					),
+				)) + unsafeExecuteShowSessionParameter(),
 				Check: resource.ComposeAggregateTestCheckFunc(
 					resource.TestCheckResourceAttr("snowflake_unsafe_execute.t", "query_results.#", "1"),
 					resource.TestCheckResourceAttr("snowflake_unsafe_execute.t", "query_results.0.value", "31337"),
@@ -634,7 +660,7 @@ func TestAcc_Provider_JwtAuth(t *testing.T) {
 				PreConfig: func() {
 					t.Setenv(snowflakeenvs.ConfigPath, tmpIncorrectServiceUserConfig.Path)
 				},
-				Config:      providerConfigWithProfileAndAuthenticator(tmpIncorrectServiceUserConfig.Profile, sdk.AuthenticationTypeJwt),
+				Config:      config.FromModels(t, providermodel.SnowflakeProvider().WithProfile(tmpIncorrectServiceUserConfig.Profile).WithAuthenticatorType(sdk.AuthenticationTypeJwt), datasourceModel()),
 				ExpectError: regexp.MustCompile("JWT token is invalid"),
 			},
 			// authenticate with unencrypted private key
@@ -642,19 +668,19 @@ func TestAcc_Provider_JwtAuth(t *testing.T) {
 				PreConfig: func() {
 					t.Setenv(snowflakeenvs.ConfigPath, tmpServiceUserConfig.Path)
 				},
-				Config: providerConfigWithProfileAndAuthenticator(tmpServiceUserConfig.Profile, sdk.AuthenticationTypeJwt),
+				Config: config.FromModels(t, providermodel.SnowflakeProvider().WithProfile(tmpServiceUserConfig.Profile).WithAuthenticatorType(sdk.AuthenticationTypeJwt), datasourceModel()),
 			},
 			// authenticate with unencrypted private key with a legacy authenticator value
 			// solves https://github.com/Snowflake-Labs/terraform-provider-snowflake/issues/2983
 			{
-				Config: providerConfigWithProfileAndAuthenticator(tmpServiceUserConfig.Profile, sdk.AuthenticationTypeJwtLegacy),
+				Config: config.FromModels(t, providermodel.SnowflakeProvider().WithProfile(tmpServiceUserConfig.Profile).WithAuthenticatorType(sdk.AuthenticationTypeJwtLegacy), datasourceModel()),
 			},
 			// check encrypted private key with incorrect password
 			{
 				PreConfig: func() {
 					t.Setenv(snowflakeenvs.ConfigPath, tmpIncorrectServiceUserWithEncryptedKeyConfig.Path)
 				},
-				Config:      providerConfigWithProfileAndAuthenticator(tmpIncorrectServiceUserWithEncryptedKeyConfig.Profile, sdk.AuthenticationTypeJwt),
+				Config:      config.FromModels(t, providermodel.SnowflakeProvider().WithProfile(tmpIncorrectServiceUserWithEncryptedKeyConfig.Profile).WithAuthenticatorType(sdk.AuthenticationTypeJwt), datasourceModel()),
 				ExpectError: regexp.MustCompile("pkcs8: incorrect password"),
 			},
 			// authenticate with encrypted private key
@@ -662,7 +688,7 @@ func TestAcc_Provider_JwtAuth(t *testing.T) {
 				PreConfig: func() {
 					t.Setenv(snowflakeenvs.ConfigPath, tmpServiceUserWithEncryptedKeyConfig.Path)
 				},
-				Config: providerConfigWithProfileAndAuthenticator(tmpServiceUserWithEncryptedKeyConfig.Profile, sdk.AuthenticationTypeJwt),
+				Config: config.FromModels(t, providermodel.SnowflakeProvider().WithProfile(tmpServiceUserWithEncryptedKeyConfig.Profile).WithAuthenticatorType(sdk.AuthenticationTypeJwt), datasourceModel()),
 			},
 		},
 	})
@@ -687,14 +713,14 @@ func TestAcc_Provider_SnowflakeAuth(t *testing.T) {
 				PreConfig: func() {
 					t.Setenv(snowflakeenvs.ConfigPath, incorrectLegacyServiceUserConfig.Path)
 				},
-				Config:      providerConfig(incorrectLegacyServiceUserConfig.Profile),
+				Config:      config.FromModels(t, providermodel.SnowflakeProvider().WithProfile(incorrectLegacyServiceUserConfig.Profile), datasourceModel()),
 				ExpectError: regexp.MustCompile("Incorrect username or password was specified"),
 			},
 			{
 				PreConfig: func() {
 					t.Setenv(snowflakeenvs.ConfigPath, tmpLegacyServiceUserConfig.Path)
 				},
-				Config: providerConfig(tmpLegacyServiceUserConfig.Profile),
+				Config: config.FromModels(t, providermodel.SnowflakeProvider().WithProfile(tmpLegacyServiceUserConfig.Profile), datasourceModel()),
 			},
 		},
 	})
@@ -718,260 +744,63 @@ func TestAcc_Provider_invalidConfigurations(t *testing.T) {
 		},
 		Steps: []resource.TestStep{
 			{
-				Config:      providerConfigWithClientIp(tmpServiceUserConfig.Profile, "invalid"),
+				Config:      config.FromModels(t, providermodel.SnowflakeProvider().WithProfile(tmpServiceUserConfig.Profile).WithClientIp("invalid"), datasourceModel()),
 				ExpectError: regexp.MustCompile("expected client_ip to contain a valid IP"),
 			},
 			{
-				Config:      providerConfigWithProtocol(tmpServiceUserConfig.Profile, "invalid"),
+				Config:      config.FromModels(t, providermodel.SnowflakeProvider().WithProfile(tmpServiceUserConfig.Profile).WithProtocol("invalid"), datasourceModel()),
 				ExpectError: regexp.MustCompile("invalid protocol: invalid"),
 			},
 			{
-				Config:      providerConfigWithPort(tmpServiceUserConfig.Profile, 123456789),
+				Config:      config.FromModels(t, providermodel.SnowflakeProvider().WithProfile(tmpServiceUserConfig.Profile).WithPort(123456789), datasourceModel()),
 				ExpectError: regexp.MustCompile(`expected "port" to be a valid port number or 0, got: 123456789`),
 			},
 			{
-				Config:      providerConfigWithAuthType(tmpServiceUserConfig.Profile, "invalid"),
+				Config:      config.FromModels(t, providermodel.SnowflakeProvider().WithProfile(tmpServiceUserConfig.Profile).WithAuthenticator("invalid"), datasourceModel()),
 				ExpectError: regexp.MustCompile("invalid authenticator type: invalid"),
 			},
 			{
-				Config:      providerConfigWithOktaUrl(tmpServiceUserConfig.Profile, "invalid"),
+				Config:      config.FromModels(t, providermodel.SnowflakeProvider().WithProfile(tmpServiceUserConfig.Profile).WithOktaUrl("invalid"), datasourceModel()),
 				ExpectError: regexp.MustCompile(`expected "okta_url" to have a host, got invalid`),
 			},
 			{
-				Config:      providerConfigWithTimeout(tmpServiceUserConfig.Profile, "login_timeout", -1),
+				Config:      config.FromModels(t, providermodel.SnowflakeProvider().WithProfile(tmpServiceUserConfig.Profile).WithLoginTimeout(-1), datasourceModel()),
 				ExpectError: regexp.MustCompile(`expected login_timeout to be at least \(0\), got -1`),
 			},
 			{
-				Config:      providerConfigWithTokenEndpoint(tmpServiceUserConfig.Profile, "invalid"),
+				Config: config.FromModels(
+					t,
+					providermodel.SnowflakeProvider().
+						WithProfile(tmpServiceUserConfig.Profile).
+						WithTokenAccessorValue(
+							tfconfig.ObjectVariable(
+								map[string]tfconfig.Variable{
+									"token_endpoint": tfconfig.StringVariable("invalid"),
+									"refresh_token":  tfconfig.StringVariable("refresh_token"),
+									"client_id":      tfconfig.StringVariable("client_id"),
+									"client_secret":  tfconfig.StringVariable("client_secret"),
+									"redirect_uri":   tfconfig.StringVariable("redirect_uri"),
+								},
+							),
+						),
+					datasourceModel(),
+				),
 				ExpectError: regexp.MustCompile(`expected "token_endpoint" to have a host, got invalid`),
 			},
 			{
-				Config:      providerConfigWithLogLevel(tmpServiceUserConfig.Profile, "invalid"),
+				Config:      config.FromModels(t, providermodel.SnowflakeProvider().WithProfile(tmpServiceUserConfig.Profile).WithDriverTracing("invalid"), datasourceModel()),
 				ExpectError: regexp.MustCompile(`invalid driver log level: invalid`),
 			},
 			{
-				Config:      providerConfig("non-existing"),
+				Config:      config.FromModels(t, providermodel.SnowflakeProvider().WithProfile("non-existing"), datasourceModel()),
 				ExpectError: regexp.MustCompile(fmt.Sprintf(`profile "non-existing" not found in file %s`, tmpServiceUserConfig.Path)),
 			},
 		},
 	})
 }
 
-func providerConfigWithProfileAndAuthenticator(profile string, authenticator sdk.AuthenticationType) string {
-	return fmt.Sprintf(`
-provider "snowflake" {
-	profile = "%[1]s"
-	authenticator    = "%[2]s"
-}
-`, profile, authenticator) + datasourceConfig()
-}
-
-func providerConfigWithAuthenticator(authenticator sdk.AuthenticationType) string {
-	return fmt.Sprintf(`
-provider "snowflake" {
-	authenticator    = "%[1]s"
-}`, authenticator) + datasourceConfig()
-}
-
-func providerConfig(profile string) string {
-	return fmt.Sprintf(`
-provider "snowflake" {
-	profile = "%[1]s"
-}
-`, profile) + datasourceConfig()
-}
-
-func providerConfigWithExplicitValidationAndRole(profile string, role string, validate bool) string {
-	return fmt.Sprintf(`
-provider "snowflake" {
-	profile = "%[1]s"
-	role    = "%[2]s"
-
-	validate_default_parameters = "%[3]t"
-}
-`, profile, role, validate) + datasourceConfig()
-}
-
-func providerConfigWithExplicitValidationAndWarehouse(profile string, warehouse string, validate bool) string {
-	return fmt.Sprintf(`
-provider "snowflake" {
-	profile   = "%[1]s"
-	warehouse = "%[2]s"
-
-	validate_default_parameters = "%[3]t"
-}
-`, profile, warehouse, validate) + datasourceConfig()
-}
-
-func providerConfigWithClientStoreTemporaryCredential(profile, clientStoreTemporaryCredential string) string {
-	return fmt.Sprintf(`
-provider "snowflake" {
-	profile = "%[1]s"
-	client_store_temporary_credential    = %[2]s
-}
-`, profile, clientStoreTemporaryCredential) + datasourceConfig()
-}
-
-func providerConfigWithProtocol(profile, protocol string) string {
-	return fmt.Sprintf(`
-provider "snowflake" {
-	profile = "%[1]s"
-	protocol    = "%[2]s"
-}
-`, profile, protocol) + datasourceConfig()
-}
-
-func providerConfigWithPort(profile string, port int) string {
-	return fmt.Sprintf(`
-provider "snowflake" {
-	profile = "%[1]s"
-	port    = %[2]d
-}
-`, profile, port) + datasourceConfig()
-}
-
-func providerConfigWithAuthType(profile, authType string) string {
-	return fmt.Sprintf(`
-provider "snowflake" {
-	profile = "%[1]s"
-	authenticator    = "%[2]s"
-}
-`, profile, authType) + datasourceConfig()
-}
-
-func providerConfigWithOktaUrl(profile, oktaUrl string) string {
-	return fmt.Sprintf(`
-provider "snowflake" {
-	profile = "%[1]s"
-	okta_url    = "%[2]s"
-}
-`, profile, oktaUrl) + datasourceConfig()
-}
-
-func providerConfigWithTimeout(profile, timeoutName string, timeoutSeconds int) string {
-	return fmt.Sprintf(`
-provider "snowflake" {
-	profile = "%[1]s"
-	%[2]s    = %[3]d
-}
-`, profile, timeoutName, timeoutSeconds) + datasourceConfig()
-}
-
-func providerConfigWithTokenEndpoint(profile, tokenEndpoint string) string {
-	return fmt.Sprintf(`
-provider "snowflake" {
-	profile = "%[1]s"
-	token_accessor {
-		token_endpoint = "%[2]s"
-		refresh_token = "refresh_token"
-		client_id = "client_id"
-		client_secret = "client_secret"
-		redirect_uri = "redirect_uri"
-	}
-}
-`, profile, tokenEndpoint) + datasourceConfig()
-}
-
-func providerConfigWithLogLevel(profile, logLevel string) string {
-	return fmt.Sprintf(`
-provider "snowflake" {
-	profile = "%[1]s"
-	driver_tracing    = "%[2]s"
-}
-`, profile, logLevel) + datasourceConfig()
-}
-
-func providerConfigWithClientIp(profile, clientIp string) string {
-	return fmt.Sprintf(`
-provider "snowflake" {
-	profile = "%[1]s"
-	client_ip    = "%[2]s"
-}
-`, profile, clientIp) + datasourceConfig()
-}
-
-func providerConfigWithUserAndProfile(userId sdk.AccountObjectIdentifier, profile string) string {
-	return fmt.Sprintf(`
-provider "snowflake" {
-	authenticator = "SNOWFLAKE_JWT"
-	user = "%[1]s"
-	profile = "%[2]s"
-}
-`, userId.Name(), profile) + datasourceConfig()
-}
-
-func providerConfigWithUserPrivateKeyAndProfile(userId sdk.AccountObjectIdentifier, key string, role string, profile string) string {
-	return fmt.Sprintf(`
-provider "snowflake" {
-	authenticator = "SNOWFLAKE_JWT"
-	user = "%[1]s"
-	private_key = <<EOT
-%[2]sEOT
-	role = "%[3]s"
-	profile = "%[4]s"
-}
-`, userId.Name(), key, role, profile) + datasourceConfig()
-}
-
-func datasourceConfig() string {
-	return fmt.Sprintf(`
-data snowflake_database "t" {
-	name = "%s"
-}`, acc.TestDatabaseName)
-}
-
-func providerConfigAllFields(tmpConfig *helpers.TmpTomlConfig, tmpUser *helpers.TmpServiceUser) string {
-	return fmt.Sprintf(`
-provider "snowflake" {
-	profile = "%[1]s"
-	organization_name = "%[2]s"
-	account_name = "%[3]s"
-	user = "%[4]s"
-	private_key = <<EOT
-%[7]sEOT
-	warehouse = "%[5]s"
-	protocol = "https"
-	port = "443"
-	role = "%[6]s"
-	validate_default_parameters = true
-	client_ip = "3.3.3.3"
-	authenticator = "SNOWFLAKE_JWT"
-	okta_url = "https://example-tf.com"
-	login_timeout = 101
-	request_timeout = 201
-	jwt_expire_timeout = 301
-	client_timeout = 401
-	jwt_client_timeout = 501
-	external_browser_timeout = 601
-	insecure_mode = true
-	ocsp_fail_open = true
-	keep_session_alive = true
-	disable_telemetry = true
-	client_request_mfa_token = true
-	client_store_temporary_credential = true
-	disable_query_context_cache = true
-	include_retry_reason = true
-	max_retry_count = 3
-	driver_tracing = "warning"
-	tmp_directory_path = "../../"
-	disable_console_login = true
-	params = {
-		foo = "piyo"
-	}
-}
-`, tmpConfig.Profile, tmpUser.AccountId.OrganizationName(), tmpUser.AccountId.AccountName(), tmpUser.UserId.Name(), tmpUser.WarehouseId.Name(), tmpUser.RoleId.Name(), tmpUser.PrivateKey) + datasourceConfig()
-}
-
-// TODO(SNOW-1348325): Use parameter data source with `IN SESSION` filtering.
-func providerWithParamsConfig(profile string, statementTimeoutInSeconds int) string {
-	return fmt.Sprintf(`
-provider "snowflake" {
-    profile = "%[1]s"
-    params = {
-        statement_timeout_in_seconds = %[2]d
-    }
-}
-`, profile, statementTimeoutInSeconds) + unsafeExecuteShowSessionParameter()
+func datasourceModel() config.DatasourceModel {
+	return datasourcemodel.Database("t", acc.TestDatabaseName)
 }
 
 func unsafeExecuteShowSessionParameter() string {
diff --git a/pkg/resources/grant_ownership_acceptance_test.go b/pkg/resources/grant_ownership_acceptance_test.go
index c7b3455596..d23933dac8 100644
--- a/pkg/resources/grant_ownership_acceptance_test.go
+++ b/pkg/resources/grant_ownership_acceptance_test.go
@@ -884,6 +884,7 @@ resource "snowflake_grant_account_role" "test" {
 }
 `, accountRoleName, databaseName, userName)
 
+	// TODO [SNOW-1501905]: build these configs from builders
 	secondaryProviderConfig := fmt.Sprintf(`
 provider "snowflake" {
   profile = "default"
diff --git a/pkg/resources/object_renaming_acceptance_test.go b/pkg/resources/object_renaming_acceptance_test.go
index 462035c8c8..15be4da721 100644
--- a/pkg/resources/object_renaming_acceptance_test.go
+++ b/pkg/resources/object_renaming_acceptance_test.go
@@ -318,7 +318,7 @@ func TestAcc_ShallowHierarchy_IsInConfig_RenamedExternally_WithoutDependency_Aft
 		CheckDestroy: acc.CheckDestroy(t, resources.Schema),
 		Steps: []resource.TestStep{
 			{
-				Config: config.FromModels(t, databaseConfigModel, schemaModelConfig),
+				Config: config.FromModelsDeprecated(t, databaseConfigModel, schemaModelConfig),
 			},
 			{
 				// This step has inconsistent results, and it depends on the Terraform execution order which seems to be non-deterministic in this case
@@ -333,7 +333,7 @@ func TestAcc_ShallowHierarchy_IsInConfig_RenamedExternally_WithoutDependency_Aft
 						plancheck.ExpectResourceAction("snowflake_schema.test", plancheck.ResourceActionCreate),
 					},
 				},
-				Config: config.FromModels(t, databaseConfigModel, schemaModelConfig),
+				Config: config.FromModelsDeprecated(t, databaseConfigModel, schemaModelConfig),
 				// ExpectError: regexp.MustCompile("does not exist or not authorized"),
 			},
 		},
@@ -362,7 +362,7 @@ func TestAcc_ShallowHierarchy_IsInConfig_RenamedExternally_WithoutDependency_Aft
 		CheckDestroy: acc.CheckDestroy(t, resources.Schema),
 		Steps: []resource.TestStep{
 			{
-				Config: config.FromModels(t, schemaModelConfig, databaseConfigModel),
+				Config: config.FromModelsDeprecated(t, schemaModelConfig, databaseConfigModel),
 			},
 			{
 				PreConfig: func() {
@@ -376,7 +376,7 @@ func TestAcc_ShallowHierarchy_IsInConfig_RenamedExternally_WithoutDependency_Aft
 						plancheck.ExpectResourceAction("snowflake_schema.test", plancheck.ResourceActionCreate),
 					},
 				},
-				Config:      config.FromModels(t, schemaModelConfig, databaseConfigModel),
+				Config:      config.FromModelsDeprecated(t, schemaModelConfig, databaseConfigModel),
 				ExpectError: regexp.MustCompile("does not exist or not authorized"),
 			},
 		},
diff --git a/pkg/resources/testdata/TestAcc_View/basic_update/test.tf b/pkg/resources/testdata/TestAcc_View/basic_update/test.tf
deleted file mode 100644
index fd96e26315..0000000000
--- a/pkg/resources/testdata/TestAcc_View/basic_update/test.tf
+++ /dev/null
@@ -1,31 +0,0 @@
-resource "snowflake_view" "test" {
-  name     = var.name
-  database = var.database
-  schema   = var.schema
-
-  dynamic "column" {
-    for_each = var.column
-    content {
-      column_name = column.value["column_name"]
-    }
-  }
-
-  row_access_policy {
-    policy_name = var.row_access_policy
-    on          = var.row_access_policy_on
-  }
-  aggregation_policy {
-    policy_name = var.aggregation_policy
-    entity_key  = var.aggregation_policy_entity_key
-  }
-  data_metric_function {
-    function_name   = var.data_metric_function
-    on              = var.data_metric_function_on
-    schedule_status = var.schedule_status
-  }
-  data_metric_schedule {
-    using_cron = var.data_metric_schedule_using_cron
-  }
-  statement = var.statement
-  comment   = var.comment
-}
diff --git a/pkg/resources/testdata/TestAcc_View/basic_update/variables.tf b/pkg/resources/testdata/TestAcc_View/basic_update/variables.tf
deleted file mode 100644
index 2a299e3bdb..0000000000
--- a/pkg/resources/testdata/TestAcc_View/basic_update/variables.tf
+++ /dev/null
@@ -1,55 +0,0 @@
-variable "name" {
-  type = string
-}
-
-variable "database" {
-  type = string
-}
-
-variable "schema" {
-  type = string
-}
-
-variable "statement" {
-  type = string
-}
-
-variable "row_access_policy" {
-  type = string
-}
-
-variable "row_access_policy_on" {
-  type = list(string)
-}
-
-variable "aggregation_policy" {
-  type = string
-}
-
-variable "aggregation_policy_entity_key" {
-  type = list(string)
-}
-
-variable "comment" {
-  type = string
-}
-
-variable "data_metric_schedule_using_cron" {
-  type = string
-}
-
-variable "data_metric_function" {
-  type = string
-}
-
-variable "data_metric_function_on" {
-  type = list(string)
-}
-
-variable "schedule_status" {
-  type = string
-}
-
-variable "column" {
-  type = set(map(string))
-}
diff --git a/pkg/resources/view_acceptance_test.go b/pkg/resources/view_acceptance_test.go
index 2db7a4d7a1..b64f342a1a 100644
--- a/pkg/resources/view_acceptance_test.go
+++ b/pkg/resources/view_acceptance_test.go
@@ -19,6 +19,7 @@ import (
 	"github.com/Snowflake-Labs/terraform-provider-snowflake/pkg/acceptance/testenvs"
 	"github.com/Snowflake-Labs/terraform-provider-snowflake/pkg/helpers"
 	"github.com/Snowflake-Labs/terraform-provider-snowflake/pkg/internal/collections"
+	"github.com/Snowflake-Labs/terraform-provider-snowflake/pkg/internal/provider"
 	"github.com/Snowflake-Labs/terraform-provider-snowflake/pkg/internal/snowflakeroles"
 	"github.com/Snowflake-Labs/terraform-provider-snowflake/pkg/provider/resources"
 	"github.com/Snowflake-Labs/terraform-provider-snowflake/pkg/sdk"
@@ -63,51 +64,26 @@ func TestAcc_View_basic(t *testing.T) {
 	otherStatement := fmt.Sprintf("SELECT foo, id FROM %s", table.ID().FullyQualifiedName())
 	comment := random.Comment()
 
-	// generators currently don't handle lists of objects, so use the old way
-	basicView := func(configStatement string) config.Variables {
-		return config.Variables{
-			"name":      config.StringVariable(id.Name()),
-			"database":  config.StringVariable(id.DatabaseName()),
-			"schema":    config.StringVariable(id.SchemaName()),
-			"statement": config.StringVariable(configStatement),
-			"column": config.SetVariable(
-				config.MapVariable(map[string]config.Variable{
-					"column_name": config.StringVariable("ID"),
-				}),
-				config.MapVariable(map[string]config.Variable{
-					"column_name": config.StringVariable("FOO"),
-				}),
-			),
-		}
-	}
-	basicViewWithIsRecursive := basicView(otherStatement)
-	basicViewWithIsRecursive["is_recursive"] = config.BoolVariable(true)
+	columnNames := []string{"ID", "FOO"}
+	basicViewModel := model.View("test", id.DatabaseName(), id.Name(), id.SchemaName(), statement).WithColumnNames(columnNames...)
+	viewModelRecursiveWithOtherStatement := model.View("test", id.DatabaseName(), id.Name(), id.SchemaName(), otherStatement).WithColumnNames(columnNames...).WithIsRecursive(provider.BooleanTrue)
+	viewModelWithOtherStatement := model.View("test", id.DatabaseName(), id.Name(), id.SchemaName(), otherStatement).WithColumnNames(columnNames...)
 
-	// generators currently don't handle lists of objects, so use the old way
-	basicUpdate := func(rap, ap, functionId sdk.SchemaObjectIdentifier, statement, cron string, scheduleStatus sdk.DataMetricScheduleStatusOption) config.Variables {
-		return config.Variables{
-			"name":                            config.StringVariable(id.Name()),
-			"database":                        config.StringVariable(id.DatabaseName()),
-			"schema":                          config.StringVariable(id.SchemaName()),
-			"statement":                       config.StringVariable(statement),
-			"row_access_policy":               config.StringVariable(rap.FullyQualifiedName()),
-			"row_access_policy_on":            config.ListVariable(config.StringVariable("ID")),
-			"aggregation_policy":              config.StringVariable(ap.FullyQualifiedName()),
-			"aggregation_policy_entity_key":   config.ListVariable(config.StringVariable("ID")),
-			"data_metric_function":            config.StringVariable(functionId.FullyQualifiedName()),
-			"data_metric_function_on":         config.ListVariable(config.StringVariable("ID")),
-			"data_metric_schedule_using_cron": config.StringVariable(cron),
-			"comment":                         config.StringVariable(comment),
-			"schedule_status":                 config.StringVariable(string(scheduleStatus)),
-			"column": config.SetVariable(
-				config.MapVariable(map[string]config.Variable{
-					"column_name": config.StringVariable("ID"),
-				}),
-				config.MapVariable(map[string]config.Variable{
-					"column_name": config.StringVariable("FOO"),
-				}),
-			),
-		}
+	updatedViewModel := func(
+		rowAccessPolicyId sdk.SchemaObjectIdentifier,
+		aggregationPolicyId sdk.SchemaObjectIdentifier,
+		dataMetricFunctionId sdk.SchemaObjectIdentifier,
+		statement string,
+		cron string,
+		scheduleStatus sdk.DataMetricScheduleStatusOption,
+	) *model.ViewModel {
+		return model.View("test", id.DatabaseName(), id.Name(), id.SchemaName(), statement).
+			WithRowAccessPolicy(rowAccessPolicyId, "ID").
+			WithAggregationPolicy(aggregationPolicyId, "ID").
+			WithDataMetricFunction(dataMetricFunctionId, "ID", scheduleStatus).
+			WithDataMetricSchedule(cron).
+			WithComment(comment).
+			WithColumnNames(columnNames...)
 	}
 
 	resource.Test(t, resource.TestCase{
@@ -119,10 +95,9 @@ func TestAcc_View_basic(t *testing.T) {
 		Steps: []resource.TestStep{
 			// without optionals
 			{
-				ConfigDirectory: acc.ConfigurationDirectory("TestAcc_View/basic"),
-				ConfigVariables: basicView(statement),
+				Config: accconfig.ResourceFromModel(t, basicViewModel),
 				Check: assert.AssertThat(t,
-					resourceassert.ViewResource(t, "snowflake_view.test").
+					resourceassert.ViewResource(t, basicViewModel.ResourceReference()).
 						HasNameString(id.Name()).
 						HasStatementString(statement).
 						HasDatabaseString(id.DatabaseName()).
@@ -132,10 +107,9 @@ func TestAcc_View_basic(t *testing.T) {
 			},
 			// import - without optionals
 			{
-				ConfigDirectory: acc.ConfigurationDirectory("TestAcc_View/basic"),
-				ConfigVariables: basicView(statement),
-				ResourceName:    "snowflake_view.test",
-				ImportState:     true,
+				Config:       accconfig.ResourceFromModel(t, basicViewModel),
+				ResourceName: basicViewModel.ResourceReference(),
+				ImportState:  true,
 				ImportStateCheck: assert.AssertThatImport(t,
 					resourceassert.ImportedViewResource(t, resourceId).
 						HasNameString(id.Name()).
@@ -158,10 +132,9 @@ func TestAcc_View_basic(t *testing.T) {
 						},
 					})))
 				},
-				ConfigDirectory: acc.ConfigurationDirectory("TestAcc_View/basic"),
-				ConfigVariables: basicView(statement),
+				Config: accconfig.ResourceFromModel(t, basicViewModel),
 				Check: assert.AssertThat(t,
-					resourceassert.ViewResource(t, "snowflake_view.test").
+					resourceassert.ViewResource(t, basicViewModel.ResourceReference()).
 						HasNameString(id.Name()).
 						HasStatementString(statement).
 						HasDatabaseString(id.DatabaseName()).
@@ -174,14 +147,13 @@ func TestAcc_View_basic(t *testing.T) {
 			},
 			// set other fields
 			{
-				ConfigDirectory: acc.ConfigurationDirectory("TestAcc_View/basic_update"),
-				ConfigVariables: basicUpdate(rowAccessPolicy.ID(), aggregationPolicy, functionId, statement, cron, sdk.DataMetricScheduleStatusStarted),
+				Config: accconfig.ResourceFromModel(t, updatedViewModel(rowAccessPolicy.ID(), aggregationPolicy, functionId, statement, cron, sdk.DataMetricScheduleStatusStarted)),
 				ConfigPlanChecks: resource.ConfigPlanChecks{
 					PreApply: []plancheck.PlanCheck{
-						plancheck.ExpectResourceAction("snowflake_view.test", plancheck.ResourceActionUpdate),
+						plancheck.ExpectResourceAction(basicViewModel.ResourceReference(), plancheck.ResourceActionUpdate),
 					},
 				},
-				Check: assert.AssertThat(t, resourceassert.ViewResource(t, "snowflake_view.test").
+				Check: assert.AssertThat(t, resourceassert.ViewResource(t, basicViewModel.ResourceReference()).
 					HasNameString(id.Name()).
 					HasStatementString(statement).
 					HasDatabaseString(id.DatabaseName()).
@@ -191,24 +163,23 @@ func TestAcc_View_basic(t *testing.T) {
 					HasRowAccessPolicyLength(1).
 					HasDataMetricScheduleLength(1).
 					HasDataMetricFunctionLength(1),
-					assert.Check(resource.TestCheckResourceAttr("snowflake_view.test", "aggregation_policy.0.policy_name", aggregationPolicy.FullyQualifiedName())),
-					assert.Check(resource.TestCheckResourceAttr("snowflake_view.test", "aggregation_policy.0.entity_key.#", "1")),
-					assert.Check(resource.TestCheckResourceAttr("snowflake_view.test", "aggregation_policy.0.entity_key.0", "ID")),
-					assert.Check(resource.TestCheckResourceAttr("snowflake_view.test", "row_access_policy.0.policy_name", rowAccessPolicy.ID().FullyQualifiedName())),
-					assert.Check(resource.TestCheckResourceAttr("snowflake_view.test", "row_access_policy.0.on.#", "1")),
-					assert.Check(resource.TestCheckResourceAttr("snowflake_view.test", "row_access_policy.0.on.0", "ID")),
-					assert.Check(resource.TestCheckResourceAttr("snowflake_view.test", "data_metric_schedule.0.using_cron", cron)),
-					assert.Check(resource.TestCheckResourceAttr("snowflake_view.test", "data_metric_schedule.0.minutes", "0")),
-					assert.Check(resource.TestCheckResourceAttr("snowflake_view.test", "data_metric_function.0.function_name", functionId.FullyQualifiedName())),
-					assert.Check(resource.TestCheckResourceAttr("snowflake_view.test", "data_metric_function.0.on.#", "1")),
-					assert.Check(resource.TestCheckResourceAttr("snowflake_view.test", "data_metric_function.0.on.0", "ID")),
+					assert.Check(resource.TestCheckResourceAttr(basicViewModel.ResourceReference(), "aggregation_policy.0.policy_name", aggregationPolicy.FullyQualifiedName())),
+					assert.Check(resource.TestCheckResourceAttr(basicViewModel.ResourceReference(), "aggregation_policy.0.entity_key.#", "1")),
+					assert.Check(resource.TestCheckResourceAttr(basicViewModel.ResourceReference(), "aggregation_policy.0.entity_key.0", "ID")),
+					assert.Check(resource.TestCheckResourceAttr(basicViewModel.ResourceReference(), "row_access_policy.0.policy_name", rowAccessPolicy.ID().FullyQualifiedName())),
+					assert.Check(resource.TestCheckResourceAttr(basicViewModel.ResourceReference(), "row_access_policy.0.on.#", "1")),
+					assert.Check(resource.TestCheckResourceAttr(basicViewModel.ResourceReference(), "row_access_policy.0.on.0", "ID")),
+					assert.Check(resource.TestCheckResourceAttr(basicViewModel.ResourceReference(), "data_metric_schedule.0.using_cron", cron)),
+					assert.Check(resource.TestCheckResourceAttr(basicViewModel.ResourceReference(), "data_metric_schedule.0.minutes", "0")),
+					assert.Check(resource.TestCheckResourceAttr(basicViewModel.ResourceReference(), "data_metric_function.0.function_name", functionId.FullyQualifiedName())),
+					assert.Check(resource.TestCheckResourceAttr(basicViewModel.ResourceReference(), "data_metric_function.0.on.#", "1")),
+					assert.Check(resource.TestCheckResourceAttr(basicViewModel.ResourceReference(), "data_metric_function.0.on.0", "ID")),
 				),
 			},
 			// change policies and dmfs
 			{
-				ConfigDirectory: acc.ConfigurationDirectory("TestAcc_View/basic_update"),
-				ConfigVariables: basicUpdate(rowAccessPolicy2.ID(), aggregationPolicy2, function2Id, statement, cron2, sdk.DataMetricScheduleStatusStarted),
-				Check: assert.AssertThat(t, resourceassert.ViewResource(t, "snowflake_view.test").
+				Config: accconfig.ResourceFromModel(t, updatedViewModel(rowAccessPolicy2.ID(), aggregationPolicy2, function2Id, statement, cron2, sdk.DataMetricScheduleStatusStarted)),
+				Check: assert.AssertThat(t, resourceassert.ViewResource(t, basicViewModel.ResourceReference()).
 					HasNameString(id.Name()).
 					HasStatementString(statement).
 					HasDatabaseString(id.DatabaseName()).
@@ -218,25 +189,24 @@ func TestAcc_View_basic(t *testing.T) {
 					HasRowAccessPolicyLength(1).
 					HasDataMetricScheduleLength(1).
 					HasDataMetricFunctionLength(1),
-					assert.Check(resource.TestCheckResourceAttr("snowflake_view.test", "aggregation_policy.0.policy_name", aggregationPolicy2.FullyQualifiedName())),
-					assert.Check(resource.TestCheckResourceAttr("snowflake_view.test", "aggregation_policy.0.entity_key.#", "1")),
-					assert.Check(resource.TestCheckResourceAttr("snowflake_view.test", "aggregation_policy.0.entity_key.0", "ID")),
-					assert.Check(resource.TestCheckResourceAttr("snowflake_view.test", "row_access_policy.0.policy_name", rowAccessPolicy2.ID().FullyQualifiedName())),
-					assert.Check(resource.TestCheckResourceAttr("snowflake_view.test", "row_access_policy.0.on.#", "1")),
-					assert.Check(resource.TestCheckResourceAttr("snowflake_view.test", "row_access_policy.0.on.0", "ID")),
-					assert.Check(resource.TestCheckResourceAttr("snowflake_view.test", "data_metric_schedule.0.using_cron", cron2)),
-					assert.Check(resource.TestCheckResourceAttr("snowflake_view.test", "data_metric_schedule.0.minutes", "0")),
-					assert.Check(resource.TestCheckResourceAttr("snowflake_view.test", "data_metric_function.0.schedule_status", string(sdk.DataMetricScheduleStatusStarted))),
-					assert.Check(resource.TestCheckResourceAttr("snowflake_view.test", "data_metric_function.0.function_name", function2Id.FullyQualifiedName())),
-					assert.Check(resource.TestCheckResourceAttr("snowflake_view.test", "data_metric_function.0.on.#", "1")),
-					assert.Check(resource.TestCheckResourceAttr("snowflake_view.test", "data_metric_function.0.on.0", "ID")),
+					assert.Check(resource.TestCheckResourceAttr(basicViewModel.ResourceReference(), "aggregation_policy.0.policy_name", aggregationPolicy2.FullyQualifiedName())),
+					assert.Check(resource.TestCheckResourceAttr(basicViewModel.ResourceReference(), "aggregation_policy.0.entity_key.#", "1")),
+					assert.Check(resource.TestCheckResourceAttr(basicViewModel.ResourceReference(), "aggregation_policy.0.entity_key.0", "ID")),
+					assert.Check(resource.TestCheckResourceAttr(basicViewModel.ResourceReference(), "row_access_policy.0.policy_name", rowAccessPolicy2.ID().FullyQualifiedName())),
+					assert.Check(resource.TestCheckResourceAttr(basicViewModel.ResourceReference(), "row_access_policy.0.on.#", "1")),
+					assert.Check(resource.TestCheckResourceAttr(basicViewModel.ResourceReference(), "row_access_policy.0.on.0", "ID")),
+					assert.Check(resource.TestCheckResourceAttr(basicViewModel.ResourceReference(), "data_metric_schedule.0.using_cron", cron2)),
+					assert.Check(resource.TestCheckResourceAttr(basicViewModel.ResourceReference(), "data_metric_schedule.0.minutes", "0")),
+					assert.Check(resource.TestCheckResourceAttr(basicViewModel.ResourceReference(), "data_metric_function.0.schedule_status", string(sdk.DataMetricScheduleStatusStarted))),
+					assert.Check(resource.TestCheckResourceAttr(basicViewModel.ResourceReference(), "data_metric_function.0.function_name", function2Id.FullyQualifiedName())),
+					assert.Check(resource.TestCheckResourceAttr(basicViewModel.ResourceReference(), "data_metric_function.0.on.#", "1")),
+					assert.Check(resource.TestCheckResourceAttr(basicViewModel.ResourceReference(), "data_metric_function.0.on.0", "ID")),
 				),
 			},
 			// change dmf status
 			{
-				ConfigDirectory: acc.ConfigurationDirectory("TestAcc_View/basic_update"),
-				ConfigVariables: basicUpdate(rowAccessPolicy2.ID(), aggregationPolicy2, function2Id, statement, cron2, sdk.DataMetricScheduleStatusSuspended),
-				Check: assert.AssertThat(t, resourceassert.ViewResource(t, "snowflake_view.test").
+				Config: accconfig.ResourceFromModel(t, updatedViewModel(rowAccessPolicy2.ID(), aggregationPolicy2, function2Id, statement, cron2, sdk.DataMetricScheduleStatusSuspended)),
+				Check: assert.AssertThat(t, resourceassert.ViewResource(t, basicViewModel.ResourceReference()).
 					HasNameString(id.Name()).
 					HasStatementString(statement).
 					HasDatabaseString(id.DatabaseName()).
@@ -246,25 +216,24 @@ func TestAcc_View_basic(t *testing.T) {
 					HasRowAccessPolicyLength(1).
 					HasDataMetricScheduleLength(1).
 					HasDataMetricFunctionLength(1),
-					assert.Check(resource.TestCheckResourceAttr("snowflake_view.test", "aggregation_policy.0.policy_name", aggregationPolicy2.FullyQualifiedName())),
-					assert.Check(resource.TestCheckResourceAttr("snowflake_view.test", "aggregation_policy.0.entity_key.#", "1")),
-					assert.Check(resource.TestCheckResourceAttr("snowflake_view.test", "aggregation_policy.0.entity_key.0", "ID")),
-					assert.Check(resource.TestCheckResourceAttr("snowflake_view.test", "row_access_policy.0.policy_name", rowAccessPolicy2.ID().FullyQualifiedName())),
-					assert.Check(resource.TestCheckResourceAttr("snowflake_view.test", "row_access_policy.0.on.#", "1")),
-					assert.Check(resource.TestCheckResourceAttr("snowflake_view.test", "row_access_policy.0.on.0", "ID")),
-					assert.Check(resource.TestCheckResourceAttr("snowflake_view.test", "data_metric_schedule.0.using_cron", cron2)),
-					assert.Check(resource.TestCheckResourceAttr("snowflake_view.test", "data_metric_schedule.0.minutes", "0")),
-					assert.Check(resource.TestCheckResourceAttr("snowflake_view.test", "data_metric_function.0.schedule_status", string(sdk.DataMetricScheduleStatusSuspended))),
-					assert.Check(resource.TestCheckResourceAttr("snowflake_view.test", "data_metric_function.0.function_name", function2Id.FullyQualifiedName())),
-					assert.Check(resource.TestCheckResourceAttr("snowflake_view.test", "data_metric_function.0.on.#", "1")),
-					assert.Check(resource.TestCheckResourceAttr("snowflake_view.test", "data_metric_function.0.on.0", "ID")),
+					assert.Check(resource.TestCheckResourceAttr(basicViewModel.ResourceReference(), "aggregation_policy.0.policy_name", aggregationPolicy2.FullyQualifiedName())),
+					assert.Check(resource.TestCheckResourceAttr(basicViewModel.ResourceReference(), "aggregation_policy.0.entity_key.#", "1")),
+					assert.Check(resource.TestCheckResourceAttr(basicViewModel.ResourceReference(), "aggregation_policy.0.entity_key.0", "ID")),
+					assert.Check(resource.TestCheckResourceAttr(basicViewModel.ResourceReference(), "row_access_policy.0.policy_name", rowAccessPolicy2.ID().FullyQualifiedName())),
+					assert.Check(resource.TestCheckResourceAttr(basicViewModel.ResourceReference(), "row_access_policy.0.on.#", "1")),
+					assert.Check(resource.TestCheckResourceAttr(basicViewModel.ResourceReference(), "row_access_policy.0.on.0", "ID")),
+					assert.Check(resource.TestCheckResourceAttr(basicViewModel.ResourceReference(), "data_metric_schedule.0.using_cron", cron2)),
+					assert.Check(resource.TestCheckResourceAttr(basicViewModel.ResourceReference(), "data_metric_schedule.0.minutes", "0")),
+					assert.Check(resource.TestCheckResourceAttr(basicViewModel.ResourceReference(), "data_metric_function.0.schedule_status", string(sdk.DataMetricScheduleStatusSuspended))),
+					assert.Check(resource.TestCheckResourceAttr(basicViewModel.ResourceReference(), "data_metric_function.0.function_name", function2Id.FullyQualifiedName())),
+					assert.Check(resource.TestCheckResourceAttr(basicViewModel.ResourceReference(), "data_metric_function.0.on.#", "1")),
+					assert.Check(resource.TestCheckResourceAttr(basicViewModel.ResourceReference(), "data_metric_function.0.on.0", "ID")),
 				),
 			},
 			// change statement and policies
 			{
-				ConfigDirectory: acc.ConfigurationDirectory("TestAcc_View/basic_update"),
-				ConfigVariables: basicUpdate(rowAccessPolicy.ID(), aggregationPolicy, functionId, otherStatement, cron, sdk.DataMetricScheduleStatusStarted),
-				Check: assert.AssertThat(t, resourceassert.ViewResource(t, "snowflake_view.test").
+				Config: accconfig.ResourceFromModel(t, updatedViewModel(rowAccessPolicy.ID(), aggregationPolicy, functionId, otherStatement, cron, sdk.DataMetricScheduleStatusStarted)),
+				Check: assert.AssertThat(t, resourceassert.ViewResource(t, basicViewModel.ResourceReference()).
 					HasNameString(id.Name()).
 					HasStatementString(otherStatement).
 					HasDatabaseString(id.DatabaseName()).
@@ -274,17 +243,17 @@ func TestAcc_View_basic(t *testing.T) {
 					HasRowAccessPolicyLength(1).
 					HasDataMetricScheduleLength(1).
 					HasDataMetricFunctionLength(1),
-					assert.Check(resource.TestCheckResourceAttr("snowflake_view.test", "aggregation_policy.0.policy_name", aggregationPolicy.FullyQualifiedName())),
-					assert.Check(resource.TestCheckResourceAttr("snowflake_view.test", "aggregation_policy.0.entity_key.#", "1")),
-					assert.Check(resource.TestCheckResourceAttr("snowflake_view.test", "aggregation_policy.0.entity_key.0", "ID")),
-					assert.Check(resource.TestCheckResourceAttr("snowflake_view.test", "row_access_policy.0.policy_name", rowAccessPolicy.ID().FullyQualifiedName())),
-					assert.Check(resource.TestCheckResourceAttr("snowflake_view.test", "row_access_policy.0.on.#", "1")),
-					assert.Check(resource.TestCheckResourceAttr("snowflake_view.test", "row_access_policy.0.on.0", "ID")),
-					assert.Check(resource.TestCheckResourceAttr("snowflake_view.test", "data_metric_schedule.0.using_cron", cron)),
-					assert.Check(resource.TestCheckResourceAttr("snowflake_view.test", "data_metric_schedule.0.minutes", "0")),
-					assert.Check(resource.TestCheckResourceAttr("snowflake_view.test", "data_metric_function.0.function_name", functionId.FullyQualifiedName())),
-					assert.Check(resource.TestCheckResourceAttr("snowflake_view.test", "data_metric_function.0.on.#", "1")),
-					assert.Check(resource.TestCheckResourceAttr("snowflake_view.test", "data_metric_function.0.on.0", "ID")),
+					assert.Check(resource.TestCheckResourceAttr(basicViewModel.ResourceReference(), "aggregation_policy.0.policy_name", aggregationPolicy.FullyQualifiedName())),
+					assert.Check(resource.TestCheckResourceAttr(basicViewModel.ResourceReference(), "aggregation_policy.0.entity_key.#", "1")),
+					assert.Check(resource.TestCheckResourceAttr(basicViewModel.ResourceReference(), "aggregation_policy.0.entity_key.0", "ID")),
+					assert.Check(resource.TestCheckResourceAttr(basicViewModel.ResourceReference(), "row_access_policy.0.policy_name", rowAccessPolicy.ID().FullyQualifiedName())),
+					assert.Check(resource.TestCheckResourceAttr(basicViewModel.ResourceReference(), "row_access_policy.0.on.#", "1")),
+					assert.Check(resource.TestCheckResourceAttr(basicViewModel.ResourceReference(), "row_access_policy.0.on.0", "ID")),
+					assert.Check(resource.TestCheckResourceAttr(basicViewModel.ResourceReference(), "data_metric_schedule.0.using_cron", cron)),
+					assert.Check(resource.TestCheckResourceAttr(basicViewModel.ResourceReference(), "data_metric_schedule.0.minutes", "0")),
+					assert.Check(resource.TestCheckResourceAttr(basicViewModel.ResourceReference(), "data_metric_function.0.function_name", functionId.FullyQualifiedName())),
+					assert.Check(resource.TestCheckResourceAttr(basicViewModel.ResourceReference(), "data_metric_function.0.on.#", "1")),
+					assert.Check(resource.TestCheckResourceAttr(basicViewModel.ResourceReference(), "data_metric_function.0.on.0", "ID")),
 				),
 			},
 			// change statements externally
@@ -292,9 +261,8 @@ func TestAcc_View_basic(t *testing.T) {
 				PreConfig: func() {
 					acc.TestClient().View.RecreateView(t, id, statement)
 				},
-				ConfigDirectory: acc.ConfigurationDirectory("TestAcc_View/basic_update"),
-				ConfigVariables: basicUpdate(rowAccessPolicy.ID(), aggregationPolicy, functionId, otherStatement, cron, sdk.DataMetricScheduleStatusStarted),
-				Check: assert.AssertThat(t, resourceassert.ViewResource(t, "snowflake_view.test").
+				Config: accconfig.ResourceFromModel(t, updatedViewModel(rowAccessPolicy.ID(), aggregationPolicy, functionId, otherStatement, cron, sdk.DataMetricScheduleStatusStarted)),
+				Check: assert.AssertThat(t, resourceassert.ViewResource(t, basicViewModel.ResourceReference()).
 					HasNameString(id.Name()).
 					HasStatementString(otherStatement).
 					HasDatabaseString(id.DatabaseName()).
@@ -304,17 +272,17 @@ func TestAcc_View_basic(t *testing.T) {
 					HasRowAccessPolicyLength(1).
 					HasDataMetricScheduleLength(1).
 					HasDataMetricFunctionLength(1),
-					assert.Check(resource.TestCheckResourceAttr("snowflake_view.test", "aggregation_policy.0.policy_name", aggregationPolicy.FullyQualifiedName())),
-					assert.Check(resource.TestCheckResourceAttr("snowflake_view.test", "aggregation_policy.0.entity_key.#", "1")),
-					assert.Check(resource.TestCheckResourceAttr("snowflake_view.test", "aggregation_policy.0.entity_key.0", "ID")),
-					assert.Check(resource.TestCheckResourceAttr("snowflake_view.test", "row_access_policy.0.policy_name", rowAccessPolicy.ID().FullyQualifiedName())),
-					assert.Check(resource.TestCheckResourceAttr("snowflake_view.test", "row_access_policy.0.on.#", "1")),
-					assert.Check(resource.TestCheckResourceAttr("snowflake_view.test", "row_access_policy.0.on.0", "ID")),
-					assert.Check(resource.TestCheckResourceAttr("snowflake_view.test", "data_metric_schedule.0.using_cron", cron)),
-					assert.Check(resource.TestCheckResourceAttr("snowflake_view.test", "data_metric_schedule.0.minutes", "0")),
-					assert.Check(resource.TestCheckResourceAttr("snowflake_view.test", "data_metric_function.0.function_name", functionId.FullyQualifiedName())),
-					assert.Check(resource.TestCheckResourceAttr("snowflake_view.test", "data_metric_function.0.on.#", "1")),
-					assert.Check(resource.TestCheckResourceAttr("snowflake_view.test", "data_metric_function.0.on.0", "ID")),
+					assert.Check(resource.TestCheckResourceAttr(basicViewModel.ResourceReference(), "aggregation_policy.0.policy_name", aggregationPolicy.FullyQualifiedName())),
+					assert.Check(resource.TestCheckResourceAttr(basicViewModel.ResourceReference(), "aggregation_policy.0.entity_key.#", "1")),
+					assert.Check(resource.TestCheckResourceAttr(basicViewModel.ResourceReference(), "aggregation_policy.0.entity_key.0", "ID")),
+					assert.Check(resource.TestCheckResourceAttr(basicViewModel.ResourceReference(), "row_access_policy.0.policy_name", rowAccessPolicy.ID().FullyQualifiedName())),
+					assert.Check(resource.TestCheckResourceAttr(basicViewModel.ResourceReference(), "row_access_policy.0.on.#", "1")),
+					assert.Check(resource.TestCheckResourceAttr(basicViewModel.ResourceReference(), "row_access_policy.0.on.0", "ID")),
+					assert.Check(resource.TestCheckResourceAttr(basicViewModel.ResourceReference(), "data_metric_schedule.0.using_cron", cron)),
+					assert.Check(resource.TestCheckResourceAttr(basicViewModel.ResourceReference(), "data_metric_schedule.0.minutes", "0")),
+					assert.Check(resource.TestCheckResourceAttr(basicViewModel.ResourceReference(), "data_metric_function.0.function_name", functionId.FullyQualifiedName())),
+					assert.Check(resource.TestCheckResourceAttr(basicViewModel.ResourceReference(), "data_metric_function.0.on.#", "1")),
+					assert.Check(resource.TestCheckResourceAttr(basicViewModel.ResourceReference(), "data_metric_function.0.on.0", "ID")),
 				),
 			},
 			// unset policies externally
@@ -323,9 +291,8 @@ func TestAcc_View_basic(t *testing.T) {
 					acc.TestClient().View.Alter(t, sdk.NewAlterViewRequest(id).WithDropAllRowAccessPolicies(true))
 					acc.TestClient().View.Alter(t, sdk.NewAlterViewRequest(id).WithUnsetAggregationPolicy(*sdk.NewViewUnsetAggregationPolicyRequest()))
 				},
-				ConfigDirectory: acc.ConfigurationDirectory("TestAcc_View/basic_update"),
-				ConfigVariables: basicUpdate(rowAccessPolicy.ID(), aggregationPolicy, functionId, otherStatement, cron, sdk.DataMetricScheduleStatusStarted),
-				Check: assert.AssertThat(t, resourceassert.ViewResource(t, "snowflake_view.test").
+				Config: accconfig.ResourceFromModel(t, updatedViewModel(rowAccessPolicy.ID(), aggregationPolicy, functionId, otherStatement, cron, sdk.DataMetricScheduleStatusStarted)),
+				Check: assert.AssertThat(t, resourceassert.ViewResource(t, basicViewModel.ResourceReference()).
 					HasNameString(id.Name()).
 					HasStatementString(otherStatement).
 					HasDatabaseString(id.DatabaseName()).
@@ -335,25 +302,24 @@ func TestAcc_View_basic(t *testing.T) {
 					HasRowAccessPolicyLength(1).
 					HasDataMetricScheduleLength(1).
 					HasDataMetricFunctionLength(1),
-					assert.Check(resource.TestCheckResourceAttr("snowflake_view.test", "aggregation_policy.0.policy_name", aggregationPolicy.FullyQualifiedName())),
-					assert.Check(resource.TestCheckResourceAttr("snowflake_view.test", "aggregation_policy.0.entity_key.#", "1")),
-					assert.Check(resource.TestCheckResourceAttr("snowflake_view.test", "aggregation_policy.0.entity_key.0", "ID")),
-					assert.Check(resource.TestCheckResourceAttr("snowflake_view.test", "row_access_policy.0.policy_name", rowAccessPolicy.ID().FullyQualifiedName())),
-					assert.Check(resource.TestCheckResourceAttr("snowflake_view.test", "row_access_policy.0.on.#", "1")),
-					assert.Check(resource.TestCheckResourceAttr("snowflake_view.test", "row_access_policy.0.on.0", "ID")),
-					assert.Check(resource.TestCheckResourceAttr("snowflake_view.test", "data_metric_schedule.0.using_cron", cron)),
-					assert.Check(resource.TestCheckResourceAttr("snowflake_view.test", "data_metric_schedule.0.minutes", "0")),
-					assert.Check(resource.TestCheckResourceAttr("snowflake_view.test", "data_metric_function.0.function_name", functionId.FullyQualifiedName())),
-					assert.Check(resource.TestCheckResourceAttr("snowflake_view.test", "data_metric_function.0.on.#", "1")),
-					assert.Check(resource.TestCheckResourceAttr("snowflake_view.test", "data_metric_function.0.on.0", "ID")),
+					assert.Check(resource.TestCheckResourceAttr(basicViewModel.ResourceReference(), "aggregation_policy.0.policy_name", aggregationPolicy.FullyQualifiedName())),
+					assert.Check(resource.TestCheckResourceAttr(basicViewModel.ResourceReference(), "aggregation_policy.0.entity_key.#", "1")),
+					assert.Check(resource.TestCheckResourceAttr(basicViewModel.ResourceReference(), "aggregation_policy.0.entity_key.0", "ID")),
+					assert.Check(resource.TestCheckResourceAttr(basicViewModel.ResourceReference(), "row_access_policy.0.policy_name", rowAccessPolicy.ID().FullyQualifiedName())),
+					assert.Check(resource.TestCheckResourceAttr(basicViewModel.ResourceReference(), "row_access_policy.0.on.#", "1")),
+					assert.Check(resource.TestCheckResourceAttr(basicViewModel.ResourceReference(), "row_access_policy.0.on.0", "ID")),
+					assert.Check(resource.TestCheckResourceAttr(basicViewModel.ResourceReference(), "data_metric_schedule.0.using_cron", cron)),
+					assert.Check(resource.TestCheckResourceAttr(basicViewModel.ResourceReference(), "data_metric_schedule.0.minutes", "0")),
+					assert.Check(resource.TestCheckResourceAttr(basicViewModel.ResourceReference(), "data_metric_function.0.function_name", functionId.FullyQualifiedName())),
+					assert.Check(resource.TestCheckResourceAttr(basicViewModel.ResourceReference(), "data_metric_function.0.on.#", "1")),
+					assert.Check(resource.TestCheckResourceAttr(basicViewModel.ResourceReference(), "data_metric_function.0.on.0", "ID")),
 				),
 			},
 			// import - with optionals
 			{
-				ConfigDirectory: acc.ConfigurationDirectory("TestAcc_View/basic_update"),
-				ConfigVariables: basicUpdate(rowAccessPolicy.ID(), aggregationPolicy, functionId, otherStatement, cron, sdk.DataMetricScheduleStatusStarted),
-				ResourceName:    "snowflake_view.test",
-				ImportState:     true,
+				Config:       accconfig.ResourceFromModel(t, updatedViewModel(rowAccessPolicy.ID(), aggregationPolicy, functionId, otherStatement, cron, sdk.DataMetricScheduleStatusStarted)),
+				ResourceName: basicViewModel.ResourceReference(),
+				ImportState:  true,
 				ImportStateCheck: assert.AssertThatImport(t, assert.CheckImport(importchecks.TestCheckResourceAttrInstanceState(resourceId, "name", id.Name())),
 					resourceassert.ImportedViewResource(t, resourceId).
 						HasNameString(id.Name()).
@@ -376,10 +342,9 @@ func TestAcc_View_basic(t *testing.T) {
 			},
 			// unset
 			{
-				ConfigDirectory: acc.ConfigurationDirectory("TestAcc_View/basic"),
-				ConfigVariables: basicView(otherStatement),
-				ResourceName:    "snowflake_view.test",
-				Check: assert.AssertThat(t, resourceassert.ViewResource(t, "snowflake_view.test").
+				Config:       accconfig.ResourceFromModel(t, viewModelWithOtherStatement),
+				ResourceName: basicViewModel.ResourceReference(),
+				Check: assert.AssertThat(t, resourceassert.ViewResource(t, basicViewModel.ResourceReference()).
 					HasNameString(id.Name()).
 					HasStatementString(otherStatement).
 					HasDatabaseString(id.DatabaseName()).
@@ -393,9 +358,8 @@ func TestAcc_View_basic(t *testing.T) {
 			},
 			// recreate - change is_recursive
 			{
-				ConfigDirectory: acc.ConfigurationDirectory("TestAcc_View/basic_is_recursive"),
-				ConfigVariables: basicViewWithIsRecursive,
-				Check: assert.AssertThat(t, resourceassert.ViewResource(t, "snowflake_view.test").
+				Config: accconfig.ResourceFromModel(t, viewModelRecursiveWithOtherStatement),
+				Check: assert.AssertThat(t, resourceassert.ViewResource(t, basicViewModel.ResourceReference()).
 					HasNameString(id.Name()).
 					HasStatementString(otherStatement).
 					HasDatabaseString(id.DatabaseName()).
diff --git a/v1-preparations/LIST_OF_PREVIEW_FEATURES_FOR_V1.md b/v1-preparations/LIST_OF_PREVIEW_FEATURES_FOR_V1.md
index 1f51a82107..dcb77aa33d 100644
--- a/v1-preparations/LIST_OF_PREVIEW_FEATURES_FOR_V1.md
+++ b/v1-preparations/LIST_OF_PREVIEW_FEATURES_FOR_V1.md
@@ -7,6 +7,7 @@
 * [snowflake_api_integration](https://registry.terraform.io/providers/Snowflake-Labs/snowflake/0.97.0/docs/resources/api_integration)
 * [snowflake_cortex_search_service](https://registry.terraform.io/providers/Snowflake-Labs/snowflake/0.97.0/docs/resources/cortex_search_service)
 * [snowflake_cortex_search_services](https://registry.terraform.io/providers/Snowflake-Labs/snowflake/0.97.0/docs/data-sources/cortex_search_services) (datasource)
+* [snowflake_current_role](https://registry.terraform.io/providers/Snowflake-Labs/snowflake/0.97.0/docs/data-sources/current_role) (datasource)
 * [snowflake_database](https://registry.terraform.io/providers/Snowflake-Labs/snowflake/0.97.0/docs/data-sources/database) (datasource)
 * [snowflake_database_role](https://registry.terraform.io/providers/Snowflake-Labs/snowflake/0.97.0/docs/data-sources/database_role) (datasource)
 * [snowflake_dynamic_table](https://registry.terraform.io/providers/Snowflake-Labs/snowflake/0.97.0/docs/resources/dynamic_table)
@@ -30,7 +31,6 @@
 * [snowflake_password_policy](https://registry.terraform.io/providers/Snowflake-Labs/snowflake/0.97.0/docs/resources/password_policy)
 * [snowflake_pipe](https://registry.terraform.io/providers/Snowflake-Labs/snowflake/0.97.0/docs/resources/pipe)
 * [snowflake_pipes](https://registry.terraform.io/providers/Snowflake-Labs/snowflake/0.97.0/docs/data-sources/pipes) (datasource)
-* [snowflake_current_role](https://registry.terraform.io/providers/Snowflake-Labs/snowflake/0.97.0/docs/data-sources/current_role) (datasource)
 * [snowflake_sequence](https://registry.terraform.io/providers/Snowflake-Labs/snowflake/0.97.0/docs/resources/sequence)
 * [snowflake_sequences](https://registry.terraform.io/providers/Snowflake-Labs/snowflake/0.97.0/docs/data-sources/sequences) (datasource)
 * [snowflake_share](https://registry.terraform.io/providers/Snowflake-Labs/snowflake/0.97.0/docs/resources/share)