// GetMetricTypes returns metric types for testing func (f *Mock) GetMetricTypes(cfg plugin.Config) ([]plugin.Metric, error) { mts := []plugin.Metric{} if _, err := cfg.GetBool("test-fail"); err == nil { return mts, fmt.Errorf("testing") } if _, err := cfg.GetBool("test"); err == nil { mts = append(mts, plugin.Metric{ Namespace: plugin.NewNamespace("intel", "mock", "test"), Description: "mock description", Unit: "mock unit", }) } if _, err := cfg.GetBool("test-less"); err != nil { mts = append(mts, plugin.Metric{ Namespace: plugin.NewNamespace("intel", "mock", "foo"), Description: "mock description", Unit: "mock unit", }) } mts = append(mts, plugin.Metric{ Namespace: plugin.NewNamespace("intel", "mock", "bar"), Description: "mock description", Unit: "mock unit", }) mts = append(mts, plugin.Metric{ Namespace: plugin.NewNamespace("intel", "mock"). AddDynamicElement("host", "name of the host"). AddStaticElement("baz"), Description: "mock description", Unit: "mock unit", }) return mts, nil }
// GetMetricTypes returns metric types that can be collected func (LibvirtCollector) GetMetricTypes(cfg plugin.Config) ([]plugin.Metric, error) { var metrics []plugin.Metric ns := plugin.NewNamespace(Vendor, Plugin). AddDynamicElement("domain_id", "an id of libvirt domain") for _, value := range nsTypes.cpu { metrics = append(metrics, createMetric(ns.AddStaticElements("cpu", value))) metrics = append(metrics, createMetric(ns.AddStaticElement("cpu").AddDynamicElement("cpu_id", "id of vcpu").AddStaticElement(value))) } for _, value := range nsTypes.disk { metrics = append(metrics, createMetric( ns.AddStaticElements("disk").AddDynamicElement("device_name", "a name of filesystem device").AddStaticElement(value))) } for _, value := range nsTypes.network { metrics = append(metrics, createMetric( ns.AddStaticElements("network").AddDynamicElement("network_interface", "a name of network interface").AddStaticElement(value))) } for _, value := range nsTypes.memory { metrics = append(metrics, createMetric(ns.AddStaticElements("memory").AddStaticElement(value))) } return metrics, nil }
func TestFilePublish(t *testing.T) { metrics := []plugin.Metric{plugin.Metric{Namespace: plugin.NewNamespace("foo"), Timestamp: time.Now(), Data: 99, Tags: nil}} config := plugin.Config{"file": "/tmp/pub.out"} Convey("TestFilePublish", t, func() { fp := NewFilePublisher() So(fp, ShouldNotBeNil) err := fp.Publish(metrics, config) So(err, ShouldBeNil) filename, _ := config.GetString("file") _, err = os.Stat(filename) So(err, ShouldBeNil) }) }
func TestCollectMetric(t *testing.T) { ns0 := plugin.NewNamespace("intel", "mock", "test") ns1 := plugin.NewNamespace("intel", "mock", "foo") ns2 := plugin.NewNamespace("intel", "mock", "bar") ns3 := plugin.NewNamespace("intel", "mock").AddDynamicElement("host", "name of the host").AddStaticElement("baz") Convey("Testing CollectMetric", t, func() { newPlg := new(Mock) So(newPlg, ShouldNotBeNil) Convey("with 'test' config variable'", func() { cfg := plugin.Config{"test": true} Convey("testing specific metrics", func() { mTypes := []plugin.Metric{ plugin.Metric{Namespace: ns0, Config: cfg}, plugin.Metric{Namespace: ns1, Config: cfg}, plugin.Metric{Namespace: ns2, Config: cfg}, } mts, _ := newPlg.CollectMetrics(mTypes) Convey("returned metrics should have data type integer", func() { for _, mt := range mts { _, ok := mt.Data.(int) So(ok, ShouldBeTrue) } }) }) Convey("testing dynamic metric", func() { mt := plugin.Metric{Namespace: ns3, Config: cfg} isDynamic, _ := mt.Namespace.IsDynamic() So(isDynamic, ShouldBeTrue) Convey("for none specified instance", func() { mts, _ := newPlg.CollectMetrics([]plugin.Metric{mt}) // there is 10 available hosts (host0, host1, ..., host9) So(len(mts), ShouldEqual, 10) Convey("returned metrics should have data type integer", func() { for _, mt := range mts { _, ok := mt.Data.(int) So(ok, ShouldBeTrue) } }) Convey("returned metrics should remain dynamic", func() { for _, mt := range mts { isDynamic, _ := mt.Namespace.IsDynamic() So(isDynamic, ShouldBeTrue) } }) }) Convey("for specified instance which is available - host0", func() { mt.Namespace[2].Value = "host0" mts, _ := newPlg.CollectMetrics([]plugin.Metric{mt}) // only one metric for this specific hostname should be returned So(len(mts), ShouldEqual, 1) So(mts[0].Namespace.String(), ShouldEqual, "/intel/mock/host0/baz") Convey("returned metric should have data type integer", func() { _, ok := mts[0].Data.(int) So(ok, ShouldBeTrue) }) Convey("returned metric should remain dynamic", func() { isDynamic, _ := mt.Namespace.IsDynamic() So(isDynamic, ShouldBeTrue) }) }) Convey("for specified instance which is not available - host10", func() { mt.Namespace[2].Value = "host10" mts, err := newPlg.CollectMetrics([]plugin.Metric{mt}) So(mts, ShouldBeNil) So(err, ShouldNotBeNil) So(err.Error(), ShouldStartWith, "requested hostname `host10` is not available") }) }) }) Convey("without config variables", func() { cfg := plugin.Config{} Convey("testing specific metrics", func() { mTypes := []plugin.Metric{ plugin.Metric{Namespace: ns0, Config: cfg}, plugin.Metric{Namespace: ns1, Config: cfg}, plugin.Metric{Namespace: ns2, Config: cfg}, } mts, _ := newPlg.CollectMetrics(mTypes) Convey("returned metrics should have data type integer", func() { for _, mt := range mts { _, ok := mt.Data.(int) So(ok, ShouldBeTrue) } }) }) Convey("testing dynamic metics", func() { mTypes := []plugin.Metric{ plugin.Metric{Namespace: ns3, Config: cfg}, } mts, _ := newPlg.CollectMetrics(mTypes) Convey("returned metrics should have data type integer", func() { for _, mt := range mts { _, ok := mt.Data.(int) So(ok, ShouldBeTrue) } }) Convey("returned metrics should remain dynamic", func() { for _, mt := range mts { isDynamic, _ := mt.Namespace.IsDynamic() So(isDynamic, ShouldBeTrue) } }) }) }) }) }
func TestGetMetricTypes(t *testing.T) { Convey("Tesing GetMetricTypes", t, func() { newPlg := new(Mock) So(newPlg, ShouldNotBeNil) Convey("with missing on-load plugin config entry", func() { cfg := plugin.Config{"test-fail": true} _, err := newPlg.GetMetricTypes(cfg) So(err, ShouldNotBeNil) }) Convey("with 'test' config variable", func() { cfg := plugin.Config{"test": true} mts, err := newPlg.GetMetricTypes(cfg) So(err, ShouldBeNil) So(len(mts), ShouldEqual, 4) Convey("checking namespaces", func() { metricNames := []string{} for _, m := range mts { metricNames = append(metricNames, m.Namespace.String()) } ns := plugin.NewNamespace("intel", "mock", "test") So(str.Contains(metricNames, ns.String()), ShouldBeTrue) ns = plugin.NewNamespace("intel", "mock", "foo") So(str.Contains(metricNames, ns.String()), ShouldBeTrue) ns = plugin.NewNamespace("intel", "mock", "bar") So(str.Contains(metricNames, ns.String()), ShouldBeTrue) ns = plugin.NewNamespace("intel", "mock").AddDynamicElement("host", "name of the host").AddStaticElement("baz") So(str.Contains(metricNames, ns.String()), ShouldBeTrue) }) }) Convey("without config variables", func() { mts, err := newPlg.GetMetricTypes(plugin.Config{}) So(err, ShouldBeNil) So(len(mts), ShouldEqual, 3) Convey("checking namespaces", func() { metricNames := []string{} for _, m := range mts { metricNames = append(metricNames, m.Namespace.String()) } ns := plugin.NewNamespace("intel", "mock", "foo") So(str.Contains(metricNames, ns.String()), ShouldBeTrue) ns = plugin.NewNamespace("intel", "mock", "bar") So(str.Contains(metricNames, ns.String()), ShouldBeTrue) ns = plugin.NewNamespace("intel", "mock").AddDynamicElement("host", "name of the host").AddStaticElement("baz") So(str.Contains(metricNames, ns.String()), ShouldBeTrue) }) }) }) }
func TestLibirtPlugin(t *testing.T) { Convey("Create Libvirt Collector", t, func() { libvirtCol := LibvirtCollector{} Convey("So psCol should not be nil", func() { So(libvirtCol, ShouldNotBeNil) }) Convey("So psCol should be of Libvirt type", func() { So(libvirtCol, ShouldHaveSameTypeAs, LibvirtCollector{}) }) Convey("libvirtCol.GetConfigPolicy() should return a config policy", func() { configPolicy, _ := libvirtCol.GetConfigPolicy() Convey("So config policy should not be nil", func() { So(configPolicy, ShouldNotBeNil) }) Convey("So config policy should be a plugin.ConfigPolicy", func() { So(configPolicy, ShouldHaveSameTypeAs, plugin.ConfigPolicy{}) }) }) }) Convey("Get Metric Types", t, func() { libvirtCol := LibvirtCollector{} var cfg = plugin.Config{} metrics, err := libvirtCol.GetMetricTypes(cfg) So(err, ShouldBeNil) So(len(metrics), ShouldResemble, 25) }) Convey("Collect Metrics", t, func() { libvirtCol := LibvirtCollector{} config := plugin.Config{ "uri": "test:///default", "nova": false, } mts := []plugin.Metric{} mts = append(mts, plugin.Metric{Namespace: plugin.NewNamespace(Vendor, Plugin).AddDynamicElement("domain_id", "an id of libvirt domain").AddStaticElements("cpu", "cputime"), Config: config}) metrics, err := libvirtCol.CollectMetrics(mts) So(err, ShouldBeNil) So(len(metrics), ShouldResemble, 1) So(metrics[0].Data, ShouldNotBeNil) So(metrics[0].Namespace.Strings()[2], ShouldResemble, "test") }) Convey("Collect Vcpu Metrics", t, func() { libvirtCol := LibvirtCollector{} config := plugin.Config{ "uri": "test:///default", "nova": false, } mts := []plugin.Metric{} mts = append(mts, plugin.Metric{Namespace: plugin.NewNamespace(Vendor, Plugin).AddDynamicElement("domain_id", "an id of libvirt domain").AddStaticElement("cpu").AddDynamicElement("cpu_id", "id of vcpu").AddStaticElement("cputime"), Config: config}) metrics, err := libvirtCol.CollectMetrics(mts) So(err, ShouldBeNil) So(len(metrics), ShouldResemble, 2) So(metrics[0].Data, ShouldNotBeNil) secondLastElement := len(metrics[0].Namespace.Strings()) - 2 So(metrics[0].Namespace.Strings()[secondLastElement], ShouldBeIn, []string{"0", "1"}) So(metrics[0].Namespace.Strings()[2], ShouldResemble, "test") So(metrics[1].Namespace.Strings()[secondLastElement], ShouldBeIn, []string{"0", "1"}) So(metrics[1].Namespace.Strings()[2], ShouldResemble, "test") }) Convey("Merge two map[string]string", t, func() { one := make(map[string]string) two := make(map[string]string) one["test"] = "test" two["test1"] = "test" three := merge(one, two) result := make(map[string]string) result["test"] = "test" result["test1"] = "test" So(result, ShouldResemble, three) }) Convey("copy namespace", t, func() { mt := plugin.Metric{Namespace: plugin.NewNamespace(Vendor, Plugin).AddDynamicElement("domain_id", "an id of libvirt domain").AddStaticElements("cpu", "cputime")} ns := copyNamespace(mt) result := []plugin.NamespaceElement{plugin.NamespaceElement{Value: "intel", Description: "", Name: ""}, plugin.NamespaceElement{Value: "libvirt", Description: "", Name: ""}, plugin.NamespaceElement{Value: "*", Description: "an id of libvirt domain", Name: "domain_id"}, plugin.NamespaceElement{Value: "cpu", Description: "", Name: ""}, plugin.NamespaceElement{Value: "cputime", Description: "", Name: ""}} So(ns, ShouldResemble, result) }) Convey("filter Namespace", t, func() { mts := []plugin.Metric{ plugin.Metric{Namespace: plugin.NewNamespace(Vendor, Plugin).AddDynamicElement("domain_id", "an id of libvirt domain").AddStaticElements("cpu", "cputime")}, } countResult, result := filterNamespace("cpu", mts) So(mts, ShouldResemble, result) So(countResult, ShouldResemble, 1) countResult, result2 := filterNamespace("memory", mts) expectedType := []plugin.Metric{} So(result2, ShouldHaveSameTypeAs, expectedType) So(countResult, ShouldResemble, 0) }) }