func TestDoubleLoggingDoesntPrefixPreviousFields(t *testing.T) { var buffer bytes.Buffer var fields Fields logger := New() logger.Out = &buffer logger.Formatter = new(JSONFormatter) llog := logger.WithField("context", "eating raw fish") llog.Info("looks delicious") err := json.Unmarshal(buffer.Bytes(), &fields) assert.NoError(t, err, "should have decoded first message") assert.Equal(t, len(fields), 4, "should only have msg/time/level/context fields") assert.Equal(t, fields["msg"], "looks delicious") assert.Equal(t, fields["context"], "eating raw fish") buffer.Reset() llog.Warn("omg it is!") err = json.Unmarshal(buffer.Bytes(), &fields) assert.NoError(t, err, "should have decoded second message") assert.Equal(t, len(fields), 4, "should only have msg/time/level/context fields") assert.Equal(t, fields["msg"], "omg it is!") assert.Equal(t, fields["context"], "eating raw fish") assert.Nil(t, fields["fields.msg"], "should not have prefixed previous `msg` entry") }
func TestDeleteData(t *testing.T) { intern := 0 key := "test" data := []byte("pippo") var value []byte var err error //INTERNAL dataStore = intern Initialize() StoreData(key, data, enum.STATS) StoreData(key, data, enum.ANALYTICS) StoreData(key, data, enum.POLICIES) StoreData(key, data, enum.SHARED) err = DeleteData(key, enum.STATS) assert.NoError(t, err) value, _ = GetData(key, enum.STATS) assert.Nil(t, value) err = DeleteData(key, enum.ANALYTICS) assert.NoError(t, err) value, _ = GetData(key, enum.ANALYTICS) assert.Nil(t, value) err = DeleteData(key, enum.POLICIES) assert.NoError(t, err) value, _ = GetData(key, enum.POLICIES) assert.Nil(t, value) err = DeleteData(key, enum.SHARED) assert.NoError(t, err) value, _ = GetData(key, enum.SHARED) assert.Nil(t, value) }
func TestAddServiceInstance(t *testing.T) { defer cfg.CleanServices() cfg.SetServices(CreateMockServices()) name := "service1" service, _ := GetServiceByName(name) instance_p := "instance1_100" instance_ps := "instance1_101" instance_s := "instance1_102" var err error var status enum.Status status = enum.PENDING err = AddServiceInstance(name, instance_p, status) assert.NoError(t, err) assert.Contains(t, service.Instances.All, instance_p) assert.Contains(t, service.Instances.Pending, instance_p) status = enum.PAUSED err = AddServiceInstance(name, instance_ps, status) assert.NoError(t, err) assert.Contains(t, service.Instances.All, instance_ps) assert.Contains(t, service.Instances.Paused, instance_ps) status = enum.STOPPED err = AddServiceInstance(name, instance_s, status) assert.NoError(t, err) assert.Contains(t, service.Instances.All, instance_s) assert.Contains(t, service.Instances.Stopped, instance_s) status = enum.PENDING err = AddServiceInstance("pippo", "pippo", status) assert.Error(t, err) }
func TestGetCompleteRange(t *testing.T) { var err error var result []string invalid := "pippo" invalidLimit := "pippo-10" onveValue := "5" valid := "0-10" _, err = GetCompleteRange(invalid) assert.Error(t, err) _, err = GetCompleteRange(invalidLimit) assert.Error(t, err) result, err = GetCompleteRange(onveValue) assert.NoError(t, err) assert.Len(t, result, 1) assert.Contains(t, result, "5") result, err = GetCompleteRange(valid) assert.NoError(t, err) assert.Len(t, result, 11) assert.Contains(t, result, "0") assert.Contains(t, result, "10") assert.NotContains(t, result, "11") }
func TestChooseRandomFriends(t *testing.T) { cfg.SetNode(node.CreateMockNode()) mockPeers := createMockPeers(100) nFriends := 10 test, err := chooseRandomFriends(mockPeers, nFriends) assert.NoError(t, err, "(nFrineds > 0) Choose friends should produce no error") nFriends = 150 test, err = chooseRandomFriends(mockPeers, nFriends) friendsKeys := make([]string, 0, len(mockPeers)-1) for key, _ := range test { friendsKeys = append(friendsKeys, key) } assert.NoError(t, err, "(nFrineds > nPeers) Choose friends should produce no error") nFriends = 0 test, err = chooseRandomFriends(mockPeers, nFriends) assert.Error(t, err, "(nFriends < 0) Choose friends should produce an error") mockPeers = createMockPeers(0) nFriends = 10 _, err = chooseRandomFriends(mockPeers, nFriends) assert.Error(t, err, "(peers = 0) Choose friend should produce an error") mockPeers = createMockPeers(1) nFriends = 10 _, err = chooseRandomFriends(mockPeers, nFriends) assert.Error(t, err, "(peers = me) Choose friend should produce an error") mockPeers = createMockPeers(2) nFriends = 10 test, err = chooseRandomFriends(mockPeers, nFriends) assert.NoError(t, err, "(nFrineds == 2) Choose friends should produce no error") }
func TestAssignSpecificPortsToService(t *testing.T) { defer clearServicePorts() var err error createServicePorts() service := "pippo" id := "123456789" port1 := "50100" port2 := "50200" bindings := map[string][]string{ port1: []string{"50100"}, port2: []string{"50200"}, } err = AssignSpecifiPortsToService(service, id, bindings) assert.NoError(t, err) available1 := resources.Network.ServicePorts[service].Status[port1].Available occupied1 := resources.Network.ServicePorts[service].Status[port1].Occupied assert.Len(t, available1, 3) assert.Len(t, occupied1, 1) available2 := resources.Network.ServicePorts[service].Status[port2].Available occupied2 := resources.Network.ServicePorts[service].Status[port2].Occupied assert.Len(t, available2, 1) assert.Len(t, occupied2, 1) assert.NotEmpty(t, instanceBindings) err = AssignSpecifiPortsToService(service, id, bindings) assert.Error(t, err) available1 = resources.Network.ServicePorts[service].Status[port1].Available occupied1 = resources.Network.ServicePorts[service].Status[port1].Occupied assert.Len(t, available1, 3) assert.Len(t, occupied1, 1) available2 = resources.Network.ServicePorts[service].Status[port2].Available occupied2 = resources.Network.ServicePorts[service].Status[port2].Occupied assert.Len(t, available2, 1) assert.Len(t, occupied2, 1) bindings[port1] = []string{"50000"} bindings[port2] = []string{"50201"} err = AssignSpecifiPortsToService(service, id, bindings) assert.NoError(t, err) available1 = resources.Network.ServicePorts[service].Status[port1].Available occupied1 = resources.Network.ServicePorts[service].Status[port1].Occupied assert.Len(t, available1, 3) assert.Len(t, occupied1, 2) available2 = resources.Network.ServicePorts[service].Status[port2].Available occupied2 = resources.Network.ServicePorts[service].Status[port2].Occupied assert.Len(t, available2, 0) assert.Len(t, occupied2, 2) }
func TestGetAllData(t *testing.T) { intern := 0 //INTERNAL dataStore = intern Initialize() _, err := GetAllData(enum.STATS) assert.NoError(t, err) _, err = GetAllData(enum.ANALYTICS) assert.NoError(t, err) _, err = GetAllData(enum.POLICIES) assert.NoError(t, err) _, err = GetAllData(enum.SHARED) assert.NoError(t, err) }
func TestChangeServiceInstanceStatus(t *testing.T) { defer cfg.CleanServices() cfg.SetServices(CreateMockServices()) name := "service1" service, _ := GetServiceByName(name) instance := "instance1_3" var prev enum.Status var upd enum.Status var err error prev = enum.PENDING upd = enum.RUNNING err = ChangeServiceInstanceStatus(name, instance, prev, upd) assert.NotContains(t, service.Instances.Pending, instance) assert.Contains(t, service.Instances.Running, instance) assert.NoError(t, err) prev = enum.RUNNING upd = enum.PAUSED err = ChangeServiceInstanceStatus(name, instance, prev, upd) assert.NotContains(t, service.Instances.Running, instance) assert.Contains(t, service.Instances.Paused, instance) assert.NoError(t, err) prev = enum.PAUSED upd = enum.STOPPED err = ChangeServiceInstanceStatus(name, instance, prev, upd) assert.NotContains(t, service.Instances.Paused, instance) assert.Contains(t, service.Instances.Stopped, instance) assert.NoError(t, err) prev = enum.STOPPED upd = enum.PENDING err = ChangeServiceInstanceStatus(name, instance, prev, upd) assert.NotContains(t, service.Instances.Stopped, instance) assert.Contains(t, service.Instances.Pending, instance) assert.NoError(t, err) prev = enum.PENDING upd = enum.RUNNING err = ChangeServiceInstanceStatus("pippo", instance, prev, upd) assert.Error(t, err) prev = enum.PENDING upd = enum.RUNNING err = ChangeServiceInstanceStatus(name, "pippo", prev, upd) assert.Error(t, err) }
func TestRequestPortsForService(t *testing.T) { defer clearServicePorts() var err error createServicePorts() service := "pippo" port1 := "50100" port2 := "50200" result, err := RequestPortsForService(service) assert.NoError(t, err) assert.Len(t, result, 2) assert.Len(t, resources.Network.ServicePorts[service].LastRequested, 2) available1 := resources.Network.ServicePorts[service].Status[port1].Available occupied1 := resources.Network.ServicePorts[service].Status[port1].Occupied assert.Len(t, available1, 4) assert.Len(t, occupied1, 0) available2 := resources.Network.ServicePorts[service].Status[port2].Available occupied2 := resources.Network.ServicePorts[service].Status[port2].Occupied assert.Len(t, available2, 2) assert.Len(t, occupied2, 0) ports := resources.Network.ServicePorts[service] status := ports.Status[port1] status.Available = []string{} ports.Status[port1] = status resources.Network.ServicePorts[service] = ports _, err = RequestPortsForService(service) assert.Error(t, err) assert.Empty(t, resources.Network.ServicePorts[service].LastRequested) }
func LogAndAssertText(t *testing.T, log func(*Logger), assertions func(fields map[string]string)) { var buffer bytes.Buffer logger := New() logger.Out = &buffer logger.Formatter = &TextFormatter{ DisableColors: true, } log(logger) fields := make(map[string]string) for _, kv := range strings.Split(buffer.String(), " ") { if !strings.Contains(kv, "=") { continue } kvArr := strings.Split(kv, "=") key := strings.TrimSpace(kvArr[0]) val := kvArr[1] if kvArr[1][0] == '"' { var err error val, err = strconv.Unquote(val) assert.NoError(t, err) } fields[key] = val } assertions(fields) }
func TestCreateInfluxMetrics(t *testing.T) { New("influxdb", createInfluxMockConfig()) mockMetrics := CreateMockMetrics() points, err := createInfluxMetrics(mockMetrics) assert.NoError(t, err) assert.NotEmpty(t, points) }
func TestStoreClusterData(t *testing.T) { New("internal") var err error data := []byte{1, 2, 3, 4, 5} err = StoreClusterData(data, enum.POLICIES) assert.NoError(t, err) }
func TestGetServiceById(t *testing.T) { defer cfg.CleanServices() var err error cfg.SetServices(CreateMockServices()) srv1, err := GetServiceById("instance1_0") assert.NoError(t, err) assert.Equal(t, "service1", srv1.Name) srv2, err := GetServiceById("instance2_1") assert.NoError(t, err) assert.Equal(t, "service2", srv2.Name) _, err = GetServiceById("pippo") assert.Error(t, err) }
func TestStoreData(t *testing.T) { intern := 0 key := "test" data := []byte("pippo") var err error //INTERNAL dataStore = intern Initialize() err = StoreData(key, data, enum.STATS) assert.NoError(t, err) err = StoreData(key, data, enum.ANALYTICS) assert.NoError(t, err) err = StoreData(key, data, enum.POLICIES) assert.NoError(t, err) err = StoreData(key, data, enum.SHARED) assert.NoError(t, err) }
func TestGetClusterData(t *testing.T) { data := []byte{1, 2, 3, 4, 5} New("intenal") StoreData(enum.CLUSTER.ToString(), data, enum.POLICIES) test, err := GetClusterData(enum.POLICIES) assert.NoError(t, err) assert.Equal(t, data, test) }
func TestNew(t *testing.T) { var err error _, err = New("dummy") assert.NoError(t, err) assert.Equal(t, "dummy", Name()) _, err = New("probcumulative") assert.NoError(t, err) assert.Equal(t, "probcumulative", Name()) _, err = New("probdelta") assert.NoError(t, err) assert.Equal(t, "probdelta", Name()) _, err = New("notImplemented") assert.Error(t, err) assert.Equal(t, "dummy", Name()) }
func TestGetAnalytics(t *testing.T) { defer storage.DeleteAllData(enum.ANALYTICS) var err error _, err = GetAnalytics() assert.Error(t, err) expected := CreateMockAnalytics() SaveMockAnalytics() analytics, err := GetAnalytics() assert.NoError(t, err) assert.Equal(t, expected, analytics) }
func TestGetStats(t *testing.T) { defer storage.DeleteAllData(enum.STATS) var err error _, err = GetStats() assert.Error(t, err) expected := CreateMockStats() SaveMockStats() stats, err := GetStats() assert.NoError(t, err) assert.Equal(t, expected, stats) }
func TestGetPolicy(t *testing.T) { defer storage.DeleteAllData(enum.POLICIES) var err error _, err = GetPolicy() assert.Error(t, err) expected := CreateRandomMockPolicies(1)[0] SavePolicy(expected) policy, err := GetPolicy() assert.NoError(t, err) assert.Equal(t, expected, policy) }
func TestGeShared(t *testing.T) { defer storage.DeleteAllData(enum.SHARED) var err error expected := CreateMockShared() // Local _, err = GetSharedLocal() assert.Error(t, err) SaveSharedLocal(expected) info, err := GetSharedLocal() assert.NoError(t, err) assert.Equal(t, expected, info) // Local _, err = GetSharedCluster() assert.Error(t, err) SaveSharedCluster(expected) info, err = GetSharedCluster() assert.NoError(t, err) assert.Equal(t, expected, info) }
func TestClearFriendsData(t *testing.T) { var err error storage.New("internal") data := []byte{} storage.StoreLocalData(data, enum.SHARED) storage.StoreClusterData(data, enum.SHARED) storage.StoreData("node1", data, enum.SHARED) storage.StoreData("node2", data, enum.SHARED) storage.StoreData("node3", data, enum.SHARED) err = clearFriendsData() assert.NoError(t, err) stored, _ := storage.GetAllData(enum.SHARED) assert.Equal(t, 2, len(stored)) }
func TestMergeInfo(t *testing.T) { defer service.ClearMockServices() var err error service.SetMockServices() shared1 := CreateMockShared() shared2 := CreateMockShared() shared3 := CreateMockShared() peers := []Shared{shared1, shared2, shared3} merged, err := MergeShared(peers) assert.NoError(t, err) assert.Equal(t, shared1.Service["service1"].Data.BaseShared[enum.METRIC_CPU_AVG.ToString()], merged.Service["service1"].Data.BaseShared[enum.METRIC_CPU_AVG.ToString()]) assert.Equal(t, shared1.System.ActiveServices, merged.System.ActiveServices) empty := []Shared{} _, err = MergeShared(empty) assert.Error(t, err) one := []Shared{shared1} _, err = MergeShared(one) assert.NoError(t, err) }
func TestFillStruct(t *testing.T) { testMap := map[string]interface{}{ "Pippo": 5, "Topolino": 4.6, "Paperino": "ciao", } noErr := &noError{} err1 := &wrongField{} err2 := &wrongType{} err3 := &cantSet{} assert.NoError(t, FillStruct(noErr, testMap)) assert.Error(t, FillStruct(err1, testMap)) assert.Error(t, FillStruct(err2, testMap)) assert.Error(t, FillStruct(err3, testMap)) }
func TestByteToPolicy(t *testing.T) { var encoded []byte var decoded Policy var err error policy := CreateRandomMockPolicies(1)[0] encoded, _ = json.Marshal(policy) decoded, err = ByteToPolicy(encoded) assert.NoError(t, err) assert.Equal(t, policy, decoded) bad := 0 encoded, _ = json.Marshal(bad) decoded, err = ByteToPolicy(encoded) assert.Error(t, err) }
func TestByteToAnalytics(t *testing.T) { var encoded []byte var decoded GruAnalytics var err error analytics := CreateMockAnalytics() encoded, _ = json.Marshal(analytics) decoded, err = ByteToAnalytics(encoded) assert.NoError(t, err) assert.Equal(t, analytics, decoded) bad := 0 encoded, _ = json.Marshal(bad) decoded, err = ByteToAnalytics(encoded) assert.Error(t, err) }
func TestByteToInfo(t *testing.T) { var encoded []byte var decoded Shared var err error info := CreateMockShared() encoded, _ = json.Marshal(info) decoded, err = ByteToShared(encoded) assert.NoError(t, err) assert.Equal(t, info, decoded) bad := 0 encoded, _ = json.Marshal(bad) decoded, err = ByteToShared(encoded) assert.Error(t, err) }
func TestByteToStats(t *testing.T) { var encoded []byte var decoded GruStats var err error stats := CreateMockStats() encoded, _ = json.Marshal(stats) decoded, err = ByteToStats(encoded) assert.NoError(t, err) assert.Equal(t, stats, decoded) bad := 0 encoded, _ = json.Marshal(bad) decoded, err = ByteToStats(encoded) assert.Error(t, err) }
func TestNew(t *testing.T) { noService := "noservice" noServiceConf := CreateMetricsMockConfig(noService) influxService := "influxdb" influxConf := CreateMetricsMockConfig(influxService) test, testErr := New(influxService, influxConf) assert.NoError(t, testErr) assert.Equal(t, test.Name(), influxService) influxConf["Username"] = 1 test, testErr = New(influxService, influxConf) assert.Error(t, testErr) assert.Equal(t, test.Name(), noService) test, testErr = New(noService, noServiceConf) assert.Error(t, testErr) assert.Equal(t, test.Name(), noService) }
func TestNew(t *testing.T) { supported := "internal" notSuported := "notSupported" _, err := New(supported) assert.NoError(t, err) assert.Equal(t, "internal", Name()) test := client() assert.Equal(t, "internal", test.Name()) _, err = New(notSuported) assert.Error(t, err) assert.Equal(t, "internal", Name()) test = client() assert.Equal(t, "internal", test.Name()) }
func TestGetCoresNumber(t *testing.T) { var err error cores := "0,1,2,3" cores_tooMany := "0,1,2,3,4,5,6" cores_wrongNumber := "0,1,85" cores_atoi := "1,pippo" var n []int n, err = getCoresNumber(cores) assert.NoError(t, err) assert.Equal(t, []int{0, 1, 2, 3}, n) n, err = getCoresNumber(cores_tooMany) assert.Error(t, err) n, err = getCoresNumber(cores_wrongNumber) assert.Error(t, err) n, err = getCoresNumber(cores_atoi) assert.Error(t, err) }