From 554fc90c3931e8ac77d5121095616a83633d339e Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Jan=20Cie=C5=9Blak?= Date: Fri, 20 Sep 2024 16:06:10 +0200 Subject: [PATCH] changes after review --- .../assert/objectassert/task_snowflake_gen.go | 2 +- .../gen/object_parameters_def.go | 132 ++ .../task_parameters_snowflake_gen.go | 1151 +++++++++++++++++ pkg/acceptance/helpers/parameter_client.go | 11 + pkg/resources/task.go | 12 +- pkg/sdk/parameters.go | 66 + pkg/sdk/testint/tasks_gen_integration_test.go | 88 +- 7 files changed, 1449 insertions(+), 13 deletions(-) create mode 100644 pkg/acceptance/bettertestspoc/assert/objectparametersassert/task_parameters_snowflake_gen.go diff --git a/pkg/acceptance/bettertestspoc/assert/objectassert/task_snowflake_gen.go b/pkg/acceptance/bettertestspoc/assert/objectassert/task_snowflake_gen.go index 4f3674e8b5..c0180747ab 100644 --- a/pkg/acceptance/bettertestspoc/assert/objectassert/task_snowflake_gen.go +++ b/pkg/acceptance/bettertestspoc/assert/objectassert/task_snowflake_gen.go @@ -173,7 +173,7 @@ func (t *TaskAssert) HasAllowOverlappingExecution(expected bool) *TaskAssert { return t } -func (t *TaskAssert) HasErrorIntegration(expected string) *TaskAssert { +func (t *TaskAssert) HasErrorIntegration(expected *sdk.AccountObjectIdentifier) *TaskAssert { t.AddAssertion(func(t *testing.T, o *sdk.Task) error { t.Helper() if o.ErrorIntegration != expected { diff --git a/pkg/acceptance/bettertestspoc/assert/objectparametersassert/gen/object_parameters_def.go b/pkg/acceptance/bettertestspoc/assert/objectparametersassert/gen/object_parameters_def.go index b87151ccae..9c302aa2eb 100644 --- a/pkg/acceptance/bettertestspoc/assert/objectparametersassert/gen/object_parameters_def.go +++ b/pkg/acceptance/bettertestspoc/assert/objectparametersassert/gen/object_parameters_def.go @@ -128,4 +128,136 @@ var allObjectsParameters = []SnowflakeObjectParameters{ {ParameterName: string(sdk.DatabaseParameterEnableConsoleOutput), ParameterType: "bool", DefaultValue: "false", DefaultLevel: "sdk.ParameterTypeSnowflakeDefault"}, }, }, + { + Name: "Task", + IdType: "sdk.SchemaObjectIdentifier", + Level: sdk.ParameterTypeTask, + Parameters: []SnowflakeParameter{ + // ABORT_DETACHED_QUERY + // ACTIVE_PYTHON_PROFILER + {ParameterName: string(sdk.TaskParameterAutocommit), ParameterType: "bool", DefaultValue: "true", DefaultLevel: "sdk.ParameterTypeAccount"}, + // AUTOCOMMIT_API_SUPPORTED + {ParameterName: string(sdk.TaskParameterBinaryInputFormat), ParameterType: "sdk.BinaryInputFormat", DefaultValue: "sdk.BinaryInputFormatHex", DefaultLevel: "sdk.ParameterTypeSnowflakeDefault"}, + {ParameterName: string(sdk.TaskParameterBinaryOutputFormat), ParameterType: "sdk.BinaryOutputFormat", DefaultValue: "sdk.BinaryOutputFormatHex", DefaultLevel: "sdk.ParameterTypeSnowflakeDefault"}, + // CLIENT_ENABLE_CONSERVATIVE_MEMORY_USAGE + // CLIENT_ENABLE_DEFAULT_OVERWRITE_IN_PUT + // CLIENT_ENABLE_LOG_INFO_STATEMENT_PARAMETERS + {ParameterName: string(sdk.TaskParameterClientMemoryLimit), ParameterType: "int", DefaultValue: "1536", DefaultLevel: "sdk.ParameterTypeSnowflakeDefault"}, + {ParameterName: string(sdk.TaskParameterClientMetadataRequestUseConnectionCtx), ParameterType: "bool", DefaultValue: "false", DefaultLevel: "sdk.ParameterTypeSnowflakeDefault"}, + // CLIENT_METADATA_USE_SESSION_DATABASE + {ParameterName: string(sdk.TaskParameterClientPrefetchThreads), ParameterType: "int", DefaultValue: "4", DefaultLevel: "sdk.ParameterTypeSnowflakeDefault"}, + {ParameterName: string(sdk.TaskParameterClientResultChunkSize), ParameterType: "int", DefaultValue: "160", DefaultLevel: "sdk.ParameterTypeSnowflakeDefault"}, + {ParameterName: string(sdk.TaskParameterClientResultColumnCaseInsensitive), ParameterType: "bool", DefaultValue: "false", DefaultLevel: "sdk.ParameterTypeSnowflakeDefault"}, + // CLIENT_SESSION_CLONE + {ParameterName: string(sdk.TaskParameterClientSessionKeepAlive), ParameterType: "bool", DefaultValue: "false", DefaultLevel: "sdk.ParameterTypeSnowflakeDefault"}, + {ParameterName: string(sdk.TaskParameterClientSessionKeepAliveHeartbeatFrequency), ParameterType: "int", DefaultValue: "3600", DefaultLevel: "sdk.ParameterTypeSnowflakeDefault"}, + {ParameterName: string(sdk.TaskParameterClientTimestampTypeMapping), ParameterType: "sdk.ClientTimestampTypeMapping", DefaultValue: "sdk.ClientTimestampTypeMappingLtz", DefaultLevel: "sdk.ParameterTypeSnowflakeDefault"}, + // CSV_TIMESTAMP_FORMAT + // C_API_QUERY_RESULT_FORMAT + {ParameterName: string(sdk.TaskParameterDateInputFormat), ParameterType: "string", DefaultValue: "AUTO", DefaultLevel: "sdk.ParameterTypeSnowflakeDefault"}, + {ParameterName: string(sdk.TaskParameterDateOutputFormat), ParameterType: "string", DefaultValue: "YYYY-MM-DD", DefaultLevel: "sdk.ParameterTypeSnowflakeDefault"}, + // DOTNET_QUERY_RESULT_FORMAT + // DYNAMIC_TABLES_VIEW_VERSION + // DYNAMIC_TABLE_GRAPH_HISTORY_VIEW_VERSION + // DYNAMIC_TABLE_REFRESH_HISTORY_VIEW_VERSION + // ENABLE_CONSOLE_OUTPUT + // ENABLE_PROVIDER_LISTING_PROGRAMMATIC_ACCESS_DESCRIBE_LISTING + // ENABLE_SNOW_API_FOR_COMPUTE_POOL + // ENABLE_SNOW_API_FOR_COPILOT + // ENABLE_SNOW_API_FOR_DATABASE + // ENABLE_SNOW_API_FOR_FUNCTION + // ENABLE_SNOW_API_FOR_GRANT + // ENABLE_SNOW_API_FOR_ICEBERG + // ENABLE_SNOW_API_FOR_IMAGE_REPOSITORY + // ENABLE_SNOW_API_FOR_RESULT + // ENABLE_SNOW_API_FOR_ROLE + // ENABLE_SNOW_API_FOR_SCHEMA + // ENABLE_SNOW_API_FOR_SERVICE + // ENABLE_SNOW_API_FOR_SESSION + // ENABLE_SNOW_API_FOR_STAGE + // ENABLE_SNOW_API_FOR_TABLE + // ENABLE_SNOW_API_FOR_TASK + // ENABLE_SNOW_API_FOR_USER + // ENABLE_SNOW_API_FOR_WAREHOUSE + {ParameterName: string(sdk.TaskParameterEnableUnloadPhysicalTypeOptimization), ParameterType: "bool", DefaultValue: "true", DefaultLevel: "sdk.ParameterTypeSnowflakeDefault"}, + {ParameterName: string(sdk.TaskParameterErrorOnNondeterministicMerge), ParameterType: "bool", DefaultValue: "true", DefaultLevel: "sdk.ParameterTypeSnowflakeDefault"}, + {ParameterName: string(sdk.TaskParameterErrorOnNondeterministicUpdate), ParameterType: "bool", DefaultValue: "false", DefaultLevel: "sdk.ParameterTypeSnowflakeDefault"}, + {ParameterName: string(sdk.TaskParameterGeographyOutputFormat), ParameterType: "sdk.GeographyOutputFormat", DefaultValue: "sdk.GeographyOutputFormatGeoJSON", DefaultLevel: "sdk.ParameterTypeSnowflakeDefault"}, + {ParameterName: string(sdk.TaskParameterGeometryOutputFormat), ParameterType: "sdk.GeometryOutputFormat", DefaultValue: "sdk.GeometryOutputFormatGeoJSON", DefaultLevel: "sdk.ParameterTypeSnowflakeDefault"}, + // GO_QUERY_RESULT_FORMAT + // HYBRID_TABLE_LOCK_TIMEOUT + // INCLUDE_DT_WITH_TABLE_KIND_IN_SHOW_OBJECTS + // INCLUDE_DYNAMIC_TABLES_WITH_TABLE_KIND + // JDBC_FORMAT_DATE_WITH_TIMEZONE + // JDBC_QUERY_RESULT_FORMAT + {ParameterName: string(sdk.TaskParameterJdbcTreatTimestampNtzAsUtc), ParameterType: "bool", DefaultValue: "false", DefaultLevel: "sdk.ParameterTypeSnowflakeDefault"}, + {ParameterName: string(sdk.TaskParameterJdbcUseSessionTimezone), ParameterType: "bool", DefaultValue: "true", DefaultLevel: "sdk.ParameterTypeSnowflakeDefault"}, + {ParameterName: string(sdk.TaskParameterJsonIndent), ParameterType: "int", DefaultValue: "2", DefaultLevel: "sdk.ParameterTypeSnowflakeDefault"}, + // LANGUAGE + {ParameterName: string(sdk.TaskParameterLockTimeout), ParameterType: "int", DefaultValue: "43200", DefaultLevel: "sdk.ParameterTypeSnowflakeDefault"}, + {ParameterName: string(sdk.TaskParameterLogLevel), ParameterType: "sdk.LogLevel", DefaultValue: "sdk.LogLevelOff", DefaultLevel: "sdk.ParameterTypeSnowflakeDefault"}, + // METRIC_LEVEL + {ParameterName: string(sdk.TaskParameterMultiStatementCount), ParameterType: "int", DefaultValue: "1", DefaultLevel: "sdk.ParameterTypeSnowflakeDefault"}, + {ParameterName: string(sdk.TaskParameterNoorderSequenceAsDefault), ParameterType: "bool", DefaultValue: "true", DefaultLevel: "sdk.ParameterTypeSnowflakeDefault"}, + // ODBC_QUERY_RESULT_FORMAT + {ParameterName: string(sdk.TaskParameterOdbcTreatDecimalAsInt), ParameterType: "bool", DefaultValue: "false", DefaultLevel: "sdk.ParameterTypeSnowflakeDefault"}, + // PYTHON_CONNECTOR_QUERY_RESULT_FORMAT + // PYTHON_CONNECTOR_USE_NANOARROW + // PYTHON_PROFILER_MODULES + // PYTHON_PROFILER_TARGET_STAGE + // PYTHON_SNOWPARK_AUTO_CLEAN_UP_TEMP_TABLE_ENABLED + // PYTHON_SNOWPARK_COMPILATION_STAGE_ENABLED + // PYTHON_SNOWPARK_ELIMINATE_NUMERIC_SQL_VALUE_CAST_ENABLED + // PYTHON_SNOWPARK_USE_CTE_OPTIMIZATION + // PYTHON_SNOWPARK_USE_LARGE_QUERY_BREAKDOWN_OPTIMIZATION + // PYTHON_SNOWPARK_USE_LOGICAL_TYPE_FOR_CREATE_DATAFRAME + // PYTHON_SNOWPARK_USE_SCOPED_TEMP_OBJECTS + // PYTHON_SNOWPARK_USE_SQL_SIMPLIFIER + // QA_TEST_NAME + // QUERY_RESULT_FORMAT + {ParameterName: string(sdk.TaskParameterQueryTag), ParameterType: "string", DefaultLevel: "sdk.ParameterTypeSnowflakeDefault"}, + {ParameterName: string(sdk.TaskParameterQuotedIdentifiersIgnoreCase), ParameterType: "bool", DefaultValue: "false", DefaultLevel: "sdk.ParameterTypeAccount"}, + {ParameterName: string(sdk.TaskParameterRowsPerResultset), ParameterType: "int", DefaultValue: "0", DefaultLevel: "sdk.ParameterTypeSnowflakeDefault"}, + {ParameterName: string(sdk.TaskParameterS3StageVpceDnsName), ParameterType: "string", DefaultLevel: "sdk.ParameterTypeSnowflakeDefault"}, + {ParameterName: string(sdk.TaskParameterSearchPath), ParameterType: "string", DefaultValue: "$current, $public", DefaultLevel: "sdk.ParameterTypeSnowflakeDefault"}, + // SHOW_EXTERNAL_TABLE_KIND_AS_TABLE + // SNOWPARK_HIDE_INTERNAL_ALIAS + // SNOWPARK_LAZY_ANALYSIS + // SNOWPARK_REQUEST_TIMEOUT_IN_SECONDS + // SNOWPARK_STORED_PROC_IS_FINAL_TABLE_QUERY + // SNOWPARK_USE_SCOPED_TEMP_OBJECTS + // SQL_API_NULLABLE_IN_RESULT_SET + // SQL_API_QUERY_RESULT_FORMAT + {ParameterName: string(sdk.TaskParameterStatementQueuedTimeoutInSeconds), ParameterType: "int", DefaultValue: "0", DefaultLevel: "sdk.ParameterTypeSnowflakeDefault"}, + {ParameterName: string(sdk.TaskParameterStatementTimeoutInSeconds), ParameterType: "int", DefaultValue: "172800", DefaultLevel: "sdk.ParameterTypeSnowflakeDefault"}, + {ParameterName: string(sdk.TaskParameterStrictJsonOutput), ParameterType: "bool", DefaultValue: "false", DefaultLevel: "sdk.ParameterTypeSnowflakeDefault"}, + // TODO: SUSPEND_TASK_AFTER_NUM_FAILURES + // TODO: TASK_AUTO_RETRY_ATTEMPTS + {ParameterName: string(sdk.TaskParameterTimestampDayIsAlways24h), ParameterType: "bool", DefaultValue: "false", DefaultLevel: "sdk.ParameterTypeSnowflakeDefault"}, + {ParameterName: string(sdk.TaskParameterTimestampInputFormat), ParameterType: "string", DefaultValue: "AUTO", DefaultLevel: "sdk.ParameterTypeSnowflakeDefault"}, + {ParameterName: string(sdk.TaskParameterTimestampLtzOutputFormat), ParameterType: "string", DefaultLevel: "sdk.ParameterTypeSnowflakeDefault"}, + {ParameterName: string(sdk.TaskParameterTimestampNtzOutputFormat), ParameterType: "string", DefaultValue: "YYYY-MM-DD HH24:MI:SS.FF3", DefaultLevel: "sdk.ParameterTypeSnowflakeDefault"}, + {ParameterName: string(sdk.TaskParameterTimestampOutputFormat), ParameterType: "string", DefaultValue: "YYYY-MM-DD HH24:MI:SS.FF3 TZHTZM", DefaultLevel: "sdk.ParameterTypeSnowflakeDefault"}, + {ParameterName: string(sdk.TaskParameterTimestampTypeMapping), ParameterType: "sdk.TimestampTypeMapping", DefaultValue: "sdk.TimestampTypeMappingNtz", DefaultLevel: "sdk.ParameterTypeSnowflakeDefault"}, + {ParameterName: string(sdk.TaskParameterTimestampTzOutputFormat), ParameterType: "string", DefaultLevel: "sdk.ParameterTypeSnowflakeDefault"}, + {ParameterName: string(sdk.TaskParameterTimezone), ParameterType: "string", DefaultValue: "America/Los_Angeles", DefaultLevel: "sdk.ParameterTypeSnowflakeDefault"}, + {ParameterName: string(sdk.TaskParameterTimeInputFormat), ParameterType: "string", DefaultValue: "AUTO", DefaultLevel: "sdk.ParameterTypeSnowflakeDefault"}, + {ParameterName: string(sdk.TaskParameterTimeOutputFormat), ParameterType: "string", DefaultValue: "HH24:MI:SS", DefaultLevel: "sdk.ParameterTypeSnowflakeDefault"}, + {ParameterName: string(sdk.TaskParameterTraceLevel), ParameterType: "sdk.TraceLevel", DefaultValue: "sdk.TraceLevelOff", DefaultLevel: "sdk.ParameterTypeSnowflakeDefault"}, + {ParameterName: string(sdk.TaskParameterTransactionAbortOnError), ParameterType: "bool", DefaultValue: "false", DefaultLevel: "sdk.ParameterTypeAccount"}, + {ParameterName: string(sdk.TaskParameterTransactionDefaultIsolationLevel), ParameterType: "sdk.TransactionDefaultIsolationLevel", DefaultValue: "sdk.TransactionDefaultIsolationLevelReadCommitted", DefaultLevel: "sdk.ParameterTypeSnowflakeDefault"}, + {ParameterName: string(sdk.TaskParameterTwoDigitCenturyStart), ParameterType: "int", DefaultValue: "1970", DefaultLevel: "sdk.ParameterTypeSnowflakeDefault"}, + // TODO UI_QUERY_RESULT_FORMAT + // TODO [SNOW-1501905]: quick workaround for now: lowercase for ignore in snowflake by default but uppercase for FAIL + {ParameterName: string(sdk.TaskParameterUnsupportedDdlAction), ParameterType: "sdk.UnsupportedDDLAction", DefaultValue: "sdk.UnsupportedDDLAction(strings.ToLower(string(sdk.UnsupportedDDLActionIgnore)))", DefaultLevel: "sdk.ParameterTypeSnowflakeDefault"}, + {ParameterName: string(sdk.TaskParameterUserTaskManagedInitialWarehouseSize), ParameterType: "sdk.WarehouseSize", DefaultValue: "Medium", DefaultLevel: "sdk.ParameterTypeSnowflakeDefault"}, + //{ParameterName: string(sdk.UserParameterUnsupportedUserTaskMinimumTriggerIntervalInSeconds), ParameterType: "int", DefaultValue: "30", DefaultLevel: "sdk.ParameterTypeSnowflakeDefault"}, + //{ParameterName: string(sdk.UserParameterUnsupportedUserTaskTimeoutMs), ParameterType: "int", DefaultValue: "3600000", DefaultLevel: "sdk.ParameterTypeSnowflakeDefault"}, + {ParameterName: string(sdk.TaskParameterUseCachedResult), ParameterType: "bool", DefaultValue: "true", DefaultLevel: "sdk.ParameterTypeSnowflakeDefault"}, + {ParameterName: string(sdk.TaskParameterWeekOfYearPolicy), ParameterType: "int", DefaultValue: "0", DefaultLevel: "sdk.ParameterTypeSnowflakeDefault"}, + {ParameterName: string(sdk.TaskParameterWeekStart), ParameterType: "int", DefaultValue: "0", DefaultLevel: "sdk.ParameterTypeSnowflakeDefault"}, + }, + // for the quickfix above + AdditionalImports: []string{"strings"}, + }, } diff --git a/pkg/acceptance/bettertestspoc/assert/objectparametersassert/task_parameters_snowflake_gen.go b/pkg/acceptance/bettertestspoc/assert/objectparametersassert/task_parameters_snowflake_gen.go new file mode 100644 index 0000000000..8feaea52b1 --- /dev/null +++ b/pkg/acceptance/bettertestspoc/assert/objectparametersassert/task_parameters_snowflake_gen.go @@ -0,0 +1,1151 @@ +// Code generated by assertions generator; DO NOT EDIT. + +package objectparametersassert + +import ( + "strings" + "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 TaskParametersAssert struct { + *assert.SnowflakeParametersAssert[sdk.SchemaObjectIdentifier] +} + +func TaskParameters(t *testing.T, id sdk.SchemaObjectIdentifier) *TaskParametersAssert { + t.Helper() + return &TaskParametersAssert{ + assert.NewSnowflakeParametersAssertWithProvider(id, sdk.ObjectTypeTask, acc.TestClient().Parameter.ShowTaskParameters), + } +} + +func TaskParametersPrefetched(t *testing.T, id sdk.SchemaObjectIdentifier, parameters []*sdk.Parameter) *TaskParametersAssert { + t.Helper() + return &TaskParametersAssert{ + assert.NewSnowflakeParametersAssertWithParameters(id, sdk.ObjectTypeTask, parameters), + } +} + +////////////////////////////// +// Generic parameter checks // +////////////////////////////// + +func (t *TaskParametersAssert) HasBoolParameterValue(parameterName sdk.TaskParameter, expected bool) *TaskParametersAssert { + t.AddAssertion(assert.SnowflakeParameterBoolValueSet(parameterName, expected)) + return t +} + +func (t *TaskParametersAssert) HasIntParameterValue(parameterName sdk.TaskParameter, expected int) *TaskParametersAssert { + t.AddAssertion(assert.SnowflakeParameterIntValueSet(parameterName, expected)) + return t +} + +func (t *TaskParametersAssert) HasStringParameterValue(parameterName sdk.TaskParameter, expected string) *TaskParametersAssert { + t.AddAssertion(assert.SnowflakeParameterValueSet(parameterName, expected)) + return t +} + +func (t *TaskParametersAssert) HasDefaultParameterValue(parameterName sdk.TaskParameter) *TaskParametersAssert { + t.AddAssertion(assert.SnowflakeParameterDefaultValueSet(parameterName)) + return t +} + +func (t *TaskParametersAssert) HasDefaultParameterValueOnLevel(parameterName sdk.TaskParameter, parameterType sdk.ParameterType) *TaskParametersAssert { + t.AddAssertion(assert.SnowflakeParameterDefaultValueOnLevelSet(parameterName, parameterType)) + return t +} + +/////////////////////////////// +// Aggregated generic checks // +/////////////////////////////// + +// HasAllDefaults checks if all the parameters: +// - have a default value by comparing current value of the sdk.Parameter with its default +// - have an expected level +func (t *TaskParametersAssert) HasAllDefaults() *TaskParametersAssert { + return t. + HasDefaultParameterValueOnLevel(sdk.TaskParameterAutocommit, sdk.ParameterTypeAccount). + HasDefaultParameterValueOnLevel(sdk.TaskParameterBinaryInputFormat, sdk.ParameterTypeSnowflakeDefault). + HasDefaultParameterValueOnLevel(sdk.TaskParameterBinaryOutputFormat, sdk.ParameterTypeSnowflakeDefault). + HasDefaultParameterValueOnLevel(sdk.TaskParameterClientMemoryLimit, sdk.ParameterTypeSnowflakeDefault). + HasDefaultParameterValueOnLevel(sdk.TaskParameterClientMetadataRequestUseConnectionCtx, sdk.ParameterTypeSnowflakeDefault). + HasDefaultParameterValueOnLevel(sdk.TaskParameterClientPrefetchThreads, sdk.ParameterTypeSnowflakeDefault). + HasDefaultParameterValueOnLevel(sdk.TaskParameterClientResultChunkSize, sdk.ParameterTypeSnowflakeDefault). + HasDefaultParameterValueOnLevel(sdk.TaskParameterClientResultColumnCaseInsensitive, sdk.ParameterTypeSnowflakeDefault). + HasDefaultParameterValueOnLevel(sdk.TaskParameterClientSessionKeepAlive, sdk.ParameterTypeSnowflakeDefault). + HasDefaultParameterValueOnLevel(sdk.TaskParameterClientSessionKeepAliveHeartbeatFrequency, sdk.ParameterTypeSnowflakeDefault). + HasDefaultParameterValueOnLevel(sdk.TaskParameterClientTimestampTypeMapping, sdk.ParameterTypeSnowflakeDefault). + HasDefaultParameterValueOnLevel(sdk.TaskParameterDateInputFormat, sdk.ParameterTypeSnowflakeDefault). + HasDefaultParameterValueOnLevel(sdk.TaskParameterDateOutputFormat, sdk.ParameterTypeSnowflakeDefault). + HasDefaultParameterValueOnLevel(sdk.TaskParameterEnableUnloadPhysicalTypeOptimization, sdk.ParameterTypeSnowflakeDefault). + HasDefaultParameterValueOnLevel(sdk.TaskParameterErrorOnNondeterministicMerge, sdk.ParameterTypeSnowflakeDefault). + HasDefaultParameterValueOnLevel(sdk.TaskParameterErrorOnNondeterministicUpdate, sdk.ParameterTypeSnowflakeDefault). + HasDefaultParameterValueOnLevel(sdk.TaskParameterGeographyOutputFormat, sdk.ParameterTypeSnowflakeDefault). + HasDefaultParameterValueOnLevel(sdk.TaskParameterGeometryOutputFormat, sdk.ParameterTypeSnowflakeDefault). + HasDefaultParameterValueOnLevel(sdk.TaskParameterJdbcTreatTimestampNtzAsUtc, sdk.ParameterTypeSnowflakeDefault). + HasDefaultParameterValueOnLevel(sdk.TaskParameterJdbcUseSessionTimezone, sdk.ParameterTypeSnowflakeDefault). + HasDefaultParameterValueOnLevel(sdk.TaskParameterJsonIndent, sdk.ParameterTypeSnowflakeDefault). + HasDefaultParameterValueOnLevel(sdk.TaskParameterLockTimeout, sdk.ParameterTypeSnowflakeDefault). + HasDefaultParameterValueOnLevel(sdk.TaskParameterLogLevel, sdk.ParameterTypeSnowflakeDefault). + HasDefaultParameterValueOnLevel(sdk.TaskParameterMultiStatementCount, sdk.ParameterTypeSnowflakeDefault). + HasDefaultParameterValueOnLevel(sdk.TaskParameterNoorderSequenceAsDefault, sdk.ParameterTypeSnowflakeDefault). + HasDefaultParameterValueOnLevel(sdk.TaskParameterOdbcTreatDecimalAsInt, sdk.ParameterTypeSnowflakeDefault). + HasDefaultParameterValueOnLevel(sdk.TaskParameterQueryTag, sdk.ParameterTypeSnowflakeDefault). + HasDefaultParameterValueOnLevel(sdk.TaskParameterQuotedIdentifiersIgnoreCase, sdk.ParameterTypeAccount). + HasDefaultParameterValueOnLevel(sdk.TaskParameterRowsPerResultset, sdk.ParameterTypeSnowflakeDefault). + HasDefaultParameterValueOnLevel(sdk.TaskParameterS3StageVpceDnsName, sdk.ParameterTypeSnowflakeDefault). + HasDefaultParameterValueOnLevel(sdk.TaskParameterSearchPath, sdk.ParameterTypeSnowflakeDefault). + HasDefaultParameterValueOnLevel(sdk.TaskParameterStatementQueuedTimeoutInSeconds, sdk.ParameterTypeSnowflakeDefault). + HasDefaultParameterValueOnLevel(sdk.TaskParameterStatementTimeoutInSeconds, sdk.ParameterTypeSnowflakeDefault). + HasDefaultParameterValueOnLevel(sdk.TaskParameterStrictJsonOutput, sdk.ParameterTypeSnowflakeDefault). + HasDefaultParameterValueOnLevel(sdk.TaskParameterTimestampDayIsAlways24h, sdk.ParameterTypeSnowflakeDefault). + HasDefaultParameterValueOnLevel(sdk.TaskParameterTimestampInputFormat, sdk.ParameterTypeSnowflakeDefault). + HasDefaultParameterValueOnLevel(sdk.TaskParameterTimestampLtzOutputFormat, sdk.ParameterTypeSnowflakeDefault). + HasDefaultParameterValueOnLevel(sdk.TaskParameterTimestampNtzOutputFormat, sdk.ParameterTypeSnowflakeDefault). + HasDefaultParameterValueOnLevel(sdk.TaskParameterTimestampOutputFormat, sdk.ParameterTypeSnowflakeDefault). + HasDefaultParameterValueOnLevel(sdk.TaskParameterTimestampTypeMapping, sdk.ParameterTypeSnowflakeDefault). + HasDefaultParameterValueOnLevel(sdk.TaskParameterTimestampTzOutputFormat, sdk.ParameterTypeSnowflakeDefault). + HasDefaultParameterValueOnLevel(sdk.TaskParameterTimezone, sdk.ParameterTypeSnowflakeDefault). + HasDefaultParameterValueOnLevel(sdk.TaskParameterTimeInputFormat, sdk.ParameterTypeSnowflakeDefault). + HasDefaultParameterValueOnLevel(sdk.TaskParameterTimeOutputFormat, sdk.ParameterTypeSnowflakeDefault). + HasDefaultParameterValueOnLevel(sdk.TaskParameterTraceLevel, sdk.ParameterTypeSnowflakeDefault). + HasDefaultParameterValueOnLevel(sdk.TaskParameterTransactionAbortOnError, sdk.ParameterTypeAccount). + HasDefaultParameterValueOnLevel(sdk.TaskParameterTransactionDefaultIsolationLevel, sdk.ParameterTypeSnowflakeDefault). + HasDefaultParameterValueOnLevel(sdk.TaskParameterTwoDigitCenturyStart, sdk.ParameterTypeSnowflakeDefault). + HasDefaultParameterValueOnLevel(sdk.TaskParameterUnsupportedDdlAction, sdk.ParameterTypeSnowflakeDefault). + HasDefaultParameterValueOnLevel(sdk.TaskParameterUserTaskManagedInitialWarehouseSize, sdk.ParameterTypeSnowflakeDefault). + HasDefaultParameterValueOnLevel(sdk.TaskParameterUseCachedResult, sdk.ParameterTypeSnowflakeDefault). + HasDefaultParameterValueOnLevel(sdk.TaskParameterWeekOfYearPolicy, sdk.ParameterTypeSnowflakeDefault). + HasDefaultParameterValueOnLevel(sdk.TaskParameterWeekStart, sdk.ParameterTypeSnowflakeDefault) +} + +func (t *TaskParametersAssert) HasAllDefaultsExplicit() *TaskParametersAssert { + return t. + HasDefaultAutocommitValueExplicit(). + HasDefaultBinaryInputFormatValueExplicit(). + HasDefaultBinaryOutputFormatValueExplicit(). + HasDefaultClientMemoryLimitValueExplicit(). + HasDefaultClientMetadataRequestUseConnectionCtxValueExplicit(). + HasDefaultClientPrefetchThreadsValueExplicit(). + HasDefaultClientResultChunkSizeValueExplicit(). + HasDefaultClientResultColumnCaseInsensitiveValueExplicit(). + HasDefaultClientSessionKeepAliveValueExplicit(). + HasDefaultClientSessionKeepAliveHeartbeatFrequencyValueExplicit(). + HasDefaultClientTimestampTypeMappingValueExplicit(). + HasDefaultDateInputFormatValueExplicit(). + HasDefaultDateOutputFormatValueExplicit(). + HasDefaultEnableUnloadPhysicalTypeOptimizationValueExplicit(). + HasDefaultErrorOnNondeterministicMergeValueExplicit(). + HasDefaultErrorOnNondeterministicUpdateValueExplicit(). + HasDefaultGeographyOutputFormatValueExplicit(). + HasDefaultGeometryOutputFormatValueExplicit(). + HasDefaultJdbcTreatTimestampNtzAsUtcValueExplicit(). + HasDefaultJdbcUseSessionTimezoneValueExplicit(). + HasDefaultJsonIndentValueExplicit(). + HasDefaultLockTimeoutValueExplicit(). + HasDefaultLogLevelValueExplicit(). + HasDefaultMultiStatementCountValueExplicit(). + HasDefaultNoorderSequenceAsDefaultValueExplicit(). + HasDefaultOdbcTreatDecimalAsIntValueExplicit(). + HasDefaultQueryTagValueExplicit(). + HasDefaultQuotedIdentifiersIgnoreCaseValueExplicit(). + HasDefaultRowsPerResultsetValueExplicit(). + HasDefaultS3StageVpceDnsNameValueExplicit(). + HasDefaultSearchPathValueExplicit(). + HasDefaultStatementQueuedTimeoutInSecondsValueExplicit(). + HasDefaultStatementTimeoutInSecondsValueExplicit(). + HasDefaultStrictJsonOutputValueExplicit(). + HasDefaultTimestampDayIsAlways24hValueExplicit(). + HasDefaultTimestampInputFormatValueExplicit(). + HasDefaultTimestampLtzOutputFormatValueExplicit(). + HasDefaultTimestampNtzOutputFormatValueExplicit(). + HasDefaultTimestampOutputFormatValueExplicit(). + HasDefaultTimestampTypeMappingValueExplicit(). + HasDefaultTimestampTzOutputFormatValueExplicit(). + HasDefaultTimezoneValueExplicit(). + HasDefaultTimeInputFormatValueExplicit(). + HasDefaultTimeOutputFormatValueExplicit(). + HasDefaultTraceLevelValueExplicit(). + HasDefaultTransactionAbortOnErrorValueExplicit(). + HasDefaultTransactionDefaultIsolationLevelValueExplicit(). + HasDefaultTwoDigitCenturyStartValueExplicit(). + HasDefaultUnsupportedDdlActionValueExplicit(). + HasDefaultUserTaskManagedInitialWarehouseSizeValueExplicit(). + HasDefaultUseCachedResultValueExplicit(). + HasDefaultWeekOfYearPolicyValueExplicit(). + HasDefaultWeekStartValueExplicit() +} + +//////////////////////////// +// Parameter value checks // +//////////////////////////// + +func (t *TaskParametersAssert) HasAutocommit(expected bool) *TaskParametersAssert { + t.AddAssertion(assert.SnowflakeParameterBoolValueSet(sdk.TaskParameterAutocommit, expected)) + return t +} + +func (t *TaskParametersAssert) HasBinaryInputFormat(expected sdk.BinaryInputFormat) *TaskParametersAssert { + t.AddAssertion(assert.SnowflakeParameterStringUnderlyingValueSet(sdk.TaskParameterBinaryInputFormat, expected)) + return t +} + +func (t *TaskParametersAssert) HasBinaryOutputFormat(expected sdk.BinaryOutputFormat) *TaskParametersAssert { + t.AddAssertion(assert.SnowflakeParameterStringUnderlyingValueSet(sdk.TaskParameterBinaryOutputFormat, expected)) + return t +} + +func (t *TaskParametersAssert) HasClientMemoryLimit(expected int) *TaskParametersAssert { + t.AddAssertion(assert.SnowflakeParameterIntValueSet(sdk.TaskParameterClientMemoryLimit, expected)) + return t +} + +func (t *TaskParametersAssert) HasClientMetadataRequestUseConnectionCtx(expected bool) *TaskParametersAssert { + t.AddAssertion(assert.SnowflakeParameterBoolValueSet(sdk.TaskParameterClientMetadataRequestUseConnectionCtx, expected)) + return t +} + +func (t *TaskParametersAssert) HasClientPrefetchThreads(expected int) *TaskParametersAssert { + t.AddAssertion(assert.SnowflakeParameterIntValueSet(sdk.TaskParameterClientPrefetchThreads, expected)) + return t +} + +func (t *TaskParametersAssert) HasClientResultChunkSize(expected int) *TaskParametersAssert { + t.AddAssertion(assert.SnowflakeParameterIntValueSet(sdk.TaskParameterClientResultChunkSize, expected)) + return t +} + +func (t *TaskParametersAssert) HasClientResultColumnCaseInsensitive(expected bool) *TaskParametersAssert { + t.AddAssertion(assert.SnowflakeParameterBoolValueSet(sdk.TaskParameterClientResultColumnCaseInsensitive, expected)) + return t +} + +func (t *TaskParametersAssert) HasClientSessionKeepAlive(expected bool) *TaskParametersAssert { + t.AddAssertion(assert.SnowflakeParameterBoolValueSet(sdk.TaskParameterClientSessionKeepAlive, expected)) + return t +} + +func (t *TaskParametersAssert) HasClientSessionKeepAliveHeartbeatFrequency(expected int) *TaskParametersAssert { + t.AddAssertion(assert.SnowflakeParameterIntValueSet(sdk.TaskParameterClientSessionKeepAliveHeartbeatFrequency, expected)) + return t +} + +func (t *TaskParametersAssert) HasClientTimestampTypeMapping(expected sdk.ClientTimestampTypeMapping) *TaskParametersAssert { + t.AddAssertion(assert.SnowflakeParameterStringUnderlyingValueSet(sdk.TaskParameterClientTimestampTypeMapping, expected)) + return t +} + +func (t *TaskParametersAssert) HasDateInputFormat(expected string) *TaskParametersAssert { + t.AddAssertion(assert.SnowflakeParameterValueSet(sdk.TaskParameterDateInputFormat, expected)) + return t +} + +func (t *TaskParametersAssert) HasDateOutputFormat(expected string) *TaskParametersAssert { + t.AddAssertion(assert.SnowflakeParameterValueSet(sdk.TaskParameterDateOutputFormat, expected)) + return t +} + +func (t *TaskParametersAssert) HasEnableUnloadPhysicalTypeOptimization(expected bool) *TaskParametersAssert { + t.AddAssertion(assert.SnowflakeParameterBoolValueSet(sdk.TaskParameterEnableUnloadPhysicalTypeOptimization, expected)) + return t +} + +func (t *TaskParametersAssert) HasErrorOnNondeterministicMerge(expected bool) *TaskParametersAssert { + t.AddAssertion(assert.SnowflakeParameterBoolValueSet(sdk.TaskParameterErrorOnNondeterministicMerge, expected)) + return t +} + +func (t *TaskParametersAssert) HasErrorOnNondeterministicUpdate(expected bool) *TaskParametersAssert { + t.AddAssertion(assert.SnowflakeParameterBoolValueSet(sdk.TaskParameterErrorOnNondeterministicUpdate, expected)) + return t +} + +func (t *TaskParametersAssert) HasGeographyOutputFormat(expected sdk.GeographyOutputFormat) *TaskParametersAssert { + t.AddAssertion(assert.SnowflakeParameterStringUnderlyingValueSet(sdk.TaskParameterGeographyOutputFormat, expected)) + return t +} + +func (t *TaskParametersAssert) HasGeometryOutputFormat(expected sdk.GeometryOutputFormat) *TaskParametersAssert { + t.AddAssertion(assert.SnowflakeParameterStringUnderlyingValueSet(sdk.TaskParameterGeometryOutputFormat, expected)) + return t +} + +func (t *TaskParametersAssert) HasJdbcTreatTimestampNtzAsUtc(expected bool) *TaskParametersAssert { + t.AddAssertion(assert.SnowflakeParameterBoolValueSet(sdk.TaskParameterJdbcTreatTimestampNtzAsUtc, expected)) + return t +} + +func (t *TaskParametersAssert) HasJdbcUseSessionTimezone(expected bool) *TaskParametersAssert { + t.AddAssertion(assert.SnowflakeParameterBoolValueSet(sdk.TaskParameterJdbcUseSessionTimezone, expected)) + return t +} + +func (t *TaskParametersAssert) HasJsonIndent(expected int) *TaskParametersAssert { + t.AddAssertion(assert.SnowflakeParameterIntValueSet(sdk.TaskParameterJsonIndent, expected)) + return t +} + +func (t *TaskParametersAssert) HasLockTimeout(expected int) *TaskParametersAssert { + t.AddAssertion(assert.SnowflakeParameterIntValueSet(sdk.TaskParameterLockTimeout, expected)) + return t +} + +func (t *TaskParametersAssert) HasLogLevel(expected sdk.LogLevel) *TaskParametersAssert { + t.AddAssertion(assert.SnowflakeParameterStringUnderlyingValueSet(sdk.TaskParameterLogLevel, expected)) + return t +} + +func (t *TaskParametersAssert) HasMultiStatementCount(expected int) *TaskParametersAssert { + t.AddAssertion(assert.SnowflakeParameterIntValueSet(sdk.TaskParameterMultiStatementCount, expected)) + return t +} + +func (t *TaskParametersAssert) HasNoorderSequenceAsDefault(expected bool) *TaskParametersAssert { + t.AddAssertion(assert.SnowflakeParameterBoolValueSet(sdk.TaskParameterNoorderSequenceAsDefault, expected)) + return t +} + +func (t *TaskParametersAssert) HasOdbcTreatDecimalAsInt(expected bool) *TaskParametersAssert { + t.AddAssertion(assert.SnowflakeParameterBoolValueSet(sdk.TaskParameterOdbcTreatDecimalAsInt, expected)) + return t +} + +func (t *TaskParametersAssert) HasQueryTag(expected string) *TaskParametersAssert { + t.AddAssertion(assert.SnowflakeParameterValueSet(sdk.TaskParameterQueryTag, expected)) + return t +} + +func (t *TaskParametersAssert) HasQuotedIdentifiersIgnoreCase(expected bool) *TaskParametersAssert { + t.AddAssertion(assert.SnowflakeParameterBoolValueSet(sdk.TaskParameterQuotedIdentifiersIgnoreCase, expected)) + return t +} + +func (t *TaskParametersAssert) HasRowsPerResultset(expected int) *TaskParametersAssert { + t.AddAssertion(assert.SnowflakeParameterIntValueSet(sdk.TaskParameterRowsPerResultset, expected)) + return t +} + +func (t *TaskParametersAssert) HasS3StageVpceDnsName(expected string) *TaskParametersAssert { + t.AddAssertion(assert.SnowflakeParameterValueSet(sdk.TaskParameterS3StageVpceDnsName, expected)) + return t +} + +func (t *TaskParametersAssert) HasSearchPath(expected string) *TaskParametersAssert { + t.AddAssertion(assert.SnowflakeParameterValueSet(sdk.TaskParameterSearchPath, expected)) + return t +} + +func (t *TaskParametersAssert) HasStatementQueuedTimeoutInSeconds(expected int) *TaskParametersAssert { + t.AddAssertion(assert.SnowflakeParameterIntValueSet(sdk.TaskParameterStatementQueuedTimeoutInSeconds, expected)) + return t +} + +func (t *TaskParametersAssert) HasStatementTimeoutInSeconds(expected int) *TaskParametersAssert { + t.AddAssertion(assert.SnowflakeParameterIntValueSet(sdk.TaskParameterStatementTimeoutInSeconds, expected)) + return t +} + +func (t *TaskParametersAssert) HasStrictJsonOutput(expected bool) *TaskParametersAssert { + t.AddAssertion(assert.SnowflakeParameterBoolValueSet(sdk.TaskParameterStrictJsonOutput, expected)) + return t +} + +func (t *TaskParametersAssert) HasTimestampDayIsAlways24h(expected bool) *TaskParametersAssert { + t.AddAssertion(assert.SnowflakeParameterBoolValueSet(sdk.TaskParameterTimestampDayIsAlways24h, expected)) + return t +} + +func (t *TaskParametersAssert) HasTimestampInputFormat(expected string) *TaskParametersAssert { + t.AddAssertion(assert.SnowflakeParameterValueSet(sdk.TaskParameterTimestampInputFormat, expected)) + return t +} + +func (t *TaskParametersAssert) HasTimestampLtzOutputFormat(expected string) *TaskParametersAssert { + t.AddAssertion(assert.SnowflakeParameterValueSet(sdk.TaskParameterTimestampLtzOutputFormat, expected)) + return t +} + +func (t *TaskParametersAssert) HasTimestampNtzOutputFormat(expected string) *TaskParametersAssert { + t.AddAssertion(assert.SnowflakeParameterValueSet(sdk.TaskParameterTimestampNtzOutputFormat, expected)) + return t +} + +func (t *TaskParametersAssert) HasTimestampOutputFormat(expected string) *TaskParametersAssert { + t.AddAssertion(assert.SnowflakeParameterValueSet(sdk.TaskParameterTimestampOutputFormat, expected)) + return t +} + +func (t *TaskParametersAssert) HasTimestampTypeMapping(expected sdk.TimestampTypeMapping) *TaskParametersAssert { + t.AddAssertion(assert.SnowflakeParameterStringUnderlyingValueSet(sdk.TaskParameterTimestampTypeMapping, expected)) + return t +} + +func (t *TaskParametersAssert) HasTimestampTzOutputFormat(expected string) *TaskParametersAssert { + t.AddAssertion(assert.SnowflakeParameterValueSet(sdk.TaskParameterTimestampTzOutputFormat, expected)) + return t +} + +func (t *TaskParametersAssert) HasTimezone(expected string) *TaskParametersAssert { + t.AddAssertion(assert.SnowflakeParameterValueSet(sdk.TaskParameterTimezone, expected)) + return t +} + +func (t *TaskParametersAssert) HasTimeInputFormat(expected string) *TaskParametersAssert { + t.AddAssertion(assert.SnowflakeParameterValueSet(sdk.TaskParameterTimeInputFormat, expected)) + return t +} + +func (t *TaskParametersAssert) HasTimeOutputFormat(expected string) *TaskParametersAssert { + t.AddAssertion(assert.SnowflakeParameterValueSet(sdk.TaskParameterTimeOutputFormat, expected)) + return t +} + +func (t *TaskParametersAssert) HasTraceLevel(expected sdk.TraceLevel) *TaskParametersAssert { + t.AddAssertion(assert.SnowflakeParameterStringUnderlyingValueSet(sdk.TaskParameterTraceLevel, expected)) + return t +} + +func (t *TaskParametersAssert) HasTransactionAbortOnError(expected bool) *TaskParametersAssert { + t.AddAssertion(assert.SnowflakeParameterBoolValueSet(sdk.TaskParameterTransactionAbortOnError, expected)) + return t +} + +func (t *TaskParametersAssert) HasTransactionDefaultIsolationLevel(expected sdk.TransactionDefaultIsolationLevel) *TaskParametersAssert { + t.AddAssertion(assert.SnowflakeParameterStringUnderlyingValueSet(sdk.TaskParameterTransactionDefaultIsolationLevel, expected)) + return t +} + +func (t *TaskParametersAssert) HasTwoDigitCenturyStart(expected int) *TaskParametersAssert { + t.AddAssertion(assert.SnowflakeParameterIntValueSet(sdk.TaskParameterTwoDigitCenturyStart, expected)) + return t +} + +func (t *TaskParametersAssert) HasUnsupportedDdlAction(expected sdk.UnsupportedDDLAction) *TaskParametersAssert { + t.AddAssertion(assert.SnowflakeParameterStringUnderlyingValueSet(sdk.TaskParameterUnsupportedDdlAction, expected)) + return t +} + +func (t *TaskParametersAssert) HasUserTaskManagedInitialWarehouseSize(expected sdk.WarehouseSize) *TaskParametersAssert { + t.AddAssertion(assert.SnowflakeParameterStringUnderlyingValueSet(sdk.TaskParameterUserTaskManagedInitialWarehouseSize, expected)) + return t +} + +func (t *TaskParametersAssert) HasUseCachedResult(expected bool) *TaskParametersAssert { + t.AddAssertion(assert.SnowflakeParameterBoolValueSet(sdk.TaskParameterUseCachedResult, expected)) + return t +} + +func (t *TaskParametersAssert) HasWeekOfYearPolicy(expected int) *TaskParametersAssert { + t.AddAssertion(assert.SnowflakeParameterIntValueSet(sdk.TaskParameterWeekOfYearPolicy, expected)) + return t +} + +func (t *TaskParametersAssert) HasWeekStart(expected int) *TaskParametersAssert { + t.AddAssertion(assert.SnowflakeParameterIntValueSet(sdk.TaskParameterWeekStart, expected)) + return t +} + +//////////////////////////// +// Parameter level checks // +//////////////////////////// + +func (t *TaskParametersAssert) HasAutocommitLevel(expected sdk.ParameterType) *TaskParametersAssert { + t.AddAssertion(assert.SnowflakeParameterLevelSet(sdk.TaskParameterAutocommit, expected)) + return t +} + +func (t *TaskParametersAssert) HasBinaryInputFormatLevel(expected sdk.ParameterType) *TaskParametersAssert { + t.AddAssertion(assert.SnowflakeParameterLevelSet(sdk.TaskParameterBinaryInputFormat, expected)) + return t +} + +func (t *TaskParametersAssert) HasBinaryOutputFormatLevel(expected sdk.ParameterType) *TaskParametersAssert { + t.AddAssertion(assert.SnowflakeParameterLevelSet(sdk.TaskParameterBinaryOutputFormat, expected)) + return t +} + +func (t *TaskParametersAssert) HasClientMemoryLimitLevel(expected sdk.ParameterType) *TaskParametersAssert { + t.AddAssertion(assert.SnowflakeParameterLevelSet(sdk.TaskParameterClientMemoryLimit, expected)) + return t +} + +func (t *TaskParametersAssert) HasClientMetadataRequestUseConnectionCtxLevel(expected sdk.ParameterType) *TaskParametersAssert { + t.AddAssertion(assert.SnowflakeParameterLevelSet(sdk.TaskParameterClientMetadataRequestUseConnectionCtx, expected)) + return t +} + +func (t *TaskParametersAssert) HasClientPrefetchThreadsLevel(expected sdk.ParameterType) *TaskParametersAssert { + t.AddAssertion(assert.SnowflakeParameterLevelSet(sdk.TaskParameterClientPrefetchThreads, expected)) + return t +} + +func (t *TaskParametersAssert) HasClientResultChunkSizeLevel(expected sdk.ParameterType) *TaskParametersAssert { + t.AddAssertion(assert.SnowflakeParameterLevelSet(sdk.TaskParameterClientResultChunkSize, expected)) + return t +} + +func (t *TaskParametersAssert) HasClientResultColumnCaseInsensitiveLevel(expected sdk.ParameterType) *TaskParametersAssert { + t.AddAssertion(assert.SnowflakeParameterLevelSet(sdk.TaskParameterClientResultColumnCaseInsensitive, expected)) + return t +} + +func (t *TaskParametersAssert) HasClientSessionKeepAliveLevel(expected sdk.ParameterType) *TaskParametersAssert { + t.AddAssertion(assert.SnowflakeParameterLevelSet(sdk.TaskParameterClientSessionKeepAlive, expected)) + return t +} + +func (t *TaskParametersAssert) HasClientSessionKeepAliveHeartbeatFrequencyLevel(expected sdk.ParameterType) *TaskParametersAssert { + t.AddAssertion(assert.SnowflakeParameterLevelSet(sdk.TaskParameterClientSessionKeepAliveHeartbeatFrequency, expected)) + return t +} + +func (t *TaskParametersAssert) HasClientTimestampTypeMappingLevel(expected sdk.ParameterType) *TaskParametersAssert { + t.AddAssertion(assert.SnowflakeParameterLevelSet(sdk.TaskParameterClientTimestampTypeMapping, expected)) + return t +} + +func (t *TaskParametersAssert) HasDateInputFormatLevel(expected sdk.ParameterType) *TaskParametersAssert { + t.AddAssertion(assert.SnowflakeParameterLevelSet(sdk.TaskParameterDateInputFormat, expected)) + return t +} + +func (t *TaskParametersAssert) HasDateOutputFormatLevel(expected sdk.ParameterType) *TaskParametersAssert { + t.AddAssertion(assert.SnowflakeParameterLevelSet(sdk.TaskParameterDateOutputFormat, expected)) + return t +} + +func (t *TaskParametersAssert) HasEnableUnloadPhysicalTypeOptimizationLevel(expected sdk.ParameterType) *TaskParametersAssert { + t.AddAssertion(assert.SnowflakeParameterLevelSet(sdk.TaskParameterEnableUnloadPhysicalTypeOptimization, expected)) + return t +} + +func (t *TaskParametersAssert) HasErrorOnNondeterministicMergeLevel(expected sdk.ParameterType) *TaskParametersAssert { + t.AddAssertion(assert.SnowflakeParameterLevelSet(sdk.TaskParameterErrorOnNondeterministicMerge, expected)) + return t +} + +func (t *TaskParametersAssert) HasErrorOnNondeterministicUpdateLevel(expected sdk.ParameterType) *TaskParametersAssert { + t.AddAssertion(assert.SnowflakeParameterLevelSet(sdk.TaskParameterErrorOnNondeterministicUpdate, expected)) + return t +} + +func (t *TaskParametersAssert) HasGeographyOutputFormatLevel(expected sdk.ParameterType) *TaskParametersAssert { + t.AddAssertion(assert.SnowflakeParameterLevelSet(sdk.TaskParameterGeographyOutputFormat, expected)) + return t +} + +func (t *TaskParametersAssert) HasGeometryOutputFormatLevel(expected sdk.ParameterType) *TaskParametersAssert { + t.AddAssertion(assert.SnowflakeParameterLevelSet(sdk.TaskParameterGeometryOutputFormat, expected)) + return t +} + +func (t *TaskParametersAssert) HasJdbcTreatTimestampNtzAsUtcLevel(expected sdk.ParameterType) *TaskParametersAssert { + t.AddAssertion(assert.SnowflakeParameterLevelSet(sdk.TaskParameterJdbcTreatTimestampNtzAsUtc, expected)) + return t +} + +func (t *TaskParametersAssert) HasJdbcUseSessionTimezoneLevel(expected sdk.ParameterType) *TaskParametersAssert { + t.AddAssertion(assert.SnowflakeParameterLevelSet(sdk.TaskParameterJdbcUseSessionTimezone, expected)) + return t +} + +func (t *TaskParametersAssert) HasJsonIndentLevel(expected sdk.ParameterType) *TaskParametersAssert { + t.AddAssertion(assert.SnowflakeParameterLevelSet(sdk.TaskParameterJsonIndent, expected)) + return t +} + +func (t *TaskParametersAssert) HasLockTimeoutLevel(expected sdk.ParameterType) *TaskParametersAssert { + t.AddAssertion(assert.SnowflakeParameterLevelSet(sdk.TaskParameterLockTimeout, expected)) + return t +} + +func (t *TaskParametersAssert) HasLogLevelLevel(expected sdk.ParameterType) *TaskParametersAssert { + t.AddAssertion(assert.SnowflakeParameterLevelSet(sdk.TaskParameterLogLevel, expected)) + return t +} + +func (t *TaskParametersAssert) HasMultiStatementCountLevel(expected sdk.ParameterType) *TaskParametersAssert { + t.AddAssertion(assert.SnowflakeParameterLevelSet(sdk.TaskParameterMultiStatementCount, expected)) + return t +} + +func (t *TaskParametersAssert) HasNoorderSequenceAsDefaultLevel(expected sdk.ParameterType) *TaskParametersAssert { + t.AddAssertion(assert.SnowflakeParameterLevelSet(sdk.TaskParameterNoorderSequenceAsDefault, expected)) + return t +} + +func (t *TaskParametersAssert) HasOdbcTreatDecimalAsIntLevel(expected sdk.ParameterType) *TaskParametersAssert { + t.AddAssertion(assert.SnowflakeParameterLevelSet(sdk.TaskParameterOdbcTreatDecimalAsInt, expected)) + return t +} + +func (t *TaskParametersAssert) HasQueryTagLevel(expected sdk.ParameterType) *TaskParametersAssert { + t.AddAssertion(assert.SnowflakeParameterLevelSet(sdk.TaskParameterQueryTag, expected)) + return t +} + +func (t *TaskParametersAssert) HasQuotedIdentifiersIgnoreCaseLevel(expected sdk.ParameterType) *TaskParametersAssert { + t.AddAssertion(assert.SnowflakeParameterLevelSet(sdk.TaskParameterQuotedIdentifiersIgnoreCase, expected)) + return t +} + +func (t *TaskParametersAssert) HasRowsPerResultsetLevel(expected sdk.ParameterType) *TaskParametersAssert { + t.AddAssertion(assert.SnowflakeParameterLevelSet(sdk.TaskParameterRowsPerResultset, expected)) + return t +} + +func (t *TaskParametersAssert) HasS3StageVpceDnsNameLevel(expected sdk.ParameterType) *TaskParametersAssert { + t.AddAssertion(assert.SnowflakeParameterLevelSet(sdk.TaskParameterS3StageVpceDnsName, expected)) + return t +} + +func (t *TaskParametersAssert) HasSearchPathLevel(expected sdk.ParameterType) *TaskParametersAssert { + t.AddAssertion(assert.SnowflakeParameterLevelSet(sdk.TaskParameterSearchPath, expected)) + return t +} + +func (t *TaskParametersAssert) HasStatementQueuedTimeoutInSecondsLevel(expected sdk.ParameterType) *TaskParametersAssert { + t.AddAssertion(assert.SnowflakeParameterLevelSet(sdk.TaskParameterStatementQueuedTimeoutInSeconds, expected)) + return t +} + +func (t *TaskParametersAssert) HasStatementTimeoutInSecondsLevel(expected sdk.ParameterType) *TaskParametersAssert { + t.AddAssertion(assert.SnowflakeParameterLevelSet(sdk.TaskParameterStatementTimeoutInSeconds, expected)) + return t +} + +func (t *TaskParametersAssert) HasStrictJsonOutputLevel(expected sdk.ParameterType) *TaskParametersAssert { + t.AddAssertion(assert.SnowflakeParameterLevelSet(sdk.TaskParameterStrictJsonOutput, expected)) + return t +} + +func (t *TaskParametersAssert) HasTimestampDayIsAlways24hLevel(expected sdk.ParameterType) *TaskParametersAssert { + t.AddAssertion(assert.SnowflakeParameterLevelSet(sdk.TaskParameterTimestampDayIsAlways24h, expected)) + return t +} + +func (t *TaskParametersAssert) HasTimestampInputFormatLevel(expected sdk.ParameterType) *TaskParametersAssert { + t.AddAssertion(assert.SnowflakeParameterLevelSet(sdk.TaskParameterTimestampInputFormat, expected)) + return t +} + +func (t *TaskParametersAssert) HasTimestampLtzOutputFormatLevel(expected sdk.ParameterType) *TaskParametersAssert { + t.AddAssertion(assert.SnowflakeParameterLevelSet(sdk.TaskParameterTimestampLtzOutputFormat, expected)) + return t +} + +func (t *TaskParametersAssert) HasTimestampNtzOutputFormatLevel(expected sdk.ParameterType) *TaskParametersAssert { + t.AddAssertion(assert.SnowflakeParameterLevelSet(sdk.TaskParameterTimestampNtzOutputFormat, expected)) + return t +} + +func (t *TaskParametersAssert) HasTimestampOutputFormatLevel(expected sdk.ParameterType) *TaskParametersAssert { + t.AddAssertion(assert.SnowflakeParameterLevelSet(sdk.TaskParameterTimestampOutputFormat, expected)) + return t +} + +func (t *TaskParametersAssert) HasTimestampTypeMappingLevel(expected sdk.ParameterType) *TaskParametersAssert { + t.AddAssertion(assert.SnowflakeParameterLevelSet(sdk.TaskParameterTimestampTypeMapping, expected)) + return t +} + +func (t *TaskParametersAssert) HasTimestampTzOutputFormatLevel(expected sdk.ParameterType) *TaskParametersAssert { + t.AddAssertion(assert.SnowflakeParameterLevelSet(sdk.TaskParameterTimestampTzOutputFormat, expected)) + return t +} + +func (t *TaskParametersAssert) HasTimezoneLevel(expected sdk.ParameterType) *TaskParametersAssert { + t.AddAssertion(assert.SnowflakeParameterLevelSet(sdk.TaskParameterTimezone, expected)) + return t +} + +func (t *TaskParametersAssert) HasTimeInputFormatLevel(expected sdk.ParameterType) *TaskParametersAssert { + t.AddAssertion(assert.SnowflakeParameterLevelSet(sdk.TaskParameterTimeInputFormat, expected)) + return t +} + +func (t *TaskParametersAssert) HasTimeOutputFormatLevel(expected sdk.ParameterType) *TaskParametersAssert { + t.AddAssertion(assert.SnowflakeParameterLevelSet(sdk.TaskParameterTimeOutputFormat, expected)) + return t +} + +func (t *TaskParametersAssert) HasTraceLevelLevel(expected sdk.ParameterType) *TaskParametersAssert { + t.AddAssertion(assert.SnowflakeParameterLevelSet(sdk.TaskParameterTraceLevel, expected)) + return t +} + +func (t *TaskParametersAssert) HasTransactionAbortOnErrorLevel(expected sdk.ParameterType) *TaskParametersAssert { + t.AddAssertion(assert.SnowflakeParameterLevelSet(sdk.TaskParameterTransactionAbortOnError, expected)) + return t +} + +func (t *TaskParametersAssert) HasTransactionDefaultIsolationLevelLevel(expected sdk.ParameterType) *TaskParametersAssert { + t.AddAssertion(assert.SnowflakeParameterLevelSet(sdk.TaskParameterTransactionDefaultIsolationLevel, expected)) + return t +} + +func (t *TaskParametersAssert) HasTwoDigitCenturyStartLevel(expected sdk.ParameterType) *TaskParametersAssert { + t.AddAssertion(assert.SnowflakeParameterLevelSet(sdk.TaskParameterTwoDigitCenturyStart, expected)) + return t +} + +func (t *TaskParametersAssert) HasUnsupportedDdlActionLevel(expected sdk.ParameterType) *TaskParametersAssert { + t.AddAssertion(assert.SnowflakeParameterLevelSet(sdk.TaskParameterUnsupportedDdlAction, expected)) + return t +} + +func (t *TaskParametersAssert) HasUserTaskManagedInitialWarehouseSizeLevel(expected sdk.ParameterType) *TaskParametersAssert { + t.AddAssertion(assert.SnowflakeParameterLevelSet(sdk.TaskParameterUserTaskManagedInitialWarehouseSize, expected)) + return t +} + +func (t *TaskParametersAssert) HasUseCachedResultLevel(expected sdk.ParameterType) *TaskParametersAssert { + t.AddAssertion(assert.SnowflakeParameterLevelSet(sdk.TaskParameterUseCachedResult, expected)) + return t +} + +func (t *TaskParametersAssert) HasWeekOfYearPolicyLevel(expected sdk.ParameterType) *TaskParametersAssert { + t.AddAssertion(assert.SnowflakeParameterLevelSet(sdk.TaskParameterWeekOfYearPolicy, expected)) + return t +} + +func (t *TaskParametersAssert) HasWeekStartLevel(expected sdk.ParameterType) *TaskParametersAssert { + t.AddAssertion(assert.SnowflakeParameterLevelSet(sdk.TaskParameterWeekStart, expected)) + return t +} + +//////////////////////////////////// +// Parameter default value checks // +//////////////////////////////////// + +func (t *TaskParametersAssert) HasDefaultAutocommitValue() *TaskParametersAssert { + return t.HasDefaultParameterValue(sdk.TaskParameterAutocommit) +} + +func (t *TaskParametersAssert) HasDefaultBinaryInputFormatValue() *TaskParametersAssert { + return t.HasDefaultParameterValue(sdk.TaskParameterBinaryInputFormat) +} + +func (t *TaskParametersAssert) HasDefaultBinaryOutputFormatValue() *TaskParametersAssert { + return t.HasDefaultParameterValue(sdk.TaskParameterBinaryOutputFormat) +} + +func (t *TaskParametersAssert) HasDefaultClientMemoryLimitValue() *TaskParametersAssert { + return t.HasDefaultParameterValue(sdk.TaskParameterClientMemoryLimit) +} + +func (t *TaskParametersAssert) HasDefaultClientMetadataRequestUseConnectionCtxValue() *TaskParametersAssert { + return t.HasDefaultParameterValue(sdk.TaskParameterClientMetadataRequestUseConnectionCtx) +} + +func (t *TaskParametersAssert) HasDefaultClientPrefetchThreadsValue() *TaskParametersAssert { + return t.HasDefaultParameterValue(sdk.TaskParameterClientPrefetchThreads) +} + +func (t *TaskParametersAssert) HasDefaultClientResultChunkSizeValue() *TaskParametersAssert { + return t.HasDefaultParameterValue(sdk.TaskParameterClientResultChunkSize) +} + +func (t *TaskParametersAssert) HasDefaultClientResultColumnCaseInsensitiveValue() *TaskParametersAssert { + return t.HasDefaultParameterValue(sdk.TaskParameterClientResultColumnCaseInsensitive) +} + +func (t *TaskParametersAssert) HasDefaultClientSessionKeepAliveValue() *TaskParametersAssert { + return t.HasDefaultParameterValue(sdk.TaskParameterClientSessionKeepAlive) +} + +func (t *TaskParametersAssert) HasDefaultClientSessionKeepAliveHeartbeatFrequencyValue() *TaskParametersAssert { + return t.HasDefaultParameterValue(sdk.TaskParameterClientSessionKeepAliveHeartbeatFrequency) +} + +func (t *TaskParametersAssert) HasDefaultClientTimestampTypeMappingValue() *TaskParametersAssert { + return t.HasDefaultParameterValue(sdk.TaskParameterClientTimestampTypeMapping) +} + +func (t *TaskParametersAssert) HasDefaultDateInputFormatValue() *TaskParametersAssert { + return t.HasDefaultParameterValue(sdk.TaskParameterDateInputFormat) +} + +func (t *TaskParametersAssert) HasDefaultDateOutputFormatValue() *TaskParametersAssert { + return t.HasDefaultParameterValue(sdk.TaskParameterDateOutputFormat) +} + +func (t *TaskParametersAssert) HasDefaultEnableUnloadPhysicalTypeOptimizationValue() *TaskParametersAssert { + return t.HasDefaultParameterValue(sdk.TaskParameterEnableUnloadPhysicalTypeOptimization) +} + +func (t *TaskParametersAssert) HasDefaultErrorOnNondeterministicMergeValue() *TaskParametersAssert { + return t.HasDefaultParameterValue(sdk.TaskParameterErrorOnNondeterministicMerge) +} + +func (t *TaskParametersAssert) HasDefaultErrorOnNondeterministicUpdateValue() *TaskParametersAssert { + return t.HasDefaultParameterValue(sdk.TaskParameterErrorOnNondeterministicUpdate) +} + +func (t *TaskParametersAssert) HasDefaultGeographyOutputFormatValue() *TaskParametersAssert { + return t.HasDefaultParameterValue(sdk.TaskParameterGeographyOutputFormat) +} + +func (t *TaskParametersAssert) HasDefaultGeometryOutputFormatValue() *TaskParametersAssert { + return t.HasDefaultParameterValue(sdk.TaskParameterGeometryOutputFormat) +} + +func (t *TaskParametersAssert) HasDefaultJdbcTreatTimestampNtzAsUtcValue() *TaskParametersAssert { + return t.HasDefaultParameterValue(sdk.TaskParameterJdbcTreatTimestampNtzAsUtc) +} + +func (t *TaskParametersAssert) HasDefaultJdbcUseSessionTimezoneValue() *TaskParametersAssert { + return t.HasDefaultParameterValue(sdk.TaskParameterJdbcUseSessionTimezone) +} + +func (t *TaskParametersAssert) HasDefaultJsonIndentValue() *TaskParametersAssert { + return t.HasDefaultParameterValue(sdk.TaskParameterJsonIndent) +} + +func (t *TaskParametersAssert) HasDefaultLockTimeoutValue() *TaskParametersAssert { + return t.HasDefaultParameterValue(sdk.TaskParameterLockTimeout) +} + +func (t *TaskParametersAssert) HasDefaultLogLevelValue() *TaskParametersAssert { + return t.HasDefaultParameterValue(sdk.TaskParameterLogLevel) +} + +func (t *TaskParametersAssert) HasDefaultMultiStatementCountValue() *TaskParametersAssert { + return t.HasDefaultParameterValue(sdk.TaskParameterMultiStatementCount) +} + +func (t *TaskParametersAssert) HasDefaultNoorderSequenceAsDefaultValue() *TaskParametersAssert { + return t.HasDefaultParameterValue(sdk.TaskParameterNoorderSequenceAsDefault) +} + +func (t *TaskParametersAssert) HasDefaultOdbcTreatDecimalAsIntValue() *TaskParametersAssert { + return t.HasDefaultParameterValue(sdk.TaskParameterOdbcTreatDecimalAsInt) +} + +func (t *TaskParametersAssert) HasDefaultQueryTagValue() *TaskParametersAssert { + return t.HasDefaultParameterValue(sdk.TaskParameterQueryTag) +} + +func (t *TaskParametersAssert) HasDefaultQuotedIdentifiersIgnoreCaseValue() *TaskParametersAssert { + return t.HasDefaultParameterValue(sdk.TaskParameterQuotedIdentifiersIgnoreCase) +} + +func (t *TaskParametersAssert) HasDefaultRowsPerResultsetValue() *TaskParametersAssert { + return t.HasDefaultParameterValue(sdk.TaskParameterRowsPerResultset) +} + +func (t *TaskParametersAssert) HasDefaultS3StageVpceDnsNameValue() *TaskParametersAssert { + return t.HasDefaultParameterValue(sdk.TaskParameterS3StageVpceDnsName) +} + +func (t *TaskParametersAssert) HasDefaultSearchPathValue() *TaskParametersAssert { + return t.HasDefaultParameterValue(sdk.TaskParameterSearchPath) +} + +func (t *TaskParametersAssert) HasDefaultStatementQueuedTimeoutInSecondsValue() *TaskParametersAssert { + return t.HasDefaultParameterValue(sdk.TaskParameterStatementQueuedTimeoutInSeconds) +} + +func (t *TaskParametersAssert) HasDefaultStatementTimeoutInSecondsValue() *TaskParametersAssert { + return t.HasDefaultParameterValue(sdk.TaskParameterStatementTimeoutInSeconds) +} + +func (t *TaskParametersAssert) HasDefaultStrictJsonOutputValue() *TaskParametersAssert { + return t.HasDefaultParameterValue(sdk.TaskParameterStrictJsonOutput) +} + +func (t *TaskParametersAssert) HasDefaultTimestampDayIsAlways24hValue() *TaskParametersAssert { + return t.HasDefaultParameterValue(sdk.TaskParameterTimestampDayIsAlways24h) +} + +func (t *TaskParametersAssert) HasDefaultTimestampInputFormatValue() *TaskParametersAssert { + return t.HasDefaultParameterValue(sdk.TaskParameterTimestampInputFormat) +} + +func (t *TaskParametersAssert) HasDefaultTimestampLtzOutputFormatValue() *TaskParametersAssert { + return t.HasDefaultParameterValue(sdk.TaskParameterTimestampLtzOutputFormat) +} + +func (t *TaskParametersAssert) HasDefaultTimestampNtzOutputFormatValue() *TaskParametersAssert { + return t.HasDefaultParameterValue(sdk.TaskParameterTimestampNtzOutputFormat) +} + +func (t *TaskParametersAssert) HasDefaultTimestampOutputFormatValue() *TaskParametersAssert { + return t.HasDefaultParameterValue(sdk.TaskParameterTimestampOutputFormat) +} + +func (t *TaskParametersAssert) HasDefaultTimestampTypeMappingValue() *TaskParametersAssert { + return t.HasDefaultParameterValue(sdk.TaskParameterTimestampTypeMapping) +} + +func (t *TaskParametersAssert) HasDefaultTimestampTzOutputFormatValue() *TaskParametersAssert { + return t.HasDefaultParameterValue(sdk.TaskParameterTimestampTzOutputFormat) +} + +func (t *TaskParametersAssert) HasDefaultTimezoneValue() *TaskParametersAssert { + return t.HasDefaultParameterValue(sdk.TaskParameterTimezone) +} + +func (t *TaskParametersAssert) HasDefaultTimeInputFormatValue() *TaskParametersAssert { + return t.HasDefaultParameterValue(sdk.TaskParameterTimeInputFormat) +} + +func (t *TaskParametersAssert) HasDefaultTimeOutputFormatValue() *TaskParametersAssert { + return t.HasDefaultParameterValue(sdk.TaskParameterTimeOutputFormat) +} + +func (t *TaskParametersAssert) HasDefaultTraceLevelValue() *TaskParametersAssert { + return t.HasDefaultParameterValue(sdk.TaskParameterTraceLevel) +} + +func (t *TaskParametersAssert) HasDefaultTransactionAbortOnErrorValue() *TaskParametersAssert { + return t.HasDefaultParameterValue(sdk.TaskParameterTransactionAbortOnError) +} + +func (t *TaskParametersAssert) HasDefaultTransactionDefaultIsolationLevelValue() *TaskParametersAssert { + return t.HasDefaultParameterValue(sdk.TaskParameterTransactionDefaultIsolationLevel) +} + +func (t *TaskParametersAssert) HasDefaultTwoDigitCenturyStartValue() *TaskParametersAssert { + return t.HasDefaultParameterValue(sdk.TaskParameterTwoDigitCenturyStart) +} + +func (t *TaskParametersAssert) HasDefaultUnsupportedDdlActionValue() *TaskParametersAssert { + return t.HasDefaultParameterValue(sdk.TaskParameterUnsupportedDdlAction) +} + +func (t *TaskParametersAssert) HasDefaultUserTaskManagedInitialWarehouseSizeValue() *TaskParametersAssert { + return t.HasDefaultParameterValue(sdk.TaskParameterUserTaskManagedInitialWarehouseSize) +} + +func (t *TaskParametersAssert) HasDefaultUseCachedResultValue() *TaskParametersAssert { + return t.HasDefaultParameterValue(sdk.TaskParameterUseCachedResult) +} + +func (t *TaskParametersAssert) HasDefaultWeekOfYearPolicyValue() *TaskParametersAssert { + return t.HasDefaultParameterValue(sdk.TaskParameterWeekOfYearPolicy) +} + +func (t *TaskParametersAssert) HasDefaultWeekStartValue() *TaskParametersAssert { + return t.HasDefaultParameterValue(sdk.TaskParameterWeekStart) +} + +///////////////////////////////////////////// +// Parameter explicit default value checks // +///////////////////////////////////////////// + +func (t *TaskParametersAssert) HasDefaultAutocommitValueExplicit() *TaskParametersAssert { + return t.HasAutocommit(true) +} + +func (t *TaskParametersAssert) HasDefaultBinaryInputFormatValueExplicit() *TaskParametersAssert { + return t.HasBinaryInputFormat(sdk.BinaryInputFormatHex) +} + +func (t *TaskParametersAssert) HasDefaultBinaryOutputFormatValueExplicit() *TaskParametersAssert { + return t.HasBinaryOutputFormat(sdk.BinaryOutputFormatHex) +} + +func (t *TaskParametersAssert) HasDefaultClientMemoryLimitValueExplicit() *TaskParametersAssert { + return t.HasClientMemoryLimit(1536) +} + +func (t *TaskParametersAssert) HasDefaultClientMetadataRequestUseConnectionCtxValueExplicit() *TaskParametersAssert { + return t.HasClientMetadataRequestUseConnectionCtx(false) +} + +func (t *TaskParametersAssert) HasDefaultClientPrefetchThreadsValueExplicit() *TaskParametersAssert { + return t.HasClientPrefetchThreads(4) +} + +func (t *TaskParametersAssert) HasDefaultClientResultChunkSizeValueExplicit() *TaskParametersAssert { + return t.HasClientResultChunkSize(160) +} + +func (t *TaskParametersAssert) HasDefaultClientResultColumnCaseInsensitiveValueExplicit() *TaskParametersAssert { + return t.HasClientResultColumnCaseInsensitive(false) +} + +func (t *TaskParametersAssert) HasDefaultClientSessionKeepAliveValueExplicit() *TaskParametersAssert { + return t.HasClientSessionKeepAlive(false) +} + +func (t *TaskParametersAssert) HasDefaultClientSessionKeepAliveHeartbeatFrequencyValueExplicit() *TaskParametersAssert { + return t.HasClientSessionKeepAliveHeartbeatFrequency(3600) +} + +func (t *TaskParametersAssert) HasDefaultClientTimestampTypeMappingValueExplicit() *TaskParametersAssert { + return t.HasClientTimestampTypeMapping(sdk.ClientTimestampTypeMappingLtz) +} + +func (t *TaskParametersAssert) HasDefaultDateInputFormatValueExplicit() *TaskParametersAssert { + return t.HasDateInputFormat("AUTO") +} + +func (t *TaskParametersAssert) HasDefaultDateOutputFormatValueExplicit() *TaskParametersAssert { + return t.HasDateOutputFormat("YYYY-MM-DD") +} + +func (t *TaskParametersAssert) HasDefaultEnableUnloadPhysicalTypeOptimizationValueExplicit() *TaskParametersAssert { + return t.HasEnableUnloadPhysicalTypeOptimization(true) +} + +func (t *TaskParametersAssert) HasDefaultErrorOnNondeterministicMergeValueExplicit() *TaskParametersAssert { + return t.HasErrorOnNondeterministicMerge(true) +} + +func (t *TaskParametersAssert) HasDefaultErrorOnNondeterministicUpdateValueExplicit() *TaskParametersAssert { + return t.HasErrorOnNondeterministicUpdate(false) +} + +func (t *TaskParametersAssert) HasDefaultGeographyOutputFormatValueExplicit() *TaskParametersAssert { + return t.HasGeographyOutputFormat(sdk.GeographyOutputFormatGeoJSON) +} + +func (t *TaskParametersAssert) HasDefaultGeometryOutputFormatValueExplicit() *TaskParametersAssert { + return t.HasGeometryOutputFormat(sdk.GeometryOutputFormatGeoJSON) +} + +func (t *TaskParametersAssert) HasDefaultJdbcTreatTimestampNtzAsUtcValueExplicit() *TaskParametersAssert { + return t.HasJdbcTreatTimestampNtzAsUtc(false) +} + +func (t *TaskParametersAssert) HasDefaultJdbcUseSessionTimezoneValueExplicit() *TaskParametersAssert { + return t.HasJdbcUseSessionTimezone(true) +} + +func (t *TaskParametersAssert) HasDefaultJsonIndentValueExplicit() *TaskParametersAssert { + return t.HasJsonIndent(2) +} + +func (t *TaskParametersAssert) HasDefaultLockTimeoutValueExplicit() *TaskParametersAssert { + return t.HasLockTimeout(43200) +} + +func (t *TaskParametersAssert) HasDefaultLogLevelValueExplicit() *TaskParametersAssert { + return t.HasLogLevel(sdk.LogLevelOff) +} + +func (t *TaskParametersAssert) HasDefaultMultiStatementCountValueExplicit() *TaskParametersAssert { + return t.HasMultiStatementCount(1) +} + +func (t *TaskParametersAssert) HasDefaultNoorderSequenceAsDefaultValueExplicit() *TaskParametersAssert { + return t.HasNoorderSequenceAsDefault(true) +} + +func (t *TaskParametersAssert) HasDefaultOdbcTreatDecimalAsIntValueExplicit() *TaskParametersAssert { + return t.HasOdbcTreatDecimalAsInt(false) +} + +func (t *TaskParametersAssert) HasDefaultQueryTagValueExplicit() *TaskParametersAssert { + return t.HasQueryTag("") +} + +func (t *TaskParametersAssert) HasDefaultQuotedIdentifiersIgnoreCaseValueExplicit() *TaskParametersAssert { + return t.HasQuotedIdentifiersIgnoreCase(false) +} + +func (t *TaskParametersAssert) HasDefaultRowsPerResultsetValueExplicit() *TaskParametersAssert { + return t.HasRowsPerResultset(0) +} + +func (t *TaskParametersAssert) HasDefaultS3StageVpceDnsNameValueExplicit() *TaskParametersAssert { + return t.HasS3StageVpceDnsName("") +} + +func (t *TaskParametersAssert) HasDefaultSearchPathValueExplicit() *TaskParametersAssert { + return t.HasSearchPath("$current, $public") +} + +func (t *TaskParametersAssert) HasDefaultStatementQueuedTimeoutInSecondsValueExplicit() *TaskParametersAssert { + return t.HasStatementQueuedTimeoutInSeconds(0) +} + +func (t *TaskParametersAssert) HasDefaultStatementTimeoutInSecondsValueExplicit() *TaskParametersAssert { + return t.HasStatementTimeoutInSeconds(172800) +} + +func (t *TaskParametersAssert) HasDefaultStrictJsonOutputValueExplicit() *TaskParametersAssert { + return t.HasStrictJsonOutput(false) +} + +func (t *TaskParametersAssert) HasDefaultTimestampDayIsAlways24hValueExplicit() *TaskParametersAssert { + return t.HasTimestampDayIsAlways24h(false) +} + +func (t *TaskParametersAssert) HasDefaultTimestampInputFormatValueExplicit() *TaskParametersAssert { + return t.HasTimestampInputFormat("AUTO") +} + +func (t *TaskParametersAssert) HasDefaultTimestampLtzOutputFormatValueExplicit() *TaskParametersAssert { + return t.HasTimestampLtzOutputFormat("") +} + +func (t *TaskParametersAssert) HasDefaultTimestampNtzOutputFormatValueExplicit() *TaskParametersAssert { + return t.HasTimestampNtzOutputFormat("YYYY-MM-DD HH24:MI:SS.FF3") +} + +func (t *TaskParametersAssert) HasDefaultTimestampOutputFormatValueExplicit() *TaskParametersAssert { + return t.HasTimestampOutputFormat("YYYY-MM-DD HH24:MI:SS.FF3 TZHTZM") +} + +func (t *TaskParametersAssert) HasDefaultTimestampTypeMappingValueExplicit() *TaskParametersAssert { + return t.HasTimestampTypeMapping(sdk.TimestampTypeMappingNtz) +} + +func (t *TaskParametersAssert) HasDefaultTimestampTzOutputFormatValueExplicit() *TaskParametersAssert { + return t.HasTimestampTzOutputFormat("") +} + +func (t *TaskParametersAssert) HasDefaultTimezoneValueExplicit() *TaskParametersAssert { + return t.HasTimezone("America/Los_Angeles") +} + +func (t *TaskParametersAssert) HasDefaultTimeInputFormatValueExplicit() *TaskParametersAssert { + return t.HasTimeInputFormat("AUTO") +} + +func (t *TaskParametersAssert) HasDefaultTimeOutputFormatValueExplicit() *TaskParametersAssert { + return t.HasTimeOutputFormat("HH24:MI:SS") +} + +func (t *TaskParametersAssert) HasDefaultTraceLevelValueExplicit() *TaskParametersAssert { + return t.HasTraceLevel(sdk.TraceLevelOff) +} + +func (t *TaskParametersAssert) HasDefaultTransactionAbortOnErrorValueExplicit() *TaskParametersAssert { + return t.HasTransactionAbortOnError(false) +} + +func (t *TaskParametersAssert) HasDefaultTransactionDefaultIsolationLevelValueExplicit() *TaskParametersAssert { + return t.HasTransactionDefaultIsolationLevel(sdk.TransactionDefaultIsolationLevelReadCommitted) +} + +func (t *TaskParametersAssert) HasDefaultTwoDigitCenturyStartValueExplicit() *TaskParametersAssert { + return t.HasTwoDigitCenturyStart(1970) +} + +func (t *TaskParametersAssert) HasDefaultUnsupportedDdlActionValueExplicit() *TaskParametersAssert { + return t.HasUnsupportedDdlAction(sdk.UnsupportedDDLAction(strings.ToLower(string(sdk.UnsupportedDDLActionIgnore)))) +} + +func (t *TaskParametersAssert) HasDefaultUserTaskManagedInitialWarehouseSizeValueExplicit() *TaskParametersAssert { + return t.HasUserTaskManagedInitialWarehouseSize("Medium") +} + +func (t *TaskParametersAssert) HasDefaultUseCachedResultValueExplicit() *TaskParametersAssert { + return t.HasUseCachedResult(true) +} + +func (t *TaskParametersAssert) HasDefaultWeekOfYearPolicyValueExplicit() *TaskParametersAssert { + return t.HasWeekOfYearPolicy(0) +} + +func (t *TaskParametersAssert) HasDefaultWeekStartValueExplicit() *TaskParametersAssert { + return t.HasWeekStart(0) +} diff --git a/pkg/acceptance/helpers/parameter_client.go b/pkg/acceptance/helpers/parameter_client.go index 3a138fe5ba..70321379b1 100644 --- a/pkg/acceptance/helpers/parameter_client.go +++ b/pkg/acceptance/helpers/parameter_client.go @@ -80,6 +80,17 @@ func (c *ParameterClient) ShowUserParameters(t *testing.T, id sdk.AccountObjectI return params } +func (c *ParameterClient) ShowTaskParameters(t *testing.T, id sdk.SchemaObjectIdentifier) []*sdk.Parameter { + t.Helper() + params, err := c.client().ShowParameters(context.Background(), &sdk.ShowParametersOptions{ + In: &sdk.ParametersIn{ + Task: id, + }, + }) + require.NoError(t, err) + return params +} + func (c *ParameterClient) UpdateAccountParameterTemporarily(t *testing.T, parameter sdk.AccountParameter, newValue string) func() { t.Helper() ctx := context.Background() diff --git a/pkg/resources/task.go b/pkg/resources/task.go index de23008e43..078e29686d 100644 --- a/pkg/resources/task.go +++ b/pkg/resources/task.go @@ -345,7 +345,11 @@ func CreateTask(d *schema.ResourceData, meta interface{}) error { } if v, ok := d.GetOk("error_integration"); ok { - createRequest.WithErrorIntegration(v.(string)) + errorIntegrationId, err := sdk.ParseAccountObjectIdentifier(v.(string)) + if err != nil { + return err + } + createRequest.WithErrorNotificationIntegration(errorIntegrationId) } if v, ok := d.GetOk("after"); ok { @@ -459,7 +463,11 @@ func UpdateTask(d *schema.ResourceData, meta interface{}) error { if newErrorIntegration == "" { alterRequest.WithUnset(*sdk.NewTaskUnsetRequest().WithErrorIntegration(true)) } else { - alterRequest.WithSet(*sdk.NewTaskSetRequest().WithErrorIntegration(newErrorIntegration.(string))) + newErrorIntegrationId, err := sdk.ParseAccountObjectIdentifier(newErrorIntegration.(string)) + if err != nil { + return err + } + alterRequest.WithSet(*sdk.NewTaskSetRequest().WithErrorNotificationIntegration(newErrorIntegrationId)) } err := client.Tasks.Alter(ctx, alterRequest) if err != nil { diff --git a/pkg/sdk/parameters.go b/pkg/sdk/parameters.go index 79445c3eae..763cd7668c 100644 --- a/pkg/sdk/parameters.go +++ b/pkg/sdk/parameters.go @@ -654,6 +654,71 @@ var AllUserParameters = []UserParameter{ UserParameterPreventUnloadToInternalStages, } +type TaskParameter string + +// TODO(SNOW-1348116 - next prs): Handle task parameters +const ( + // Task Parameters + TaskParameterUserTaskManagedInitialWarehouseSize TaskParameter = "USER_TASK_MANAGED_INITIAL_WAREHOUSE_SIZE" + + // Session Parameters (inherited) + TaskParameterAbortDetachedQuery TaskParameter = "ABORT_DETACHED_QUERY" + TaskParameterAutocommit TaskParameter = "AUTOCOMMIT" + TaskParameterBinaryInputFormat TaskParameter = "BINARY_INPUT_FORMAT" + TaskParameterBinaryOutputFormat TaskParameter = "BINARY_OUTPUT_FORMAT" + TaskParameterClientMemoryLimit TaskParameter = "CLIENT_MEMORY_LIMIT" + TaskParameterClientMetadataRequestUseConnectionCtx TaskParameter = "CLIENT_METADATA_REQUEST_USE_CONNECTION_CTX" + TaskParameterClientPrefetchThreads TaskParameter = "CLIENT_PREFETCH_THREADS" + TaskParameterClientResultChunkSize TaskParameter = "CLIENT_RESULT_CHUNK_SIZE" + TaskParameterClientResultColumnCaseInsensitive TaskParameter = "CLIENT_RESULT_COLUMN_CASE_INSENSITIVE" + TaskParameterClientSessionKeepAlive TaskParameter = "CLIENT_SESSION_KEEP_ALIVE" + TaskParameterClientSessionKeepAliveHeartbeatFrequency TaskParameter = "CLIENT_SESSION_KEEP_ALIVE_HEARTBEAT_FREQUENCY" + TaskParameterClientTimestampTypeMapping TaskParameter = "CLIENT_TIMESTAMP_TYPE_MAPPING" + TaskParameterDateInputFormat TaskParameter = "DATE_INPUT_FORMAT" + TaskParameterDateOutputFormat TaskParameter = "DATE_OUTPUT_FORMAT" + TaskParameterEnableUnloadPhysicalTypeOptimization TaskParameter = "ENABLE_UNLOAD_PHYSICAL_TYPE_OPTIMIZATION" + TaskParameterErrorOnNondeterministicMerge TaskParameter = "ERROR_ON_NONDETERMINISTIC_MERGE" + TaskParameterErrorOnNondeterministicUpdate TaskParameter = "ERROR_ON_NONDETERMINISTIC_UPDATE" + TaskParameterGeographyOutputFormat TaskParameter = "GEOGRAPHY_OUTPUT_FORMAT" + TaskParameterGeometryOutputFormat TaskParameter = "GEOMETRY_OUTPUT_FORMAT" + TaskParameterJdbcTreatDecimalAsInt TaskParameter = "JDBC_TREAT_DECIMAL_AS_INT" + TaskParameterJdbcTreatTimestampNtzAsUtc TaskParameter = "JDBC_TREAT_TIMESTAMP_NTZ_AS_UTC" + TaskParameterJdbcUseSessionTimezone TaskParameter = "JDBC_USE_SESSION_TIMEZONE" + TaskParameterJsonIndent TaskParameter = "JSON_INDENT" + TaskParameterLockTimeout TaskParameter = "LOCK_TIMEOUT" + TaskParameterLogLevel TaskParameter = "LOG_LEVEL" + TaskParameterMultiStatementCount TaskParameter = "MULTI_STATEMENT_COUNT" + TaskParameterNoorderSequenceAsDefault TaskParameter = "NOORDER_SEQUENCE_AS_DEFAULT" + TaskParameterOdbcTreatDecimalAsInt TaskParameter = "ODBC_TREAT_DECIMAL_AS_INT" + TaskParameterQueryTag TaskParameter = "QUERY_TAG" + TaskParameterQuotedIdentifiersIgnoreCase TaskParameter = "QUOTED_IDENTIFIERS_IGNORE_CASE" + TaskParameterRowsPerResultset TaskParameter = "ROWS_PER_RESULTSET" + TaskParameterS3StageVpceDnsName TaskParameter = "S3_STAGE_VPCE_DNS_NAME" + TaskParameterSearchPath TaskParameter = "SEARCH_PATH" + TaskParameterSimulatedDataSharingConsumer TaskParameter = "SIMULATED_DATA_SHARING_CONSUMER" + TaskParameterStatementQueuedTimeoutInSeconds TaskParameter = "STATEMENT_QUEUED_TIMEOUT_IN_SECONDS" + TaskParameterStatementTimeoutInSeconds TaskParameter = "STATEMENT_TIMEOUT_IN_SECONDS" + TaskParameterStrictJsonOutput TaskParameter = "STRICT_JSON_OUTPUT" + TaskParameterTimestampDayIsAlways24h TaskParameter = "TIMESTAMP_DAY_IS_ALWAYS_24H" + TaskParameterTimestampInputFormat TaskParameter = "TIMESTAMP_INPUT_FORMAT" + TaskParameterTimestampLtzOutputFormat TaskParameter = "TIMESTAMP_LTZ_OUTPUT_FORMAT" + TaskParameterTimestampNtzOutputFormat TaskParameter = "TIMESTAMP_NTZ_OUTPUT_FORMAT" + TaskParameterTimestampOutputFormat TaskParameter = "TIMESTAMP_OUTPUT_FORMAT" + TaskParameterTimestampTypeMapping TaskParameter = "TIMESTAMP_TYPE_MAPPING" + TaskParameterTimestampTzOutputFormat TaskParameter = "TIMESTAMP_TZ_OUTPUT_FORMAT" + TaskParameterTimezone TaskParameter = "TIMEZONE" + TaskParameterTimeInputFormat TaskParameter = "TIME_INPUT_FORMAT" + TaskParameterTimeOutputFormat TaskParameter = "TIME_OUTPUT_FORMAT" + TaskParameterTraceLevel TaskParameter = "TRACE_LEVEL" + TaskParameterTransactionAbortOnError TaskParameter = "TRANSACTION_ABORT_ON_ERROR" + TaskParameterTransactionDefaultIsolationLevel TaskParameter = "TRANSACTION_DEFAULT_ISOLATION_LEVEL" + TaskParameterTwoDigitCenturyStart TaskParameter = "TWO_DIGIT_CENTURY_START" + TaskParameterUnsupportedDdlAction TaskParameter = "UNSUPPORTED_DDL_ACTION" + TaskParameterUseCachedResult TaskParameter = "USE_CACHED_RESULT" + TaskParameterWeekOfYearPolicy TaskParameter = "WEEK_OF_YEAR_POLICY" + TaskParameterWeekStart TaskParameter = "WEEK_START" +) + type WarehouseParameter string const ( @@ -1239,6 +1304,7 @@ const ( ParameterTypeWarehouse ParameterType = "WAREHOUSE" ParameterTypeDatabase ParameterType = "DATABASE" ParameterTypeSchema ParameterType = "SCHEMA" + ParameterTypeTask ParameterType = "TASK" ) type Parameter struct { diff --git a/pkg/sdk/testint/tasks_gen_integration_test.go b/pkg/sdk/testint/tasks_gen_integration_test.go index 71fca789e2..ceeb7054a9 100644 --- a/pkg/sdk/testint/tasks_gen_integration_test.go +++ b/pkg/sdk/testint/tasks_gen_integration_test.go @@ -1,8 +1,11 @@ package testint import ( + "fmt" + "github.com/Snowflake-Labs/terraform-provider-snowflake/pkg/acceptance/bettertestspoc/assert/objectparametersassert" "github.com/Snowflake-Labs/terraform-provider-snowflake/pkg/acceptance/helpers/random" "testing" + "time" assertions "github.com/Snowflake-Labs/terraform-provider-snowflake/pkg/acceptance/bettertestspoc/assert" "github.com/Snowflake-Labs/terraform-provider-snowflake/pkg/acceptance/bettertestspoc/assert/objectassert" @@ -27,6 +30,9 @@ func TestInt_Tasks(t *testing.T) { ), ) require.NoError(t, err) + t.Cleanup(func() { + require.NoError(t, client.NotificationIntegrations.Drop(ctx, sdk.NewDropNotificationIntegrationRequest(errorIntegrationId).WithIfExists(sdk.Bool(true)))) + }) assertTask := func(t *testing.T, task *sdk.Task, id sdk.SchemaObjectIdentifier, warehouseName string) { t.Helper() @@ -45,7 +51,7 @@ func TestInt_Tasks(t *testing.T) { HasDefinition(sql). HasCondition(""). HasAllowOverlappingExecution(false). - HasErrorIntegration(""). + HasErrorIntegration(nil). HasLastCommittedOn(""). HasLastSuspendedOn(""). HasOwnerRoleType("ROLE"). @@ -56,7 +62,7 @@ func TestInt_Tasks(t *testing.T) { ) } - 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, errorIntegrationName string) { + 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, errorIntegrationName *sdk.AccountObjectIdentifier) { t.Helper() asserts := objectassert.TaskFromObject(t, task). @@ -112,7 +118,7 @@ func TestInt_Tasks(t *testing.T) { HasDefinition(""). HasCondition(""). HasAllowOverlappingExecution(false). - HasErrorIntegration(""). + HasErrorIntegration(nil). HasLastCommittedOn(""). HasLastSuspendedOn(""). HasOwnerRoleType(""). @@ -146,6 +152,10 @@ func TestInt_Tasks(t *testing.T) { task, err := testClientHelper().Task.Show(t, id) require.NoError(t, err) + assertions.AssertThat(t, objectparametersassert.TaskParameters(t, task.ID()). + HasUserTaskManagedInitialWarehouseSize(sdk.WarehouseSizeXSmall), + ) + assertTask(t, task, id, "") }) @@ -172,7 +182,7 @@ func TestInt_Tasks(t *testing.T) { task, err := testClientHelper().Task.Show(t, id) require.NoError(t, err) - assertTaskWithOptions(t, task, id, "some comment", testClientHelper().Ids.WarehouseId().Name(), "10 MINUTE", `SYSTEM$STREAM_HAS_DATA('MYSTREAM')`, true, `{"output_dir": "/temp/test_directory/", "learning_rate": 0.1}`, nil, errorIntegrationId.Name()) + assertTaskWithOptions(t, task, id, "some comment", testClientHelper().Ids.WarehouseId().Name(), "10 MINUTE", `SYSTEM$STREAM_HAS_DATA('MYSTREAM')`, true, `{"output_dir": "/temp/test_directory/", "learning_rate": 0.1}`, nil, &errorIntegrationId) }) t.Run("create task: with after", func(t *testing.T) { @@ -190,7 +200,7 @@ func TestInt_Tasks(t *testing.T) { task, err := testClientHelper().Task.Show(t, id) require.NoError(t, err) - assertTaskWithOptions(t, task, id, "", "", "", "", false, "", &rootTaskId, "") + assertTaskWithOptions(t, task, id, "", "", "", "", false, "", &rootTaskId, nil) }) t.Run("create task: with after and finalizer", func(t *testing.T) { @@ -411,6 +421,7 @@ func TestInt_Tasks(t *testing.T) { WithAllowOverlappingExecution(true). WithUserTaskTimeoutMs(10). WithSessionParameters(sdk.SessionParameters{ + // TODO(SNOW-1348116 - next prs): fill and assert parameters Autocommit: sdk.Bool(true), }). WithSuspendTaskAfterNumFailures(15). @@ -474,9 +485,14 @@ func TestInt_Tasks(t *testing.T) { t.Cleanup(taskCleanup) err := client.Tasks.Alter(ctx, sdk.NewAlterTaskRequest(task.ID()).WithSet(*sdk.NewTaskSetRequest(). - // TODO: Cannot set warehouse due to Snowflake error + // TODO(SNOW-1348116): Cannot set warehouse due to Snowflake error // WithWarehouse(testClientHelper().Ids.WarehouseId()). WithErrorNotificationIntegration(errorIntegrationId). + WithSessionParameters(sdk.SessionParameters{ + Autocommit: sdk.Bool(true), + ClientSessionKeepAlive: sdk.Bool(true), + // TODO(SNOW-1348116 - next prs): fill and assert parameters + }). WithSchedule("10 MINUTE"). WithConfig(`$${"output_dir": "/temp/test_directory/", "learning_rate": 0.1}$$`). WithAllowOverlappingExecution(true). @@ -488,9 +504,14 @@ func TestInt_Tasks(t *testing.T) { )) require.NoError(t, err) + // TODO(SNOW-1348116 - next prs): Assert parameters + //assertions.AssertThat(t, objectparametersassert.TaskParameters(t, task.ID()). + // HasUserTaskManagedInitialWarehouseSize() + //) + assertions.AssertThat(t, objectassert.Task(t, task.ID()). // HasWarehouse(testClientHelper().Ids.WarehouseId().Name()). - HasErrorIntegration(errorIntegrationId.Name()). + HasErrorIntegration(sdk.Pointer(errorIntegrationId)). HasSchedule("10 MINUTE"). HasConfig(`{"output_dir": "/temp/test_directory/", "learning_rate": 0.1}`). HasAllowOverlappingExecution(true). @@ -499,6 +520,10 @@ func TestInt_Tasks(t *testing.T) { err = client.Tasks.Alter(ctx, sdk.NewAlterTaskRequest(task.ID()).WithUnset(*sdk.NewTaskUnsetRequest(). WithErrorIntegration(true). + WithSessionParametersUnset(sdk.SessionParametersUnset{ + Autocommit: sdk.Bool(true), + ClientSessionKeepAlive: sdk.Bool(true), + }). WithWarehouse(true). WithSchedule(true). WithConfig(true). @@ -512,12 +537,17 @@ func TestInt_Tasks(t *testing.T) { require.NoError(t, err) assertions.AssertThat(t, objectassert.Task(t, task.ID()). - HasErrorIntegration(""). + HasErrorIntegration(nil). HasSchedule(""). HasConfig(""). HasAllowOverlappingExecution(false). HasComment(""), ) + + // TODO(SNOW-1348116 - next prs): Assert parameters + //assertions.AssertThat(t, objectparametersassert.TaskParameters(t, task.ID()). + // HasUserTaskManagedInitialWarehouseSize() + //) }) t.Run("alter task: set and unset tag", func(t *testing.T) { @@ -714,11 +744,41 @@ func TestInt_Tasks(t *testing.T) { task, taskCleanup := testClientHelper().Task.Create(t) t.Cleanup(taskCleanup) - executeRequest := sdk.NewExecuteTaskRequest(task.ID()) - err := client.Tasks.Execute(ctx, executeRequest) + err := client.Tasks.Execute(ctx, sdk.NewExecuteTaskRequest(task.ID())) require.NoError(t, err) }) + t.Run("execute task: retry last after successful last task", func(t *testing.T) { + task, taskCleanup := testClientHelper().Task.Create(t) + t.Cleanup(taskCleanup) + + _, subTaskCleanup := testClientHelper().Task.CreateWithAfter(t, task.ID()) + t.Cleanup(subTaskCleanup) + + err := client.Tasks.Execute(ctx, sdk.NewExecuteTaskRequest(task.ID())) + require.NoError(t, err) + + err = client.Tasks.Execute(ctx, sdk.NewExecuteTaskRequest(task.ID()).WithRetryLast(true)) + require.ErrorContains(t, err, fmt.Sprintf("Cannot perform retry: no suitable run of graph with root task %s to retry.", task.ID().Name())) + }) + + t.Run("execute task: retry last after failed last task", func(t *testing.T) { + task, taskCleanup := testClientHelper().Task.Create(t) + t.Cleanup(taskCleanup) + + id := testClientHelper().Ids.RandomSchemaObjectIdentifier() + _, subTaskCleanup := testClientHelper().Task.CreateWithRequest(t, sdk.NewCreateTaskRequest(id, "select * from not_existing_table")) + t.Cleanup(subTaskCleanup) + + err := client.Tasks.Execute(ctx, sdk.NewExecuteTaskRequest(task.ID())) + require.NoError(t, err) + + require.Eventually(t, func() bool { + err := client.Tasks.Execute(ctx, sdk.NewExecuteTaskRequest(task.ID()).WithRetryLast(true)) + return err != nil + }, time.Second, time.Millisecond*500) + }) + t.Run("temporarily suspend root tasks", func(t *testing.T) { rootTaskId := testClientHelper().Ids.RandomSchemaObjectIdentifier() rootTask, rootTaskCleanup := testClientHelper().Task.CreateWithRequest(t, sdk.NewCreateTaskRequest(rootTaskId, sql).WithSchedule("60 MINUTES")) @@ -747,6 +807,14 @@ func TestInt_Tasks(t *testing.T) { require.Equal(t, sdk.TaskStateStarted, rootTaskStatus.State) }) + // Tested graph + // root1 + // \ + // t1 + // / + // root2 + // Because graph validation occurs only after resuming the root task, we assume that Snowflake will throw + // validation error with given graph configuration. t.Run("resume root tasks within a graph containing more than one root task", func(t *testing.T) { rootTaskId := testClientHelper().Ids.RandomSchemaObjectIdentifier() rootTask, rootTaskCleanup := testClientHelper().Task.CreateWithRequest(t, sdk.NewCreateTaskRequest(rootTaskId, sql).WithSchedule("60 MINUTES"))