func TestPrometheusClientCounterWithFullLabels(t *testing.T) { config.Global.Set("prometheus.namelabel", true) config.Global.Set("prometheus.sitecodelabel", true) store := data.NewSimpleInMemoryStore() test.ExecuteCompletePipe(t, store) // It is kinda complicated to collect values from CounterVecs, // so for now this test simply makes sure that the application doesn't // crash if extended node labels are activated. }
func TestLoadingLegacyNodesJson(t *testing.T) { assert := assert.New(t) nodeJsonPath := "../../../../../../nodes.json" store := data.NewSimpleInMemoryStore() importer := &FFMapBackendDataLoader{Store: store} err := importer.LoadNodesFromFile(nodeJsonPath) assert.Nil(err) assert.True(0 < len(store.GetNodeInfos())) }
func TestCompletePipe(t *testing.T) { assert := assert.New(t) log.SetLevel(log.ErrorLevel) store := data.NewSimpleInMemoryStore() test.ExecuteCompletePipe(t, store) graphGenerator := &meshviewer.GraphGenerator{Store: store} nodesGenerator := &meshviewer.NodesJsonGenerator{Store: store} graph := graphGenerator.GenerateGraph() assert.NotNil(graph) assert.Equal(169, len(graph.Batadv.Nodes)) assert.Equal(66, len(graph.Batadv.Links)) nodes := nodesGenerator.GetNodesJson() assert.NotNil(nodes) }
func TestGeneratingNodeGraph(t *testing.T) { assert := assert.New(t) log.SetLevel(log.ErrorLevel) assert.True(true) store := data.NewSimpleInMemoryStore() test.ExecuteCompletePipe(t, store) graphGenerator := &GraphGenerator{Store: store} graphGenerator.UpdateGraphJson() graphData := &GraphJson{} err := json.Unmarshal([]byte(graphGenerator.cachedJsonString), graphData) assert.Nil(err) assert.NotNil(graphData) testForDoublettes(assert, graphData.Batadv.Nodes) }
func TestCorrectGraphFormat(t *testing.T) { assert := assert.New(t) store := data.NewSimpleInMemoryStore() for _, neighbour := range neighbourInfos { store.PutNodeNeighbours(neighbour) } store.PutNodeStatusInfo("001122334455", nodeStatus[0]) graphGenerator := &GraphGenerator{Store: store} _, nodeList := graphGenerator.buildNodeTableAndList() assert.NotNil(nodeList) assert.Equal(1, len(nodeList)) assert.Equal("001122334455", nodeList[0].NodeId) // Access to the map after unmarshalling has no stable order, so both bat macs // could be in the id field, but either way should be fine assert.True(nodeList[0].Id == "001122aa44aa" || nodeList[0].Id == "001122aa44cc") }
func CreateDataStore() { dbType := conf.UString("store.type", "memory") switch dbType { case "memory": DataStore = data.NewSimpleInMemoryStore() case "bolt": storagePath := conf.UString("store.path", "/opt/gluon-collector/collector.db") boltStore, err := data.NewBoltStore(storagePath) if err != nil { log.WithFields(log.Fields{ "error": err, "storePath": storagePath, "storeType": dbType, }).Fatal("Can't create bolt store") } else { Closeables = append(Closeables, boltStore) DataStore = boltStore } default: log.Fatalf("Unknown store type %s", dbType) } }
func TestNodesJsonHasFlaggedUplinks(t *testing.T) { assert := assert.New(t) store := data.NewSimpleInMemoryStore() test.ExecuteCompletePipe(t, store) statistics := data.StatisticsStruct{} err := json.Unmarshal([]byte(uplinkStats), &statistics) assert.Nil(err) store.PutStatistics(statistics) generator := &NodesJsonGenerator{Store: store} nodesJson := generator.GetNodesJson() uplinkFound := false for _, node := range nodesJson.Nodes { if node.Flags.Uplink && node.Nodeinfo.NodeId == "e8de27252554" { uplinkFound = true break } } assert.True(uplinkFound, "No node was flagged as uplink") statistics = data.StatisticsStruct{} err = json.Unmarshal([]byte(nonUplinkStats), &statistics) assert.Nil(err) uplinkFound = false store.PutStatistics(statistics) nodesJson = generator.GetNodesJson() for _, node := range nodesJson.Nodes { if !node.Flags.Uplink && node.Nodeinfo.NodeId == "e8de27252554" { uplinkFound = true break } } assert.True(uplinkFound, "A node was not correctly flagged") }
func TestPrometheusClientCounter(t *testing.T) { assert := assert.New(t) assert.True(true) var expectedClientCounts = []float64{13, 11, 15} finishChan := make(chan bool) store := data.NewSimpleInMemoryStore() processPipeline := pipeline.NewProcessPipeline(&prometheus.ClientCountPipe{Store: store}, &collectors.StatisticsCollector{Store: store}) prometheus.TotalClientCounter.Set(10.0) var packetCount int = 0 go processPipeline.Dequeue(func(response data.ParsedResponse) { value := collectGaugeValue(prometheus.TotalClientCounter) assert.Equal(expectedClientCounts[packetCount], value) packetCount = packetCount + 1 if packetCount == len(expectedClientCounts) { finishChan <- true close(finishChan) } }) feedClientsStat(processPipeline, 3) // Give the collector pipe a little time to execute its go routin // in production it is very very unrealistic that we will have two Statistics // Responses from the same node in the channel at the same time. time.Sleep(time.Millisecond * 50) feedClientsStat(processPipeline, 1) time.Sleep(time.Millisecond * 50) feedClientsStat(processPipeline, 5) for range finishChan { processPipeline.Close() } }