func TestPrometheusFiltersMetrics(t *testing.T) { assert := assert.New(t) //Create a prometheus collector using the config file 'sample_config_prometheus_filtered.json' configFile, err := ioutil.ReadFile("config/sample_config_prometheus_filtered.json") containerHandler := containertest.NewMockContainerHandler("mockContainer") collector, err := NewPrometheusCollector("Prometheus", configFile, 100, containerHandler, http.DefaultClient) assert.NoError(err) assert.Equal(collector.name, "Prometheus") assert.Equal(collector.configFile.Endpoint.URL, "http://localhost:8080/metrics") tempServer := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) { text := "# HELP go_gc_duration_seconds A summary of the GC invocation durations.\n" text += "# TYPE go_gc_duration_seconds summary\n" text += "go_gc_duration_seconds{quantile=\"0\"} 5.8348000000000004e-05\n" text += "go_gc_duration_seconds{quantile=\"1\"} 0.000499764\n" text += "# HELP go_goroutines Number of goroutines that currently exist.\n" text += "# TYPE go_goroutines gauge\n" text += "go_goroutines 16" fmt.Fprintln(w, text) })) defer tempServer.Close() collector.configFile.Endpoint.URL = tempServer.URL metrics := map[string][]v1.MetricVal{} _, metrics, errMetric := collector.Collect(metrics) assert.NoError(errMetric) assert.Len(metrics, 1) goRoutines := metrics["go_goroutines"] assert.Equal(goRoutines[0].FloatValue, 16) }
func TestMetricCollection(t *testing.T) { assert := assert.New(t) //Collect nginx metrics from a fake nginx endpoint configFile, err := ioutil.ReadFile("config/sample_config.json") assert.NoError(err) containerHandler := containertest.NewMockContainerHandler("mockContainer") fakeCollector, err := NewCollector("nginx", configFile, 100, containerHandler, http.DefaultClient) assert.NoError(err) tempServer := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) { fmt.Fprintln(w, "Active connections: 3\nserver accepts handled requests") fmt.Fprintln(w, "5 5 32\nReading: 0 Writing: 1 Waiting: 2") })) defer tempServer.Close() fakeCollector.configFile.Endpoint.URL = tempServer.URL metrics := map[string][]v1.MetricVal{} _, metrics, errMetric := fakeCollector.Collect(metrics) assert.NoError(errMetric) metricNames := []string{"activeConnections", "reading", "writing", "waiting"} // activeConnections = 3 assert.Equal(metrics[metricNames[0]][0].IntValue, 3) assert.Equal(metrics[metricNames[0]][0].FloatValue, 0) // reading = 0 assert.Equal(metrics[metricNames[1]][0].IntValue, 0) assert.Equal(metrics[metricNames[1]][0].FloatValue, 0) // writing = 1 assert.Equal(metrics[metricNames[2]][0].IntValue, 1) assert.Equal(metrics[metricNames[2]][0].FloatValue, 0) // waiting = 2 assert.Equal(metrics[metricNames[3]][0].IntValue, 2) assert.Equal(metrics[metricNames[3]][0].FloatValue, 0) }
func TestPrometheusMetricCountLimit(t *testing.T) { assert := assert.New(t) //Create a prometheus collector using the config file 'sample_config_prometheus.json' configFile, err := ioutil.ReadFile("config/sample_config_prometheus.json") containerHandler := containertest.NewMockContainerHandler("mockContainer") collector, err := NewPrometheusCollector("Prometheus", configFile, 10, containerHandler, http.DefaultClient) assert.NoError(err) assert.Equal(collector.name, "Prometheus") assert.Equal(collector.configFile.Endpoint.URL, "http://localhost:8080/metrics") tempServer := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) { for i := 0; i < 30; i++ { fmt.Fprintf(w, "# HELP m%d Number of goroutines that currently exist.\n", i) fmt.Fprintf(w, "# TYPE m%d gauge\n", i) fmt.Fprintf(w, "m%d %d", i, i) } })) defer tempServer.Close() collector.configFile.Endpoint.URL = tempServer.URL metrics := map[string][]v1.MetricVal{} _, result, errMetric := collector.Collect(metrics) assert.Error(errMetric) assert.Equal(len(metrics), 0) assert.Nil(result) }
func TestConfigWithErrors(t *testing.T) { assert := assert.New(t) //Syntax error: Missed '"' after activeConnections invalid := ` { "endpoint" : "http://localhost:8000/nginx_status", "metrics_config" : [ { "name" : "activeConnections, "metric_type" : "gauge", "data_type" : "int", "polling_frequency" : 10, "regex" : "Active connections: ([0-9]+)" } ] } ` //Create a temporary config file 'temp.json' with invalid json format assert.NoError(ioutil.WriteFile("temp.json", []byte(invalid), 0777)) configFile, err := ioutil.ReadFile("temp.json") assert.NoError(err) containerHandler := containertest.NewMockContainerHandler("mockContainer") _, err = NewCollector("tempCollector", configFile, 100, containerHandler, http.DefaultClient) assert.Error(err) assert.NoError(os.Remove("temp.json")) }
func TestPrometheusFiltersMetricsCountLimit(t *testing.T) { assert := assert.New(t) //Create a prometheus collector using the config file 'sample_config_prometheus_filtered.json' configFile, err := ioutil.ReadFile("config/sample_config_prometheus_filtered.json") containerHandler := containertest.NewMockContainerHandler("mockContainer") _, err = NewPrometheusCollector("Prometheus", configFile, 1, containerHandler, http.DefaultClient) assert.Error(err) }
func TestGetContainerInfoV2Failure(t *testing.T) { successful := "/" statless := "/c1" failing := "/c2" containers := []string{ successful, statless, failing, } options := v2.RequestOptions{ IdType: v2.TypeName, Count: 1, Recursive: true, } query := &info.ContainerInfoRequest{ NumStats: 2, } m, _, handlerMap := expectManagerWithContainers(containers, query, t) // Remove /c1 stats err := m.memoryCache.RemoveContainer(statless) if err != nil { t.Fatalf("RemoveContainer failed: %v", err) } // Make GetSpec fail on /c2 mockErr := fmt.Errorf("intentional GetSpec failure") failingHandler := containertest.NewMockContainerHandler(failing) failingHandler.On("GetSpec").Return(info.ContainerSpec{}, mockErr) failingHandler.On("Exists").Return(true) *handlerMap[failing] = *failingHandler m.containers[namespacedContainerName{Name: failing}].lastUpdatedTime = time.Time{} // Force GetSpec. infos, err := m.GetContainerInfoV2("/", options) if err == nil { t.Error("Expected error calling GetContainerInfoV2") } // Successful containers still successful. info, ok := infos[successful] assert.True(t, ok, "Missing info for container %q", successful) assert.NotEqual(t, v2.ContainerSpec{}, info.Spec, "Empty spec for container %q", successful) assert.NotEmpty(t, info.Stats, "Missing stats for container %q", successful) // "/c1" present with spec. info, ok = infos[statless] assert.True(t, ok, "Missing info for container %q", statless) assert.NotEqual(t, v2.ContainerSpec{}, info.Spec, "Empty spec for container %q", statless) assert.Empty(t, info.Stats, "Missing stats for container %q", successful) // "/c2" should be present but empty. info, ok = infos[failing] assert.True(t, ok, "Missing info for failed container") assert.Equal(t, v2.ContainerInfo{}, info, "Empty spec for failed container") assert.Empty(t, info.Stats, "Missing stats for failed container") }
func TestMetricCollectionLimit(t *testing.T) { assert := assert.New(t) //Collect nginx metrics from a fake nginx endpoint configFile, err := ioutil.ReadFile("config/sample_config.json") assert.NoError(err) containerHandler := containertest.NewMockContainerHandler("mockContainer") _, err = NewCollector("nginx", configFile, 1, containerHandler, http.DefaultClient) assert.Error(err) }
// Create a containerData instance for a test. func setupContainerData(t *testing.T, spec info.ContainerSpec) (*containerData, *containertest.MockContainerHandler, *memory.InMemoryCache) { mockHandler := containertest.NewMockContainerHandler(containerName) mockHandler.On("GetSpec").Return( spec, nil, ) memoryCache := memory.New(60, nil) ret, err := newContainerData(containerName, memoryCache, mockHandler, false, &collector.GenericCollectorManager{}, 60*time.Second, true) if err != nil { t.Fatal(err) } return ret, mockHandler, memoryCache }
func TestConfig(t *testing.T) { assert := assert.New(t) //Create an nginx collector using the config file 'sample_config.json' configFile, err := ioutil.ReadFile("config/sample_config.json") assert.NoError(err) containerHandler := containertest.NewMockContainerHandler("mockContainer") collector, err := NewCollector("nginx", configFile, 100, containerHandler, http.DefaultClient) assert.NoError(err) assert.Equal(collector.name, "nginx") assert.Equal(collector.configFile.Endpoint.URL, "http://localhost:8000/nginx_status") assert.Equal(collector.configFile.MetricsConfig[0].Name, "activeConnections") }
func TestPrometheusEndpointConfig(t *testing.T) { assert := assert.New(t) //Create a prometheus collector using the config file 'sample_config_prometheus.json' configFile, err := ioutil.ReadFile("config/sample_config_prometheus_endpoint_config.json") containerHandler := containertest.NewMockContainerHandler("mockContainer") containerHandler.On("GetContainerIPAddress").Return( "222.222.222.222", ) collector, err := NewPrometheusCollector("Prometheus", configFile, 100, containerHandler, http.DefaultClient) assert.NoError(err) assert.Equal(collector.name, "Prometheus") assert.Equal(collector.configFile.Endpoint.URL, "http://222.222.222.222:8081/METRICS") }
func TestEndpointConfig(t *testing.T) { assert := assert.New(t) configFile, err := ioutil.ReadFile("config/sample_config_endpoint_config.json") assert.NoError(err) containerHandler := containertest.NewMockContainerHandler("mockContainer") containerHandler.On("GetContainerIPAddress").Return( "111.111.111.111", ) collector, err := NewCollector("nginx", configFile, 100, containerHandler, http.DefaultClient) assert.NoError(err) assert.Equal(collector.name, "nginx") assert.Equal(collector.configFile.Endpoint.URL, "https://111.111.111.111:8000/nginx_status") assert.Equal(collector.configFile.MetricsConfig[0].Name, "activeConnections") }
func TestPrometheusShortResponse(t *testing.T) { assert := assert.New(t) //Create a prometheus collector using the config file 'sample_config_prometheus.json' configFile, err := ioutil.ReadFile("config/sample_config_prometheus.json") containerHandler := containertest.NewMockContainerHandler("mockContainer") collector, err := NewPrometheusCollector("Prometheus", configFile, 100, containerHandler, http.DefaultClient) assert.NoError(err) assert.Equal(collector.name, "Prometheus") assert.Equal(collector.configFile.Endpoint.URL, "http://localhost:8080/metrics") tempServer := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) { text := "# HELP empty_metric A metric without any values" fmt.Fprint(w, text) })) defer tempServer.Close() collector.configFile.Endpoint.URL = tempServer.URL assert.NotPanics(func() { collector.GetSpec() }) }
func TestConfigWithRegexErrors(t *testing.T) { assert := assert.New(t) //Error: Missed operand for '+' in activeConnections regex invalid := ` { "endpoint" : "host:port/nginx_status", "metrics_config" : [ { "name" : "activeConnections", "metric_type" : "gauge", "data_type" : "int", "polling_frequency" : 10, "regex" : "Active connections: (+)" }, { "name" : "reading", "metric_type" : "gauge", "data_type" : "int", "polling_frequency" : 10, "regex" : "Reading: ([0-9]+) .*" } ] } ` //Create a temporary config file 'temp.json' assert.NoError(ioutil.WriteFile("temp.json", []byte(invalid), 0777)) configFile, err := ioutil.ReadFile("temp.json") assert.NoError(err) containerHandler := containertest.NewMockContainerHandler("mockContainer") _, err = NewCollector("tempCollector", configFile, 100, containerHandler, http.DefaultClient) assert.Error(err) assert.NoError(os.Remove("temp.json")) }
func createManagerAndAddContainers( memoryCache *memory.InMemoryCache, sysfs *fakesysfs.FakeSysFs, containers []string, f func(*containertest.MockContainerHandler), t *testing.T, ) *manager { container.ClearContainerHandlerFactories() mif := &manager{ containers: make(map[namespacedContainerName]*containerData), quitChannels: make([]chan error, 0, 2), memoryCache: memoryCache, } for _, name := range containers { mockHandler := containertest.NewMockContainerHandler(name) spec := itest.GenerateRandomContainerSpec(4) mockHandler.On("GetSpec").Return( spec, nil, ).Once() cont, err := newContainerData(name, memoryCache, mockHandler, false, &collector.GenericCollectorManager{}, 60*time.Second, true) if err != nil { t.Fatal(err) } mif.containers[namespacedContainerName{ Name: name, }] = cont // Add Docker containers under their namespace. if strings.HasPrefix(name, "/docker") { mif.containers[namespacedContainerName{ Namespace: docker.DockerNamespace, Name: strings.TrimPrefix(name, "/docker/"), }] = cont } f(mockHandler) } return mif }
func TestEmptyConfig(t *testing.T) { assert := assert.New(t) emptyConfig := ` { "endpoint" : "http://localhost:8000/nginx_status", "metrics_config" : [ ] } ` //Create a temporary config file 'temp.json' with invalid json format assert.NoError(ioutil.WriteFile("temp.json", []byte(emptyConfig), 0777)) configFile, err := ioutil.ReadFile("temp.json") assert.NoError(err) containerHandler := containertest.NewMockContainerHandler("mockContainer") _, err = NewCollector("tempCollector", configFile, 100, containerHandler, http.DefaultClient) assert.Error(err) assert.NoError(os.Remove("temp.json")) }