func TestGetSingleValueFromHeader(t *testing.T) { t.Log("Simple OK") { val, err := GetSingleValueFromHeader("Key", http.Header{"Key": {"value1"}}) require.NoError(t, err) require.Equal(t, "value1", val) } t.Log("Not found - empty header") { _, err := GetSingleValueFromHeader("No-Key", http.Header{}) require.EqualError(t, err, "No value found in HEADER for the key: No-Key") } t.Log("Not found - different key") { _, err := GetSingleValueFromHeader("No-Key", http.Header{"Key": {"value1"}}) require.EqualError(t, err, "No value found in HEADER for the key: No-Key") } t.Log("Multiple values") { _, err := GetSingleValueFromHeader("Key", http.Header{"Key": {"value1", "value2"}}) require.EqualError(t, err, "Multiple values found in HEADER for the key: Key") } }
func Test_transformTagPushEvent(t *testing.T) { t.Log("Do Transform") { tagPush := TagPushEventModel{ ObjectKind: "tag_push", Ref: "refs/tags/v0.0.2", CheckoutSHA: "7f29cdf31fdff43d7f31a279eec06c9f19ae0d6b", } hookTransformResult := transformTagPushEvent(tagPush) require.NoError(t, hookTransformResult.Error) require.False(t, hookTransformResult.ShouldSkip) require.Equal(t, []bitriseapi.TriggerAPIParamsModel{ { BuildParams: bitriseapi.BuildParamsModel{ Tag: "v0.0.2", CommitHash: "7f29cdf31fdff43d7f31a279eec06c9f19ae0d6b", }, }, }, hookTransformResult.TriggerAPIParams) } t.Log("No CheckoutSHA (tag delete)") { tagPush := TagPushEventModel{ ObjectKind: "tag_push", Ref: "refs/tags/v0.0.2", CheckoutSHA: "", } hookTransformResult := transformTagPushEvent(tagPush) require.EqualError(t, hookTransformResult.Error, "This is a Tag Deleted event, no build is required") require.True(t, hookTransformResult.ShouldSkip) require.Nil(t, hookTransformResult.TriggerAPIParams) } t.Log("Not a tags ref") { tagPush := TagPushEventModel{ ObjectKind: "tag_push", Ref: "refs/not/a/tag", CheckoutSHA: "7f29cdf31fdff43d7f31a279eec06c9f19ae0d6b", } hookTransformResult := transformTagPushEvent(tagPush) require.EqualError(t, hookTransformResult.Error, "Ref (refs/not/a/tag) is not a tags ref") require.False(t, hookTransformResult.ShouldSkip) require.Nil(t, hookTransformResult.TriggerAPIParams) } t.Log("Not a tag_push object") { tagPush := TagPushEventModel{ ObjectKind: "not-a-tag_push", Ref: "refs/tags/v0.0.2", CheckoutSHA: "7f29cdf31fdff43d7f31a279eec06c9f19ae0d6b", } hookTransformResult := transformTagPushEvent(tagPush) require.EqualError(t, hookTransformResult.Error, "Not a Tag Push object: not-a-tag_push") require.False(t, hookTransformResult.ShouldSkip) require.Nil(t, hookTransformResult.TriggerAPIParams) } }
func Test_detectContentTypeAndEventID(t *testing.T) { t.Log("Code Push event") { header := http.Header{ "X-Gogs-Event": {"push"}, "Content-Type": {"application/json"}, } contentType, eventID, err := detectContentTypeAndEventID(header) require.NoError(t, err) require.Equal(t, "application/json", contentType) require.Equal(t, "push", eventID) } t.Log("Missing X-Gogs-Event header") { header := http.Header{ "Content-Type": {"application/json"}, } contentType, eventID, err := detectContentTypeAndEventID(header) require.EqualError(t, err, "Issue with X-Gogs-Event Header: No value found in HEADER for the key: X-Gogs-Event") require.Equal(t, "", contentType) require.Equal(t, "", eventID) } t.Log("Missing Content-Type") { header := http.Header{ "X-Gogs-Event": {"push"}, } contentType, eventID, err := detectContentTypeAndEventID(header) require.EqualError(t, err, "Issue with Content-Type Header: No value found in HEADER for the key: Content-Type") require.Equal(t, "", contentType) require.Equal(t, "", eventID) } }
func TestSignedFullSerializeAndToken(t *testing.T) { b := Signed(rsaSigner).Claims(&testClaims{"foo"}) jwt, err := b.FullSerialize() require.NoError(t, err, "Error creating JWT.") parsed, err := ParseSigned(jwt) require.NoError(t, err, "Error parsing JWT.") out := &testClaims{} if assert.NoError(t, parsed.Claims(&testPrivRSAKey1.PublicKey, &out), "Error unmarshaling claims.") { assert.Equal(t, &testClaims{ Subject: "foo", }, out) } jwt2, err := b.Token() require.NoError(t, err, "Error creating JWT.") out2 := &testClaims{} if assert.NoError(t, jwt2.Claims(&testPrivRSAKey1.PublicKey, &out2), "Error unmarshaling claims.") { assert.Equal(t, &testClaims{ Subject: "foo", }, out2) } b2 := Signed(rsaSigner).Claims(&invalidMarshalClaims{}) _, err = b2.FullSerialize() require.EqualError(t, err, "json: error calling MarshalJSON for type *jwt.invalidMarshalClaims: Failed marshaling invalid claims.") _, err = b2.Token() require.EqualError(t, err, "json: error calling MarshalJSON for type *jwt.invalidMarshalClaims: Failed marshaling invalid claims.") }
func Test_HookProvider_TransformRequest(t *testing.T) { provider := HookProvider{} t.Log("Should be OK") { request := http.Request{ Header: http.Header{ "Content-Type": {"application/x-www-form-urlencoded"}, }, } form := url.Values{} form.Add("trigger_word", "bitrise:") form.Add("text", "bitrise: branch:master") request.PostForm = form hookTransformResult := provider.TransformRequest(&request) require.NoError(t, hookTransformResult.Error) require.False(t, hookTransformResult.ShouldSkip) require.Equal(t, []bitriseapi.TriggerAPIParamsModel{ { BuildParams: bitriseapi.BuildParamsModel{ Branch: "master", Environments: []bitriseapi.EnvironmentItem{}, }, }, }, hookTransformResult.TriggerAPIParams) } t.Log("Unsupported Event Type") { request := http.Request{ Header: http.Header{ "Content-Type": {"application/json"}, }, } hookTransformResult := provider.TransformRequest(&request) require.False(t, hookTransformResult.ShouldSkip) require.EqualError(t, hookTransformResult.Error, "Content-Type is not supported: application/json") } t.Log("Missing 'text' from request data") { request := http.Request{ Header: http.Header{ "Content-Type": {"application/x-www-form-urlencoded"}, }, } form := url.Values{} form.Add("trigger_word", "the trigger word") request.PostForm = form hookTransformResult := provider.TransformRequest(&request) require.False(t, hookTransformResult.ShouldSkip) require.EqualError(t, hookTransformResult.Error, "Failed to parse the request/message: 'trigger_word' parameter found, but 'text' parameter is missing or empty") } }
func TestBrokenCall(t *testing.T) { cli, listener, conn := prepTest(t) defer endTest(t, conn, listener) err := cli.BrokenMethod() require.EqualError(t, err, "method 'broken' not found in protocol 'test.1.testp'") err = cli.BrokenProtocol() require.EqualError(t, err, "protocol not found: test.2.testp") }
func TestSetNotifiesStage(t *testing.T) { tnflog := &testNflog{} s := &SetNotifiesStage{ recv: &nflogpb.Receiver{GroupName: "test"}, nflog: tnflog, } alerts := []*types.Alert{{}, {}, {}} ctx := context.Background() resctx, res, err := s.Exec(ctx, alerts...) require.EqualError(t, err, "notification hash missing") require.Nil(t, res) require.NotNil(t, resctx) ctx = WithNotificationHash(ctx, []byte{1, 2, 3}) _, res, err = s.Exec(ctx, alerts...) require.EqualError(t, err, "group key missing") require.Nil(t, res) require.NotNil(t, resctx) ctx = WithGroupKey(ctx, 1) s.resolved = func([]*types.Alert) bool { return false } tnflog.logActiveFunc = func(r *nflogpb.Receiver, gkey, hash []byte) error { require.Equal(t, s.recv, r) require.Equal(t, []byte{0, 0, 0, 0, 0, 0, 0, 1}, gkey) require.Equal(t, []byte{1, 2, 3}, hash) return nil } tnflog.logResolvedFunc = func(r *nflogpb.Receiver, gkey, hash []byte) error { t.Fatalf("LogResolved called unexpectedly") return nil } resctx, res, err = s.Exec(ctx, alerts...) require.Nil(t, err) require.Equal(t, alerts, res) require.NotNil(t, resctx) s.resolved = func([]*types.Alert) bool { return true } tnflog.logActiveFunc = func(r *nflogpb.Receiver, gkey, hash []byte) error { t.Fatalf("LogActive called unexpectedly") return nil } tnflog.logResolvedFunc = func(r *nflogpb.Receiver, gkey, hash []byte) error { require.Equal(t, s.recv, r) require.Equal(t, []byte{0, 0, 0, 0, 0, 0, 0, 1}, gkey) require.Equal(t, []byte{1, 2, 3}, hash) return nil } resctx, res, err = s.Exec(ctx, alerts...) require.Nil(t, err) require.Equal(t, alerts, res) require.NotNil(t, resctx) }
func Test_getInputTextFromFormRequest(t *testing.T) { t.Log("Proper Form content") { request := http.Request{} form := url.Values{} form.Add("trigger_word", "the trigger word") form.Add("text", "the trigger word the text") request.PostForm = form text, err := getInputTextFromFormRequest(&request) require.NoError(t, err) require.Equal(t, "the text", text) } t.Log("Missing trigger_word") { request := http.Request{} form := url.Values{} form.Add("text", "the text") request.PostForm = form text, err := getInputTextFromFormRequest(&request) require.EqualError(t, err, "Missing required parameter: either 'command' or 'trigger_word' should be specified") require.Equal(t, "", text) } t.Log("Missing text - trigger_word") { request := http.Request{} form := url.Values{} form.Add("trigger_word", "the trigger word") request.PostForm = form text, err := getInputTextFromFormRequest(&request) require.EqualError(t, err, "'trigger_word' parameter found, but 'text' parameter is missing or empty") require.Equal(t, "", text) } t.Log("Missing text - command") { request := http.Request{} form := url.Values{} form.Add("command", "the-command") request.PostForm = form text, err := getInputTextFromFormRequest(&request) require.EqualError(t, err, "'command' parameter found, but 'text' parameter is missing or empty") require.Equal(t, "", text) } }
func TestLongCallCancel(t *testing.T) { cli, listener, conn := prepTest(t) defer endTest(t, conn, listener) ctx, cancel := context.WithCancel(context.Background()) ctx = AddRpcTagsToContext(ctx, CtxRpcTags{"hello": []string{"world"}}) resultCh := make(chan longCallResult) runInBg(func() error { var longResult interface{} var err error longResult, err = cli.LongCall(ctx) resultCh <- longCallResult{longResult, err} longResult, err = cli.LongCallResult(context.Background()) resultCh <- longCallResult{longResult, err} longResult, err = cli.LongCallDebugTags(context.Background()) resultCh <- longCallResult{longResult, err} return nil }) // TODO figure out a way to avoid this sleep time.Sleep(time.Millisecond) cancel() res := <-resultCh require.EqualError(t, res.err, context.Canceled.Error()) require.Equal(t, 0, res.res, "call should be canceled") res = <-resultCh require.Nil(t, res.err, "call should have succeeded") require.Equal(t, -1, res.res, "canceled call should have set the longCallResult to canceled") res = <-resultCh require.Nil(t, res.err, "call should have succeeded") require.Equal(t, CtxRpcTags{"hello": []interface{}{"world"}}, res.res, "canceled call should have set the debug tags") }
func TestCloseReceiver(t *testing.T) { // Call error status waitCh := make(chan error, 1) p := &Protocol{ Name: "waiter", Methods: map[string]ServeHandlerDescription{ "wait": { MakeArg: func() interface{} { return nil }, Handler: func(c context.Context, i interface{}) (interface{}, error) { <-c.Done() waitCh <- c.Err() return nil, c.Err() }, MethodType: MethodCall, }, }, } receiver, _ := testReceive( t, p, makeCall( 0, "waiter.wait", nil, ), ) <-receiver.Close() err := <-waitCh require.EqualError(t, err, context.Canceled.Error()) }
func Test_MachineConfigModel_normalizeAndValidate(t *testing.T) { t.Log("Invalid CleanupMode") { configModel := MachineConfigModel{CleanupMode: ""} require.EqualError(t, configModel.normalizeAndValidate(), "Invalid CleanupMode: ") } t.Log("Minimal valid") { configModel := MachineConfigModel{ CleanupMode: CleanupModeRollback, IsCleanupBeforeSetup: true, IsDoTimesyncAtSetup: false, } t.Logf("configModel: %#v", configModel) require.NoError(t, configModel.normalizeAndValidate()) require.Equal(t, true, configModel.IsCleanupBeforeSetup) require.Equal(t, false, configModel.IsDoTimesyncAtSetup) // defaults require.Equal(t, EnvItemsModel{}, configModel.Envs) require.Equal(t, map[string]EnvItemsModel{}, configModel.ConfigTypeEnvs) } }
func TestBadStatusCode(t *testing.T) { ts := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) { w.WriteHeader(http.StatusServiceUnavailable) json.NewEncoder(w).Encode(`{ "errors": { "system": [ "The API is currently down for maintenance. It'll be back shortly." ] } }`) })) defer ts.Close() l := NewLibrato(ts.URL) l.ApiUser = "******" l.ApiToken = "123456" err := l.Connect() require.NoError(t, err) err = l.Write(testutil.MockBatchPoints().Points()) if err == nil { t.Errorf("error expected but none returned") } else { require.EqualError(t, fmt.Errorf("received bad status code, 503\n"), err.Error()) } }
func Test_InvalidCommand(t *testing.T) { t.Log("Invalid command") { _, err := cmdex.RunCommandAndReturnCombinedStdoutAndStderr(binPath(), "invalidcmd") require.EqualError(t, err, "exit status 1") } }
func Test_detectContentTypeAndEventID(t *testing.T) { t.Log("Code Push event") { header := http.Header{ "X-Gitlab-Event": {"Push Hook"}, "Content-Type": {"application/json"}, } contentType, eventID, err := detectContentTypeAndEventID(header) require.NoError(t, err) require.Equal(t, "application/json", contentType) require.Equal(t, "Push Hook", eventID) } t.Log("Unsupported event - will be handled in Transform") { header := http.Header{ "X-Gitlab-Event": {"Tag Push Hook"}, "Content-Type": {"application/json"}, } contentType, eventID, err := detectContentTypeAndEventID(header) require.NoError(t, err) require.Equal(t, "application/json", contentType) require.Equal(t, "Tag Push Hook", eventID) } t.Log("Missing X-Gitlab-Event header") { header := http.Header{ "Content-Type": {"application/json"}, } contentType, eventID, err := detectContentTypeAndEventID(header) require.EqualError(t, err, "Issue with X-Gitlab-Event Header: No value found in HEADER for the key: X-Gitlab-Event") require.Equal(t, "", contentType) require.Equal(t, "", eventID) } t.Log("Missing Content-Type") { header := http.Header{ "X-Gitlab-Event": {"Push Hook"}, } contentType, eventID, err := detectContentTypeAndEventID(header) require.EqualError(t, err, "Issue with Content-Type Header: No value found in HEADER for the key: Content-Type") require.Equal(t, "", contentType) require.Equal(t, "", eventID) } }
func Test_parseGoVersionFromGoVersionOutput(t *testing.T) { t.Log("Example OK") { verStr, err := parseGoVersionFromGoVersionOutput("go version go1.7 darwin/amd64") require.NoError(t, err) require.Equal(t, "1.7", verStr) } t.Log("Example OK 2") { verStr, err := parseGoVersionFromGoVersionOutput(`go version go1.7 darwin/amd64 `) require.NoError(t, err) require.Equal(t, "1.7", verStr) } t.Log("Example OK 3") { verStr, err := parseGoVersionFromGoVersionOutput("go version go1.7.1 darwin/amd64") require.NoError(t, err) require.Equal(t, "1.7.1", verStr) } t.Log("Empty") { verStr, err := parseGoVersionFromGoVersionOutput("") require.EqualError(t, err, "Failed to parse Go version, error: version call output was empty") require.Equal(t, "", verStr) } t.Log("Empty 2") { verStr, err := parseGoVersionFromGoVersionOutput(` `) require.EqualError(t, err, "Failed to parse Go version, error: version call output was empty") require.Equal(t, "", verStr) } t.Log("Invalid") { verStr, err := parseGoVersionFromGoVersionOutput("go version REMOVED darwin/amd64") require.EqualError(t, err, "Failed to parse Go version, error: failed to find version in input: go version REMOVED darwin/amd64") require.Equal(t, "", verStr) } }
func TestSnapshotMarshalJSONMarshallingErrorsPropagated(t *testing.T) { setDefaultSerializer(errorSerializer{}) defer setDefaultSerializer(canonicalJSON{}) sn := SignedSnapshot{ Signed: Snapshot{Type: "Snapshot", Version: 2, Expires: time.Now()}, } _, err := sn.MarshalJSON() require.EqualError(t, err, "bad") }
func TestTimeToFormattedSeconds(t *testing.T) { t.Log("formatted print rounds") { timeStr, err := FormattedSecondsToMax8Chars(secToDuration(0.999)) require.NoError(t, err) require.Equal(t, "1.00 sec", timeStr) } t.Log("sec < 1.0") { timeStr, err := FormattedSecondsToMax8Chars(secToDuration(0.111)) require.NoError(t, err) require.Equal(t, "0.11 sec", timeStr) } t.Log("sec < 10.0") { timeStr, err := FormattedSecondsToMax8Chars(secToDuration(9.111)) require.NoError(t, err) require.Equal(t, "9.11 sec", timeStr) } t.Log("sec < 600 | min < 10") { timeStr, err := FormattedSecondsToMax8Chars(secToDuration(599.111)) require.NoError(t, err) require.Equal(t, "599 sec", timeStr) } t.Log("min < 60") { timeStr, err := FormattedSecondsToMax8Chars(minToDuration(59.111)) require.NoError(t, err) require.Equal(t, "59.1 min", timeStr) } t.Log("hour < 10") { timeStr, err := FormattedSecondsToMax8Chars(hourToDuration(9.111)) require.NoError(t, err) require.Equal(t, "9.1 hour", timeStr) } t.Log("hour < 1000") { timeStr, err := FormattedSecondsToMax8Chars(hourToDuration(999.111)) require.NoError(t, err) require.Equal(t, "999 hour", timeStr) } t.Log("hour >= 1000") { timeStr, err := FormattedSecondsToMax8Chars(hourToDuration(1000)) require.EqualError(t, err, "time (1000.000000 hour) greater then max allowed (999 hour)") require.Equal(t, "", timeStr) } }
func TestFailureCase(t *testing.T) { fakeClient := &fakeFleetClientApi{} fakeClient.f = func() ([]machine.MachineState, error) { return nil, fmt.Errorf("test error") } nodesApi := &fleetNodes{client: fakeClient} _, err := nodesApi.List() require.EqualError(t, err, "test error") }
func TestTargetsToSignedMarshallingErrorsPropagated(t *testing.T) { setDefaultSerializer(errorSerializer{}) defer setDefaultSerializer(canonicalJSON{}) tg := SignedTargets{ Signed: Targets{SignedCommon: SignedCommon{Type: "Targets", Version: 2, Expires: time.Now()}}, } _, err := tg.ToSigned() require.EqualError(t, err, "bad") }
func TestTimestampMarshalJSONMarshallingErrorsPropagated(t *testing.T) { setDefaultSerializer(errorSerializer{}) defer setDefaultSerializer(canonicalJSON{}) ts := SignedTimestamp{ Signed: Timestamp{Type: "Timestamp", Version: 2, Expires: time.Now()}, } _, err := ts.MarshalJSON() require.EqualError(t, err, "bad") }
func TestRootToSignedMarshallingErrorsPropagated(t *testing.T) { setDefaultSerializer(errorSerializer{}) defer setDefaultSerializer(canonicalJSON{}) r := SignedRoot{ Signed: Root{Type: "root", Version: 2, Expires: time.Now()}, } _, err := r.ToSigned() require.EqualError(t, err, "bad") }
func TestSnapshotToSignedMarshallingErrorsPropagated(t *testing.T) { setDefaultSerializer(errorSerializer{}) defer setDefaultSerializer(canonicalJSON{}) sn := SignedSnapshot{ Signed: Snapshot{SignedCommon: SignedCommon{ Type: TUFTypes[CanonicalSnapshotRole], Version: 2, Expires: time.Now()}}, } _, err := sn.ToSigned() require.EqualError(t, err, "bad") }
func TestSnapshotFromSignedUnmarshallingErrorsPropagated(t *testing.T) { signed, err := validSnapshotTemplate().ToSigned() require.NoError(t, err) setDefaultSerializer(errorSerializer{}) defer setDefaultSerializer(canonicalJSON{}) _, err = SnapshotFromSigned(signed) require.EqualError(t, err, "bad") }
func TestRootMarshalJSONMarshallingErrorsPropagated(t *testing.T) { setDefaultSerializer(errorSerializer{}) defer setDefaultSerializer(canonicalJSON{}) r := SignedRoot{ Signed: Root{SignedCommon: SignedCommon{ Type: TUFTypes[CanonicalRootRole], Version: 2, Expires: time.Now()}}, } _, err := r.MarshalJSON() require.EqualError(t, err, "bad") }
func TestTimestampToSignedMarshallingErrorsPropagated(t *testing.T) { setDefaultSerializer(errorSerializer{}) defer setDefaultSerializer(canonicalJSON{}) ts := SignedTimestamp{ Signed: Timestamp{SignedCommon: SignedCommon{ Type: TUFTypes[CanonicalTimestampRole], Version: 2, Expires: time.Now()}}, } _, err := ts.ToSigned() require.EqualError(t, err, "bad") }
func TestTargetsFromSignedUnmarshallingErrorsPropagated(t *testing.T) { signed, err := validTargetsTemplate().ToSigned() require.NoError(t, err) setDefaultSerializer(errorSerializer{}) defer setDefaultSerializer(canonicalJSON{}) _, err = TargetsFromSigned(signed, CanonicalTargetsRole) require.EqualError(t, err, "bad") }
func TestSelectFromStringsFromReader(t *testing.T) { availableOptions := []string{"first", "second", "third"} t.Log("TestSelectFromStringsFromReader - NO input") { _, err := SelectFromStringsFromReader("Select something", availableOptions, strings.NewReader("")) require.Error(t, err) } t.Log("TestSelectFromStringsFromReader - INVALID input") { _, err := SelectFromStringsFromReader("Select something", availableOptions, strings.NewReader("-1")) require.EqualError(t, err, "Invalid option: You entered a number less than 1") } t.Log("TestSelectFromStringsFromReader - input") { res, err := SelectFromStringsFromReader("Select something", availableOptions, strings.NewReader("1")) require.NoError(t, err) require.Equal(t, "first", res) } t.Log("TestSelectFromStringsFromReader - input") { res, err := SelectFromStringsFromReader("Select something", availableOptions, strings.NewReader("2")) require.NoError(t, err) require.Equal(t, "second", res) } t.Log("TestSelectFromStringsFromReader - input") { res, err := SelectFromStringsFromReader("Select something", availableOptions, strings.NewReader("3")) require.NoError(t, err) require.Equal(t, "third", res) } t.Log("TestSelectFromStringsFromReader - INVALID input") { _, err := SelectFromStringsFromReader("Select something", availableOptions, strings.NewReader("4")) require.EqualError(t, err, "Invalid option: You entered a number greater than the last option's number") } }
func TestReceiveResponseNilCall(t *testing.T) { c := &rpcResponseMessage{c: &call{}} _, errCh := testReceive( t, nil, c, ) err := <-errCh require.True(t, shouldContinue(err)) require.EqualError(t, err, "Call not found for sequence number 0") }
func TestEncryptedFullSerializeAndToken(t *testing.T) { recipient := jose.Recipient{ Algorithm: jose.RSA1_5, Key: testPrivRSAKey1.Public(), } encrypter, err := jose.NewEncrypter(jose.A128CBC_HS256, recipient, nil) require.NoError(t, err, "Error creating encrypter.") b := Encrypted(encrypter).Claims(&testClaims{"foo"}) jwt, err := b.FullSerialize() require.NoError(t, err, "Error creating JWT.") parsed, err := ParseEncrypted(jwt) require.NoError(t, err, "Error parsing JWT.") out := &testClaims{} if assert.NoError(t, parsed.Claims(testPrivRSAKey1, &out)) { assert.Equal(t, &testClaims{ Subject: "foo", }, out) } jwt2, err := b.Token() require.NoError(t, err, "Error creating JWT.") out2 := &testClaims{} if assert.NoError(t, jwt2.Claims(testPrivRSAKey1, &out2)) { assert.Equal(t, &testClaims{ Subject: "foo", }, out2) } b2 := Encrypted(encrypter).Claims(&invalidMarshalClaims{}) _, err = b2.FullSerialize() require.EqualError(t, err, "json: error calling MarshalJSON for type *jwt.invalidMarshalClaims: Failed marshaling invalid claims.") _, err = b2.Token() require.EqualError(t, err, "json: error calling MarshalJSON for type *jwt.invalidMarshalClaims: Failed marshaling invalid claims.") }
func TestAcceptGone(t *testing.T) { defer sleepWhile(&mu, func() bool { return len(sockets) != 0 }) s, err := NewSocket("udp", "localhost:0") require.NoError(t, err) defer s.Close() _, err = DialTimeout(s.Addr().String(), time.Millisecond) require.Error(t, err) // Will succeed because we don't signal that we give up dialing, or check // that the handshake is completed before returning the new Conn. c, err := s.Accept() require.NoError(t, err) defer c.Close() err = c.SetReadDeadline(time.Now().Add(time.Millisecond)) _, err = c.Read(nil) require.EqualError(t, err, "i/o timeout") }