github.com/blend/go-sdk@v1.20240719.1/sentry/client_test.go (about)

     1  /*
     2  
     3  Copyright (c) 2024 - Present. Blend Labs, Inc. All rights reserved
     4  Use of this source code is governed by a MIT license that can be found in the LICENSE file.
     5  
     6  */
     7  
     8  package sentry
     9  
    10  import (
    11  	"context"
    12  	"crypto/tls"
    13  	"net/http"
    14  	"testing"
    15  
    16  	"github.com/blend/go-sdk/assert"
    17  	"github.com/blend/go-sdk/ex"
    18  	"github.com/blend/go-sdk/logger"
    19  	"github.com/blend/go-sdk/webutil"
    20  )
    21  
    22  func TestNew(t *testing.T) {
    23  	assert := assert.New(t)
    24  
    25  	c, err := New(Config{
    26  		DSN: "https://example.org",
    27  	})
    28  	assert.NotNil(err)
    29  	assert.Nil(c)
    30  
    31  	c, err = New(Config{
    32  		DSN:         "https://foo@example.org/1",
    33  		Environment: "test",
    34  		ServerName:  "go-sdk-server",
    35  		Release:     "v1.0.0",
    36  		Dist:        "deadbeef",
    37  	})
    38  	assert.Nil(err)
    39  	assert.Equal("test", c.Client.Options().Environment)
    40  	assert.Equal("go-sdk-server", c.Client.Options().ServerName)
    41  	assert.Equal("v1.0.0", c.Client.Options().Release)
    42  	assert.Equal("deadbeef", c.Client.Options().Dist)
    43  }
    44  
    45  func TestErrEvent(t *testing.T) {
    46  	assert := assert.New(t)
    47  
    48  	event := errEvent(context.Background(), logger.ErrorEvent{
    49  		Flag: logger.Fatal,
    50  		Err:  ex.New("this is a test", ex.OptMessage("a message")),
    51  		State: &http.Request{
    52  			Method: "POST",
    53  			Host:   "example.org",
    54  			TLS:    &tls.ConnectionState{},
    55  			URL:    webutil.MustParseURL("https://example.org/foo"),
    56  		},
    57  	})
    58  
    59  	assert.NotNil(event)
    60  	assert.NotZero(event.Timestamp)
    61  	assert.Equal(logger.Fatal, event.Level)
    62  	assert.Equal("go", event.Platform)
    63  	assert.Equal(SDK, event.Sdk.Name)
    64  	assert.Equal("this is a test", event.Message)
    65  	assert.NotEmpty(event.Exception)
    66  	assert.NotEmpty(event.Fingerprint)
    67  	assert.NotNil(event.Exception[0].Stacktrace)
    68  	assert.NotEmpty(event.Exception[0].Stacktrace.Frames)
    69  }
    70  
    71  func TestErrEvent_Inner(t *testing.T) {
    72  	assert := assert.New(t)
    73  
    74  	inner0 := ex.New("this is inner exception 0", ex.OptMessage("inner message 0"))
    75  	inner1 := ex.New("this is inner exception 1", ex.OptMessage("inner message 1"))
    76  	inner2 := ex.New("this is inner exception 2", ex.OptMessage("inner message 2"))
    77  	err := ex.New("this is a test", ex.OptMessage("a message"))
    78  
    79  	event := errEvent(context.Background(), logger.ErrorEvent{
    80  		Flag: logger.Fatal,
    81  		Err:  ex.Nest(err, inner0, inner1, inner2),
    82  		State: &http.Request{
    83  			Method: "POST",
    84  			Host:   "example.org",
    85  			TLS:    &tls.ConnectionState{},
    86  			URL:    webutil.MustParseURL("https://example.org/foo"),
    87  		},
    88  	})
    89  
    90  	assert.NotNil(event)
    91  	assert.NotZero(event.Timestamp)
    92  	assert.Equal(logger.Fatal, event.Level)
    93  	assert.Equal("go", event.Platform)
    94  	assert.Equal(SDK, event.Sdk.Name)
    95  	assert.Equal("this is a test", event.Message)
    96  	assert.Len(event.Exception, 4)
    97  	assert.NotEmpty(event.Fingerprint)
    98  	assert.NotNil(event.Exception[0].Stacktrace)
    99  	assert.NotEmpty(event.Exception[0].Stacktrace.Frames)
   100  }
   101  
   102  func TestErrRequest(t *testing.T) {
   103  	assert := assert.New(t)
   104  
   105  	res := errRequest(logger.ErrorEvent{})
   106  	assert.Empty(res.URL)
   107  
   108  	res = errRequest(logger.ErrorEvent{
   109  		State: &http.Request{
   110  			Method: "POST",
   111  			Host:   "example.org",
   112  			TLS:    &tls.ConnectionState{},
   113  			URL:    webutil.MustParseURL("https://example.org/foo"),
   114  		},
   115  	})
   116  	assert.Equal("POST", res.Method)
   117  	assert.Equal("https://example.org/foo", res.URL)
   118  }
   119  
   120  func TestErrFrames(t *testing.T) {
   121  	assert := assert.New(t)
   122  
   123  	err := ex.New("this is only a test")
   124  	assert.NotEmpty(errFrames(err))
   125  }
   126  
   127  func TestErrEventFingerprintDefault(t *testing.T) {
   128  	assert := assert.New(t)
   129  
   130  	event := errEvent(context.Background(), logger.ErrorEvent{
   131  		Flag: logger.Fatal,
   132  		Err:  ex.New("this is a test", ex.OptMessage("a message")),
   133  		State: &http.Request{
   134  			Method: "POST",
   135  			Host:   "example.org",
   136  			TLS:    &tls.ConnectionState{},
   137  			URL:    webutil.MustParseURL("https://example.org/foo"),
   138  		},
   139  	})
   140  
   141  	assert.NotNil(event)
   142  	assert.NotEmpty(event.Fingerprint)
   143  	assert.Equal([]string{"this is a test"}, event.Fingerprint)
   144  }
   145  
   146  func TestErrEventFingerprintIgnoresPath(t *testing.T) {
   147  	assert := assert.New(t)
   148  
   149  	ctx := logger.WithPath(context.Background(), "foo", "bar")
   150  
   151  	event := errEvent(ctx, logger.ErrorEvent{
   152  		Flag: logger.Fatal,
   153  		Err:  ex.New("this is a test", ex.OptMessage("a message")),
   154  		State: &http.Request{
   155  			Method: "POST",
   156  			Host:   "example.org",
   157  			TLS:    &tls.ConnectionState{},
   158  			URL:    webutil.MustParseURL("https://example.org/foo"),
   159  		},
   160  	})
   161  
   162  	assert.NotNil(event)
   163  	assert.NotEmpty(event.Fingerprint)
   164  	assert.Equal([]string{"this is a test"}, event.Fingerprint)
   165  }
   166  
   167  func TestErrEventFingerprintOverride(t *testing.T) {
   168  	assert := assert.New(t)
   169  
   170  	ctx := WithFingerprint(context.Background(), "test", "fingerprint")
   171  
   172  	event := errEvent(ctx, logger.ErrorEvent{
   173  		Flag: logger.Fatal,
   174  		Err:  ex.New("this is a test", ex.OptMessage("a message")),
   175  		State: &http.Request{
   176  			Method: "POST",
   177  			Host:   "example.org",
   178  			TLS:    &tls.ConnectionState{},
   179  			URL:    webutil.MustParseURL("https://example.org/foo"),
   180  		},
   181  	})
   182  	assert.NotNil(event)
   183  	assert.NotEmpty(event.Fingerprint)
   184  	assert.Equal([]string{"test", "fingerprint"}, event.Fingerprint)
   185  }