func TestMarshallAuthor(t *testing.T) { a := &entity.Author{ ID: 13, Ordering: 65, Name: "Tilo Jung", Title: "Politik", URL: "/13--tilo-jung", Biography: "Tilo Jung", SocialMedia: "TWITTER | FACEBOOK", CreatedAt: time.Date(2016, 06, 05, 22, 32, 0, 0, time.UTC), UpdatedAt: time.Date(2016, 06, 05, 22, 32, 0, 0, time.UTC), } b, err := json.Marshal(Author(a)) assert.Nil(t, err) assert.JSONEq( t, `{"data":{"id":13,"order":65,"name":"Tilo Jung","title":"Politik","url":"https://krautreporter.de/13--tilo-jung","biography":"Tilo Jung","socialmedia":"TWITTER | FACEBOOK","created_at":"2016-06-05T22:32:00Z","updated_at":"2016-06-05T22:32:00Z","images":null}}`, string(b), ) a.Images = append(a.Images, entity.Image{ID: 123, Width: 256, Src: "/foo.jpg"}) b, err = json.Marshal(Author(a)) assert.Nil(t, err) assert.JSONEq( t, `{"data":{"id":13,"order":65,"name":"Tilo Jung","title":"Politik","url":"https://krautreporter.de/13--tilo-jung","biography":"Tilo Jung","socialmedia":"TWITTER | FACEBOOK","created_at":"2016-06-05T22:32:00Z","updated_at":"2016-06-05T22:32:00Z","images":{"data":[{"id":123,"width":256,"src":"https://krautreporter.de/foo.jpg"}]}}}`, string(b), ) }
func TestMarshallArticle(t *testing.T) { a := &entity.Article{ ID: 123, Ordering: 10, Title: "Title", Headline: "Headline", Preview: true, URL: "/123--article", Excerpt: "foo", Content: "bar", AuthorID: 13, } b, err := json.Marshal(Article(a)) assert.Nil(t, err) assert.JSONEq( t, `{"data":{"id":123,"order":10,"title":"Title","headline":"Headline","date":"0001-01-01T00:00:00Z","morgenpost":false,"preview":true,"url":"https://krautreporter.de/123--article","excerpt":"foo","content":"bar","created_at":"0001-01-01T00:00:00Z","updated_at":"0001-01-01T00:00:00Z","author_id":13,"images":null}}`, string(b), ) a.Images = append(a.Images, entity.Image{ID: 123, Width: 256, Src: "/foo.jpg"}) b, err = json.Marshal(Article(a)) assert.Nil(t, err) assert.JSONEq( t, `{"data":{"id":123,"order":10,"title":"Title","headline":"Headline","date":"0001-01-01T00:00:00Z","morgenpost":false,"preview":true,"url":"https://krautreporter.de/123--article","excerpt":"foo","content":"bar","created_at":"0001-01-01T00:00:00Z","updated_at":"0001-01-01T00:00:00Z","author_id":13,"images":{"data":[{"id":123,"width":256,"src":"https://krautreporter.de/foo.jpg"}]}}}`, string(b), ) }
func TestImage(t *testing.T) { i := []entity.Image{} b, err := json.Marshal(Images(i)) assert.Nil(t, err) assert.JSONEq(t, `{"data":null}`, string(b)) i = append(i, entity.Image{ID: 123, Width: 256, Src: "/foo.jpg"}) b, err = json.Marshal(Images(i)) assert.Nil(t, err) assert.JSONEq(t, `{"data":[{"id":123,"width":256,"src":"https://krautreporter.de/foo.jpg"}]}`, string(b)) }
func (s *LTMTestSuite) TestCreateIRule() { s.Client.CreateIRule("rule1", `when CLIENT_ACCEPTED { log local0. "test"}`) assert.Equal(s.T(), fmt.Sprintf("/mgmt/tm/%s", uriRule), s.LastRequest.URL.Path) assert.Equal(s.T(), "POST", s.LastRequest.Method) assert.JSONEq(s.T(), `{"name":"rule1","apiAnonymous":"when CLIENT_ACCEPTED { log local0. \"test\"}"}`, s.LastRequestBody) }
func (s *LTMTestSuite) TestModifyIRule() { s.Client.ModifyIRule("rule1", &IRule{Rule: "modified"}) assert.Equal(s.T(), fmt.Sprintf("/mgmt/tm/%s/%s", uriRule, "rule1"), s.LastRequest.URL.Path) assert.Equal(s.T(), "PUT", s.LastRequest.Method) assert.JSONEq(s.T(), `{"name":"rule1","apiAnonymous":"modified"}`, s.LastRequestBody) }
// Looking at the gorilla/mux CombinedLoggingHandler, the only test is for the WriteCombinedLog function, so doing the same here // (this test inspired by their test) func TestWriteLog(t *testing.T) { assert := assert.New(t) now := time.Now().Format(time.RFC3339) resptime := time.Millisecond * 123 // A typical request with an OK response req, err := http.NewRequest("GET", "http://example.com", nil) req.RemoteAddr = "192.168.100.11" req.Header.Set("Referer", "http://example.com") req.Header.Set("User-Agent", "User agent") logger := log.New() buf := new(bytes.Buffer) logger.Out = buf logger.Formatter = new(log.JSONFormatter) writeRequestLog(logger, req, knownTransactionID, *req.URL, resptime, http.StatusOK, 100) var fields log.Fields err = json.Unmarshal(buf.Bytes(), &fields) assert.NoError(err, "Could not unmarshall") expected := fmt.Sprintf(`{"host":"192.168.100.11", "level":"info","method":"GET","msg":"","protocol":"HTTP/1.1", "referer":"http://example.com","responsetime":%d,"size":100,"status":200, "time":"%s", "transaction_id":"KnownTransactionId", "uri":"/","userAgent":"User agent","username":"******"}`, int64(resptime.Seconds()*1000), now) assert.JSONEq(expected, buf.String(), "Log format didn't match") }
func TestConvertWithNewLines(t *testing.T) { assert := assert.New(t) s := `<?xml version="1.0" encoding="UTF-8"?> <osm> <foo> foo bar </foo> </osm>` // Build SimpleJSON json, err := sj.NewJson([]byte(`{ "osm": { "foo": "foo\n\n\t\tbar" } }`)) assert.NoError(err) expected, err := json.MarshalJSON() assert.NoError(err) // Then encode it in JSON res, err := Convert(strings.NewReader(s)) assert.NoError(err) // Assertion assert.JSONEq(string(expected), res.String(), "Drumroll") }
func TestJobsProperties(t *testing.T) { assert := assert.New(t) workDir, err := os.Getwd() assert.NoError(err) ntpReleasePath := filepath.Join(workDir, "../test-assets/ntp-release") ntpReleasePathBoshCache := filepath.Join(ntpReleasePath, "bosh-cache") release, err := NewDevRelease(ntpReleasePath, "", "", ntpReleasePathBoshCache) assert.NoError(err) assert.Len(release.Jobs, 1) lightOpinionsPath := filepath.Join(workDir, "../test-assets/ntp-opinions/opinions.yml") darkOpinionsPath := filepath.Join(workDir, "../test-assets/ntp-opinions/dark-opinions.yml") opinions, err := newOpinions(lightOpinionsPath, darkOpinionsPath) assert.NoError(err) properties, err := release.Jobs[0].getPropertiesForJob(opinions) assert.Len(properties, 2) actualJSON, err := json.Marshal(properties) if assert.NoError(err) { assert.JSONEq(`{ "ntp_conf" : "zip.conf", "with": { "json": { "default": { "key": "value" } } } }`, string(actualJSON), "Unexpected properties") } }
func TestMarshallImage(t *testing.T) { i := entity.Image{ID: 123, Width: 256, Src: "/foo.jpg"} b, err := json.Marshal(marshallImage(i)) assert.Nil(t, err) assert.JSONEq(t, `{"id":123,"width":256,"src":"https://krautreporter.de/foo.jpg"}`, string(b)) }
func assertRestCall(s *NetTestSuite, method, path, body string) { assert.Equal(s.T(), method, s.LastRequest.Method) assert.Equal(s.T(), path, s.LastRequest.URL.Path) if body != "" { assert.JSONEq(s.T(), body, s.LastRequestBody) } }
func TestGrantAndRevokeChannelLevelSubscribe(t *testing.T) { assert := assert.New(t) stop, sleep := NewVCRNonSubscribe( "fixtures/pam/grantAndRevokeChannelLevelSubscribe", []string{"uuid", "signature", "timestamp"}) defer stop() pubnubInstance := messaging.NewPubnub(PamPubKey, PamSubKey, PamSecKey, "", false, "") channel := "testChannelGrantAndRevokeChannelLevelSubscribe" ttl := 8 message := fmt.Sprintf(`{"status":200,"service":"Access Manager","message":"Success","payload":{"channels":{"%s":{"r":1,"m":0,"w":1}},"subscribe_key":"%s","ttl":%d,"level":"channel"}}`, channel, PamSubKey, ttl) message2 := fmt.Sprintf(`{"status":200,"service":"Access Manager","message":"Success","payload":{"channels":{"%s":{"r":0,"m":0,"w":0}},"subscribe_key":"%s","ttl":%d,"level":"channel"}}`, channel, PamSubKey, 1) successChannel := make(chan []byte) errorChannel := make(chan []byte) go pubnubInstance.GrantSubscribe(channel, true, true, ttl, "", successChannel, errorChannel) select { case resp := <-successChannel: response := string(resp) assert.JSONEq(message, response) case err := <-errorChannel: assert.Fail(string(err)) case <-timeout(): assert.Fail("GrantSubscribe Timeout") } successChannel2 := make(chan []byte) errorChannel2 := make(chan []byte) sleep(5) go pubnubInstance.GrantSubscribe(channel, false, false, -1, "", successChannel2, errorChannel2) select { case resp := <-successChannel2: response := string(resp) assert.JSONEq(message2, response) case err := <-errorChannel2: assert.Fail(string(err)) case <-timeout(): assert.Fail("GrantSubscribe Timeout") } }
func TestGetLogs(t *testing.T) { tempDir, _ := ioutil.TempDir("", "logs") defer os.RemoveAll(tempDir) deploymentLogger := NewDeploymentLogManager(tempDir) // test message formatting when have no log file logs, err := deploymentLogger.GetLogs("non-existing-log-file") assert.NoError(t, err) assert.JSONEq(t, `{"messages":[]}`, string(logs)) // test message formating with correct log file // add some content to the first file logFileWithContent := path.Join(tempDir, fmt.Sprintf(logFileNameScheme, 1, "1111-2222")) logContent := `{"msg":"test"}` err = openLogFileWithContent(logFileWithContent, logContent) assert.NoError(t, err) // check if file really exists _, err = deploymentLogger.findLogsForSpecificID("1111-2222") assert.NoError(t, err) logs, err = deploymentLogger.GetLogs("1111-2222") assert.JSONEq(t, `{"messages":[{"msg":"test"}]}`, string(logs)) // test message formating with empty log file; // below should create empty log file deploymentLogger.Enable("1111-3333") _, err = deploymentLogger.findLogsForSpecificID("1111-3333") assert.NoError(t, err) logs, err = deploymentLogger.GetLogs("1111-3333") assert.JSONEq(t, `{"messages":[]}`, string(logs)) // test broken log entry logFileWithContent = path.Join(tempDir, fmt.Sprintf(logFileNameScheme, 1, "1111-4444")) logContent = `{"msg":"test"} {"msg": "broken {"msg": "test2"}` err = openLogFileWithContent(logFileWithContent, logContent) assert.NoError(t, err) logs, err = deploymentLogger.GetLogs("1111-4444") assert.JSONEq(t, `{"messages":[{"msg":"test"}, {"msg": "test2"}]}`, string(logs)) }
func TestAuthorize(t *testing.T) { t.Parallel() storageConfig := CreateStorageConfig("Authorize") var err error svc := createDynamoDB() storage := New(svc, storageConfig) err = storage.CreateSchema() assert.Nil(t, err, "%s", err) defer storage.DropSchema() client := &osin.DefaultClient{ Id: "1234", Secret: "aabbccdd", } err = storage.CreateClient(client) assert.Nil(t, err, "%s", err) authorizeData := &osin.AuthorizeData{ Client: client, Code: "9999", ExpiresIn: 3600, RedirectUri: "/dev/null", CreatedAt: time.Now(), } got, err := storage.LoadAuthorize(authorizeData.Code) assert.Equal(t, ErrAuthorizeNotFound, err) assert.Nil(t, got) err = storage.SaveAuthorize(authorizeData) assert.Nil(t, err, "%s", err) got, err = storage.LoadAuthorize(authorizeData.Code) // We need to convert it to json as pointers inside structs are different // and assert library doesn't provide recursive value comparison for structs assert.Nil(t, err, "%s", err) gotJSON, err := json.Marshal(got) assert.Nil(t, err, "%s", err) expectedJSON, err := json.Marshal(authorizeData) assert.Nil(t, err, "%s", err) assert.JSONEq(t, string(expectedJSON), string(gotJSON)) err = storage.RemoveAuthorize(authorizeData.Code) assert.Nil(t, err, "%s", err) got, err = storage.LoadAuthorize(authorizeData.Code) assert.Equal(t, ErrAuthorizeNotFound, err) assert.Nil(t, got) // let's try with expired token authorizeData.CreatedAt = authorizeData.CreatedAt.Add(-time.Duration(authorizeData.ExpiresIn) * time.Second) err = storage.SaveAuthorize(authorizeData) assert.Nil(t, err, "%s", err) got, err = storage.LoadAuthorize(authorizeData.Code) assert.Equal(t, ErrTokenExpired, err) assert.Nil(t, got) }
func TestMiddleware_ServeHTTP(t *testing.T) { mw, rec, req := setupServeHTTP(t) mw.ServeHTTP(rec, req, func(w http.ResponseWriter, r *http.Request) { w.WriteHeader(418) }) lines := strings.Split(strings.TrimSpace(mw.Logger.Out.(*bytes.Buffer).String()), "\n") assert.Len(t, lines, 2) assert.JSONEq(t, fmt.Sprintf(`{"level":"info","method":"GET","msg":"started handling request",`+ `"remote":"10.10.10.10","request":"http://example.com/stuff?rly=ya",`+ `"request_id":"22035D08-98EF-413C-BBA0-C4E66A11B28D","time":"%s"}`, nowToday), lines[0]) assert.JSONEq(t, fmt.Sprintf(`{"level":"info","method":"GET","msg":"completed handling request",`+ `"remote":"10.10.10.10","request":"http://example.com/stuff?rly=ya",`+ `"measure#web.latency":10000,"took":10000,"text_status":"I'm a teapot",`+ `"status":418,"request_id":"22035D08-98EF-413C-BBA0-C4E66A11B28D","time":"%s"}`, nowToday), lines[1]) }
func equalJSONs(t assert.TestingT, exp, act interface{}) bool { e, err := json.Marshal(exp) if assert.NoError(t, err) { return false } a, err := json.Marshal(act) if assert.NoError(t, err) { return false } return assert.JSONEq(t, string(e), string(a)) }
// fieldValidator returns a encoderValidator that will compare the JSON of v["properties"][fieldName] only, where v is a // top-level JSONSchema object. func fieldValidator(fieldName, expected string) encoderValidator { return func(t *testing.T, result []byte) { v := struct { Properties map[string]interface{} `json:"properties"` }{} err := json.Unmarshal(result, &v) assert.NoError(t, err, "Input ('%s') needs to be valid JSON", result) actual, err := json.Marshal(v.Properties[fieldName]) assert.NoError(t, err) assert.JSONEq(t, expected, string(actual)) } }
func TestJSONHelperValidInput(t *testing.T) { assert := assert.New(t) testDataList := []jsonHelpInputTestData{ jsonHelpInputTestData{ name: "Simple number input", yaml: `1`, json: `1`, }, jsonHelpInputTestData{ name: "Simple map", yaml: `a: 1`, json: `{"a": 1}`, }, jsonHelpInputTestData{ name: "Nested map", yaml: `a: { b: c }`, json: `{"a": {"b": "c"}}`, }, jsonHelpInputTestData{ name: "Map in slice", yaml: `[ { a: b } ]`, json: `[ {"a": "b" } ]`, }, jsonHelpInputTestData{ name: "Map with non-string keys", yaml: `1: 2`, errMsg: `Failed to convert keys in path : Invalid key 1`, }, jsonHelpInputTestData{ name: "Nested map with non-string keys", yaml: `a: { b: { 1: 2 } }`, errMsg: `Failed to convert keys in path a.b: Invalid key 1`, }, } for _, testData := range testDataList { var unmarshaled interface{} err := yaml.Unmarshal([]byte(testData.yaml), &unmarshaled) if !assert.NoError(err, "Failed to unmarshal YAML data for test sample %s", testData.name) { continue } result, err := JSONMarshal(unmarshaled) if testData.errMsg != "" { assert.Error(err, "Exepected test sample %s to result in an error", testData.name) assert.Contains(err.Error(), testData.errMsg, "Error message did not contain expected string for test sample %s", testData.name) } else { if assert.NoError(err, "Unexpected error for test sample %s", testData.name) { assert.JSONEq(testData.json, string(result), "Unexpected result for test sample %s", testData.name) } } } }
func TestStatusClient(t *testing.T) { responder := &struct { httpStatus int recdata []byte path string }{ http.StatusNoContent, // 204 []byte{}, "", } // Test server that always responds with 200 code, and specific payload ts := httptest.NewTLSServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) { w.WriteHeader(responder.httpStatus) responder.recdata, _ = ioutil.ReadAll(r.Body) responder.path = r.URL.Path })) defer ts.Close() ac, err := NewApiClient( Config{"client.crt", "client.key", "server.crt", true, false}, ) assert.NotNil(t, ac) assert.NoError(t, err) client := NewStatus() assert.NotNil(t, client) err = client.Report(NewMockApiClient(nil, errors.New("foo")), ts.URL, StatusReport{ DeploymentID: "deployment1", Status: StatusFailure, }) assert.Error(t, err) err = client.Report(ac, ts.URL, StatusReport{ DeploymentID: "deployment1", Status: StatusFailure, }) assert.NoError(t, err) assert.NotNil(t, responder.recdata) assert.JSONEq(t, `{"status": "failure"}`, string(responder.recdata)) assert.Equal(t, apiPrefix+"deployments/device/deployments/deployment1/status", responder.path) responder.httpStatus = 401 err = client.Report(ac, ts.URL, StatusReport{ DeploymentID: "deployment1", Status: StatusSuccess, }) assert.Error(t, err) }
func TestInventoryClient(t *testing.T) { responder := &struct { httpStatus int recdata []byte path string }{ http.StatusOK, []byte{}, "", } // Test server that always responds with 200 code, and specific payload ts := httptest.NewTLSServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) { w.WriteHeader(responder.httpStatus) responder.recdata, _ = ioutil.ReadAll(r.Body) responder.path = r.URL.Path })) defer ts.Close() ac, err := NewApiClient( Config{"client.crt", "client.key", "server.crt", true, false}, ) assert.NotNil(t, ac) assert.NoError(t, err) client := NewInventory() assert.NotNil(t, client) err = client.Submit(NewMockApiClient(nil, errors.New("foo")), ts.URL, InventoryData{ {"foo", "bar"}, }) assert.Error(t, err) err = client.Submit(ac, ts.URL, InventoryData{ {"foo", "bar"}, {"bar", []string{"baz", "zen"}}, }) assert.NoError(t, err) assert.NotNil(t, responder.recdata) assert.JSONEq(t, `[{"name": "foo", "value": "bar"},{"name": "bar", "value": ["baz", "zen"]}]`, string(responder.recdata)) assert.Equal(t, apiPrefix+"inventory/device/attributes", responder.path) responder.httpStatus = 401 err = client.Submit(ac, ts.URL, nil) assert.Error(t, err) }
func TestGetHandler(t *testing.T) { assert := assert.New(t) tests := []test{ {"Success", newRequest("GET", fmt.Sprintf("/content/%s/annotations", knownUUID), "application/json", nil), dummyService{contentUUID: knownUUID}, http.StatusOK, "", "[]"}, {"NotFound", newRequest("GET", fmt.Sprintf("/content/%s/annotations", "99999"), "application/json", nil), dummyService{contentUUID: knownUUID}, http.StatusNotFound, "", message("No annotations found for content with uuid 99999.")}, {"ReadError", newRequest("GET", fmt.Sprintf("/content/%s/annotations", knownUUID), "application/json", nil), dummyService{contentUUID: knownUUID, failRead: true}, http.StatusServiceUnavailable, "", message("Error getting annotations (TEST failing to READ)")}, } for _, test := range tests { rec := httptest.NewRecorder() router(httpHandlers{test.dummyService}).ServeHTTP(rec, test.req) assert.True(test.statusCode == rec.Code, fmt.Sprintf("%s: Wrong response code, was %d, should be %d", test.name, rec.Code, test.statusCode)) assert.JSONEq(test.body, rec.Body.String(), fmt.Sprintf("%s: Wrong body", test.name)) } }
func (tc *encoderTestCase) Run(t *testing.T) { t.Run(tc.name, func(t *testing.T) { t.Parallel() b := new(bytes.Buffer) enc := jsonschema.NewEncoder(b) assert.NoError(t, enc.Encode(&tc.schema)) if tc.customValidate == nil { assert.JSONEq(t, tc.expect, b.String()) } else { tc.customValidate(t, b.Bytes()) } }) }
func TestMiddleware_ServeHTTP_AfterOverride(t *testing.T) { mw, rec, req := setupServeHTTP(t) mw.After = func(entry *logrus.Entry, _ negroni.ResponseWriter, _ time.Duration, _ string) *logrus.Entry { return entry.WithFields(logrus.Fields{"hambone": 57}) } mw.ServeHTTP(rec, req, func(w http.ResponseWriter, r *http.Request) { w.WriteHeader(418) }) lines := strings.Split(strings.TrimSpace(mw.Logger.Out.(*bytes.Buffer).String()), "\n") assert.Len(t, lines, 2) assert.JSONEq(t, fmt.Sprintf(`{"hambone":57,"level":"info","method":"GET","msg":"completed handling request",`+ `"remote":"10.10.10.10","request":"http://example.com/stuff?rly=ya",`+ `"request_id":"22035D08-98EF-413C-BBA0-C4E66A11B28D","time":"%s"}`, nowToday), lines[1]) }
func TestMiddleware_ServeHTTP_BeforeOverride(t *testing.T) { mw, rec, req := setupServeHTTP(t) mw.Before = func(entry *logrus.Entry, _ *http.Request, _ string) *logrus.Entry { return entry.WithFields(logrus.Fields{"wat": 200}) } mw.ServeHTTP(rec, req, func(w http.ResponseWriter, r *http.Request) { w.WriteHeader(418) }) lines := strings.Split(strings.TrimSpace(mw.Logger.Out.(*bytes.Buffer).String()), "\n") assert.Len(t, lines, 2) assert.JSONEq(t, fmt.Sprintf(`{"wat":200,"level":"info","msg":"completed handling request",`+ `"measure#web.latency":10000,"took":10000,"text_status":"I'm a teapot",`+ `"status":418,"request_id":"22035D08-98EF-413C-BBA0-C4E66A11B28D","time":"%s"}`, nowToday), lines[1]) }
func TestMarshallAuthors(t *testing.T) { authors := []*entity.Author{{ ID: 1, Ordering: 1, }, { ID: 2, Ordering: 0, }} b, err := json.Marshal(Authors(authors)) assert.Nil(t, err) assert.JSONEq( t, `{"data":[{"id":1,"order":1,"name":"","title":"","url":"https://krautreporter.de","biography":"","socialmedia":"","created_at":"0001-01-01T00:00:00Z","updated_at":"0001-01-01T00:00:00Z","images":null},{"id":2,"order":0,"name":"","title":"","url":"https://krautreporter.de","biography":"","socialmedia":"","created_at":"0001-01-01T00:00:00Z","updated_at":"0001-01-01T00:00:00Z","images":null}]}`, string(b), ) }
func TestHandleInterfaceEmptySuccess(t *testing.T) { h := func(ctx context.Context, _ yarpc.ReqMeta, body interface{}) (interface{}, yarpc.ResMeta, error) { return body, nil, nil } handler := jsonHandler{reader: ifaceEmptyReader{}, handler: reflect.ValueOf(h)} resw := new(transporttest.FakeResponseWriter) err := handler.Handle(context.Background(), &transport.Request{ Procedure: "foo", Encoding: "json", Body: jsonBody(`["a", "b", "c"]`), }, resw) require.NoError(t, err) assert.JSONEq(t, `["a", "b", "c"]`, resw.Body.String()) }
func TestMarshallArticles(t *testing.T) { articles := []*entity.Article{{ ID: 1, Ordering: 1, }, { ID: 2, Ordering: 0, }} b, err := json.Marshal(Articles(articles)) assert.Nil(t, err) assert.JSONEq( t, `{"data":[{"id":1,"order":1,"title":"","headline":"","date":"0001-01-01T00:00:00Z","morgenpost":false,"preview":false,"url":"https://krautreporter.de","excerpt":"","content":"","created_at":"0001-01-01T00:00:00Z","updated_at":"0001-01-01T00:00:00Z","author_id":0,"images":null},{"id":2,"order":0,"title":"","headline":"","date":"0001-01-01T00:00:00Z","morgenpost":false,"preview":false,"url":"https://krautreporter.de","excerpt":"","content":"","created_at":"0001-01-01T00:00:00Z","updated_at":"0001-01-01T00:00:00Z","author_id":0,"images":null}]}`, string(b), ) }
func TestGrantChannelLevelSubscribeWithAuth(t *testing.T) { assert := assert.New(t) stop, _ := NewVCRNonSubscribe( "fixtures/pam/grantChannelLevelSubscribeWithAuth", []string{"uuid", "signature", "timestamp"}) defer stop() pubnubInstance := messaging.NewPubnub(PamPubKey, PamSubKey, PamSecKey, "", false, "") channel := "testGrantChannelLevelSubscribeWithAuth" authKey := "myAuthKey" ttl := 1 expected := fmt.Sprintf(`{ "auths":{"%s":{"r":1,"m":0,"w":1}}, "channel":"%s", "level":"user", "ttl":%d, "subscribe_key":"%s" }`, authKey, channel, ttl, PamSubKey) successChannel := make(chan []byte) errorChannel := make(chan []byte) go pubnubInstance.GrantSubscribe(channel, true, true, ttl, authKey, successChannel, errorChannel) select { case resp := <-successChannel: var response PamResponse err := json.Unmarshal(resp, &response) if err != nil { assert.Fail(err.Error()) } payload, err := json.Marshal(response.Payload) if err != nil { assert.Fail(err.Error()) } assert.JSONEq(expected, string(payload)) case err := <-errorChannel: assert.Fail(string(err)) case <-timeout(): assert.Fail("GrantSubscribe Timeout") } }
func (s *LTMTestSuite) TestCreateVitualAddress() { s.Client.CreateVirtualAddress("test-va", &VirtualAddress{Address: "10.10.10.10", ARP: true, AutoDelete: false}) assert.Equal(s.T(), "POST", s.LastRequest.Method) assert.Equal(s.T(), fmt.Sprintf("/mgmt/tm/%s/%s", uriLtm, uriVirtualAddress), s.LastRequest.URL.Path) assert.JSONEq(s.T(), ` {"name":"test-va", "arp":"enabled", "autoDelete":"false", "address" : "10.10.10.10", "enabled":"no", "floating":"disabled", "icmpEcho":"disabled", "inheritedTrafficGroup":"no", "routeAdvertisement":"disabled"}`, s.LastRequestBody) }
func TestConvertWithMixedTags(t *testing.T) { assert := assert.New(t) s := `<?xml version="1.0" encoding="UTF-8"?> <soap-env:Envelope xmlns:soap-env="http://schemas.xmlsoap.org/soap/envelope/"> <soap-env:Header> <wsse:Security xmlns:wsse="http://schemas.xmlsoap.org/ws/2002/12/secext"> <wsse:BinarySecurityToken valueType="String" EncodingType="wsse:Base64Binary"> Shared/IDL:IceSess\/SessMgr:1\.0.IDL/Common/!ICESMS\/ACPCRTC!ICESMSLB\/CRT.LB!-3379045898978075261!1563026!0 </wsse:BinarySecurityToken> </wsse:Security> </soap-env:Header> </soap-env:Envelope> ` // Build SimpleJSON json, err := sj.NewJson([]byte(`{ "Envelope": { "Header": { "Security": { "-wsse": "http://schemas.xmlsoap.org/ws/2002/12/secext", "BinarySecurityToken": { "#content": "Shared/IDL:IceSess\\/SessMgr:1\\.0.IDL/Common/!ICESMS\\/ACPCRTC!ICESMSLB\\/CRT.LB!-3379045898978075261!1563026!0", "-EncodingType": "wsse:Base64Binary", "-valueType": "String" } } }, "-soap-env": "http://schemas.xmlsoap.org/soap/envelope/" } }`)) assert.NoError(err) expected, err := json.MarshalJSON() assert.NoError(err) // Then encode it in JSON res, err := Convert(strings.NewReader(s)) assert.NoError(err) // Assertion assert.JSONEq(string(expected), res.String(), "Drumroll") }
func TestPutHandler(t *testing.T) { assert := assert.New(t) body, err := ioutil.ReadFile("annotations/examplePutBody.json") assert.NoError(err, "Unexpected error") invalidBody := []byte(`{"id": "1234"}`) missingConceptIDBody := []byte(`"{"thing": {"prefLabel": "Apple"}`) tests := []test{ {"Success", newRequest("PUT", fmt.Sprintf("/content/%s/annotations", knownUUID), "application/json", body), dummyService{contentUUID: knownUUID}, http.StatusCreated, "application/json", message("Annotations for content 12345 created")}, {"ParseError", newRequest("PUT", fmt.Sprintf("/content/%s/annotations", knownUUID), "application/json", invalidBody), dummyService{contentUUID: knownUUID, failParse: true}, http.StatusBadRequest, "application/json", message("Error (TEST failing to DECODE) parsing annotation request")}, {"ValidationError", newRequest("PUT", fmt.Sprintf("/content/%s/annotations", knownUUID), "application/json", missingConceptIDBody), dummyService{contentUUID: knownUUID, failValidation: true}, http.StatusBadRequest, "application/json", message("Error creating annotations (TEST failing validation)")}, {"NotJson", newRequest("PUT", fmt.Sprintf("/content/%s/annotations", knownUUID), "text/html", body), dummyService{contentUUID: knownUUID}, http.StatusBadRequest, "application/json", message("Http Header 'Content-Type' is not 'application/json', this is a JSON API")}, {"WriteFailed", newRequest("PUT", fmt.Sprintf("/content/%s/annotations", knownUUID), "application/json", body), dummyService{contentUUID: knownUUID, failWrite: true}, http.StatusServiceUnavailable, "application/json", message("Error creating annotations (TEST failing to WRITE)")}, } for _, test := range tests { rec := httptest.NewRecorder() router(httpHandlers{test.dummyService}).ServeHTTP(rec, test.req) assert.True(test.statusCode == rec.Code, fmt.Sprintf("%s: Wrong response code, was %d, should be %d", test.name, rec.Code, test.statusCode)) assert.JSONEq(test.body, rec.Body.String(), fmt.Sprintf("%s: Wrong body", test.name)) } }