diff --git a/CHANGELOG.md b/CHANGELOG.md index 4b78064d7..e09995699 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -424,6 +424,8 @@ - **Dependencies:** Bump STACKIT SDK core module from `v0.25.0` to `v0.26.0` - [v0.2.0](services/telemetryrouter/CHANGELOG.md#v020) - **Feature:** Added `_UNKNOWN_DEFAULT_OPEN_API` fallback value to all enums to handle unknown API values gracefully. + - [v0.2.1](services/telemetryrouter/CHANGELOG.md#v021) + - **Improvement**: Use new `WaiterHandler` struct in the DNS WaitHandler - `vpn`: - [v0.4.2](services/vpn/CHANGELOG.md#v042) - **Dependencies:** Bump STACKIT SDK core module from `v0.24.0` to `v0.24.1` diff --git a/examples/telemetryrouter/go.mod b/examples/telemetryrouter/go.mod new file mode 100644 index 000000000..3c40071c5 --- /dev/null +++ b/examples/telemetryrouter/go.mod @@ -0,0 +1,16 @@ +module github.com/stackitcloud/stackit-sdk-go/examples/telemetryrouter + +go 1.25 + +// This is not needed in production. This is only here to point the golangci linter to the local version instead of the last release on GitHub. +replace github.com/stackitcloud/stackit-sdk-go/services/telemetryrouter => ../../services/telemetryrouter + +require ( + github.com/stackitcloud/stackit-sdk-go/core v0.26.0 + github.com/stackitcloud/stackit-sdk-go/services/telemetryrouter v0.2.1 +) + +require ( + github.com/golang-jwt/jwt/v5 v5.3.1 // indirect + github.com/google/uuid v1.6.0 // indirect +) diff --git a/examples/telemetryrouter/go.sum b/examples/telemetryrouter/go.sum new file mode 100644 index 000000000..3712a0c87 --- /dev/null +++ b/examples/telemetryrouter/go.sum @@ -0,0 +1,8 @@ +github.com/golang-jwt/jwt/v5 v5.3.1 h1:kYf81DTWFe7t+1VvL7eS+jKFVWaUnK9cB1qbwn63YCY= +github.com/golang-jwt/jwt/v5 v5.3.1/go.mod h1:fxCRLWMO43lRc8nhHWY6LGqRcf+1gQWArsqaEUEa5bE= +github.com/google/go-cmp v0.7.0 h1:wk8382ETsv4JYUZwIsn6YpYiWiBsYLSJiTsyBybVuN8= +github.com/google/go-cmp v0.7.0/go.mod h1:pXiqmnSA92OHEEa9HXL2W4E7lf9JzCmGVUdgjX3N/iU= +github.com/google/uuid v1.6.0 h1:NIvaJDMOsjHA8n1jAhLSgzrAzy1Hgr+hNrb57e+94F0= +github.com/google/uuid v1.6.0/go.mod h1:TIyPZe4MgqvfeYDBFedMoGGpEw/LqOeaOT+nhxU+yHo= +github.com/stackitcloud/stackit-sdk-go/core v0.26.0 h1:jQEb9gkehfp6VCP6TcYk7BI10cz4l0KM2L6hqYBH2QA= +github.com/stackitcloud/stackit-sdk-go/core v0.26.0/go.mod h1:WU1hhxnjXw2EV7CYa1nlEvNpMiRY6CvmIOaHuL3pOaA= diff --git a/examples/telemetryrouter/telemetryrouter.go b/examples/telemetryrouter/telemetryrouter.go new file mode 100644 index 000000000..14d5cfcf6 --- /dev/null +++ b/examples/telemetryrouter/telemetryrouter.go @@ -0,0 +1,390 @@ +package main + +import ( + "context" + "log" + + "github.com/stackitcloud/stackit-sdk-go/core/utils" + telemetryrouter "github.com/stackitcloud/stackit-sdk-go/services/telemetryrouter/v1betaapi" + "github.com/stackitcloud/stackit-sdk-go/services/telemetryrouter/v1betaapi/wait" +) + +func main() { + ctx := context.Background() + + projectId := "PROJECT_ID" // the uuid of your STACKIT project + regionId := "eu01" + + client, err := telemetryrouter.NewAPIClient() + if err != nil { + log.Fatalf("[TelemetryRouter API] Creating API client: %v\n", err) + } + + // Create a Telemetry Router Instance + log.Printf("[TelemetryRouter API] Creating TelemetryRouter Instance.\n") + var createdInstance string + createInstancePayload := telemetryrouter.CreateTelemetryRouterPayload{ + DisplayName: "my-tlmr-instance", + } + createResp, err := client.DefaultAPI.CreateTelemetryRouter(ctx, projectId, regionId). + CreateTelemetryRouterPayload(createInstancePayload). + Execute() + if err != nil { + log.Fatalf("[TelemetryRouter API] Error when calling `CreateTelemetryRouter`: %v\n", err) + } + log.Printf("[TelemetryRouter API] Created TelemetryRouter Instance with ID \"%s\".\n", createResp.Id) + createdInstance = createResp.Id + + // Wait for the Telemetry Router Instance to be ready + log.Printf("[TelemetryRouter API] Waiting for TelemetryRouter Instance to be created.\n") + _, err = wait.CreateTelemetryRouterWaitHandler(ctx, client.DefaultAPI, projectId, regionId, createdInstance).WaitWithContext(context.Background()) + if err != nil { + log.Fatalf("[TelemetryRouter API] Error when waiting for creation: %v\n", err) + } + log.Printf("[TelemetryRouter API] TelemetryRouter Instance \"%s\" has been successfully created.\n", createdInstance) + + // List Telemetry Router Instances + log.Printf("[TelemetryRouter API] Retrieving TelemetryRouter Instances.\n") + listResp, err := client.DefaultAPI.ListTelemetryRouters(ctx, projectId, regionId).Execute() + if err != nil { + log.Fatalf("[Telemetry Router API] Error when calling `ListTelemetryRouters`: %v\n", err) + } + log.Printf("[Telemetry Router API] Retrieved %d Telemetry Router Instances.\n", len(listResp.TelemetryRouters)) + + // Get the created Telemetry Router Instance + log.Printf("[TelemetryRouter API] Getting TelemetryRouter Instance with ID \"%s\".\n", createResp.Id) + getResp, err := client.DefaultAPI.GetTelemetryRouter(ctx, projectId, regionId, createdInstance).Execute() + if err != nil { + log.Fatalf("[Telemetry Router API] Error when calling `GetTelemetryRouter`: %v\n", err) + } + log.Printf("[Telemetry Router API] Retrieved TelemetryRouter Instance with ID \"%s\" and Display Name \"%s\".\n", getResp.Id, getResp.DisplayName) + + // Update the created Telemetry Router Instance + log.Printf("[TelemetryRouter API] Updating TelemetryRouter Instance with ID \"%s\".\n", createResp.Id) + updatePayload := telemetryrouter.UpdateTelemetryRouterPayload{ + DisplayName: utils.Ptr("my-updated-tlmr-instance"), + Filter: &telemetryrouter.ConfigFilter{ + Attributes: []telemetryrouter.ConfigFilterAttributes{ + { + Key: "service.name", + Level: "logRecord", + Matcher: "=", + Values: []string{"service1", "service2"}, + }, + }, + }, + } + updateResp, err := client.DefaultAPI.UpdateTelemetryRouter(ctx, projectId, regionId, createdInstance). + UpdateTelemetryRouterPayload(updatePayload). + Execute() + if err != nil { + log.Fatalf("[Telemetry Router API] Error when calling `UpdateTelemetryRouter`: %v\n", err) + } + log.Printf("[Telemetry Router API] Updated Telemetry Router Instance with ID \"%s\" to Display Name \"%s\".\n", updateResp.Id, updateResp.DisplayName) + + // Wait for the Telemetry Router Instance to be updated + log.Printf("[TelemetryRouter API] Waiting for TelemetryRouter Instance with ID \"%s\" to be updated.\n", createResp.Id) + _, err = wait.UpdateTelemetryRouterWaitHandler(ctx, client.DefaultAPI, projectId, regionId, createdInstance).WaitWithContext(context.Background()) + if err != nil { + log.Fatalf("[Telemetry Router API] Error when waiting for update: %v\n", err) + } + log.Printf("[Telemetry Router API] TelemetryRouter Instance \"%s\" has been successfully updated.\n", createdInstance) + + // Create an Access Token + log.Printf("[TelemetryRouter API] Creating AccessToken for TelemetryRouter Instance with ID \"%s\".\n", createResp.Id) + createTokenPayload := telemetryrouter.CreateAccessTokenPayload{ + DisplayName: "my-access-token", + } + createTokenResp, err := client.DefaultAPI.CreateAccessToken(ctx, projectId, regionId, createdInstance). + CreateAccessTokenPayload(createTokenPayload). + Execute() + if err != nil { + log.Fatalf("[Telemetry Router API] Error when calling `CreateAccessToken`: %v\n", err) + } + log.Printf("[Telemetry Router API] Created Access Token with ID \"%s\".\n", createTokenResp.Id) + + // Wait for the Access Token to be created + log.Printf("[TelemetryRouter API] Waiting for AccessToken for TelemetryRouter Instance with ID \"%s\" to be created.\n", createResp.Id) + _, err = wait.CreateAccessTokenWaitHandler(ctx, client.DefaultAPI, projectId, regionId, createdInstance, createTokenResp.Id).WaitWithContext(context.Background()) + if err != nil { + log.Fatalf("[Telemetry Router API] Error when waiting for creation: %v\n", err) + } + log.Printf("[Telemetry Router API] Access Token \"%s\" has been successfully created.\n", createTokenResp.Id) + + // Get the created Access Token + log.Printf("[TelemetryRouter API] Retrieving the AccessToken with ID \"%s\".\n", createTokenResp.Id) + getTokenResp, err := client.DefaultAPI.GetAccessToken(ctx, projectId, regionId, createdInstance, createTokenResp.Id).Execute() + if err != nil { + log.Fatalf("[Telemetry Router API] Error when calling `GetAccessToken`: %v\n", err) + } + log.Printf("[Telemetry Router API] Retrieved Access Token with ID \"%s\" and Display Name \"%s\".\n", getTokenResp.Id, getTokenResp.DisplayName) + + // List Access Tokens + log.Printf("[TelemetryRouter API] Listing AccessTokens.\n") + listTokenResp, err := client.DefaultAPI.ListAccessTokens(ctx, projectId, regionId, createdInstance).Execute() + if err != nil { + log.Fatalf("[Telemetry Router API] Error when calling `ListAccessTokens`: %v\n", err) + } + log.Printf("[Telemetry Router API] Retrieved %d Access Tokens.\n", len(listTokenResp.AccessTokens)) + + // Update an Access Token + log.Printf("[Telemetry Router API] Updating the Access Token with ID \"%s\".\n", createTokenResp.Id) + newDisplayNameNS := telemetryrouter.NullableString{} + newDisplayNameNS.Set(utils.Ptr("my-updated-acc-token")) + updateTokenPayload := telemetryrouter.UpdateAccessTokenPayload{ + DisplayName: newDisplayNameNS, + } + updateTokenResp, err := client.DefaultAPI.UpdateAccessToken(ctx, projectId, regionId, createdInstance, createTokenResp.Id). + UpdateAccessTokenPayload(updateTokenPayload). + Execute() + if err != nil { + log.Fatalf("[Telemetry Router API] Error when calling `UpdateAccessToken`: %v\n", err) + } + log.Printf("[Telemetry Router API] Updated Access Token with ID \"%s\" to Display Name \"%s\".\n.\n", updateTokenResp.Id, updateTokenResp.DisplayName) + + // Wait for the Access Token to be updated + log.Printf("[Telemetry Router API] Waiting for the Access Token with ID \"%s\" to be updated.\n", createTokenResp.Id) + _, err = wait.UpdateAccessTokenWaitHandler(ctx, client.DefaultAPI, projectId, regionId, createdInstance, updateTokenResp.Id).WaitWithContext(context.Background()) + if err != nil { + log.Fatalf("[Telemetry Router API] Error when waiting for update: %v\n", err) + } + log.Printf("[Telemetry Router API] Access Token \"%s\" has been successfully updated.\n", updateTokenResp.Id) + + // Delete Access Token + log.Printf("[Telemetry Router API] Deleting for the Access Token with ID \"%s\".\n", createTokenResp.Id) + err = client.DefaultAPI.DeleteAccessToken(ctx, projectId, regionId, createdInstance, updateTokenResp.Id).Execute() + if err != nil { + log.Fatalf("[Telemetry Router API] Error when calling `DeleteAccessToken`: %v\n", err) + } + log.Printf("[Telemetry Router API] Deleted Access Tokens.\n") + + // Wait for the Access Token to be deleted + log.Printf("[Telemetry Router API] Waiting for the Access Token with ID \"%s\" to be deleted.\n", createTokenResp.Id) + _, err = wait.DeleteAccessTokenWaitHandler(ctx, client.DefaultAPI, projectId, regionId, createdInstance, updateTokenResp.Id).WaitWithContext(context.Background()) + if err != nil { + log.Fatalf("[Telemetry Router API] Error when waiting for deletion: %v\n", err) + } + log.Printf("[Telemetry Router API] Access Token \"%s\" has been successfully deleted.\n", updateTokenResp.Id) + + // Create S3 Destination + log.Printf("[Telemetry Router API] Creating Destination.\n") + createS3DestinationPayload := telemetryrouter.CreateDestinationPayload{ + DisplayName: "s3-destination", + Config: telemetryrouter.DestinationConfig{ + ConfigType: "S3", + S3: &telemetryrouter.DestinationConfigS3{ + AccessKey: &telemetryrouter.DestinationConfigS3AccessKey{ + Id: "id", + Secret: "secret", + }, + Bucket: "bucket", + Endpoint: "https://portal.stackit.cloud/", + }, + }, + } + createS3DestinationResp, err := client.DefaultAPI.CreateDestination(ctx, projectId, regionId, createdInstance). + CreateDestinationPayload(createS3DestinationPayload).Execute() + if err != nil { + log.Fatalf("[Telemetry Router API] Error when calling `CreateDestination`: %v\n", err) + } + log.Printf("[Telemetry Router API] Created Destination with ID \"%s\".\n", createS3DestinationResp.Id) + + // Wait for the S3 Destination to be created + log.Printf("[Telemetry Router API] Waiting for a Destination to be created.\n") + _, err = wait.CreateDestinationWaitHandler(ctx, client.DefaultAPI, projectId, regionId, createdInstance, createS3DestinationResp.Id).WaitWithContext(context.Background()) + if err != nil { + log.Fatalf("[Telemetry Router API] Error when waiting for creation: %v\n", err) + } + log.Printf("[Telemetry Router API] Destination \"%s\" has been successfully created.\n", createS3DestinationResp.Id) + + // Get the created S3 Destination + log.Printf("[Telemetry Router API] Retrieving Destination with ID \"%s\".\n", createS3DestinationResp.Id) + getS3DestinationResp, err := client.DefaultAPI.GetDestination(ctx, projectId, regionId, createdInstance, createS3DestinationResp.Id).Execute() + if err != nil { + log.Fatalf("[Telemetry Router API] Error when calling `GetDestination`: %v\n", err) + } + log.Printf("[Telemetry Router API] Retrieved Destination with ID \"%s\" and Display Name \"%s\".\n", getS3DestinationResp.Id, getS3DestinationResp.DisplayName) + + // List Destinations + log.Printf("[Telemetry Router API] Listing Destinations.\n") + listDestinationResp, err := client.DefaultAPI.ListDestinations(ctx, projectId, regionId, createdInstance).Execute() + if err != nil { + log.Fatalf("[Telemetry Router API] Error when calling `ListDestinations`: %v\n", err) + } + log.Printf("[Telemetry Router API] Retrieved %d Destinations.\n", len(listDestinationResp.Destinations)) + + // Update S3 Destination + log.Printf("[Telemetry Router API] Updating Destination with ID \"%s\".\n", createS3DestinationResp.Id) + updateS3DestinationPayload := telemetryrouter.UpdateDestinationPayload{ + DisplayName: utils.Ptr("updated-s3-destination"), + Config: &telemetryrouter.DestinationConfig{ + ConfigType: "S3", + S3: &telemetryrouter.DestinationConfigS3{ + AccessKey: &telemetryrouter.DestinationConfigS3AccessKey{ + Id: "id", + Secret: "secret", + }, + Bucket: "bucket", + Endpoint: "https://portal.stackit.cloud/", + }, + Filter: &telemetryrouter.ConfigFilter{ + Attributes: []telemetryrouter.ConfigFilterAttributes{ + { + Key: "service.name", + Level: "logRecord", + Matcher: "=", + Values: []string{"service1", "service2"}, + }, + }, + }, + }, + } + updateS3DestinationResp, err := client.DefaultAPI.UpdateDestination(ctx, projectId, regionId, createdInstance, createS3DestinationResp.Id). + UpdateDestinationPayload(updateS3DestinationPayload).Execute() + if err != nil { + log.Fatalf("[Telemetry Router API] Error when calling `UpdateDestination`: %v\n", err) + } + log.Printf("[Telemetry Router API] Updated Destination with ID \"%s\".\n", updateS3DestinationResp.Id) + + // Wait for the S3 Destination to be updated + log.Printf("[Telemetry Router API] Waiting for the Destination with ID \"%s\" to be updated.\n", createS3DestinationResp.Id) + _, err = wait.UpdateDestinationWaitHandler(ctx, client.DefaultAPI, projectId, regionId, createdInstance, updateS3DestinationResp.Id).WaitWithContext(context.Background()) + if err != nil { + log.Fatalf("[Telemetry Router API] Error when waiting for update: %v\n", err) + } + log.Printf("[Telemetry Router API] Destination \"%s\" has been successfully updated.\n", updateS3DestinationResp.Id) + + // Delete S3 Destination + log.Printf("[Telemetry Router API] Deleting Destination with ID \"%s\".\n", updateS3DestinationResp.Id) + err = client.DefaultAPI.DeleteDestination(ctx, projectId, regionId, createdInstance, updateS3DestinationResp.Id).Execute() + if err != nil { + log.Fatalf("[Telemetry Router API] Error when calling `DeleteDestination`: %v\n", err) + } + log.Printf("[Telemetry Router API] Deleted Destination with ID \"%s\".\n", updateS3DestinationResp.Id) + + // Wait for the S3 Destination to be deleted + log.Printf("[Telemetry Router API] Waiting for Destination with ID \"%s\" to be deleted.\n", updateS3DestinationResp.Id) + _, err = wait.DeleteDestinationWaitHandler(ctx, client.DefaultAPI, projectId, regionId, createdInstance, updateS3DestinationResp.Id).WaitWithContext(context.Background()) + if err != nil { + log.Fatalf("[Telemetry Router API] Error when waiting for deletion: %v\n", err) + } + log.Printf("[Telemetry Router API] Destination \"%s\" has been successfully deleted.\n", updateS3DestinationResp.Id) + + // Create OpenTelemetry Destination + log.Printf("[Telemetry Router API] Creating Destination.\n") + createOpenTelemetryDestinationPayload := telemetryrouter.CreateDestinationPayload{ + DisplayName: "otlp-destination", + Config: telemetryrouter.DestinationConfig{ + ConfigType: "OpenTelemetry", + OpenTelemetry: &telemetryrouter.DestinationConfigOpenTelemetry{ + BasicAuth: &telemetryrouter.DestinationConfigOpenTelemetryBasicAuth{ + Password: "password", + Username: "user", + }, + Uri: "https://portal.stackit.cloud/v1/logs", + }, + }, + } + createOpenTelemetryDestinationResp, err := client.DefaultAPI.CreateDestination(ctx, projectId, regionId, createdInstance). + CreateDestinationPayload(createOpenTelemetryDestinationPayload).Execute() + if err != nil { + log.Fatalf("[Telemetry Router API] Error when calling `CreateDestination`: %v\n", err) + } + log.Printf("[Telemetry Router API] Created Destination with ID \"%s\".\n", createOpenTelemetryDestinationResp.Id) + + // Wait for the OpenTelemetry Destination to be created + log.Printf("[Telemetry Router API] Waiting for Destination to be created.\n") + _, err = wait.CreateDestinationWaitHandler(ctx, client.DefaultAPI, projectId, regionId, createdInstance, createOpenTelemetryDestinationResp.Id).WaitWithContext(context.Background()) + if err != nil { + log.Fatalf("[Telemetry Router API] Error when waiting for creation: %v\n", err) + } + log.Printf("[Telemetry Router API] Destination \"%s\" has been successfully created.\n", createOpenTelemetryDestinationResp.Id) + + // Get the created OpenTelemetry Destination + log.Printf("[Telemetry Router API] Receiving Destination with ID \"%s\".\n", createOpenTelemetryDestinationResp.Id) + getOpenTelemetryDestinationResp, err := client.DefaultAPI.GetDestination(ctx, projectId, regionId, createdInstance, createOpenTelemetryDestinationResp.Id).Execute() + if err != nil { + log.Fatalf("[Telemetry Router API] Error when calling `GetDestination`: %v\n", err) + } + log.Printf("[Telemetry Router API] Received Destination with ID \"%s\".\n", getOpenTelemetryDestinationResp.Id) + + // List Destinations + log.Printf("[Telemetry Router API] Listing Destinations.\n") + listDestinationsResp, err := client.DefaultAPI.ListDestinations(ctx, projectId, regionId, createdInstance).Execute() + if err != nil { + log.Fatalf("[Telemetry Router API] Error when calling `ListDestinations`: %v\n", err) + } + log.Printf("[Telemetry Router API] Received %d Destinations.\n", len(listDestinationsResp.Destinations)) + + // Update S3 Destination + log.Printf("[Telemetry Router API] Updating Destination with ID \"%s\".\n", createOpenTelemetryDestinationResp.Id) + updateOTLPDestinationPayload := telemetryrouter.UpdateDestinationPayload{ + DisplayName: utils.Ptr("updated-otlp-destination"), + Config: &telemetryrouter.DestinationConfig{ + ConfigType: "OpenTelemetry", + OpenTelemetry: &telemetryrouter.DestinationConfigOpenTelemetry{ + BasicAuth: &telemetryrouter.DestinationConfigOpenTelemetryBasicAuth{ + Username: "user1", + Password: "pass", + }, + Uri: "https://portal.stackit.cloud/v1/logs", + }, + Filter: &telemetryrouter.ConfigFilter{ + Attributes: []telemetryrouter.ConfigFilterAttributes{ + { + Key: "service.name", + Level: "logRecord", + Matcher: "=", + Values: []string{"service1", "service2"}, + }, + }, + }, + }, + } + updateOTLPDestinationResp, err := client.DefaultAPI.UpdateDestination(ctx, projectId, regionId, createdInstance, createOpenTelemetryDestinationResp.Id). + UpdateDestinationPayload(updateOTLPDestinationPayload).Execute() + if err != nil { + log.Fatalf("[Telemetry Router API] Error when calling `UpdateDestination`: %v\n", err) + } + log.Printf("[Telemetry Router API] Updated Destination with ID \"%s\".\n", updateOTLPDestinationResp.Id) + + // Wait for the OpenTelemetry Destination to be updated + log.Printf("[Telemetry Router API] Waiting for Destination \"%s\" to be updated.\n", createOpenTelemetryDestinationResp.Id) + _, err = wait.UpdateDestinationWaitHandler(ctx, client.DefaultAPI, projectId, regionId, createdInstance, updateOTLPDestinationResp.Id).WaitWithContext(context.Background()) + if err != nil { + log.Fatalf("[Telemetry Router API] Error when waiting for update: %v\n", err) + } + log.Printf("[Telemetry Router API] Destination \"%s\" has been successfully updated.\n", updateOTLPDestinationResp.Id) + + // Delete OpenTelemetry Destination + log.Printf("[Telemetry Router API] Deleting Destination with ID \"%s\".\n", updateOTLPDestinationResp.Id) + err = client.DefaultAPI.DeleteDestination(ctx, projectId, regionId, createdInstance, updateOTLPDestinationResp.Id).Execute() + if err != nil { + log.Fatalf("[Telemetry Router API] Error when calling `DeleteDestination`: %v\n", err) + } + log.Printf("[Telemetry Router API] Deleted Destination with ID \"%s\".\n", updateOTLPDestinationResp.Id) + + // Wait for the OpenTelemetry Destination to be deleted + log.Printf("[Telemetry Router API] Waiting for Destination \"%s\" to be deleted.\n", updateOTLPDestinationResp.Id) + _, err = wait.DeleteDestinationWaitHandler(ctx, client.DefaultAPI, projectId, regionId, createdInstance, updateOTLPDestinationResp.Id).WaitWithContext(context.Background()) + if err != nil { + log.Fatalf("[Telemetry Router API] Error when waiting for deletion: %v\n", err) + } + log.Printf("[Telemetry Router API] Destination \"%s\" has been successfully deleted.\n", updateOTLPDestinationResp.Id) + + // Delete the created TelemetryRouter Instance + log.Printf("[Telemetry Router API] Deleting Telemetry Router Instance with ID \"%s\".\n", createdInstance) + err = client.DefaultAPI.DeleteTelemetryRouter(ctx, projectId, regionId, createdInstance).Execute() + if err != nil { + log.Fatalf("[Telemetry Router API] Error when calling `DeleteTelemetryRouter`: %v\n", err) + } + log.Printf("[Telemetry Router API] Deleted Telemetry Router Instance with ID \"%s\".\n", createdInstance) + + // Wait for the TelemetryRouter Instance to be deleted + log.Printf("[Telemetry Router API] Waiting for Telemetry Router Instance with ID \"%s\" to be deleted.\n", createdInstance) + _, err = wait.DeleteTelemetryRouterWaitHandler(ctx, client.DefaultAPI, projectId, regionId, createdInstance).WaitWithContext(context.Background()) + if err != nil { + log.Fatalf("[Telemetry Router API] Error when waiting for deletion: %v\n", err) + } + log.Printf("[Telemetry Router API] Telemetry Router Instance \"%s\" has been successfully deleted.\n", createdInstance) +} diff --git a/go.work b/go.work index 570ca9e4d..cf8c009e8 100644 --- a/go.work +++ b/go.work @@ -34,6 +34,7 @@ use ( ./examples/sfs ./examples/ske ./examples/sqlserverflex + ./examples/telemetryrouter ./examples/waiter ./services/alb ./services/albwaf diff --git a/services/telemetryrouter/CHANGELOG.md b/services/telemetryrouter/CHANGELOG.md index 84ef5c57c..2d0d23697 100644 --- a/services/telemetryrouter/CHANGELOG.md +++ b/services/telemetryrouter/CHANGELOG.md @@ -1,3 +1,6 @@ +## v0.2.1 +- **Improvement**: Use new `WaiterHandler` struct in the DNS WaitHandler + ## v0.2.0 - **Feature:** Added `_UNKNOWN_DEFAULT_OPEN_API` fallback value to all enums to handle unknown API values gracefully. diff --git a/services/telemetryrouter/VERSION b/services/telemetryrouter/VERSION index 81fd7ba08..eac0a1441 100644 --- a/services/telemetryrouter/VERSION +++ b/services/telemetryrouter/VERSION @@ -1 +1 @@ -v0.2.0 \ No newline at end of file +v0.2.1 \ No newline at end of file diff --git a/services/telemetryrouter/go.mod b/services/telemetryrouter/go.mod index 81adf4d2a..a1ccc874f 100644 --- a/services/telemetryrouter/go.mod +++ b/services/telemetryrouter/go.mod @@ -2,7 +2,10 @@ module github.com/stackitcloud/stackit-sdk-go/services/telemetryrouter go 1.25 -require github.com/stackitcloud/stackit-sdk-go/core v0.26.0 +require ( + github.com/google/go-cmp v0.7.0 + github.com/stackitcloud/stackit-sdk-go/core v0.26.0 +) require ( github.com/golang-jwt/jwt/v5 v5.3.1 // indirect diff --git a/services/telemetryrouter/v1betaapi/wait/wait.go b/services/telemetryrouter/v1betaapi/wait/wait.go new file mode 100644 index 000000000..9eb5861f6 --- /dev/null +++ b/services/telemetryrouter/v1betaapi/wait/wait.go @@ -0,0 +1,179 @@ +package wait + +import ( + "context" + "errors" + "net/http" + "time" + + "github.com/stackitcloud/stackit-sdk-go/core/wait" + telemetryrouter "github.com/stackitcloud/stackit-sdk-go/services/telemetryrouter/v1betaapi" +) + +const ( + TELEMETRYROUTER_ACTIVE = "active" + DESTINATION_ACTIVE = "active" + ACCESSTOKEN_ACTIVE = "active" +) + +// CreateTelemetryRouterWaitHandler will wait for TelemetryRouter creation +func CreateTelemetryRouterWaitHandler(ctx context.Context, a telemetryrouter.DefaultAPI, projectId, regionId, instanceId string) *wait.AsyncActionHandler[telemetryrouter.TelemetryRouterResponse] { + waitConfig := wait.WaiterHelper[telemetryrouter.TelemetryRouterResponse, string]{ + FetchInstance: a.GetTelemetryRouter(ctx, projectId, regionId, instanceId).Execute, + GetState: func(d *telemetryrouter.TelemetryRouterResponse) (string, error) { + if d == nil { + return "", errors.New("empty response") + } + return d.Status, nil + }, + ActiveState: []string{TELEMETRYROUTER_ACTIVE}, + } + + handler := wait.New(waitConfig.Wait()) + handler.SetTimeout(10 * time.Minute) + return handler +} + +// UpdateTelemetryRouterWaitHandler will wait for TelemetryRouter update +func UpdateTelemetryRouterWaitHandler(ctx context.Context, a telemetryrouter.DefaultAPI, projectId, regionId, instanceId string) *wait.AsyncActionHandler[telemetryrouter.TelemetryRouterResponse] { + waitConfig := wait.WaiterHelper[telemetryrouter.TelemetryRouterResponse, string]{ + FetchInstance: a.GetTelemetryRouter(ctx, projectId, regionId, instanceId).Execute, + GetState: func(d *telemetryrouter.TelemetryRouterResponse) (string, error) { + if d == nil { + return "", errors.New("empty response") + } + return d.Status, nil + }, + ActiveState: []string{TELEMETRYROUTER_ACTIVE}, + } + + handler := wait.New(waitConfig.Wait()) + handler.SetTimeout(10 * time.Minute) + return handler +} + +// DeleteTelemetryRouterWaitHandler will wait for TelemetryRouter deletion +func DeleteTelemetryRouterWaitHandler(ctx context.Context, a telemetryrouter.DefaultAPI, projectId, regionId, instanceId string) *wait.AsyncActionHandler[telemetryrouter.TelemetryRouterResponse] { + waitConfig := wait.WaiterHelper[telemetryrouter.TelemetryRouterResponse, string]{ + FetchInstance: a.GetTelemetryRouter(ctx, projectId, regionId, instanceId).Execute, + GetState: func(d *telemetryrouter.TelemetryRouterResponse) (string, error) { + if d == nil { + return "", errors.New("empty response") + } + return d.Status, nil + }, + DeleteHttpErrorStatusCodes: []int{http.StatusNotFound}, + } + + handler := wait.New(waitConfig.Wait()) + handler.SetTimeout(10 * time.Minute) + return handler +} + +// CreateDestinationWaitHandler will wait for Destination creation +func CreateDestinationWaitHandler(ctx context.Context, a telemetryrouter.DefaultAPI, projectId, regionId, instanceId, destinationId string) *wait.AsyncActionHandler[telemetryrouter.DestinationResponse] { + waitConfig := wait.WaiterHelper[telemetryrouter.DestinationResponse, string]{ + FetchInstance: a.GetDestination(ctx, projectId, regionId, instanceId, destinationId).Execute, + GetState: func(d *telemetryrouter.DestinationResponse) (string, error) { + if d == nil { + return "", errors.New("empty response") + } + return d.Status, nil + }, + ActiveState: []string{DESTINATION_ACTIVE}, + } + + handler := wait.New(waitConfig.Wait()) + handler.SetTimeout(10 * time.Minute) + return handler +} + +// UpdateDestinationWaitHandler will wait for Destination update +func UpdateDestinationWaitHandler(ctx context.Context, a telemetryrouter.DefaultAPI, projectId, regionId, instanceId, destinationId string) *wait.AsyncActionHandler[telemetryrouter.DestinationResponse] { + waitConfig := wait.WaiterHelper[telemetryrouter.DestinationResponse, string]{ + FetchInstance: a.GetDestination(ctx, projectId, regionId, instanceId, destinationId).Execute, + GetState: func(d *telemetryrouter.DestinationResponse) (string, error) { + if d == nil { + return "", errors.New("empty response") + } + return d.Status, nil + }, + ActiveState: []string{DESTINATION_ACTIVE}, + } + + handler := wait.New(waitConfig.Wait()) + handler.SetTimeout(10 * time.Minute) + return handler +} + +// DeleteDestinationWaitHandler will wait for Destination deletion +func DeleteDestinationWaitHandler(ctx context.Context, a telemetryrouter.DefaultAPI, projectId, regionId, instanceId, destinationId string) *wait.AsyncActionHandler[telemetryrouter.DestinationResponse] { + waitConfig := wait.WaiterHelper[telemetryrouter.DestinationResponse, string]{ + FetchInstance: a.GetDestination(ctx, projectId, regionId, instanceId, destinationId).Execute, + GetState: func(d *telemetryrouter.DestinationResponse) (string, error) { + if d == nil { + return "", errors.New("empty response") + } + return d.Status, nil + }, + DeleteHttpErrorStatusCodes: []int{http.StatusNotFound}, + } + + handler := wait.New(waitConfig.Wait()) + handler.SetTimeout(10 * time.Minute) + return handler +} + +// CreateAccessTokenWaitHandler will wait for AccessToken creation +func CreateAccessTokenWaitHandler(ctx context.Context, a telemetryrouter.DefaultAPI, projectId, regionId, instanceId, accessTokenId string) *wait.AsyncActionHandler[telemetryrouter.GetAccessTokenResponse] { + waitConfig := wait.WaiterHelper[telemetryrouter.GetAccessTokenResponse, string]{ + FetchInstance: a.GetAccessToken(ctx, projectId, regionId, instanceId, accessTokenId).Execute, + GetState: func(d *telemetryrouter.GetAccessTokenResponse) (string, error) { + if d == nil { + return "", errors.New("empty response") + } + return d.Status, nil + }, + ActiveState: []string{ACCESSTOKEN_ACTIVE}, + } + + handler := wait.New(waitConfig.Wait()) + handler.SetTimeout(10 * time.Minute) + return handler +} + +// UpdateAccessTokenWaitHandler will wait for AccessToken update +func UpdateAccessTokenWaitHandler(ctx context.Context, a telemetryrouter.DefaultAPI, projectId, regionId, instanceId, accessTokenId string) *wait.AsyncActionHandler[telemetryrouter.GetAccessTokenResponse] { + waitConfig := wait.WaiterHelper[telemetryrouter.GetAccessTokenResponse, string]{ + FetchInstance: a.GetAccessToken(ctx, projectId, regionId, instanceId, accessTokenId).Execute, + GetState: func(d *telemetryrouter.GetAccessTokenResponse) (string, error) { + if d == nil { + return "", errors.New("empty response") + } + return d.Status, nil + }, + ActiveState: []string{ACCESSTOKEN_ACTIVE}, + } + + handler := wait.New(waitConfig.Wait()) + handler.SetTimeout(10 * time.Minute) + return handler +} + +// DeleteAccessTokenWaitHandler will wait for AccessToken deletion +func DeleteAccessTokenWaitHandler(ctx context.Context, a telemetryrouter.DefaultAPI, projectId, regionId, instanceId, accessTokenId string) *wait.AsyncActionHandler[telemetryrouter.GetAccessTokenResponse] { + waitConfig := wait.WaiterHelper[telemetryrouter.GetAccessTokenResponse, string]{ + FetchInstance: a.GetAccessToken(ctx, projectId, regionId, instanceId, accessTokenId).Execute, + GetState: func(d *telemetryrouter.GetAccessTokenResponse) (string, error) { + if d == nil { + return "", errors.New("empty response") + } + return d.Status, nil + }, + DeleteHttpErrorStatusCodes: []int{http.StatusNotFound}, + } + + handler := wait.New(waitConfig.Wait()) + handler.SetTimeout(10 * time.Minute) + return handler +} diff --git a/services/telemetryrouter/v1betaapi/wait/wait_test.go b/services/telemetryrouter/v1betaapi/wait/wait_test.go new file mode 100644 index 000000000..02e1d578f --- /dev/null +++ b/services/telemetryrouter/v1betaapi/wait/wait_test.go @@ -0,0 +1,623 @@ +package wait + +import ( + "context" + "testing" + "testing/synctest" + "time" + + "github.com/google/go-cmp/cmp" + + "github.com/stackitcloud/stackit-sdk-go/core/oapierror" + "github.com/stackitcloud/stackit-sdk-go/core/utils" + telemetryrouter "github.com/stackitcloud/stackit-sdk-go/services/telemetryrouter/v1betaapi" +) + +type mockSettings struct { + getFails bool + resourceState string +} + +func newAPIMock(settings mockSettings) telemetryrouter.DefaultAPI { + return &telemetryrouter.DefaultAPIServiceMock{ + GetTelemetryRouterExecuteMock: utils.Ptr(func(_ telemetryrouter.ApiGetTelemetryRouterRequest) (*telemetryrouter.TelemetryRouterResponse, error) { + if settings.getFails { + return nil, &oapierror.GenericOpenAPIError{ + StatusCode: 500, + } + } + + return &telemetryrouter.TelemetryRouterResponse{ + Id: "trid", + Status: settings.resourceState, + }, nil + }), + GetDestinationExecuteMock: utils.Ptr(func(_ telemetryrouter.ApiGetDestinationRequest) (*telemetryrouter.DestinationResponse, error) { + if settings.getFails { + return nil, &oapierror.GenericOpenAPIError{ + StatusCode: 500, + } + } + + return &telemetryrouter.DestinationResponse{ + Id: "did", + Status: settings.resourceState, + }, nil + }), + GetAccessTokenExecuteMock: utils.Ptr(func(_ telemetryrouter.ApiGetAccessTokenRequest) (*telemetryrouter.GetAccessTokenResponse, error) { + if settings.getFails { + return nil, &oapierror.GenericOpenAPIError{ + StatusCode: 500, + } + } + + return &telemetryrouter.GetAccessTokenResponse{ + Id: "atid", + ExpirationTime: telemetryrouter.NullableTime{}, + Status: settings.resourceState, + }, nil + }), + } +} + +func TestCreateTelemetryRouterWaitHandler(t *testing.T) { + tests := []struct { + desc string + getFails bool + resourceState string + wantErr bool + wantResp bool + }{ + { + desc: "create_succeeded", + getFails: false, + resourceState: TELEMETRYROUTER_ACTIVE, + wantErr: false, + wantResp: true, + }, + { + desc: "get_fails", + getFails: true, + resourceState: "", + wantErr: true, + wantResp: false, + }, + { + desc: "timeout", + getFails: false, + resourceState: "ANOTHER STATE", + wantErr: true, + wantResp: false, + }, + } + for _, tt := range tests { + t.Run(tt.desc, func(t *testing.T) { + synctest.Test(t, func(t *testing.T) { + apiClient := newAPIMock(mockSettings{ + getFails: tt.getFails, + resourceState: tt.resourceState, + }) + + var wantRes *telemetryrouter.TelemetryRouterResponse + if tt.wantResp { + wantRes = &telemetryrouter.TelemetryRouterResponse{ + Status: tt.resourceState, + Id: "trid", + } + } + + handler := CreateTelemetryRouterWaitHandler(context.Background(), apiClient, "pid", "eu01", "trid") + + gotRes, err := handler.SetTimeout(10 * time.Millisecond).WaitWithContext(context.Background()) + + if (err != nil) != tt.wantErr { + t.Fatalf("handler error = %v, wantErr %v", err, tt.wantErr) + } + if !cmp.Equal(gotRes, wantRes) { + t.Fatalf("handler gotRes = %v, want %v", gotRes, wantRes) + } + }) + }) + } +} + +func TestUpdateTelemetryRouterWaitHandler(t *testing.T) { + tests := []struct { + desc string + getFails bool + resourceState string + wantErr bool + wantResp bool + }{ + { + desc: "update_succeeded", + getFails: false, + resourceState: TELEMETRYROUTER_ACTIVE, + wantErr: false, + wantResp: true, + }, + { + desc: "get_fails", + getFails: true, + resourceState: "", + wantErr: true, + wantResp: false, + }, + { + desc: "timeout", + getFails: false, + resourceState: "ANOTHER STATE", + wantErr: true, + wantResp: false, + }, + } + for _, tt := range tests { + t.Run(tt.desc, func(t *testing.T) { + synctest.Test(t, func(t *testing.T) { + apiClient := newAPIMock(mockSettings{ + getFails: tt.getFails, + resourceState: tt.resourceState, + }) + + var wantRes *telemetryrouter.TelemetryRouterResponse + if tt.wantResp { + wantRes = &telemetryrouter.TelemetryRouterResponse{ + Status: tt.resourceState, + Id: "trid", + } + } + + handler := UpdateTelemetryRouterWaitHandler(context.Background(), apiClient, "pid", "eu01", "trid") + + gotRes, err := handler.SetTimeout(10 * time.Millisecond).WaitWithContext(context.Background()) + + if (err != nil) != tt.wantErr { + t.Fatalf("handler error = %v, wantErr %v", err, tt.wantErr) + } + if !cmp.Equal(gotRes, wantRes) { + t.Fatalf("handler gotRes = %v, want %v", gotRes, wantRes) + } + }) + }) + } +} + +func TestDeleteTelemetryRouterWaitHandler(t *testing.T) { + tests := []struct { + desc string + getFails bool + resourceState string + wantErr bool + wantResp bool + }{ + { + desc: "get_fails", + getFails: true, + resourceState: "", + wantErr: true, + wantResp: false, + }, + { + desc: "timeout", + getFails: false, + resourceState: "ANOTHER STATE", + wantErr: true, + wantResp: false, + }, + } + for _, tt := range tests { + t.Run(tt.desc, func(t *testing.T) { + synctest.Test(t, func(t *testing.T) { + apiClient := newAPIMock(mockSettings{ + getFails: tt.getFails, + resourceState: string(tt.resourceState), + }) + + var wantRes *telemetryrouter.TelemetryRouterResponse + if tt.wantResp { + wantRes = &telemetryrouter.TelemetryRouterResponse{ + Status: tt.resourceState, + Id: "trid", + } + } else { + wantRes = nil + } + + handler := DeleteTelemetryRouterWaitHandler(context.Background(), apiClient, "pid", "zid", "trid") + + gotRes, err := handler.SetTimeout(10 * time.Millisecond).WaitWithContext(context.Background()) + + if (err != nil) != tt.wantErr { + t.Fatalf("handler error = %v, wantErr %v", err, tt.wantErr) + } + if wantRes == nil && gotRes != nil { + t.Fatalf("handler gotRes = %v, want %v", gotRes, wantRes) + } + if wantRes != nil && !cmp.Equal(gotRes, wantRes) { + t.Fatalf("handler gotRes = %v, want %v", gotRes, wantRes) + } + }) + }) + } +} + +func TestCreateDestinationWaitHandler(t *testing.T) { + tests := []struct { + desc string + getFails bool + resourceState string + wantErr bool + wantResp bool + }{ + { + desc: "create_succeeded", + getFails: false, + resourceState: DESTINATION_ACTIVE, + wantErr: false, + wantResp: true, + }, + { + desc: "get_fails", + getFails: true, + resourceState: "", + wantErr: true, + wantResp: false, + }, + { + desc: "timeout", + getFails: false, + resourceState: "ANOTHER STATE", + wantErr: true, + wantResp: false, + }, + } + for _, tt := range tests { + t.Run(tt.desc, func(t *testing.T) { + synctest.Test(t, func(t *testing.T) { + apiClient := newAPIMock(mockSettings{ + getFails: tt.getFails, + resourceState: tt.resourceState, + }) + + var wantRes *telemetryrouter.DestinationResponse + if tt.wantResp { + wantRes = &telemetryrouter.DestinationResponse{ + Status: tt.resourceState, + Id: "did", + } + } + + handler := CreateDestinationWaitHandler(context.Background(), apiClient, "pid", "eu01", "trid", "did") + + gotRes, err := handler.SetTimeout(10 * time.Millisecond).WaitWithContext(context.Background()) + + if (err != nil) != tt.wantErr { + t.Fatalf("handler error = %v, wantErr %v", err, tt.wantErr) + } + if !cmp.Equal(gotRes, wantRes) { + t.Fatalf("handler gotRes = %v, want %v", gotRes, wantRes) + } + }) + }) + } +} + +func TestUpdateDestinationWaitHandler(t *testing.T) { + tests := []struct { + desc string + getFails bool + resourceState string + wantErr bool + wantResp bool + }{ + { + desc: "update_succeeded", + getFails: false, + resourceState: DESTINATION_ACTIVE, + wantErr: false, + wantResp: true, + }, + { + desc: "get_fails", + getFails: true, + resourceState: "", + wantErr: true, + wantResp: false, + }, + { + desc: "timeout", + getFails: false, + resourceState: "ANOTHER STATE", + wantErr: true, + wantResp: false, + }, + } + for _, tt := range tests { + t.Run(tt.desc, func(t *testing.T) { + synctest.Test(t, func(t *testing.T) { + apiClient := newAPIMock(mockSettings{ + getFails: tt.getFails, + resourceState: tt.resourceState, + }) + + var wantRes *telemetryrouter.DestinationResponse + if tt.wantResp { + wantRes = &telemetryrouter.DestinationResponse{ + Status: tt.resourceState, + Id: "did", + } + } + + handler := UpdateDestinationWaitHandler(context.Background(), apiClient, "pid", "eu01", "trid", "did") + + gotRes, err := handler.SetTimeout(10 * time.Millisecond).WaitWithContext(context.Background()) + + if (err != nil) != tt.wantErr { + t.Fatalf("handler error = %v, wantErr %v", err, tt.wantErr) + } + if !cmp.Equal(gotRes, wantRes) { + t.Fatalf("handler gotRes = %v, want %v", gotRes, wantRes) + } + }) + }) + } +} + +func TestDeleteDestinationWaitHandler(t *testing.T) { + tests := []struct { + desc string + getFails bool + resourceState string + wantErr bool + wantResp bool + }{ + { + desc: "get_fails", + getFails: true, + resourceState: "", + wantErr: true, + wantResp: false, + }, + { + desc: "timeout", + getFails: false, + resourceState: "ANOTHER STATE", + wantErr: true, + wantResp: false, + }, + } + for _, tt := range tests { + t.Run(tt.desc, func(t *testing.T) { + synctest.Test(t, func(t *testing.T) { + apiClient := newAPIMock(mockSettings{ + getFails: tt.getFails, + resourceState: string(tt.resourceState), + }) + + var wantRes *telemetryrouter.DestinationResponse + if tt.wantResp { + wantRes = &telemetryrouter.DestinationResponse{ + Status: tt.resourceState, + Id: "did", + } + } else { + wantRes = nil + } + + handler := DeleteDestinationWaitHandler(context.Background(), apiClient, "pid", "zid", "trid", "did") + + gotRes, err := handler.SetTimeout(10 * time.Millisecond).WaitWithContext(context.Background()) + + if (err != nil) != tt.wantErr { + t.Fatalf("handler error = %v, wantErr %v", err, tt.wantErr) + } + if wantRes == nil && gotRes != nil { + t.Fatalf("handler gotRes = %v, want %v", gotRes, wantRes) + } + if wantRes != nil && !cmp.Equal(gotRes, wantRes) { + t.Fatalf("handler gotRes = %v, want %v", gotRes, wantRes) + } + }) + }) + } +} + +func TestCreateAccessTokenWaitHandler(t *testing.T) { + tests := []struct { + desc string + getFails bool + resourceState string + wantErr bool + wantResp bool + }{ + { + desc: "create_succeeded", + getFails: false, + resourceState: ACCESSTOKEN_ACTIVE, + wantErr: false, + wantResp: true, + }, + { + desc: "get_fails", + getFails: true, + resourceState: "", + wantErr: true, + wantResp: false, + }, + { + desc: "timeout", + getFails: false, + resourceState: "ANOTHER STATE", + wantErr: true, + wantResp: false, + }, + } + for _, tt := range tests { + t.Run(tt.desc, func(t *testing.T) { + synctest.Test(t, func(t *testing.T) { + apiClient := newAPIMock(mockSettings{ + getFails: tt.getFails, + resourceState: tt.resourceState, + }) + + var wantRes *telemetryrouter.GetAccessTokenResponse + if tt.wantResp { + wantRes = &telemetryrouter.GetAccessTokenResponse{ + Status: tt.resourceState, + Id: "atid", + } + } + + handler := CreateAccessTokenWaitHandler(context.Background(), apiClient, "pid", "eu01", "trid", "atid") + + gotRes, err := handler.SetTimeout(10 * time.Millisecond).WaitWithContext(context.Background()) + + if (err != nil) != tt.wantErr { + t.Fatalf("handler error = %v, wantErr %v", err, tt.wantErr) + } + if !cmp.Equal(gotRes, wantRes, cmp.Comparer(compareNullableTime)) { + t.Fatalf("handler gotRes = %v, want %v", gotRes, wantRes) + } + }) + }) + } +} + +func TestUpdateAccessTokenWaitHandler(t *testing.T) { + tests := []struct { + desc string + getFails bool + resourceState string + wantErr bool + wantResp bool + }{ + { + desc: "update_succeeded", + getFails: false, + resourceState: ACCESSTOKEN_ACTIVE, + wantErr: false, + wantResp: true, + }, + { + desc: "get_fails", + getFails: true, + resourceState: "", + wantErr: true, + wantResp: false, + }, + { + desc: "timeout", + getFails: false, + resourceState: "ANOTHER STATE", + wantErr: true, + wantResp: false, + }, + } + for _, tt := range tests { + t.Run(tt.desc, func(t *testing.T) { + synctest.Test(t, func(t *testing.T) { + apiClient := newAPIMock(mockSettings{ + getFails: tt.getFails, + resourceState: tt.resourceState, + }) + + var wantRes *telemetryrouter.GetAccessTokenResponse + if tt.wantResp { + wantRes = &telemetryrouter.GetAccessTokenResponse{ + Status: tt.resourceState, + Id: "atid", + } + } + + handler := UpdateAccessTokenWaitHandler(context.Background(), apiClient, "pid", "eu01", "trid", "atid") + + gotRes, err := handler.SetTimeout(10 * time.Millisecond).WaitWithContext(context.Background()) + + if (err != nil) != tt.wantErr { + t.Fatalf("handler error = %v, wantErr %v", err, tt.wantErr) + } + if !cmp.Equal(gotRes, wantRes, cmp.Comparer(compareNullableTime)) { + t.Fatalf("handler gotRes = %v, want %v", gotRes, wantRes) + } + }) + }) + } +} + +func TestDeleteAccessTokenWaitHandler(t *testing.T) { + tests := []struct { + desc string + getFails bool + resourceState string + wantErr bool + wantResp bool + }{ + { + desc: "get_fails", + getFails: true, + resourceState: "", + wantErr: true, + wantResp: false, + }, + { + desc: "timeout", + getFails: false, + resourceState: "ANOTHER STATE", + wantErr: true, + wantResp: false, + }, + } + for _, tt := range tests { + t.Run(tt.desc, func(t *testing.T) { + synctest.Test(t, func(t *testing.T) { + apiClient := newAPIMock(mockSettings{ + getFails: tt.getFails, + resourceState: tt.resourceState, + }) + + var wantRes *telemetryrouter.GetAccessTokenResponse + if tt.wantResp { + wantRes = &telemetryrouter.GetAccessTokenResponse{ + Status: tt.resourceState, + Id: "atid", + } + } else { + wantRes = nil + } + + handler := DeleteAccessTokenWaitHandler(context.Background(), apiClient, "pid", "zid", "trid", "atid") + + gotRes, err := handler.SetTimeout(10 * time.Millisecond).WaitWithContext(context.Background()) + + if (err != nil) != tt.wantErr { + t.Fatalf("handler error = %v, wantErr %v", err, tt.wantErr) + } + if wantRes == nil && gotRes != nil { + t.Fatalf("handler gotRes = %v, want %v", gotRes, wantRes) + } + if wantRes != nil && !cmp.Equal(gotRes, wantRes, cmp.Comparer(compareNullableTime)) { + t.Fatalf("handler gotRes = %v, want %v", gotRes, wantRes) + } + }) + }) + } +} + +func compareNullableTime(x, y telemetryrouter.NullableTime) bool { + if x.IsSet() != y.IsSet() { + return false + } + + if !x.IsSet() && !y.IsSet() { + return true + } + + valX := x.Get() + valY := y.Get() + + if valX == nil || valY == nil { + return valX == valY + } + + return *valX == *valY +}