github.com/anthropics/anthropic-sdk-go@v1.70.1/betatunnel_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 TestBetaTunnelNewWithOptionalParams(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.Tunnels.New(context.TODO(), anthropic.BetaTunnelNewParams{
    29  		DisplayName: anthropic.String("x"),
    30  		Betas:       []anthropic.AnthropicBeta{anthropic.AnthropicBetaMessageBatches2024_09_24},
    31  		WorkspaceID: anthropic.String("wrkspc_011CZkZaBF1tNoB5wlCeusgy"),
    32  	})
    33  	if err != nil {
    34  		var apierr *anthropic.Error
    35  		if errors.As(err, &apierr) {
    36  			t.Log(string(apierr.DumpRequest(true)))
    37  		}
    38  		t.Fatalf("err should be nil: %s", err.Error())
    39  	}
    40  }
    41  
    42  func TestBetaTunnelGetWithOptionalParams(t *testing.T) {
    43  	t.Skip("buildURL drops path-level query params (SDK-4349)")
    44  	baseURL := "http://localhost:4010"
    45  	if envURL, ok := os.LookupEnv("TEST_API_BASE_URL"); ok {
    46  		baseURL = envURL
    47  	}
    48  	if !testutil.CheckTestServer(t, baseURL) {
    49  		return
    50  	}
    51  	client := anthropic.NewClient(
    52  		option.WithBaseURL(baseURL),
    53  		option.WithAPIKey("my-anthropic-api-key"),
    54  	)
    55  	_, err := client.Beta.Tunnels.Get(
    56  		context.TODO(),
    57  		"tunnel_id",
    58  		anthropic.BetaTunnelGetParams{
    59  			Betas:       []anthropic.AnthropicBeta{anthropic.AnthropicBetaMessageBatches2024_09_24},
    60  			WorkspaceID: anthropic.String("wrkspc_011CZkZaBF1tNoB5wlCeusgy"),
    61  		},
    62  	)
    63  	if err != nil {
    64  		var apierr *anthropic.Error
    65  		if errors.As(err, &apierr) {
    66  			t.Log(string(apierr.DumpRequest(true)))
    67  		}
    68  		t.Fatalf("err should be nil: %s", err.Error())
    69  	}
    70  }
    71  
    72  func TestBetaTunnelListWithOptionalParams(t *testing.T) {
    73  	t.Skip("buildURL drops path-level query params (SDK-4349)")
    74  	baseURL := "http://localhost:4010"
    75  	if envURL, ok := os.LookupEnv("TEST_API_BASE_URL"); ok {
    76  		baseURL = envURL
    77  	}
    78  	if !testutil.CheckTestServer(t, baseURL) {
    79  		return
    80  	}
    81  	client := anthropic.NewClient(
    82  		option.WithBaseURL(baseURL),
    83  		option.WithAPIKey("my-anthropic-api-key"),
    84  	)
    85  	_, err := client.Beta.Tunnels.List(context.TODO(), anthropic.BetaTunnelListParams{
    86  		IncludeArchived: anthropic.Bool(true),
    87  		Limit:           anthropic.Int(0),
    88  		Page:            anthropic.String("page"),
    89  		Betas:           []anthropic.AnthropicBeta{anthropic.AnthropicBetaMessageBatches2024_09_24},
    90  		WorkspaceID:     anthropic.String("wrkspc_011CZkZaBF1tNoB5wlCeusgy"),
    91  	})
    92  	if err != nil {
    93  		var apierr *anthropic.Error
    94  		if errors.As(err, &apierr) {
    95  			t.Log(string(apierr.DumpRequest(true)))
    96  		}
    97  		t.Fatalf("err should be nil: %s", err.Error())
    98  	}
    99  }
   100  
   101  func TestBetaTunnelArchiveWithOptionalParams(t *testing.T) {
   102  	baseURL := "http://localhost:4010"
   103  	if envURL, ok := os.LookupEnv("TEST_API_BASE_URL"); ok {
   104  		baseURL = envURL
   105  	}
   106  	if !testutil.CheckTestServer(t, baseURL) {
   107  		return
   108  	}
   109  	client := anthropic.NewClient(
   110  		option.WithBaseURL(baseURL),
   111  		option.WithAPIKey("my-anthropic-api-key"),
   112  	)
   113  	_, err := client.Beta.Tunnels.Archive(
   114  		context.TODO(),
   115  		"tunnel_id",
   116  		anthropic.BetaTunnelArchiveParams{
   117  			Betas:       []anthropic.AnthropicBeta{anthropic.AnthropicBetaMessageBatches2024_09_24},
   118  			WorkspaceID: anthropic.String("wrkspc_011CZkZaBF1tNoB5wlCeusgy"),
   119  		},
   120  	)
   121  	if err != nil {
   122  		var apierr *anthropic.Error
   123  		if errors.As(err, &apierr) {
   124  			t.Log(string(apierr.DumpRequest(true)))
   125  		}
   126  		t.Fatalf("err should be nil: %s", err.Error())
   127  	}
   128  }
   129  
   130  func TestBetaTunnelRevealTokenWithOptionalParams(t *testing.T) {
   131  	baseURL := "http://localhost:4010"
   132  	if envURL, ok := os.LookupEnv("TEST_API_BASE_URL"); ok {
   133  		baseURL = envURL
   134  	}
   135  	if !testutil.CheckTestServer(t, baseURL) {
   136  		return
   137  	}
   138  	client := anthropic.NewClient(
   139  		option.WithBaseURL(baseURL),
   140  		option.WithAPIKey("my-anthropic-api-key"),
   141  	)
   142  	_, err := client.Beta.Tunnels.RevealToken(
   143  		context.TODO(),
   144  		"tunnel_id",
   145  		anthropic.BetaTunnelRevealTokenParams{
   146  			Betas:       []anthropic.AnthropicBeta{anthropic.AnthropicBetaMessageBatches2024_09_24},
   147  			WorkspaceID: anthropic.String("wrkspc_011CZkZaBF1tNoB5wlCeusgy"),
   148  		},
   149  	)
   150  	if err != nil {
   151  		var apierr *anthropic.Error
   152  		if errors.As(err, &apierr) {
   153  			t.Log(string(apierr.DumpRequest(true)))
   154  		}
   155  		t.Fatalf("err should be nil: %s", err.Error())
   156  	}
   157  }
   158  
   159  func TestBetaTunnelRotateTokenWithOptionalParams(t *testing.T) {
   160  	baseURL := "http://localhost:4010"
   161  	if envURL, ok := os.LookupEnv("TEST_API_BASE_URL"); ok {
   162  		baseURL = envURL
   163  	}
   164  	if !testutil.CheckTestServer(t, baseURL) {
   165  		return
   166  	}
   167  	client := anthropic.NewClient(
   168  		option.WithBaseURL(baseURL),
   169  		option.WithAPIKey("my-anthropic-api-key"),
   170  	)
   171  	_, err := client.Beta.Tunnels.RotateToken(
   172  		context.TODO(),
   173  		"tunnel_id",
   174  		anthropic.BetaTunnelRotateTokenParams{
   175  			Reason:      anthropic.String("reason"),
   176  			Betas:       []anthropic.AnthropicBeta{anthropic.AnthropicBetaMessageBatches2024_09_24},
   177  			WorkspaceID: anthropic.String("wrkspc_011CZkZaBF1tNoB5wlCeusgy"),
   178  		},
   179  	)
   180  	if err != nil {
   181  		var apierr *anthropic.Error
   182  		if errors.As(err, &apierr) {
   183  			t.Log(string(apierr.DumpRequest(true)))
   184  		}
   185  		t.Fatalf("err should be nil: %s", err.Error())
   186  	}
   187  }