github.com/anthropics/anthropic-sdk-go@v1.70.1/betaorganizationfederationrule_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  
    11  	"github.com/anthropics/anthropic-sdk-go"
    12  	"github.com/anthropics/anthropic-sdk-go/internal/testutil"
    13  	"github.com/anthropics/anthropic-sdk-go/option"
    14  )
    15  
    16  func TestBetaOrganizationFederationRuleNewWithOptionalParams(t *testing.T) {
    17  	baseURL := "http://localhost:4010"
    18  	if envURL, ok := os.LookupEnv("TEST_API_BASE_URL"); ok {
    19  		baseURL = envURL
    20  	}
    21  	if !testutil.CheckTestServer(t, baseURL) {
    22  		return
    23  	}
    24  	client := anthropic.NewClient(
    25  		option.WithBaseURL(baseURL),
    26  		option.WithAPIKey("my-anthropic-api-key"),
    27  	)
    28  	_, err := client.Beta.Organization.Federation.Rules.New(context.TODO(), anthropic.BetaOrganizationFederationRuleNewParams{
    29  		IssuerID: "issuer_id",
    30  		Match: anthropic.BetaFederationRuleMatchParam{
    31  			Audience: anthropic.String("audience"),
    32  			Claims: map[string]string{
    33  				"foo": "string",
    34  			},
    35  			Condition:     anthropic.String("condition"),
    36  			SubjectPrefix: anthropic.String("subject_prefix"),
    37  		},
    38  		Name:       "x",
    39  		OAuthScope: "x",
    40  		Target: anthropic.BetaServiceAccountTargetParam{
    41  			ServiceAccountID:   "svac_01SDCCSbTxrXDpWc1phhtcfK",
    42  			ServiceAccountName: anthropic.String("service_account_name"),
    43  		},
    44  		AppliesToAllWorkspaces: anthropic.Bool(true),
    45  		Attributes: map[string]string{
    46  			"foo": "string",
    47  		},
    48  		Description:          anthropic.String("description"),
    49  		TokenLifetimeSeconds: anthropic.Int(60),
    50  		WorkspaceID:          anthropic.String("workspace_id"),
    51  		Betas:                []anthropic.AnthropicBeta{anthropic.AnthropicBetaMessageBatches2024_09_24},
    52  	})
    53  	if err != nil {
    54  		var apierr *anthropic.Error
    55  		if errors.As(err, &apierr) {
    56  			t.Log(string(apierr.DumpRequest(true)))
    57  		}
    58  		t.Fatalf("err should be nil: %s", err.Error())
    59  	}
    60  }
    61  
    62  func TestBetaOrganizationFederationRuleGetWithOptionalParams(t *testing.T) {
    63  	baseURL := "http://localhost:4010"
    64  	if envURL, ok := os.LookupEnv("TEST_API_BASE_URL"); ok {
    65  		baseURL = envURL
    66  	}
    67  	if !testutil.CheckTestServer(t, baseURL) {
    68  		return
    69  	}
    70  	client := anthropic.NewClient(
    71  		option.WithBaseURL(baseURL),
    72  		option.WithAPIKey("my-anthropic-api-key"),
    73  	)
    74  	_, err := client.Beta.Organization.Federation.Rules.Get(
    75  		context.TODO(),
    76  		"federation_rule_id",
    77  		anthropic.BetaOrganizationFederationRuleGetParams{
    78  			Betas: []anthropic.AnthropicBeta{anthropic.AnthropicBetaMessageBatches2024_09_24},
    79  		},
    80  	)
    81  	if err != nil {
    82  		var apierr *anthropic.Error
    83  		if errors.As(err, &apierr) {
    84  			t.Log(string(apierr.DumpRequest(true)))
    85  		}
    86  		t.Fatalf("err should be nil: %s", err.Error())
    87  	}
    88  }
    89  
    90  func TestBetaOrganizationFederationRuleUpdateWithOptionalParams(t *testing.T) {
    91  	baseURL := "http://localhost:4010"
    92  	if envURL, ok := os.LookupEnv("TEST_API_BASE_URL"); ok {
    93  		baseURL = envURL
    94  	}
    95  	if !testutil.CheckTestServer(t, baseURL) {
    96  		return
    97  	}
    98  	client := anthropic.NewClient(
    99  		option.WithBaseURL(baseURL),
   100  		option.WithAPIKey("my-anthropic-api-key"),
   101  	)
   102  	_, err := client.Beta.Organization.Federation.Rules.Update(
   103  		context.TODO(),
   104  		"federation_rule_id",
   105  		anthropic.BetaOrganizationFederationRuleUpdateParams{
   106  			AppliesToAllWorkspaces: anthropic.Bool(true),
   107  			Attributes: map[string]string{
   108  				"foo": "string",
   109  			},
   110  			Description: anthropic.String("description"),
   111  			Match: anthropic.BetaFederationRuleMatchParam{
   112  				Audience: anthropic.String("audience"),
   113  				Claims: map[string]string{
   114  					"foo": "string",
   115  				},
   116  				Condition:     anthropic.String("condition"),
   117  				SubjectPrefix: anthropic.String("subject_prefix"),
   118  			},
   119  			Name:       anthropic.String("x"),
   120  			OAuthScope: anthropic.String("x"),
   121  			Target: anthropic.BetaServiceAccountTargetParam{
   122  				ServiceAccountID:   "svac_01SDCCSbTxrXDpWc1phhtcfK",
   123  				ServiceAccountName: anthropic.String("service_account_name"),
   124  			},
   125  			TokenLifetimeSeconds: anthropic.Int(60),
   126  			WorkspaceID:          anthropic.String("workspace_id"),
   127  			Betas:                []anthropic.AnthropicBeta{anthropic.AnthropicBetaMessageBatches2024_09_24},
   128  		},
   129  	)
   130  	if err != nil {
   131  		var apierr *anthropic.Error
   132  		if errors.As(err, &apierr) {
   133  			t.Log(string(apierr.DumpRequest(true)))
   134  		}
   135  		t.Fatalf("err should be nil: %s", err.Error())
   136  	}
   137  }
   138  
   139  func TestBetaOrganizationFederationRuleListWithOptionalParams(t *testing.T) {
   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.Organization.Federation.Rules.List(context.TODO(), anthropic.BetaOrganizationFederationRuleListParams{
   152  		IncludeArchived: anthropic.Bool(true),
   153  		IssuerID:        anthropic.String("issuer_id"),
   154  		Limit:           anthropic.Int(1),
   155  		Page:            anthropic.String("page"),
   156  		Betas:           []anthropic.AnthropicBeta{anthropic.AnthropicBetaMessageBatches2024_09_24},
   157  	})
   158  	if err != nil {
   159  		var apierr *anthropic.Error
   160  		if errors.As(err, &apierr) {
   161  			t.Log(string(apierr.DumpRequest(true)))
   162  		}
   163  		t.Fatalf("err should be nil: %s", err.Error())
   164  	}
   165  }
   166  
   167  func TestBetaOrganizationFederationRuleArchiveWithOptionalParams(t *testing.T) {
   168  	baseURL := "http://localhost:4010"
   169  	if envURL, ok := os.LookupEnv("TEST_API_BASE_URL"); ok {
   170  		baseURL = envURL
   171  	}
   172  	if !testutil.CheckTestServer(t, baseURL) {
   173  		return
   174  	}
   175  	client := anthropic.NewClient(
   176  		option.WithBaseURL(baseURL),
   177  		option.WithAPIKey("my-anthropic-api-key"),
   178  	)
   179  	_, err := client.Beta.Organization.Federation.Rules.Archive(
   180  		context.TODO(),
   181  		"federation_rule_id",
   182  		anthropic.BetaOrganizationFederationRuleArchiveParams{
   183  			Betas: []anthropic.AnthropicBeta{anthropic.AnthropicBetaMessageBatches2024_09_24},
   184  		},
   185  	)
   186  	if err != nil {
   187  		var apierr *anthropic.Error
   188  		if errors.As(err, &apierr) {
   189  			t.Log(string(apierr.DumpRequest(true)))
   190  		}
   191  		t.Fatalf("err should be nil: %s", err.Error())
   192  	}
   193  }