diff --git a/pkg/acceptance/bettertestspoc/assert/objectassert/task_snowflake_ext.go b/pkg/acceptance/bettertestspoc/assert/objectassert/task_snowflake_ext.go new file mode 100644 index 00000000000..6230dfd2552 --- /dev/null +++ b/pkg/acceptance/bettertestspoc/assert/objectassert/task_snowflake_ext.go @@ -0,0 +1,68 @@ +package objectassert + +import ( + "errors" + "fmt" + "github.com/Snowflake-Labs/terraform-provider-snowflake/pkg/sdk" + "reflect" + "slices" + "testing" +) + +func (w *TaskAssert) HasNotEmptyCreatedOn() *TaskAssert { + w.AddAssertion(func(t *testing.T, o *sdk.Task) error { + t.Helper() + if o.CreatedOn == "" { + return fmt.Errorf("expected created on not empty; got: %v", o.CreatedOn) + } + return nil + }) + return w +} + +func (w *TaskAssert) HasNotEmptyId() *TaskAssert { + w.AddAssertion(func(t *testing.T, o *sdk.Task) error { + t.Helper() + if o.Id == "" { + return fmt.Errorf("expected id not empty; got: %v", o.CreatedOn) + } + return nil + }) + return w +} + +func (w *TaskAssert) HasPredecessors(ids ...sdk.SchemaObjectIdentifier) *TaskAssert { + w.AddAssertion(func(t *testing.T, o *sdk.Task) error { + t.Helper() + if len(o.Predecessors) != len(ids) { + return fmt.Errorf("expected %d (%v) predecessors, got %d (%v)", len(ids), ids, len(o.Predecessors), o.Predecessors) + } + var errs []error + for _, id := range ids { + if !slices.ContainsFunc(o.Predecessors, func(predecessorId sdk.SchemaObjectIdentifier) bool { + return predecessorId.FullyQualifiedName() == id.FullyQualifiedName() + }) { + errs = append(errs, fmt.Errorf("expected id: %s, to be in the list of predecessors: %v", id.FullyQualifiedName(), o.Predecessors)) + } + } + return errors.Join(errs...) + }) + return w +} + +func (t *TaskAssert) HasTaskRelations(expected sdk.TaskRelations) *TaskAssert { + t.AddAssertion(func(t *testing.T, o *sdk.Task) error { + t.Helper() + if slices.EqualFunc(o.TaskRelations.Predecessors, expected.Predecessors, func(id sdk.SchemaObjectIdentifier, id2 sdk.SchemaObjectIdentifier) bool { + return id.FullyQualifiedName() == id2.FullyQualifiedName() + }) { + return fmt.Errorf("expected task predecessors: %v; got: %v", expected.Predecessors, o.TaskRelations.Predecessors) + } + + if !reflect.DeepEqual(expected.FinalizerTask, o.TaskRelations.FinalizerTask) { + return fmt.Errorf("expected finalizer task: %v; got: %v", expected.FinalizerTask, o.TaskRelations.FinalizerTask) + } + return nil + }) + return t +} diff --git a/pkg/acceptance/bettertestspoc/assert/objectassert/task_snowflake_gen.go b/pkg/acceptance/bettertestspoc/assert/objectassert/task_snowflake_gen.go new file mode 100644 index 00000000000..4f3674e8b5e --- /dev/null +++ b/pkg/acceptance/bettertestspoc/assert/objectassert/task_snowflake_gen.go @@ -0,0 +1,251 @@ +// Code generated by assertions generator; DO NOT EDIT. + +package objectassert + +import ( + "fmt" + "testing" + + acc "github.com/Snowflake-Labs/terraform-provider-snowflake/pkg/acceptance" + + "github.com/Snowflake-Labs/terraform-provider-snowflake/pkg/acceptance/bettertestspoc/assert" + "github.com/Snowflake-Labs/terraform-provider-snowflake/pkg/sdk" +) + +type TaskAssert struct { + *assert.SnowflakeObjectAssert[sdk.Task, sdk.SchemaObjectIdentifier] +} + +func Task(t *testing.T, id sdk.SchemaObjectIdentifier) *TaskAssert { + t.Helper() + return &TaskAssert{ + assert.NewSnowflakeObjectAssertWithProvider(sdk.ObjectTypeTask, id, acc.TestClient().Task.Show), + } +} + +func TaskFromObject(t *testing.T, task *sdk.Task) *TaskAssert { + t.Helper() + return &TaskAssert{ + assert.NewSnowflakeObjectAssertWithObject(sdk.ObjectTypeTask, task.ID(), task), + } +} + +func (t *TaskAssert) HasCreatedOn(expected string) *TaskAssert { + t.AddAssertion(func(t *testing.T, o *sdk.Task) error { + t.Helper() + if o.CreatedOn != expected { + return fmt.Errorf("expected created on: %v; got: %v", expected, o.CreatedOn) + } + return nil + }) + return t +} + +func (t *TaskAssert) HasName(expected string) *TaskAssert { + t.AddAssertion(func(t *testing.T, o *sdk.Task) error { + t.Helper() + if o.Name != expected { + return fmt.Errorf("expected name: %v; got: %v", expected, o.Name) + } + return nil + }) + return t +} + +func (t *TaskAssert) HasId(expected string) *TaskAssert { + t.AddAssertion(func(t *testing.T, o *sdk.Task) error { + t.Helper() + if o.Id != expected { + return fmt.Errorf("expected id: %v; got: %v", expected, o.Id) + } + return nil + }) + return t +} + +func (t *TaskAssert) HasDatabaseName(expected string) *TaskAssert { + t.AddAssertion(func(t *testing.T, o *sdk.Task) error { + t.Helper() + if o.DatabaseName != expected { + return fmt.Errorf("expected database name: %v; got: %v", expected, o.DatabaseName) + } + return nil + }) + return t +} + +func (t *TaskAssert) HasSchemaName(expected string) *TaskAssert { + t.AddAssertion(func(t *testing.T, o *sdk.Task) error { + t.Helper() + if o.SchemaName != expected { + return fmt.Errorf("expected schema name: %v; got: %v", expected, o.SchemaName) + } + return nil + }) + return t +} + +func (t *TaskAssert) HasOwner(expected string) *TaskAssert { + t.AddAssertion(func(t *testing.T, o *sdk.Task) error { + t.Helper() + if o.Owner != expected { + return fmt.Errorf("expected owner: %v; got: %v", expected, o.Owner) + } + return nil + }) + return t +} + +func (t *TaskAssert) HasComment(expected string) *TaskAssert { + t.AddAssertion(func(t *testing.T, o *sdk.Task) error { + t.Helper() + if o.Comment != expected { + return fmt.Errorf("expected comment: %v; got: %v", expected, o.Comment) + } + return nil + }) + return t +} + +func (t *TaskAssert) HasWarehouse(expected string) *TaskAssert { + t.AddAssertion(func(t *testing.T, o *sdk.Task) error { + t.Helper() + if o.Warehouse != expected { + return fmt.Errorf("expected warehouse: %v; got: %v", expected, o.Warehouse) + } + return nil + }) + return t +} + +func (t *TaskAssert) HasSchedule(expected string) *TaskAssert { + t.AddAssertion(func(t *testing.T, o *sdk.Task) error { + t.Helper() + if o.Schedule != expected { + return fmt.Errorf("expected schedule: %v; got: %v", expected, o.Schedule) + } + return nil + }) + return t +} + +func (t *TaskAssert) HasState(expected sdk.TaskState) *TaskAssert { + t.AddAssertion(func(t *testing.T, o *sdk.Task) error { + t.Helper() + if o.State != expected { + return fmt.Errorf("expected state: %v; got: %v", expected, o.State) + } + return nil + }) + return t +} + +func (t *TaskAssert) HasDefinition(expected string) *TaskAssert { + t.AddAssertion(func(t *testing.T, o *sdk.Task) error { + t.Helper() + if o.Definition != expected { + return fmt.Errorf("expected definition: %v; got: %v", expected, o.Definition) + } + return nil + }) + return t +} + +func (t *TaskAssert) HasCondition(expected string) *TaskAssert { + t.AddAssertion(func(t *testing.T, o *sdk.Task) error { + t.Helper() + if o.Condition != expected { + return fmt.Errorf("expected condition: %v; got: %v", expected, o.Condition) + } + return nil + }) + return t +} + +func (t *TaskAssert) HasAllowOverlappingExecution(expected bool) *TaskAssert { + t.AddAssertion(func(t *testing.T, o *sdk.Task) error { + t.Helper() + if o.AllowOverlappingExecution != expected { + return fmt.Errorf("expected allow overlapping execution: %v; got: %v", expected, o.AllowOverlappingExecution) + } + return nil + }) + return t +} + +func (t *TaskAssert) HasErrorIntegration(expected string) *TaskAssert { + t.AddAssertion(func(t *testing.T, o *sdk.Task) error { + t.Helper() + if o.ErrorIntegration != expected { + return fmt.Errorf("expected error integration: %v; got: %v", expected, o.ErrorIntegration) + } + return nil + }) + return t +} + +func (t *TaskAssert) HasLastCommittedOn(expected string) *TaskAssert { + t.AddAssertion(func(t *testing.T, o *sdk.Task) error { + t.Helper() + if o.LastCommittedOn != expected { + return fmt.Errorf("expected last committed on: %v; got: %v", expected, o.LastCommittedOn) + } + return nil + }) + return t +} + +func (t *TaskAssert) HasLastSuspendedOn(expected string) *TaskAssert { + t.AddAssertion(func(t *testing.T, o *sdk.Task) error { + t.Helper() + if o.LastSuspendedOn != expected { + return fmt.Errorf("expected last suspended on: %v; got: %v", expected, o.LastSuspendedOn) + } + return nil + }) + return t +} + +func (t *TaskAssert) HasOwnerRoleType(expected string) *TaskAssert { + t.AddAssertion(func(t *testing.T, o *sdk.Task) error { + t.Helper() + if o.OwnerRoleType != expected { + return fmt.Errorf("expected owner role type: %v; got: %v", expected, o.OwnerRoleType) + } + return nil + }) + return t +} + +func (t *TaskAssert) HasConfig(expected string) *TaskAssert { + t.AddAssertion(func(t *testing.T, o *sdk.Task) error { + t.Helper() + if o.Config != expected { + return fmt.Errorf("expected config: %v; got: %v", expected, o.Config) + } + return nil + }) + return t +} + +func (t *TaskAssert) HasBudget(expected string) *TaskAssert { + t.AddAssertion(func(t *testing.T, o *sdk.Task) error { + t.Helper() + if o.Budget != expected { + return fmt.Errorf("expected budget: %v; got: %v", expected, o.Budget) + } + return nil + }) + return t +} + +func (t *TaskAssert) HasLastSuspendedReason(expected string) *TaskAssert { + t.AddAssertion(func(t *testing.T, o *sdk.Task) error { + t.Helper() + if o.LastSuspendedReason != expected { + return fmt.Errorf("expected last suspended reason: %v; got: %v", expected, o.LastSuspendedReason) + } + return nil + }) + return t +} diff --git a/pkg/acceptance/bettertestspoc/assert/resourceparametersassert/database_resource_parameters_gen.go b/pkg/acceptance/bettertestspoc/assert/resourceparametersassert/database_resource_parameters_gen.go new file mode 100644 index 00000000000..97cf0ea7e87 --- /dev/null +++ b/pkg/acceptance/bettertestspoc/assert/resourceparametersassert/database_resource_parameters_gen.go @@ -0,0 +1,202 @@ +// Code generated by assertions generator; DO NOT EDIT. + +package resourceparametersassert + +import ( + "testing" + + "github.com/Snowflake-Labs/terraform-provider-snowflake/pkg/acceptance/bettertestspoc/assert" + "github.com/Snowflake-Labs/terraform-provider-snowflake/pkg/sdk" +) + +type DatabaseResourceParametersAssert struct { + *assert.ResourceAssert +} + +func DatabaseResourceParameters(t *testing.T, name string) *DatabaseResourceParametersAssert { + t.Helper() + + d := DatabaseResourceParametersAssert{ + ResourceAssert: assert.NewResourceAssert(name, "parameters"), + } + d.AddAssertion(assert.ValueSet("parameters.#", "1")) + return &d +} + +func ImportedDatabaseResourceParameters(t *testing.T, id string) *DatabaseResourceParametersAssert { + t.Helper() + + d := DatabaseResourceParametersAssert{ + ResourceAssert: assert.NewImportedResourceAssert(id, "imported parameters"), + } + d.AddAssertion(assert.ValueSet("parameters.#", "1")) + return &d +} + +//////////////////////////// +// Parameter value checks // +//////////////////////////// + +func (d *DatabaseResourceParametersAssert) HasDataRetentionTimeInDays(expected int) *DatabaseResourceParametersAssert { + d.AddAssertion(assert.ResourceParameterIntValueSet(sdk.DatabaseParameterDataRetentionTimeInDays, expected)) + return d +} + +func (d *DatabaseResourceParametersAssert) HasMaxDataExtensionTimeInDays(expected int) *DatabaseResourceParametersAssert { + d.AddAssertion(assert.ResourceParameterIntValueSet(sdk.DatabaseParameterMaxDataExtensionTimeInDays, expected)) + return d +} + +func (d *DatabaseResourceParametersAssert) HasExternalVolume(expected string) *DatabaseResourceParametersAssert { + d.AddAssertion(assert.ResourceParameterValueSet(sdk.DatabaseParameterExternalVolume, expected)) + return d +} + +func (d *DatabaseResourceParametersAssert) HasCatalog(expected string) *DatabaseResourceParametersAssert { + d.AddAssertion(assert.ResourceParameterValueSet(sdk.DatabaseParameterCatalog, expected)) + return d +} + +func (d *DatabaseResourceParametersAssert) HasReplaceInvalidCharacters(expected bool) *DatabaseResourceParametersAssert { + d.AddAssertion(assert.ResourceParameterBoolValueSet(sdk.DatabaseParameterReplaceInvalidCharacters, expected)) + return d +} + +func (d *DatabaseResourceParametersAssert) HasDefaultDdlCollation(expected string) *DatabaseResourceParametersAssert { + d.AddAssertion(assert.ResourceParameterValueSet(sdk.DatabaseParameterDefaultDdlCollation, expected)) + return d +} + +func (d *DatabaseResourceParametersAssert) HasStorageSerializationPolicy(expected sdk.StorageSerializationPolicy) *DatabaseResourceParametersAssert { + d.AddAssertion(assert.ResourceParameterStringUnderlyingValueSet(sdk.DatabaseParameterStorageSerializationPolicy, expected)) + return d +} + +func (d *DatabaseResourceParametersAssert) HasLogLevel(expected sdk.LogLevel) *DatabaseResourceParametersAssert { + d.AddAssertion(assert.ResourceParameterStringUnderlyingValueSet(sdk.DatabaseParameterLogLevel, expected)) + return d +} + +func (d *DatabaseResourceParametersAssert) HasTraceLevel(expected sdk.TraceLevel) *DatabaseResourceParametersAssert { + d.AddAssertion(assert.ResourceParameterStringUnderlyingValueSet(sdk.DatabaseParameterTraceLevel, expected)) + return d +} + +func (d *DatabaseResourceParametersAssert) HasSuspendTaskAfterNumFailures(expected int) *DatabaseResourceParametersAssert { + d.AddAssertion(assert.ResourceParameterIntValueSet(sdk.DatabaseParameterSuspendTaskAfterNumFailures, expected)) + return d +} + +func (d *DatabaseResourceParametersAssert) HasTaskAutoRetryAttempts(expected int) *DatabaseResourceParametersAssert { + d.AddAssertion(assert.ResourceParameterIntValueSet(sdk.DatabaseParameterTaskAutoRetryAttempts, expected)) + return d +} + +func (d *DatabaseResourceParametersAssert) HasUserTaskManagedInitialWarehouseSize(expected sdk.WarehouseSize) *DatabaseResourceParametersAssert { + d.AddAssertion(assert.ResourceParameterStringUnderlyingValueSet(sdk.DatabaseParameterUserTaskManagedInitialWarehouseSize, expected)) + return d +} + +func (d *DatabaseResourceParametersAssert) HasUserTaskTimeoutMs(expected int) *DatabaseResourceParametersAssert { + d.AddAssertion(assert.ResourceParameterIntValueSet(sdk.DatabaseParameterUserTaskTimeoutMs, expected)) + return d +} + +func (d *DatabaseResourceParametersAssert) HasUserTaskMinimumTriggerIntervalInSeconds(expected int) *DatabaseResourceParametersAssert { + d.AddAssertion(assert.ResourceParameterIntValueSet(sdk.DatabaseParameterUserTaskMinimumTriggerIntervalInSeconds, expected)) + return d +} + +func (d *DatabaseResourceParametersAssert) HasQuotedIdentifiersIgnoreCase(expected bool) *DatabaseResourceParametersAssert { + d.AddAssertion(assert.ResourceParameterBoolValueSet(sdk.DatabaseParameterQuotedIdentifiersIgnoreCase, expected)) + return d +} + +func (d *DatabaseResourceParametersAssert) HasEnableConsoleOutput(expected bool) *DatabaseResourceParametersAssert { + d.AddAssertion(assert.ResourceParameterBoolValueSet(sdk.DatabaseParameterEnableConsoleOutput, expected)) + return d +} + +//////////////////////////// +// Parameter level checks // +//////////////////////////// + +func (d *DatabaseResourceParametersAssert) HasDataRetentionTimeInDaysLevel(expected sdk.ParameterType) *DatabaseResourceParametersAssert { + d.AddAssertion(assert.ResourceParameterLevelSet(sdk.DatabaseParameterDataRetentionTimeInDays, expected)) + return d +} + +func (d *DatabaseResourceParametersAssert) HasMaxDataExtensionTimeInDaysLevel(expected sdk.ParameterType) *DatabaseResourceParametersAssert { + d.AddAssertion(assert.ResourceParameterLevelSet(sdk.DatabaseParameterMaxDataExtensionTimeInDays, expected)) + return d +} + +func (d *DatabaseResourceParametersAssert) HasExternalVolumeLevel(expected sdk.ParameterType) *DatabaseResourceParametersAssert { + d.AddAssertion(assert.ResourceParameterLevelSet(sdk.DatabaseParameterExternalVolume, expected)) + return d +} + +func (d *DatabaseResourceParametersAssert) HasCatalogLevel(expected sdk.ParameterType) *DatabaseResourceParametersAssert { + d.AddAssertion(assert.ResourceParameterLevelSet(sdk.DatabaseParameterCatalog, expected)) + return d +} + +func (d *DatabaseResourceParametersAssert) HasReplaceInvalidCharactersLevel(expected sdk.ParameterType) *DatabaseResourceParametersAssert { + d.AddAssertion(assert.ResourceParameterLevelSet(sdk.DatabaseParameterReplaceInvalidCharacters, expected)) + return d +} + +func (d *DatabaseResourceParametersAssert) HasDefaultDdlCollationLevel(expected sdk.ParameterType) *DatabaseResourceParametersAssert { + d.AddAssertion(assert.ResourceParameterLevelSet(sdk.DatabaseParameterDefaultDdlCollation, expected)) + return d +} + +func (d *DatabaseResourceParametersAssert) HasStorageSerializationPolicyLevel(expected sdk.ParameterType) *DatabaseResourceParametersAssert { + d.AddAssertion(assert.ResourceParameterLevelSet(sdk.DatabaseParameterStorageSerializationPolicy, expected)) + return d +} + +func (d *DatabaseResourceParametersAssert) HasLogLevelLevel(expected sdk.ParameterType) *DatabaseResourceParametersAssert { + d.AddAssertion(assert.ResourceParameterLevelSet(sdk.DatabaseParameterLogLevel, expected)) + return d +} + +func (d *DatabaseResourceParametersAssert) HasTraceLevelLevel(expected sdk.ParameterType) *DatabaseResourceParametersAssert { + d.AddAssertion(assert.ResourceParameterLevelSet(sdk.DatabaseParameterTraceLevel, expected)) + return d +} + +func (d *DatabaseResourceParametersAssert) HasSuspendTaskAfterNumFailuresLevel(expected sdk.ParameterType) *DatabaseResourceParametersAssert { + d.AddAssertion(assert.ResourceParameterLevelSet(sdk.DatabaseParameterSuspendTaskAfterNumFailures, expected)) + return d +} + +func (d *DatabaseResourceParametersAssert) HasTaskAutoRetryAttemptsLevel(expected sdk.ParameterType) *DatabaseResourceParametersAssert { + d.AddAssertion(assert.ResourceParameterLevelSet(sdk.DatabaseParameterTaskAutoRetryAttempts, expected)) + return d +} + +func (d *DatabaseResourceParametersAssert) HasUserTaskManagedInitialWarehouseSizeLevel(expected sdk.ParameterType) *DatabaseResourceParametersAssert { + d.AddAssertion(assert.ResourceParameterLevelSet(sdk.DatabaseParameterUserTaskManagedInitialWarehouseSize, expected)) + return d +} + +func (d *DatabaseResourceParametersAssert) HasUserTaskTimeoutMsLevel(expected sdk.ParameterType) *DatabaseResourceParametersAssert { + d.AddAssertion(assert.ResourceParameterLevelSet(sdk.DatabaseParameterUserTaskTimeoutMs, expected)) + return d +} + +func (d *DatabaseResourceParametersAssert) HasUserTaskMinimumTriggerIntervalInSecondsLevel(expected sdk.ParameterType) *DatabaseResourceParametersAssert { + d.AddAssertion(assert.ResourceParameterLevelSet(sdk.DatabaseParameterUserTaskMinimumTriggerIntervalInSeconds, expected)) + return d +} + +func (d *DatabaseResourceParametersAssert) HasQuotedIdentifiersIgnoreCaseLevel(expected sdk.ParameterType) *DatabaseResourceParametersAssert { + d.AddAssertion(assert.ResourceParameterLevelSet(sdk.DatabaseParameterQuotedIdentifiersIgnoreCase, expected)) + return d +} + +func (d *DatabaseResourceParametersAssert) HasEnableConsoleOutputLevel(expected sdk.ParameterType) *DatabaseResourceParametersAssert { + d.AddAssertion(assert.ResourceParameterLevelSet(sdk.DatabaseParameterEnableConsoleOutput, expected)) + return d +} diff --git a/pkg/acceptance/bettertestspoc/assert/resourceshowoutputassert/database_show_output_gen.go b/pkg/acceptance/bettertestspoc/assert/resourceshowoutputassert/database_show_output_gen.go new file mode 100644 index 00000000000..3e1d8b99be3 --- /dev/null +++ b/pkg/acceptance/bettertestspoc/assert/resourceshowoutputassert/database_show_output_gen.go @@ -0,0 +1,112 @@ +// Code generated by assertions generator; DO NOT EDIT. + +package resourceshowoutputassert + +import ( + "testing" + "time" + + "github.com/Snowflake-Labs/terraform-provider-snowflake/pkg/acceptance/bettertestspoc/assert" + "github.com/Snowflake-Labs/terraform-provider-snowflake/pkg/sdk" +) + +// to ensure sdk package is used +var _ = sdk.Object{} + +type DatabaseShowOutputAssert struct { + *assert.ResourceAssert +} + +func DatabaseShowOutput(t *testing.T, name string) *DatabaseShowOutputAssert { + t.Helper() + + d := DatabaseShowOutputAssert{ + ResourceAssert: assert.NewResourceAssert(name, "show_output"), + } + d.AddAssertion(assert.ValueSet("show_output.#", "1")) + return &d +} + +func ImportedDatabaseShowOutput(t *testing.T, id string) *DatabaseShowOutputAssert { + t.Helper() + + d := DatabaseShowOutputAssert{ + ResourceAssert: assert.NewImportedResourceAssert(id, "show_output"), + } + d.AddAssertion(assert.ValueSet("show_output.#", "1")) + return &d +} + +//////////////////////////// +// Attribute value checks // +//////////////////////////// + +func (d *DatabaseShowOutputAssert) HasCreatedOn(expected time.Time) *DatabaseShowOutputAssert { + d.AddAssertion(assert.ResourceShowOutputValueSet("created_on", expected.String())) + return d +} + +func (d *DatabaseShowOutputAssert) HasName(expected string) *DatabaseShowOutputAssert { + d.AddAssertion(assert.ResourceShowOutputValueSet("name", expected)) + return d +} + +func (d *DatabaseShowOutputAssert) HasIsDefault(expected bool) *DatabaseShowOutputAssert { + d.AddAssertion(assert.ResourceShowOutputBoolValueSet("is_default", expected)) + return d +} + +func (d *DatabaseShowOutputAssert) HasIsCurrent(expected bool) *DatabaseShowOutputAssert { + d.AddAssertion(assert.ResourceShowOutputBoolValueSet("is_current", expected)) + return d +} + +func (d *DatabaseShowOutputAssert) HasOrigin(expected sdk.ExternalObjectIdentifier) *DatabaseShowOutputAssert { + d.AddAssertion(assert.ResourceShowOutputStringUnderlyingValueSet("origin", expected)) + return d +} + +func (d *DatabaseShowOutputAssert) HasOwner(expected string) *DatabaseShowOutputAssert { + d.AddAssertion(assert.ResourceShowOutputValueSet("owner", expected)) + return d +} + +func (d *DatabaseShowOutputAssert) HasComment(expected string) *DatabaseShowOutputAssert { + d.AddAssertion(assert.ResourceShowOutputValueSet("comment", expected)) + return d +} + +func (d *DatabaseShowOutputAssert) HasOptions(expected string) *DatabaseShowOutputAssert { + d.AddAssertion(assert.ResourceShowOutputValueSet("options", expected)) + return d +} + +func (d *DatabaseShowOutputAssert) HasRetentionTime(expected int) *DatabaseShowOutputAssert { + d.AddAssertion(assert.ResourceShowOutputIntValueSet("retention_time", expected)) + return d +} + +func (d *DatabaseShowOutputAssert) HasResourceGroup(expected string) *DatabaseShowOutputAssert { + d.AddAssertion(assert.ResourceShowOutputValueSet("resource_group", expected)) + return d +} + +func (d *DatabaseShowOutputAssert) HasDroppedOn(expected time.Time) *DatabaseShowOutputAssert { + d.AddAssertion(assert.ResourceShowOutputValueSet("dropped_on", expected.String())) + return d +} + +func (d *DatabaseShowOutputAssert) HasTransient(expected bool) *DatabaseShowOutputAssert { + d.AddAssertion(assert.ResourceShowOutputBoolValueSet("transient", expected)) + return d +} + +func (d *DatabaseShowOutputAssert) HasKind(expected string) *DatabaseShowOutputAssert { + d.AddAssertion(assert.ResourceShowOutputValueSet("kind", expected)) + return d +} + +func (d *DatabaseShowOutputAssert) HasOwnerRoleType(expected string) *DatabaseShowOutputAssert { + d.AddAssertion(assert.ResourceShowOutputValueSet("owner_role_type", expected)) + return d +} diff --git a/pkg/sdk/tasks_def.go b/pkg/sdk/tasks_def.go index 28cb18af9eb..049551646d7 100644 --- a/pkg/sdk/tasks_def.go +++ b/pkg/sdk/tasks_def.go @@ -1,6 +1,7 @@ package sdk import ( + "encoding/json" "fmt" g "github.com/Snowflake-Labs/terraform-provider-snowflake/pkg/sdk/poc/generator" "strings" @@ -24,6 +25,53 @@ func ToTaskState(s string) (TaskState, error) { } } +type TaskRelationsRepresentation struct { + Predecessors []string `json:"Predecessors"` + FinalizerTask string `json:"FinalizerTask"` +} + +func (r *TaskRelationsRepresentation) ToTaskRelations() (TaskRelations, error) { + var predecessors []SchemaObjectIdentifier + for _, predecessor := range r.Predecessors { + id, err := ParseSchemaObjectIdentifier(predecessor) + if err != nil { + return TaskRelations{}, err + } + predecessors = append(predecessors, id) + } + + taskRelations := TaskRelations{ + Predecessors: predecessors, + } + + if len(r.FinalizerTask) > 0 { + finalizerTask, err := ParseSchemaObjectIdentifier(r.FinalizerTask) + if err != nil { + return TaskRelations{}, err + } + taskRelations.FinalizerTask = &finalizerTask + } + + return taskRelations, nil +} + +type TaskRelations struct { + Predecessors []SchemaObjectIdentifier + FinalizerTask *SchemaObjectIdentifier +} + +func ToTaskRelations(s string) (TaskRelations, error) { + var taskRelationsRepresentation TaskRelationsRepresentation + if err := json.Unmarshal([]byte(s), &taskRelationsRepresentation); err != nil { + return TaskRelations{}, err + } + taskRelations, err := taskRelationsRepresentation.ToTaskRelations() + if err != nil { + return TaskRelations{}, err + } + return taskRelations, nil +} + var taskDbRow = g.DbStruct("taskDBRow"). Text("created_on"). Text("name"). diff --git a/pkg/sdk/tasks_gen.go b/pkg/sdk/tasks_gen.go index 438fc0c1b07..ae90dc7d750 100644 --- a/pkg/sdk/tasks_gen.go +++ b/pkg/sdk/tasks_gen.go @@ -199,7 +199,7 @@ type Task struct { OwnerRoleType string Config string Budget string - TaskRelations string + TaskRelations TaskRelations LastSuspendedReason string } diff --git a/pkg/sdk/tasks_impl_gen.go b/pkg/sdk/tasks_impl_gen.go index b888ce7e1ac..2fbd13af273 100644 --- a/pkg/sdk/tasks_impl_gen.go +++ b/pkg/sdk/tasks_impl_gen.go @@ -307,7 +307,12 @@ func (r taskDBRow) convert() *Task { Definition: r.Definition, AllowOverlappingExecution: r.AllowOverlappingExecution == "true", OwnerRoleType: r.OwnerRoleType, - TaskRelations: r.TaskRelations, + } + taskRelations, err := ToTaskRelations(r.TaskRelations) + if err != nil { + log.Printf("[DEBUG] failed to convert task relations: %v", err) + } else { + task.TaskRelations = taskRelations } if r.Comment.Valid { task.Comment = r.Comment.String diff --git a/pkg/sdk/testint/tasks_gen_integration_test.go b/pkg/sdk/testint/tasks_gen_integration_test.go index ee50094503c..c13a86632eb 100644 --- a/pkg/sdk/testint/tasks_gen_integration_test.go +++ b/pkg/sdk/testint/tasks_gen_integration_test.go @@ -2,6 +2,8 @@ package testint import ( "errors" + assertions "github.com/Snowflake-Labs/terraform-provider-snowflake/pkg/acceptance/bettertestspoc/assert" + "github.com/Snowflake-Labs/terraform-provider-snowflake/pkg/acceptance/bettertestspoc/assert/objectassert" "testing" "github.com/Snowflake-Labs/terraform-provider-snowflake/pkg/sdk" @@ -15,89 +17,103 @@ import ( func TestInt_Tasks(t *testing.T) { client := testClient(t) ctx := testContext(t) - sql := "SELECT CURRENT_TIMESTAMP" + // TODO: Add new fields in asserts + assertTask := func(t *testing.T, task *sdk.Task, id sdk.SchemaObjectIdentifier, warehouseName string) { t.Helper() - assert.Equal(t, id, task.ID()) - assert.NotEmpty(t, task.CreatedOn) - assert.Equal(t, id.Name(), task.Name) - assert.NotEmpty(t, task.Id) - assert.Equal(t, testClientHelper().Ids.DatabaseId().Name(), task.DatabaseName) - assert.Equal(t, testClientHelper().Ids.SchemaId().Name(), task.SchemaName) - assert.Equal(t, "ACCOUNTADMIN", task.Owner) - assert.Equal(t, "", task.Comment) - assert.Equal(t, warehouseName, task.Warehouse) - assert.Equal(t, "", task.Schedule) - assert.Empty(t, task.Predecessors) - assert.Equal(t, sdk.TaskStateSuspended, task.State) - assert.Equal(t, sql, task.Definition) - assert.Equal(t, "", task.Condition) - assert.Equal(t, false, task.AllowOverlappingExecution) - assert.Empty(t, task.ErrorIntegration) - assert.Empty(t, task.LastCommittedOn) - assert.Empty(t, task.LastSuspendedOn) - assert.Equal(t, "ROLE", task.OwnerRoleType) - assert.Empty(t, task.Config) - assert.Empty(t, task.Budget) + assertions.AssertThat(t, objectassert.TaskFromObject(t, task). + HasNotEmptyCreatedOn(). + HasName(id.Name()). + HasNotEmptyId(). + HasDatabaseName(testClientHelper().Ids.DatabaseId().Name()). + HasSchemaName(testClientHelper().Ids.SchemaId().Name()). + HasOwner("ACCOUNTADMIN"). + HasComment(""). + HasWarehouse(warehouseName). + HasSchedule(""). + HasPredecessors(). + HasState(sdk.TaskStateStarted). + HasDefinition(sql). + HasCondition(""). + HasAllowOverlappingExecution(false). + HasErrorIntegration(""). + HasLastCommittedOn(""). + HasLastSuspendedOn(""). + HasOwnerRoleType("ROLE"). + HasConfig(""). + HasBudget(""). + HasLastSuspendedOn(""). + HasTaskRelations(sdk.TaskRelations{}), + ) } assertTaskWithOptions := func(t *testing.T, task *sdk.Task, id sdk.SchemaObjectIdentifier, comment string, warehouse string, schedule string, condition string, allowOverlappingExecution bool, config string, predecessor *sdk.SchemaObjectIdentifier) { t.Helper() - assert.Equal(t, id, task.ID()) - assert.NotEmpty(t, task.CreatedOn) - assert.Equal(t, id.Name(), task.Name) - assert.NotEmpty(t, task.Id) - assert.Equal(t, testClientHelper().Ids.DatabaseId().Name(), task.DatabaseName) - assert.Equal(t, testClientHelper().Ids.SchemaId().Name(), task.SchemaName) - assert.Equal(t, "ACCOUNTADMIN", task.Owner) - assert.Equal(t, comment, task.Comment) - assert.Equal(t, warehouse, task.Warehouse) - assert.Equal(t, schedule, task.Schedule) - assert.Equal(t, sdk.TaskStateSuspended, task.State) - assert.Equal(t, sql, task.Definition) - assert.Equal(t, condition, task.Condition) - assert.Equal(t, allowOverlappingExecution, task.AllowOverlappingExecution) - assert.Empty(t, task.ErrorIntegration) - assert.Empty(t, task.LastCommittedOn) - assert.Empty(t, task.LastSuspendedOn) - assert.Equal(t, "ROLE", task.OwnerRoleType) - assert.Equal(t, config, task.Config) - assert.Empty(t, task.Budget) + + asserts := objectassert.TaskFromObject(t, task). + HasNotEmptyCreatedOn(). + HasName(id.Name()). + HasNotEmptyId(). + HasDatabaseName(testClientHelper().Ids.DatabaseId().Name()). + HasSchemaName(testClientHelper().Ids.SchemaId().Name()). + HasOwner("ACCOUNTADMIN"). + HasComment(comment). + HasWarehouse(warehouse). + HasSchedule(schedule). + HasState(sdk.TaskStateSuspended). + HasDefinition(sql). + HasCondition(condition). + HasAllowOverlappingExecution(allowOverlappingExecution). + HasErrorIntegration(""). + HasLastCommittedOn(""). + HasLastSuspendedOn(""). + HasOwnerRoleType("ROLE"). + HasConfig(config). + HasBudget(""). + HasLastSuspendedOn("") + if predecessor != nil { - assert.Len(t, task.Predecessors, 1) - assert.Contains(t, task.Predecessors, *predecessor) + asserts.HasPredecessors(*predecessor) + asserts.HasTaskRelations(sdk.TaskRelations{ + Predecessors: []sdk.SchemaObjectIdentifier{*predecessor}, + }) } else { - assert.Empty(t, task.Predecessors) + asserts.HasPredecessors() + asserts.HasTaskRelations(sdk.TaskRelations{}) } + + assertions.AssertThat(t, asserts) } assertTaskTerse := func(t *testing.T, task *sdk.Task, id sdk.SchemaObjectIdentifier, schedule string) { t.Helper() - assert.Equal(t, id, task.ID()) - assert.NotEmpty(t, task.CreatedOn) - assert.Equal(t, id.Name(), task.Name) - assert.Equal(t, testClientHelper().Ids.DatabaseId().Name(), task.DatabaseName) - assert.Equal(t, testClientHelper().Ids.SchemaId().Name(), task.SchemaName) - assert.Equal(t, schedule, task.Schedule) - - // all below are not contained in the terse response, that's why all of them we expect to be empty - assert.Empty(t, task.Id) - assert.Empty(t, task.Owner) - assert.Empty(t, task.Comment) - assert.Empty(t, task.Warehouse) - assert.Empty(t, task.Predecessors) - assert.Empty(t, task.State) - assert.Empty(t, task.Definition) - assert.Empty(t, task.Condition) - assert.Empty(t, task.AllowOverlappingExecution) - assert.Empty(t, task.ErrorIntegration) - assert.Empty(t, task.LastCommittedOn) - assert.Empty(t, task.LastSuspendedOn) - assert.Empty(t, task.OwnerRoleType) - assert.Empty(t, task.Config) - assert.Empty(t, task.Budget) + assertions.AssertThat(t, objectassert.TaskFromObject(t, task). + HasNotEmptyCreatedOn(). + HasName(id.Name()). + HasDatabaseName(testClientHelper().Ids.DatabaseId().Name()). + HasSchemaName(testClientHelper().Ids.SchemaId().Name()). + HasSchedule(schedule). + // all below are not contained in the terse response, that's why all of them we expect to be empty + HasId(""). + HasOwner(""). + HasComment(""). + HasWarehouse(""). + HasPredecessors(). + HasState(""). + HasDefinition(""). + HasCondition(""). + HasAllowOverlappingExecution(false). + HasErrorIntegration(""). + HasLastCommittedOn(""). + HasLastSuspendedOn(""). + HasOwnerRoleType(""). + HasConfig(""). + HasBudget(""). + HasLastSuspendedOn(""). + HasTaskRelations(sdk.TaskRelations{}), + ) } t.Run("create task: no optionals", func(t *testing.T) { @@ -169,6 +185,31 @@ func TestInt_Tasks(t *testing.T) { assertTaskWithOptions(t, task, id, "", "", "", "", false, "", &rootTaskId) }) + t.Run("create task: with after and finalizer", func(t *testing.T) { + rootTaskId := testClientHelper().Ids.RandomSchemaObjectIdentifier() + id := testClientHelper().Ids.RandomSchemaObjectIdentifier() + finalizerId := testClientHelper().Ids.RandomSchemaObjectIdentifier() + + err := testClient(t).Tasks.Create(ctx, sdk.NewCreateTaskRequest(rootTaskId, sql)) + require.NoError(t, err) + t.Cleanup(testClientHelper().Task.DropTaskFunc(t, rootTaskId)) + + err = testClient(t).Tasks.Create(ctx, sdk.NewCreateTaskRequest(id, sql).WithAfter([]sdk.SchemaObjectIdentifier{rootTaskId})) + require.NoError(t, err) + t.Cleanup(testClientHelper().Task.DropTaskFunc(t, id)) + + err = testClient(t).Tasks.Create(ctx, sdk.NewCreateTaskRequest(finalizerId, sql).WithFinalize(rootTaskId)) + require.NoError(t, err) + t.Cleanup(testClientHelper().Task.DropTaskFunc(t, finalizerId)) + + assertions.AssertThat(t, objectassert.Task(t, rootTaskId). + HasTaskRelations(sdk.TaskRelations{ + Predecessors: []sdk.SchemaObjectIdentifier{}, + FinalizerTask: &finalizerId, + }), + ) + }) + t.Run("create dag of tasks", func(t *testing.T) { rootId := testClientHelper().Ids.RandomSchemaObjectIdentifier() root, rootCleanup := testClientHelper().Task.CreateWithRequest(t, sdk.NewCreateTaskRequest(rootId, sql).WithSchedule("10 MINUTE")) @@ -306,6 +347,35 @@ func TestInt_Tasks(t *testing.T) { assertTask(t, task, id, testClientHelper().Ids.WarehouseId().Name()) }) + t.Run("create or alter: complete", func(t *testing.T) { + id := testClientHelper().Ids.RandomSchemaObjectIdentifier() + err := client.Tasks.CreateOrAlter(ctx, sdk.NewCreateOrAlterTaskRequest(id, sql). + WithWarehouse(*sdk.NewCreateTaskWarehouseRequest().WithWarehouse(testClientHelper().Ids.WarehouseId())). + WithSchedule("10 MINUTES"). + WithConfig(`$${"output_dir": "/temp/test_directory/", "learning_rate": 0.1}$$`). + WithAllowOverlappingExecution(true). + WithUserTaskTimeoutMs(10). + WithSessionParameters(sdk.SessionParameters{ + Autocommit: sdk.Bool(true), + }). + WithSuspendTaskAfterNumFailures(15). + WithComment("some_comment"). + WithTaskAutoRetryAttempts(15). + WithWhen(`SYSTEM$STREAM_HAS_DATA('MYSTREAM')`), + ) + require.NoError(t, err) + + assertions.AssertThat(t, objectassert.Task(t, id). + HasWarehouse(testClientHelper().Ids.WarehouseId().Name()). + HasSchedule("10 MINUTES"). + HasConfig(`{"output_dir": "/temp/test_directory/", "learning_rate": 0.1}`). + HasAllowOverlappingExecution(true). + HasCondition(`SYSTEM$STREAM_HAS_DATA('MYSTREAM')`). + HasComment("some_comment"). + HasTaskRelations(sdk.TaskRelations{}), + ) + }) + t.Run("drop task: existing", func(t *testing.T) { task, taskCleanup := testClientHelper().Task.Create(t) t.Cleanup(taskCleanup) @@ -326,23 +396,47 @@ func TestInt_Tasks(t *testing.T) { task, taskCleanup := testClientHelper().Task.Create(t) t.Cleanup(taskCleanup) - alterRequest := sdk.NewAlterTaskRequest(task.ID()).WithSet(*sdk.NewTaskSetRequest().WithComment("new comment").WithUserTaskTimeoutMs(1000)) - err := client.Tasks.Alter(ctx, alterRequest) - require.NoError(t, err) - - alteredTask, err := client.Tasks.ShowByID(ctx, task.ID()) - require.NoError(t, err) - - assert.Equal(t, "new comment", alteredTask.Comment) - - alterRequest = sdk.NewAlterTaskRequest(task.ID()).WithUnset(*sdk.NewTaskUnsetRequest().WithComment(true).WithUserTaskTimeoutMs(true)) - err = client.Tasks.Alter(ctx, alterRequest) - require.NoError(t, err) - - alteredTask, err = client.Tasks.ShowByID(ctx, task.ID()) - require.NoError(t, err) + err := client.Tasks.Alter(ctx, sdk.NewAlterTaskRequest(task.ID()).WithSet(*sdk.NewTaskSetRequest(). + // TODO: Cannot set warehouse due to Snowflake error + //WithWarehouse(testClientHelper().Ids.WarehouseId()). + WithSchedule("10 MINUTE"). + WithConfig(`$${"output_dir": "/temp/test_directory/", "learning_rate": 0.1}$$`). + WithAllowOverlappingExecution(true). + WithUserTaskTimeoutMs(1000). + WithSuspendTaskAfterNumFailures(100). + WithComment("new comment"). + WithTaskAutoRetryAttempts(10). + WithUserTaskMinimumTriggerIntervalInSeconds(15), + )) + require.NoError(t, err) + + assertions.AssertThat(t, objectassert.Task(t, task.ID()). + //HasWarehouse(testClientHelper().Ids.WarehouseId().Name()). + HasSchedule("10 MINUTE"). + HasConfig(`{"output_dir": "/temp/test_directory/", "learning_rate": 0.1}`). + HasAllowOverlappingExecution(true). + HasComment("new comment"), + ) - assert.Equal(t, "", alteredTask.Comment) + err = client.Tasks.Alter(ctx, sdk.NewAlterTaskRequest(task.ID()).WithUnset(*sdk.NewTaskUnsetRequest(). + WithWarehouse(true). + WithSchedule(true). + WithConfig(true). + WithAllowOverlappingExecution(true). + WithUserTaskTimeoutMs(true). + WithSuspendTaskAfterNumFailures(true). + WithComment(true). + WithTaskAutoRetryAttempts(true). + WithUserTaskMinimumTriggerIntervalInSeconds(true), + )) + require.NoError(t, err) + + assertions.AssertThat(t, objectassert.Task(t, task.ID()). + HasSchedule(""). + HasConfig(""). + HasAllowOverlappingExecution(false). + HasComment(""), + ) }) t.Run("alter task: set and unset tag", func(t *testing.T) { @@ -426,6 +520,38 @@ func TestInt_Tasks(t *testing.T) { assert.Contains(t, task.Predecessors, rootTask.ID()) }) + t.Run("alter task: set and unset final task", func(t *testing.T) { + task, taskCleanup := testClientHelper().Task.Create(t) + t.Cleanup(taskCleanup) + + finalTask, finalTaskCleanup := testClientHelper().Task.Create(t) + t.Cleanup(finalTaskCleanup) + + assertions.AssertThat(t, objectassert.TaskFromObject(t, task). + HasTaskRelations(sdk.TaskRelations{ + FinalizerTask: nil, + }), + ) + + err := client.Tasks.Alter(ctx, sdk.NewAlterTaskRequest(task.ID()).WithSetFinalize(finalTask.ID())) + require.NoError(t, err) + + assertions.AssertThat(t, objectassert.TaskFromObject(t, task). + HasTaskRelations(sdk.TaskRelations{ + FinalizerTask: sdk.Pointer(finalTask.ID()), + }), + ) + + err = client.Tasks.Alter(ctx, sdk.NewAlterTaskRequest(task.ID()).WithUnsetFinalize(true)) + require.NoError(t, err) + + assertions.AssertThat(t, objectassert.TaskFromObject(t, task). + HasTaskRelations(sdk.TaskRelations{ + FinalizerTask: nil, + }), + ) + }) + t.Run("alter task: modify when and as", func(t *testing.T) { task, taskCleanup := testClientHelper().Task.Create(t) t.Cleanup(taskCleanup) @@ -434,19 +560,18 @@ func TestInt_Tasks(t *testing.T) { err := client.Tasks.Alter(ctx, sdk.NewAlterTaskRequest(task.ID()).WithModifyAs(newSql)) require.NoError(t, err) - alteredTask, err := client.Tasks.ShowByID(ctx, task.ID()) - require.NoError(t, err) - - assert.Equal(t, newSql, alteredTask.Definition) + assertions.AssertThat(t, objectassert.TaskFromObject(t, task).HasDefinition(newSql)) newWhen := `SYSTEM$STREAM_HAS_DATA('MYSTREAM')` err = client.Tasks.Alter(ctx, sdk.NewAlterTaskRequest(task.ID()).WithModifyWhen(newWhen)) require.NoError(t, err) - alteredTask, err = client.Tasks.ShowByID(ctx, task.ID()) + assertions.AssertThat(t, objectassert.TaskFromObject(t, task).HasCondition(newWhen)) + + err = client.Tasks.Alter(ctx, sdk.NewAlterTaskRequest(task.ID()).WithRemoveWhen(true)) require.NoError(t, err) - assert.Equal(t, newWhen, alteredTask.Condition) + assertions.AssertThat(t, objectassert.TaskFromObject(t, task).HasCondition("")) }) // TODO: Change this test (the search is too broad)