func TestCentosSetUserPassword(t *testing.T) { deps, centos := buildCentos() centos.SetUserPassword("my-user", "my-encrypted-password") assert.Equal(t, 1, len(deps.cmdRunner.RunCommands)) assert.Equal(t, []string{"usermod", "-p", "my-encrypted-password", "my-user"}, deps.cmdRunner.RunCommands[0]) }
func TestSearchService_Code(t *testing.T) { setup() defer tearDown() stubGet(t, "/search/code", "code_search", nil) searchResults, result := client.Search().Code(nil, M{ "query": "addClass in:file language:js repo:jquery/jquery"}) assert.False(t, result.HasError()) assert.False(t, searchResults.IncompleteResults) assert.Equal(t, 7, searchResults.TotalCount) assert.Equal(t, 7, len(searchResults.Items)) assert.EqualValues(t, "classes.js", searchResults.Items[0].Name) assert.EqualValues(t, "src/attributes/classes.js", searchResults.Items[0].Path) assert.EqualValues(t, "f9dba94f7de43d6b6b7256e05e0d17c4741a4cde", searchResults.Items[0].SHA) assert.EqualValues(t, "https://api.github.com/repositories/167174/contents/src/attributes/classes.js?ref=53aa87f3bf4284763405f3eb8affff296e55ba4f", string(searchResults.Items[0].URL)) assert.EqualValues(t, "https://api.github.com/repositories/167174/git/blobs/f9dba94f7de43d6b6b7256e05e0d17c4741a4cde", searchResults.Items[0].GitURL) assert.EqualValues(t, "https://github.com/jquery/jquery/blob/53aa87f3bf4284763405f3eb8affff296e55ba4f/src/attributes/classes.js", searchResults.Items[0].HTMLURL) assert.Equal(t, 167174, searchResults.Items[0].Repository.ID) assert.EqualValues(t, "jquery/jquery", searchResults.Items[0].Repository.FullName) }
func TestNew(t *testing.T) { // Generate 10 ids ids := make([]ID, 10) for i := 0; i < 10; i++ { ids[i] = New() } for i := 1; i < 10; i++ { prevID := ids[i-1] id := ids[i] // Test for uniqueness among all other 9 generated ids for j, tid := range ids { if j != i { assert.NotEqual(t, id, tid, "Generated ID is not unique") } } // Check that timestamp was incremented and is within 30 seconds of the previous one secs := id.Time().Sub(prevID.Time()).Seconds() assert.Equal(t, (secs >= 0 && secs <= 30), true, "Wrong timestamp in generated ID") // Check that machine ids are the same assert.Equal(t, id.Machine(), prevID.Machine()) // Check that pids are the same assert.Equal(t, id.Pid(), prevID.Pid()) // Test for proper increment delta := int(id.Counter() - prevID.Counter()) assert.Equal(t, delta, 1, "Wrong increment in generated ID") } }
func TestCullInvalidConnections(t *testing.T) { d := newDefaultDaemon() // Is fine d.ExpectingIntroductions[addr] = time.Now() // Is expired d.ExpectingIntroductions[addrb] = util.ZeroTime() // Is not in pool d.ExpectingIntroductions[addrc] = util.ZeroTime() d.Peers.Peers.AddPeer(addr) d.Peers.Peers.AddPeer(addrb) d.Peers.Peers.AddPeer(addrc) d.Pool.Pool.Addresses[addr] = gnetConnection(addr) d.Pool.Pool.Addresses[addrb] = gnetConnection(addrb) d.Pool.Pool.Addresses[addrb].Id = 2 d.Pool.Pool.Pool[1] = d.Pool.Pool.Addresses[addr] d.Pool.Pool.Pool[2] = d.Pool.Pool.Addresses[addrb] assert.NotPanics(t, d.cullInvalidConnections) assert.Equal(t, len(d.ExpectingIntroductions), 1) assert.Equal(t, len(d.Peers.Peers.Peerlist), 2) assert.Equal(t, len(d.Pool.Pool.DisconnectQueue), 1) if len(d.Pool.Pool.DisconnectQueue) == 0 { t.Fatal("pool.Pool.DisconnectQueue not empty, would block") } de := <-d.Pool.Pool.DisconnectQueue assert.Equal(t, de.ConnId, 2) assert.Equal(t, de.Reason, DisconnectIntroductionTimeout) shutdown(d) }
// TestFormIsValid tests data that come from request (url.Values) func TestFormIsValid(t *testing.T) { postData := url.Values{ "field1": []string{"Foo"}, "field2": []string{"Bar"}, "fieldX": []string{"Ham"}, } f := Form{ Fields: map[string]*Field{ "field1": &Field{ Type: &Input{}, }, "field2": &Field{ Type: &Input{}, }, }, } assert.Equal( t, f.CleanedData, *new(Data), "CleanedData should be empty at beggining") assert.True(t, f.IsValid(postData), "Form should pass") assert.Equal( t, f.CleanedData, Data{"field1": "Foo", "field2": "Bar"}, "Forms CleanedData field should contain cleaned data") assert.True(t, f.IsValid(url.Values{}), "Form should pass") assert.Equal( t, f.CleanedData, Data{"field1": "", "field2": ""}, "Form should pass") }
func TestServiceSummaryGetSummariesInCurrentSpace(t *testing.T) { req := testapi.NewCloudControllerTestRequest(testnet.TestRequest{ Method: "GET", Path: "/v2/spaces/my-space-guid/summary", Response: serviceInstanceSummariesResponse, }) ts, handler, repo := createServiceSummaryRepo(t, req) defer ts.Close() serviceInstances, apiResponse := repo.GetSummariesInCurrentSpace() assert.True(t, handler.AllRequestsCalled()) assert.True(t, apiResponse.IsSuccessful()) assert.Equal(t, 1, len(serviceInstances)) instance1 := serviceInstances[0] assert.Equal(t, instance1.Name, "my-service-instance") assert.Equal(t, instance1.ServicePlan.Name, "spark") assert.Equal(t, instance1.ServiceOffering.Label, "cleardb") assert.Equal(t, instance1.ServiceOffering.Label, "cleardb") assert.Equal(t, instance1.ServiceOffering.Provider, "cleardb-provider") assert.Equal(t, instance1.ServiceOffering.Version, "n/a") assert.Equal(t, len(instance1.ApplicationNames), 2) assert.Equal(t, instance1.ApplicationNames[0], "app1") assert.Equal(t, instance1.ApplicationNames[1], "app2") }
func TestMakePrivateConnections(t *testing.T) { d := newDefaultDaemon() defer shutdown(d) d.Pool.Config.DialTimeout = time.Hour addr := "192.168.1.198:43071" addrb := "192.168.1.197:43072" // Two privates p, err := d.Peers.Peers.AddPeer(addr) assert.Nil(t, err) p.Private = true p, err = d.Peers.Peers.AddPeer(addrb) assert.Nil(t, err) p.Private = true // Not private p, err = d.Peers.Peers.AddPeer(addrc) assert.Nil(t, err) p.Private = false // Disabled d.Config.DisableOutgoingConnections = true d.makePrivateConnections() assert.Equal(t, len(d.pendingConnections), 0) // Enabled d.Config.DisableOutgoingConnections = false d.makePrivateConnections() assert.Equal(t, len(d.pendingConnections), 2) assert.NotNil(t, d.pendingConnections[addr]) assert.NotNil(t, d.pendingConnections[addrb]) assert.Nil(t, d.pendingConnections[addrc]) }
func TestOutputService9ProtocolTestSupportsHeaderMapsCase1(t *testing.T) { svc := NewOutputService9ProtocolTest(nil) buf := bytes.NewReader([]byte("{}")) req, out := svc.OutputService9TestCaseOperation1Request(nil) req.HTTPResponse = &http.Response{StatusCode: 200, Body: ioutil.NopCloser(buf), Header: http.Header{}} // set headers req.HTTPResponse.Header.Set("Content-Length", "10") req.HTTPResponse.Header.Set("X-Bam", "boo") req.HTTPResponse.Header.Set("X-Foo", "bar") // unmarshal response restjson.UnmarshalMeta(req) restjson.Unmarshal(req) assert.NoError(t, req.Error) // assert response assert.NotNil(t, out) // ensure out variable is used assert.Equal(t, "10", *out.AllHeaders["Content-Length"]) assert.Equal(t, "boo", *out.AllHeaders["X-Bam"]) assert.Equal(t, "bar", *out.AllHeaders["X-Foo"]) assert.Equal(t, "boo", *out.PrefixedHeaders["Bam"]) assert.Equal(t, "bar", *out.PrefixedHeaders["Foo"]) }
func TestSimpleEvent(t *testing.T) { transp := newMockTransport() client := newClientTestDriver(newLumberjackClient(transp, 5*time.Second)) event := common.MapStr{"name": "me", "line": 10} client.Publish([]common.MapStr{event}) // receive window message buf := streambuf.New(nil) win, err := recvMessage(buf, transp) assert.Nil(t, err) // receive data message msg, err := recvMessage(buf, transp) assert.Nil(t, err) // send ack sendAck(transp, 1) // stop test driver transp.Close() client.Stop() // validate assert.NotNil(t, win) assert.NotNil(t, msg) assert.Equal(t, 1, len(msg.events)) msg = msg.events[0] assert.Equal(t, "me", msg.doc["name"]) assert.Equal(t, 10.0, msg.doc["line"]) }
func TestFilterFlags(t *testing.T) { result := filterFlags("text/html ") assert.Equal(t, result, "text/html") result = filterFlags("text/html;") assert.Equal(t, result, "text/html") }
func TestAddRoute(t *testing.T) { node1, node2 := NewNode(), NewNode() assert.Len(t, node1.RouteForwardingRules, 0, "Should be 0 routes") ccid := node1.AddControlChannel() node1.Tick() // run channels consuming tf := transport.NewTransportFactory() tf.ConnectNodeToNode(node1, node2) tr1, _ := tf.GetTransports() tid1 := tr1.Id incomingRouteId := messages.RandRouteId() outgoingRouteId := messages.RandRouteId() msg := messages.AddRouteControlMessage{ (messages.TransportId)(0), tr1.Id, incomingRouteId, outgoingRouteId, } msgS := messages.Serialize(messages.MsgAddRouteControlMessage, msg) controlMessage := messages.InControlMessage{ccid, msgS} node1.InjectControlMessage(controlMessage) time.Sleep(1 * time.Millisecond) assert.Len(t, node1.RouteForwardingRules, 1, "Should be 1 routes") assert.Equal(t, node1.RouteForwardingRules[incomingRouteId].IncomingRoute, incomingRouteId) assert.Equal(t, node1.RouteForwardingRules[incomingRouteId].OutgoingRoute, outgoingRouteId) assert.Equal(t, node1.RouteForwardingRules[incomingRouteId].OutgoingTransport, tid1) fmt.Println("--------------------\n") }
func TestChooseData(t *testing.T) { A := "a" B := "b" assert.Equal(t, chooseData(A, B), A) assert.Equal(t, chooseData(nil, B), B) assert.Panics(t, func() { chooseData(nil, nil) }) }
func assertRequestIsProcessedSynchronously(t *testing.T, req boshmbus.Request) { settings, handler, platform, taskService, actionFactory := getAgentDependencies() // when action is successful actionFactory.CreateAction = &fakeaction.TestAction{ RunValue: "some value", } agent := New(settings, handler, platform, taskService, actionFactory) err := agent.Run() assert.NoError(t, err) assert.True(t, handler.ReceivedRun) resp := handler.Func(req) assert.Equal(t, req.Method, actionFactory.CreateMethod) assert.Equal(t, req.GetPayload(), actionFactory.CreateAction.RunPayload) assert.Equal(t, boshmbus.NewValueResponse("some value"), resp) // when action returns an error actionFactory.CreateAction = &fakeaction.TestAction{ RunErr: errors.New("some error"), } agent = New(settings, handler, platform, taskService, actionFactory) agent.Run() resp = handler.Func(req) boshassert.MatchesJsonString(t, resp, `{"exception":{"message":"some error"}}`) }
func TestCentosSetupDhcp(t *testing.T) { deps, centos := buildCentos() testCentosSetupDhcp(t, deps, centos) assert.Equal(t, len(deps.cmdRunner.RunCommands), 1) assert.Equal(t, deps.cmdRunner.RunCommands[0], []string{"service", "network", "restart"}) }
func testStateTrace(t *testing.T, transitions []transition) *Registry { assert := assert.New(t) registry := NewInMemoryRegistry() a, _ := fakePodTask("a") a, _ = registry.Register(a, nil) // initial pending state assert.Equal(a.State, StatePending) for _, transition := range transitions { if transition.expectPanic { assert.Panics(func() { registry.UpdateStatus(fakeStatusUpdate(a.ID, transition.statusUpdate)) }) } else { a, _ = registry.UpdateStatus(fakeStatusUpdate(a.ID, transition.statusUpdate)) if transition.expectedState == nil { a, _ = registry.Get(a.ID) assert.Nil(a, "expected task to be deleted from registry after status update to %v", transition.statusUpdate) } else { assert.Equal(a.State, *transition.expectedState) } } } return ®istry }
func TestCreateSpendsWithBurn(t *testing.T) { now := tNow() amt := wallet.Balance{10e6, 100} uxs := makeUxBalances([]wallet.Balance{ wallet.Balance{1e6, 50}, wallet.Balance{8e6, 40}, wallet.Balance{2e6, 60}, }, now) // Force them to get sorted uxs[2].Head.BkSeq = uint64(0) uxs[1].Head.BkSeq = uint64(1) uxs[0].Head.BkSeq = uint64(2) cuxs := append(coin.UxArray{}, uxs...) // Should spend 8e6,2e6 for the exact amount, but have to add 1e6 to // obtain +50 for a 50% fee spends, err := createSpends(now, uxs, amt, 0, 2) assert.Nil(t, err) assert.Equal(t, len(spends), 3) assert.Equal(t, spends, coin.UxArray{cuxs[2], cuxs[1], cuxs[0]}) have := wallet.Balance{0, 0} for _, ux := range spends { have = have.Add(wallet.NewBalanceFromUxOut(now, &ux)) } burn, change, err := calculateBurnAndChange(have.Hours, amt.Hours, 0, 2) assert.Equal(t, burn, uint64(50)) assert.Equal(t, change, uint64(0)) assert.Nil(t, err) }
func TestRead(t *testing.T) { assert := assert.New(t) ds := datas.NewDataStore(chunks.NewMemoryStore()) dataString := `a,1,true b,2,false ` r := NewCSVReader(bytes.NewBufferString(dataString), ',') headers := []string{"A", "B", "C"} kinds := KindSlice{types.StringKind, types.Int8Kind, types.BoolKind} l, typeRef, typeDef := Read(r, "test", headers, kinds, ds) assert.Equal(uint64(2), l.Len()) assert.True(typeRef.IsUnresolved()) desc, ok := typeDef.Desc.(types.StructDesc) assert.True(ok) assert.Len(desc.Fields, 3) assert.Equal("A", desc.Fields[0].Name) assert.Equal("B", desc.Fields[1].Name) assert.Equal("C", desc.Fields[2].Name) assert.True(l.Get(0).(types.Struct).Get("A").Equals(types.NewString("a"))) assert.True(l.Get(1).(types.Struct).Get("A").Equals(types.NewString("b"))) assert.True(l.Get(0).(types.Struct).Get("B").Equals(types.Int8(1))) assert.True(l.Get(1).(types.Struct).Get("B").Equals(types.Int8(2))) assert.True(l.Get(0).(types.Struct).Get("C").Equals(types.Bool(true))) assert.True(l.Get(1).(types.Struct).Get("C").Equals(types.Bool(false))) }
func TestBlobLen(t *testing.T) { assert := assert.New(t) b := NewBlob(&bytes.Buffer{}) assert.Equal(uint64(0), b.Len()) b = NewBlob(bytes.NewBuffer([]byte{0x01})) assert.Equal(uint64(1), b.Len()) }
func TestSendPings(t *testing.T) { d := newDefaultDaemon() defer shutdown(d) c := gnetConnection(addr) go d.Pool.Pool.ConnectionWriteLoop(c) d.Pool.Pool.Pool[1] = c assert.NotPanics(t, d.Pool.sendPings) wait() assert.Equal(t, len(d.Pool.Pool.SendResults), 1) if len(d.Pool.Pool.SendResults) == 0 { t.Fatal("SendResults empty, would block") } sr := <-d.Pool.Pool.SendResults assert.Equal(t, sr.Connection, c) assert.Nil(t, sr.Error) _, ok := sr.Message.(*PingMessage) assert.True(t, ok) assert.False(t, c.LastSent.IsZero()) // No pings should be sent, since we just pinged lastSent := c.LastSent assert.NotPanics(t, d.Pool.sendPings) wait() assert.Equal(t, len(d.Pool.Pool.SendResults), 0) assert.Equal(t, c.LastSent, lastSent) }
func TestUpdateUser(t *testing.T) { assert := assert.New(t) s := sw.NewUserApi() newUser := sw.User{ Id: 1000, FirstName: "gopher20", LastName: "lang20", Username: "******", Password: "******", Email: "*****@*****.**", Phone: "5101112222", UserStatus: 1} apiResponse, err := s.UpdateUser("gopher", newUser) if err != nil { t.Errorf("Error while deleting user by id") t.Log(err) } if apiResponse.Response.StatusCode != 200 { t.Log(apiResponse.Response) } //verify changings are correct resp, apiResponse, err := s.GetUserByName("gopher") if err != nil { t.Errorf("Error while getting user by id") t.Log(err) } else { assert.Equal(resp.Id, int64(1000), "User id should be equal") assert.Equal(resp.FirstName, "gopher20", "User name should be gopher") assert.Equal(resp.Password, "lang", "User name should be the same") } }
func TestConnectToRandomPeer(t *testing.T) { d := newDefaultDaemon() defer shutdown(d) defer cleanupPeers() // Disabled d.Config.DisableOutgoingConnections = true assert.NotPanics(t, d.connectToRandomPeer) assert.Equal(t, len(d.pendingConnections), 0) // Enabled, but only private peers addr := "192.168.1.196:30954" p, err := d.Peers.Peers.AddPeer(addr) assert.Nil(t, err) p.Private = true d.Config.DisableOutgoingConnections = false assert.NotPanics(t, d.connectToRandomPeer) assert.Equal(t, len(d.pendingConnections), 0) // Enabled, and we have a public peer p.Private = false assert.NotPanics(t, d.connectToRandomPeer) assert.Equal(t, len(d.pendingConnections), 1) assert.NotNil(t, d.pendingConnections[addr]) }
// TestInstallSwaggerAPI verifies that the swagger api is added // at the proper endpoint. func TestInstallSwaggerAPI(t *testing.T) { etcdserver, _, assert := setUp(t) defer etcdserver.Terminate(t) mux := http.NewServeMux() server := &GenericAPIServer{} server.HandlerContainer = NewHandlerContainer(mux, nil) // Ensure swagger isn't installed without the call ws := server.HandlerContainer.RegisteredWebServices() if !assert.Equal(len(ws), 0) { for x := range ws { assert.NotEqual("/swaggerapi", ws[x].RootPath(), "SwaggerAPI was installed without a call to InstallSwaggerAPI()") } } // Install swagger and test server.InstallSwaggerAPI() ws = server.HandlerContainer.RegisteredWebServices() if assert.NotEqual(0, len(ws), "SwaggerAPI not installed.") { assert.Equal("/swaggerapi/", ws[0].RootPath(), "SwaggerAPI did not install to the proper path. %s != /swaggerapi", ws[0].RootPath()) } // Empty externalHost verification mux = http.NewServeMux() server.HandlerContainer = NewHandlerContainer(mux, nil) server.ExternalAddress = "" server.ClusterIP = net.IPv4(10, 10, 10, 10) server.PublicReadWritePort = 1010 server.InstallSwaggerAPI() if assert.NotEqual(0, len(ws), "SwaggerAPI not installed.") { assert.Equal("/swaggerapi/", ws[0].RootPath(), "SwaggerAPI did not install to the proper path. %s != /swaggerapi", ws[0].RootPath()) } }
func (suite *IntegrationMigrateSuite) TestMigrateDown() { transform, err := NewConvert(testdata.ConvertDestination1, false, false, NewNullLogger()) assert.Nil(suite.T(), err) err = transform.ConvertDirectory(testdata.ConvertSource1) assert.Nil(suite.T(), err) up := NewUp(testdata.ConvertDestination1, suite.Target) err = up.Migrate() assert.Nil(suite.T(), err) down := NewDown(suite.Target) err = down.Migrate() assert.Nil(suite.T(), err) assert.Equal(suite.T(), up.Migrations.Len()-1, down.Migrations.Len()) upFirst, err := up.Migrations.First() assert.Nil(suite.T(), err) downFirst, err := down.Migrations.First() assert.Nil(suite.T(), err) assert.Equal(suite.T(), upFirst.Id, downFirst.Id) upLast, err := up.Migrations.Last() assert.Nil(suite.T(), err) downLast, err := down.Migrations.Last() assert.Nil(suite.T(), err) assert.NotEqual(suite.T(), upLast.Id, downLast.Id) }
func TestCompileFileNameRegex(t *testing.T) { configFilePath := path.Join("testdata", "json_objects", "bag_validation_config.json") conf, errors := validation.LoadBagValidationConfig(configFilePath) if errors != nil && len(errors) > 0 { assert.Fail(t, errors[0].Error()) } err := conf.CompileFileNameRegex() assert.Nil(t, err) conf.FileNamePattern = "ThisPatternIsInvalid[-" err = conf.CompileFileNameRegex() require.NotNil(t, err) assert.True(t, strings.HasPrefix(err.Error(), "Cannot compile regex")) conf.FileNamePattern = "aptrust" err = conf.CompileFileNameRegex() assert.Nil(t, err) assert.Equal(t, constants.APTrustFileNamePattern, conf.FileNameRegex) conf.FileNamePattern = "APTRUST" err = conf.CompileFileNameRegex() assert.Nil(t, err) assert.Equal(t, constants.APTrustFileNamePattern, conf.FileNameRegex) conf.FileNamePattern = "posix" err = conf.CompileFileNameRegex() assert.Nil(t, err) assert.Equal(t, constants.PosixFileNamePattern, conf.FileNameRegex) conf.FileNamePattern = "POSIX" err = conf.CompileFileNameRegex() assert.Nil(t, err) assert.Equal(t, constants.PosixFileNamePattern, conf.FileNameRegex) }
// TestFromIsValidMap tests data that come from map func TestFromIsValidMap(t *testing.T) { f := Form{ Fields: map[string]*Field{ "field1": &Field{ Type: &Input{}, }, "field2": &Field{ Type: &Input{}, }, }, } values := map[string]interface{}{ "field1": "Spam", "field2": []string{"Ham"}, } assert.True(t, f.IsValidMap(values), "Form should pass") assert.Equal( t, f.CleanedData, Data{"field1": "Spam", "field2": "Ham"}, "Form should pass") values = map[string]interface{}{ "field1": "Spam", } assert.True(t, f.IsValidMap(values), "Form should pass") assert.Equal( t, f.CleanedData, Data{"field1": "Spam", "field2": ""}, "Form should pass") }
func TestLoadBagValidationConfig(t *testing.T) { configFilePath := path.Join("testdata", "json_objects", "bag_validation_config.json") conf, errors := validation.LoadBagValidationConfig(configFilePath) if errors != nil && len(errors) > 0 { assert.Fail(t, errors[0].Error()) } assert.True(t, conf.AllowMiscTopLevelFiles) assert.True(t, conf.AllowMiscDirectories) assert.True(t, conf.TopLevelDirMustMatchBagName) assert.Equal(t, 7, len(conf.FileSpecs)) assert.Equal(t, 3, len(conf.TagSpecs)) assert.Equal(t, 2, len(conf.FixityAlgorithms)) // Spot checks if _, ok := conf.FileSpecs["manifest-md5.txt"]; !ok { assert.Fail(t, "FileSpec for manifest-md5.txt is missing") } if _, ok := conf.FileSpecs["manifest-sha256.txt"]; !ok { assert.Fail(t, "FileSpec for manifest-sha256.txt is missing") } if _, ok := conf.TagSpecs["Title"]; !ok { assert.Fail(t, "TagSpec for Title is missing") } if len(conf.FixityAlgorithms) > 1 { assert.Equal(t, "md5", conf.FixityAlgorithms[0]) assert.Equal(t, "sha256", conf.FixityAlgorithms[1]) } assert.Equal(t, validation.REQUIRED, conf.FileSpecs["manifest-md5.txt"].Presence) assert.Equal(t, validation.OPTIONAL, conf.FileSpecs["manifest-sha256.txt"].Presence) assert.Equal(t, "aptrust-info.txt", conf.TagSpecs["Title"].FilePath) assert.Equal(t, validation.REQUIRED, conf.TagSpecs["Title"].Presence) assert.False(t, conf.TagSpecs["Title"].EmptyOK) assert.Equal(t, 3, len(conf.TagSpecs["Access"].AllowedValues)) }
func TestConfig_LoadSingleInput(t *testing.T) { c := NewConfig() c.LoadConfig("./testdata/single_plugin.toml") memcached := inputs.Inputs["memcached"]().(*memcached.Memcached) memcached.Servers = []string{"localhost"} mConfig := &InputConfig{ Name: "memcached", Filter: Filter{ Drop: []string{"other", "stuff"}, Pass: []string{"some", "strings"}, TagDrop: []TagFilter{ TagFilter{ Name: "badtag", Filter: []string{"othertag"}, }, }, TagPass: []TagFilter{ TagFilter{ Name: "goodtag", Filter: []string{"mytag"}, }, }, IsActive: true, }, Interval: 5 * time.Second, } mConfig.Tags = make(map[string]string) assert.Equal(t, memcached, c.Inputs[0].Input, "Testdata did not produce a correct memcached struct.") assert.Equal(t, mConfig, c.Inputs[0].Config, "Testdata did not produce correct memcached metadata.") }
// TestGetNodeAddresses verifies that proper results are returned // when requesting node addresses. func TestGetNodeAddresses(t *testing.T) { assert := assert.New(t) fakeNodeClient := fake.NewSimpleClientset(registrytest.MakeNodeList([]string{"node1", "node2"}, api.NodeResources{})).Core().Nodes() addressProvider := nodeAddressProvider{fakeNodeClient} // Fail case (no addresses associated with nodes) nodes, _ := fakeNodeClient.List(api.ListOptions{}) addrs, err := addressProvider.externalAddresses() assert.Error(err, "addresses should have caused an error as there are no addresses.") assert.Equal([]string(nil), addrs) // Pass case with External type IP nodes, _ = fakeNodeClient.List(api.ListOptions{}) for index := range nodes.Items { nodes.Items[index].Status.Addresses = []api.NodeAddress{{Type: api.NodeExternalIP, Address: "127.0.0.1"}} fakeNodeClient.Update(&nodes.Items[index]) } addrs, err = addressProvider.externalAddresses() assert.NoError(err, "addresses should not have returned an error.") assert.Equal([]string{"127.0.0.1", "127.0.0.1"}, addrs) // Pass case with LegacyHost type IP nodes, _ = fakeNodeClient.List(api.ListOptions{}) for index := range nodes.Items { nodes.Items[index].Status.Addresses = []api.NodeAddress{{Type: api.NodeLegacyHostIP, Address: "127.0.0.2"}} fakeNodeClient.Update(&nodes.Items[index]) } addrs, err = addressProvider.externalAddresses() assert.NoError(err, "addresses failback should not have returned an error.") assert.Equal([]string{"127.0.0.2", "127.0.0.2"}, addrs) }
func TestGetAccount(t *testing.T) { _, teardown, err := setup(t) if err != nil { t.Fatal(err) } defer teardown() // new account a := account.New() account.Set(a) act, err := account.Get(a.Pubkey) if err != nil { t.Fatal(err) } assert.Equal(t, act, a) // add wallet id act.WltIDs[bitcoin.Type] = "bitcoin_sd19" act.WltIDs[skycoin.Type] = "skycoin_sd19" account.Set(act) newA, err := account.Get(act.Pubkey) if err != nil { t.Fatal(err) } assert.Equal(t, newA, act) }
func TestGet(t *testing.T) { q := New(10) q.Put(`test`) result, err := q.Get(2) if !assert.Nil(t, err) { return } assert.Len(t, result, 1) assert.Equal(t, `test`, result[0]) assert.Equal(t, int64(0), q.Len()) q.Put(`1`) q.Put(`2`) result, err = q.Get(1) if !assert.Nil(t, err) { return } assert.Len(t, result, 1) assert.Equal(t, `1`, result[0]) assert.Equal(t, int64(1), q.Len()) result, err = q.Get(2) if !assert.Nil(t, err) { return } assert.Equal(t, `2`, result[0]) }