github.com/anthropics/anthropic-sdk-go@v1.70.1/betavaultcredential_test.go (about)

     1  // File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
     2  
     3  package anthropic_test
     4  
     5  import (
     6  	"context"
     7  	"errors"
     8  	"os"
     9  	"testing"
    10  	"time"
    11  
    12  	"github.com/anthropics/anthropic-sdk-go"
    13  	"github.com/anthropics/anthropic-sdk-go/internal/testutil"
    14  	"github.com/anthropics/anthropic-sdk-go/option"
    15  )
    16  
    17  func TestBetaVaultCredentialNewWithOptionalParams(t *testing.T) {
    18  	baseURL := "http://localhost:4010"
    19  	if envURL, ok := os.LookupEnv("TEST_API_BASE_URL"); ok {
    20  		baseURL = envURL
    21  	}
    22  	if !testutil.CheckTestServer(t, baseURL) {
    23  		return
    24  	}
    25  	client := anthropic.NewClient(
    26  		option.WithBaseURL(baseURL),
    27  		option.WithAPIKey("my-anthropic-api-key"),
    28  	)
    29  	_, err := client.Beta.Vaults.Credentials.New(
    30  		context.TODO(),
    31  		"vlt_011CZkZDLs7fYzm1hXNPeRjv",
    32  		anthropic.BetaVaultCredentialNewParams{
    33  			Auth: anthropic.BetaVaultCredentialNewParamsAuthUnion{
    34  				OfStaticBearer: &anthropic.BetaManagedAgentsStaticBearerCreateParams{
    35  					Token:        "bearer_exampletoken",
    36  					MCPServerURL: "https://example-server.modelcontextprotocol.io/sse",
    37  					Type:         anthropic.BetaManagedAgentsStaticBearerCreateParamsTypeStaticBearer,
    38  				},
    39  			},
    40  			DisplayName: anthropic.String("Example credential"),
    41  			Metadata: map[string]string{
    42  				"environment": "production",
    43  			},
    44  			Betas:       []anthropic.AnthropicBeta{anthropic.AnthropicBetaMessageBatches2024_09_24},
    45  			WorkspaceID: anthropic.String("wrkspc_011CZkZaBF1tNoB5wlCeusgy"),
    46  		},
    47  	)
    48  	if err != nil {
    49  		var apierr *anthropic.Error
    50  		if errors.As(err, &apierr) {
    51  			t.Log(string(apierr.DumpRequest(true)))
    52  		}
    53  		t.Fatalf("err should be nil: %s", err.Error())
    54  	}
    55  }
    56  
    57  func TestBetaVaultCredentialGetWithOptionalParams(t *testing.T) {
    58  	baseURL := "http://localhost:4010"
    59  	if envURL, ok := os.LookupEnv("TEST_API_BASE_URL"); ok {
    60  		baseURL = envURL
    61  	}
    62  	if !testutil.CheckTestServer(t, baseURL) {
    63  		return
    64  	}
    65  	client := anthropic.NewClient(
    66  		option.WithBaseURL(baseURL),
    67  		option.WithAPIKey("my-anthropic-api-key"),
    68  	)
    69  	_, err := client.Beta.Vaults.Credentials.Get(
    70  		context.TODO(),
    71  		"vcrd_011CZkZEMt8gZan2iYOQfSkw",
    72  		anthropic.BetaVaultCredentialGetParams{
    73  			VaultID:     "vlt_011CZkZDLs7fYzm1hXNPeRjv",
    74  			Betas:       []anthropic.AnthropicBeta{anthropic.AnthropicBetaMessageBatches2024_09_24},
    75  			WorkspaceID: anthropic.String("wrkspc_011CZkZaBF1tNoB5wlCeusgy"),
    76  		},
    77  	)
    78  	if err != nil {
    79  		var apierr *anthropic.Error
    80  		if errors.As(err, &apierr) {
    81  			t.Log(string(apierr.DumpRequest(true)))
    82  		}
    83  		t.Fatalf("err should be nil: %s", err.Error())
    84  	}
    85  }
    86  
    87  func TestBetaVaultCredentialUpdateWithOptionalParams(t *testing.T) {
    88  	baseURL := "http://localhost:4010"
    89  	if envURL, ok := os.LookupEnv("TEST_API_BASE_URL"); ok {
    90  		baseURL = envURL
    91  	}
    92  	if !testutil.CheckTestServer(t, baseURL) {
    93  		return
    94  	}
    95  	client := anthropic.NewClient(
    96  		option.WithBaseURL(baseURL),
    97  		option.WithAPIKey("my-anthropic-api-key"),
    98  	)
    99  	_, err := client.Beta.Vaults.Credentials.Update(
   100  		context.TODO(),
   101  		"vcrd_011CZkZEMt8gZan2iYOQfSkw",
   102  		anthropic.BetaVaultCredentialUpdateParams{
   103  			VaultID: "vlt_011CZkZDLs7fYzm1hXNPeRjv",
   104  			Auth: anthropic.BetaVaultCredentialUpdateParamsAuthUnion{
   105  				OfMCPOAuth: &anthropic.BetaManagedAgentsMCPOAuthUpdateParams{
   106  					Type:        anthropic.BetaManagedAgentsMCPOAuthUpdateParamsTypeMCPOAuth,
   107  					AccessToken: anthropic.String("x"),
   108  					ExpiresAt:   anthropic.Time(time.Now()),
   109  					Refresh: anthropic.BetaManagedAgentsMCPOAuthRefreshUpdateParams{
   110  						RefreshToken: anthropic.String("x"),
   111  						Scope:        anthropic.String("scope"),
   112  						TokenEndpointAuth: anthropic.BetaManagedAgentsMCPOAuthRefreshUpdateParamsTokenEndpointAuthUnion{
   113  							OfClientSecretBasic: &anthropic.BetaManagedAgentsTokenEndpointAuthBasicUpdateParam{
   114  								Type:         anthropic.BetaManagedAgentsTokenEndpointAuthBasicUpdateParamTypeClientSecretBasic,
   115  								ClientSecret: anthropic.String("x"),
   116  							},
   117  						},
   118  					},
   119  				},
   120  			},
   121  			DisplayName: anthropic.String("Example credential"),
   122  			Metadata: map[string]string{
   123  				"environment": "production",
   124  			},
   125  			Betas:       []anthropic.AnthropicBeta{anthropic.AnthropicBetaMessageBatches2024_09_24},
   126  			WorkspaceID: anthropic.String("wrkspc_011CZkZaBF1tNoB5wlCeusgy"),
   127  		},
   128  	)
   129  	if err != nil {
   130  		var apierr *anthropic.Error
   131  		if errors.As(err, &apierr) {
   132  			t.Log(string(apierr.DumpRequest(true)))
   133  		}
   134  		t.Fatalf("err should be nil: %s", err.Error())
   135  	}
   136  }
   137  
   138  func TestBetaVaultCredentialListWithOptionalParams(t *testing.T) {
   139  	t.Skip("buildURL drops path-level query params (SDK-4349)")
   140  	baseURL := "http://localhost:4010"
   141  	if envURL, ok := os.LookupEnv("TEST_API_BASE_URL"); ok {
   142  		baseURL = envURL
   143  	}
   144  	if !testutil.CheckTestServer(t, baseURL) {
   145  		return
   146  	}
   147  	client := anthropic.NewClient(
   148  		option.WithBaseURL(baseURL),
   149  		option.WithAPIKey("my-anthropic-api-key"),
   150  	)
   151  	_, err := client.Beta.Vaults.Credentials.List(
   152  		context.TODO(),
   153  		"vlt_011CZkZDLs7fYzm1hXNPeRjv",
   154  		anthropic.BetaVaultCredentialListParams{
   155  			IncludeArchived: anthropic.Bool(true),
   156  			Limit:           anthropic.Int(0),
   157  			Page:            anthropic.String("page"),
   158  			Betas:           []anthropic.AnthropicBeta{anthropic.AnthropicBetaMessageBatches2024_09_24},
   159  			WorkspaceID:     anthropic.String("wrkspc_011CZkZaBF1tNoB5wlCeusgy"),
   160  		},
   161  	)
   162  	if err != nil {
   163  		var apierr *anthropic.Error
   164  		if errors.As(err, &apierr) {
   165  			t.Log(string(apierr.DumpRequest(true)))
   166  		}
   167  		t.Fatalf("err should be nil: %s", err.Error())
   168  	}
   169  }
   170  
   171  func TestBetaVaultCredentialDeleteWithOptionalParams(t *testing.T) {
   172  	baseURL := "http://localhost:4010"
   173  	if envURL, ok := os.LookupEnv("TEST_API_BASE_URL"); ok {
   174  		baseURL = envURL
   175  	}
   176  	if !testutil.CheckTestServer(t, baseURL) {
   177  		return
   178  	}
   179  	client := anthropic.NewClient(
   180  		option.WithBaseURL(baseURL),
   181  		option.WithAPIKey("my-anthropic-api-key"),
   182  	)
   183  	_, err := client.Beta.Vaults.Credentials.Delete(
   184  		context.TODO(),
   185  		"vcrd_011CZkZEMt8gZan2iYOQfSkw",
   186  		anthropic.BetaVaultCredentialDeleteParams{
   187  			VaultID:     "vlt_011CZkZDLs7fYzm1hXNPeRjv",
   188  			Betas:       []anthropic.AnthropicBeta{anthropic.AnthropicBetaMessageBatches2024_09_24},
   189  			WorkspaceID: anthropic.String("wrkspc_011CZkZaBF1tNoB5wlCeusgy"),
   190  		},
   191  	)
   192  	if err != nil {
   193  		var apierr *anthropic.Error
   194  		if errors.As(err, &apierr) {
   195  			t.Log(string(apierr.DumpRequest(true)))
   196  		}
   197  		t.Fatalf("err should be nil: %s", err.Error())
   198  	}
   199  }
   200  
   201  func TestBetaVaultCredentialArchiveWithOptionalParams(t *testing.T) {
   202  	baseURL := "http://localhost:4010"
   203  	if envURL, ok := os.LookupEnv("TEST_API_BASE_URL"); ok {
   204  		baseURL = envURL
   205  	}
   206  	if !testutil.CheckTestServer(t, baseURL) {
   207  		return
   208  	}
   209  	client := anthropic.NewClient(
   210  		option.WithBaseURL(baseURL),
   211  		option.WithAPIKey("my-anthropic-api-key"),
   212  	)
   213  	_, err := client.Beta.Vaults.Credentials.Archive(
   214  		context.TODO(),
   215  		"vcrd_011CZkZEMt8gZan2iYOQfSkw",
   216  		anthropic.BetaVaultCredentialArchiveParams{
   217  			VaultID:     "vlt_011CZkZDLs7fYzm1hXNPeRjv",
   218  			Betas:       []anthropic.AnthropicBeta{anthropic.AnthropicBetaMessageBatches2024_09_24},
   219  			WorkspaceID: anthropic.String("wrkspc_011CZkZaBF1tNoB5wlCeusgy"),
   220  		},
   221  	)
   222  	if err != nil {
   223  		var apierr *anthropic.Error
   224  		if errors.As(err, &apierr) {
   225  			t.Log(string(apierr.DumpRequest(true)))
   226  		}
   227  		t.Fatalf("err should be nil: %s", err.Error())
   228  	}
   229  }
   230  
   231  func TestBetaVaultCredentialMCPOAuthValidateWithOptionalParams(t *testing.T) {
   232  	t.Skip("prism can't find endpoint with beta only tag")
   233  	baseURL := "http://localhost:4010"
   234  	if envURL, ok := os.LookupEnv("TEST_API_BASE_URL"); ok {
   235  		baseURL = envURL
   236  	}
   237  	if !testutil.CheckTestServer(t, baseURL) {
   238  		return
   239  	}
   240  	client := anthropic.NewClient(
   241  		option.WithBaseURL(baseURL),
   242  		option.WithAPIKey("my-anthropic-api-key"),
   243  	)
   244  	_, err := client.Beta.Vaults.Credentials.MCPOAuthValidate(
   245  		context.TODO(),
   246  		"vcrd_011CZkZEMt8gZan2iYOQfSkw",
   247  		anthropic.BetaVaultCredentialMCPOAuthValidateParams{
   248  			VaultID:     "vlt_011CZkZDLs7fYzm1hXNPeRjv",
   249  			Betas:       []anthropic.AnthropicBeta{anthropic.AnthropicBetaMessageBatches2024_09_24},
   250  			WorkspaceID: anthropic.String("wrkspc_011CZkZaBF1tNoB5wlCeusgy"),
   251  		},
   252  	)
   253  	if err != nil {
   254  		var apierr *anthropic.Error
   255  		if errors.As(err, &apierr) {
   256  			t.Log(string(apierr.DumpRequest(true)))
   257  		}
   258  		t.Fatalf("err should be nil: %s", err.Error())
   259  	}
   260  }