func Test_getCephBinaryPath(t *testing.T) {
	path := "/path/to/ceph/bin"

	Convey("path Ceph executable in Snap Global Config", t, func() {
		cmd = &TestCmd{}
		cfg := plugin.NewPluginConfigType()
		cfg.AddItem("path", ctypes.ConfigValueStr{Value: path})

		So(func() { getCephBinaryPath(cfg.Table()) }, ShouldNotPanic)
		result := getCephBinaryPath(cfg.Table())
		So(result, ShouldEqual, path)
	})

	Convey("looking for Ceph executable in $PATH with no error", t, func() {
		cfg := plugin.NewPluginConfigType()
		cmd = &TestCmd{look_path: path}
		So(func() { getCephBinaryPath(cfg.Table()) }, ShouldNotPanic)
		result := getCephBinaryPath(cfg.Table())
		So(result, ShouldEqual, path)
	})

	Convey("looking for Ceph executable in $PATH with error", t, func() {
		cfg := plugin.NewPluginConfigType()
		cmd = &TestCmd{look_path: path, look_err: errors.New("error")}
		So(func() { getCephBinaryPath(cfg.Table()) }, ShouldNotPanic)
		result := getCephBinaryPath(cfg.Table())
		// getting default path to ceph executable
		So(result, ShouldEqual, cephBinPathDefault)
	})
}
func TestGetMetricTypes(t *testing.T) {
	// Testing GetMetricTypes function covers checking initialization of Ceph plugin

	// mock ceph socket
	os.Mkdir("test", os.ModePerm)
	os.Create("test/ceph-mds.a.asok")
	os.Create("test/ceph-mds.b.asok")
	os.Create("test/ceph-mds.c.asok")

	// set ceph socket conf value
	cfg := plugin.NewPluginConfigType()
	cfg.AddItem("socket_path", ctypes.ConfigValueStr{Value: "./test"})
	cfg.AddItem("socket_prefix", ctypes.ConfigValueStr{Value: "ceph-"})
	cfg.AddItem("socket_ext", ctypes.ConfigValueStr{Value: "asok"})

	Convey("init ceph plugin and getting metric namespace", t, func() {
		ceph := &Ceph{}
		cmd = &TestCmd{out: mockOut}
		So(func() { ceph.GetMetricTypes(cfg) }, ShouldNotPanic)
		result, err := ceph.GetMetricTypes(cfg)
		So(result, ShouldNotBeNil)
		So(err, ShouldBeNil)
	})

	Convey("invalid path to ceph-daemon sockets", t, func() {
		ceph := &Ceph{}
		cmd = &TestCmd{out: mockOut}
		cfg_invalid := plugin.NewPluginConfigType()
		cfg_invalid.AddItem("socket_path", ctypes.ConfigValueStr{Value: "./test_invalid"})
		cfg_invalid.AddItem("socket_prefix", ctypes.ConfigValueStr{Value: "ceph-"})
		cfg_invalid.AddItem("socket_ext", ctypes.ConfigValueStr{Value: "asok"})
		So(func() { ceph.Init(cfg_invalid.Table()) }, ShouldPanic)
	})

	Convey("no ceph-daemon sockets available with set prefix", t, func() {
		ceph := &Ceph{}
		cmd = &TestCmd{out: mockOut}
		cfg_inv_prefix := plugin.NewPluginConfigType()
		cfg_inv_prefix.AddItem("socket_path", ctypes.ConfigValueStr{Value: "./test"})
		cfg_inv_prefix.AddItem("socket_prefix", ctypes.ConfigValueStr{Value: "ceph_inv-"})
		So(func() { ceph.Init(cfg_inv_prefix.Table()) }, ShouldNotPanic)
		err := ceph.Init(cfg_inv_prefix.Table())
		So(err, ShouldNotBeNil)
	})

	Convey("no ceph-daemon sockets available with set extension", t, func() {
		ceph := &Ceph{}
		cmd = &TestCmd{out: mockOut}
		cfg_inv_ext := plugin.NewPluginConfigType()
		cfg_inv_ext.AddItem("socket_path", ctypes.ConfigValueStr{Value: "./test"})
		cfg_inv_ext.AddItem("socket_ext", ctypes.ConfigValueStr{Value: "asok_inv"})
		So(func() { ceph.Init(cfg_inv_ext.Table()) }, ShouldNotPanic)
		err := ceph.Init(cfg_inv_ext.Table())
		So(err, ShouldNotBeNil)
	})

	os.RemoveAll("test/")
}
func TestGetGlobalConfigItem(t *testing.T) {

	Convey("Get a value of item from Global Config with no error", t, func() {
		//create global config and add item (different types)
		cfg := plugin.NewPluginConfigType()
		cfg.AddItem("dummy_string", ctypes.ConfigValueStr{Value: dummy_str})
		cfg.AddItem("dummy_bool", ctypes.ConfigValueBool{Value: dummy_bool})
		cfg.AddItem("dummy_int", ctypes.ConfigValueInt{Value: dummy_int})
		cfg.AddItem("dummy_float", ctypes.ConfigValueFloat{Value: dummy_float})

		Convey("string type of item", func() {
			result, err := GetGlobalConfigItem(cfg, "dummy_string")
			So(err, ShouldBeNil)
			So(result, ShouldEqual, dummy_str)
		})

		Convey("bool type of item", func() {
			result, err := GetGlobalConfigItem(cfg, "dummy_bool")
			So(err, ShouldBeNil)
			So(result, ShouldEqual, dummy_bool)
		})

		Convey("int type of item", func() {
			result, err := GetGlobalConfigItem(cfg, "dummy_int")
			So(err, ShouldBeNil)
			So(result, ShouldEqual, dummy_int)
		})

		Convey("float type of item", func() {
			result, err := GetGlobalConfigItem(cfg, "dummy_float")
			So(err, ShouldBeNil)
			So(result, ShouldEqual, dummy_float)
		})
	})

	Convey("Try to get value of item not defined in Global Config", t, func() {
		cfg := plugin.NewPluginConfigType()
		cfg.AddItem("foo", ctypes.ConfigValueStr{Value: "foo"})
		result, err := GetGlobalConfigItem(cfg, "foo_not_exist")
		So(err, ShouldNotBeNil)
		So(result, ShouldBeNil)
	})

	Convey("No item defined in Global Config", t, func() {
		cfg_empty := plugin.NewPluginConfigType()
		result, err := GetGlobalConfigItem(cfg_empty, "foo")
		So(err, ShouldNotBeNil)
		So(result, ShouldBeNil)
	})
}
func testingConfig() (cfg1 plugin.ConfigType, cfg2 *cdata.ConfigDataNode) {
	cfg1 = plugin.NewPluginConfigType()
	cfg2 = cdata.NewNode()

	cfg1.AddItem("openstack_user", ctypes.ConfigValueStr{Value: "x"})
	cfg1.AddItem("openstack_pass", ctypes.ConfigValueStr{Value: "x"})
	cfg1.AddItem("openstack_tenant", ctypes.ConfigValueStr{Value: "asdf"})
	cfg1.AddItem("openstack_auth_url", ctypes.ConfigValueStr{Value: "x"})

	cfg2.AddItem("openstack_user", ctypes.ConfigValueStr{Value: "x"})
	cfg2.AddItem("openstack_pass", ctypes.ConfigValueStr{Value: "x"})
	cfg2.AddItem("openstack_tenant", ctypes.ConfigValueStr{Value: "asdf"})
	cfg2.AddItem("openstack_auth_url", ctypes.ConfigValueStr{Value: "x"})

	cfg1.AddItem("allocation_ratio_cores", ctypes.ConfigValueFloat{Value: 3})
	cfg1.AddItem("allocation_ratio_ram", ctypes.ConfigValueFloat{Value: 4})
	cfg1.AddItem("reserved_node_cores", ctypes.ConfigValueFloat{Value: 5})
	cfg1.AddItem("reserved_node_ram_mb", ctypes.ConfigValueFloat{Value: 6})

	cfg2.AddItem("allocation_ratio_cores", ctypes.ConfigValueFloat{Value: 3})
	cfg2.AddItem("allocation_ratio_ram", ctypes.ConfigValueFloat{Value: 4})
	cfg2.AddItem("reserved_node_cores", ctypes.ConfigValueFloat{Value: 5})
	cfg2.AddItem("reserved_node_ram_mb", ctypes.ConfigValueFloat{Value: 6})

	return cfg1, cfg2
}
func Test_getCephBinaryPath(t *testing.T) {
	path := "/path/to/ceph/bin"
	ceph := New()

	Convey("path Ceph executable in Snap Global Config", t, func() {
		cmd = &TestCmd{}
		cfg := plugin.NewPluginConfigType()
		cfg.AddItem("path", ctypes.ConfigValueStr{Value: path})

		So(func() { getCephBinaryPath(cfg.Table()) }, ShouldNotPanic)
		result := getCephBinaryPath(cfg.Table())
		So(result, ShouldEqual, path)
	})

	Convey("looking for Ceph executable default path", t, func() {
		cp, _ := ceph.GetConfigPolicy()
		cfgRules := cp.Get([]string{"intel", "storage", "ceph"}).RulesAsTable()

		for i := range cfgRules {
			switch cfgRules[i].Name {
			case "path":
				So(cfgRules[i].Default.(*ctypes.ConfigValueStr).Value, ShouldEqual, cephBinPathDefault)
			}
		}
	})
}
func Test_getSocketConf(t *testing.T) {
	ceph := New()

	Convey("check Ceph socket default config", t, func() {
		cmd = &TestCmd{}

		cp, _ := ceph.GetConfigPolicy()
		cfgRules := cp.Get([]string{"intel", "storage", "ceph"}).RulesAsTable()

		for i := range cfgRules {
			switch cfgRules[i].Name {
			case "socket_path":
				So(cfgRules[i].Default.(*ctypes.ConfigValueStr).Value, ShouldEqual, socketPathDefault)
			case "socket_prefix":
				So(cfgRules[i].Default.(*ctypes.ConfigValueStr).Value, ShouldEqual, socketPrefixDefault)
			case "socket_ext":
				So(cfgRules[i].Default.(*ctypes.ConfigValueStr).Value, ShouldEqual, socketExtDefault)
			}
		}
	})

	Convey("customize Ceph socket conf in Snap Global Conf", t, func() {
		path := "path/to/ceph/socket"
		prefix := "test-"
		extension := "asdf"
		cmd = &TestCmd{}
		cfg := plugin.NewPluginConfigType()
		cfg.AddItem("socket_path", ctypes.ConfigValueStr{Value: path})
		cfg.AddItem("socket_prefix", ctypes.ConfigValueStr{Value: prefix})
		cfg.AddItem("socket_ext", ctypes.ConfigValueStr{Value: extension})

		So(func() { getCephSocketConf(cfg.Table()) }, ShouldNotPanic)
		result := getCephSocketConf(cfg.Table())
		So(result.path, ShouldEqual, path)
		So(result.prefix, ShouldEqual, prefix)
		So(result.ext, ShouldEqual, extension)
	})

	Convey("customize Ceph socket prefix, set none", t, func() {
		cmd = &TestCmd{}
		cfg := plugin.NewPluginConfigType()
		cfg.AddItem("socket_prefix", ctypes.ConfigValueStr{Value: "none"})
		So(func() { getCephSocketConf(cfg.Table()) }, ShouldNotPanic)
		result := getCephSocketConf(cfg.Table())
		So(result.prefix, ShouldBeEmpty)
	})
}
func getMockPluginConfig() plugin.ConfigType {
	// mocking global config
	cfg := plugin.NewPluginConfigType()
	cfg.AddItem("host", ctypes.ConfigValueStr{Value: "hostname"})
	cfg.AddItem("port", ctypes.ConfigValueInt{Value: 1234})
	cfg.AddItem("user", ctypes.ConfigValueStr{Value: "test"})
	cfg.AddItem("password", ctypes.ConfigValueStr{Value: "passwd"})

	return cfg
}
func Test_getSocketConf(t *testing.T) {
	Convey("defaults Ceph socket details", t, func() {
		cmd = &TestCmd{}
		cfg := plugin.NewPluginConfigType()

		So(func() { getCephSocketConf(cfg.Table()) }, ShouldNotPanic)
		result := getCephSocketConf(cfg.Table())
		So(result.path, ShouldEqual, socketPathDefault)
		So(result.prefix, ShouldEqual, socketPrefixDefault)
		So(result.ext, ShouldEqual, socketExtDefault)
	})

	Convey("customize Ceph socket conf in Snap Global Conf", t, func() {
		path := "path/to/ceph/socket"
		prefix := "test-"
		extension := "asdf"
		cmd = &TestCmd{}
		cfg := plugin.NewPluginConfigType()
		cfg.AddItem("socket_path", ctypes.ConfigValueStr{Value: path})
		cfg.AddItem("socket_prefix", ctypes.ConfigValueStr{Value: prefix})
		cfg.AddItem("socket_ext", ctypes.ConfigValueStr{Value: extension})

		So(func() { getCephSocketConf(cfg.Table()) }, ShouldNotPanic)
		result := getCephSocketConf(cfg.Table())
		So(result.path, ShouldEqual, path)
		So(result.prefix, ShouldEqual, prefix)
		So(result.ext, ShouldEqual, extension)
	})

	Convey("customize Ceph socket prefix, set none", t, func() {
		cmd = &TestCmd{}
		cfg := plugin.NewPluginConfigType()
		cfg.AddItem("socket_prefix", ctypes.ConfigValueStr{Value: "none"})
		So(func() { getCephSocketConf(cfg.Table()) }, ShouldNotPanic)
		result := getCephSocketConf(cfg.Table())
		So(result.prefix, ShouldBeEmpty)
	})
}
func TestGetGlobalConfigItems(t *testing.T) {

	Convey("Get values of items from Global Config with no error", t, func() {
		//create global config and add item (different types)
		cfg := plugin.NewPluginConfigType()
		cfg.AddItem("dummy_string", ctypes.ConfigValueStr{Value: dummy_str})
		cfg.AddItem("dummy_bool", ctypes.ConfigValueBool{Value: dummy_bool})
		cfg.AddItem("dummy_int", ctypes.ConfigValueInt{Value: dummy_int})
		cfg.AddItem("dummy_float", ctypes.ConfigValueFloat{Value: dummy_float})

		names := []string{"dummy_string", "dummy_bool", "dummy_int", "dummy_float"}

		result, err := GetGlobalConfigItems(cfg, names)
		So(err, ShouldBeNil)
		for _, name := range names {
			So(result[name], ShouldNotBeEmpty)
		}
	})

	Convey("Try to get values of items not defined in Global Config", t, func() {
		cfg := plugin.NewPluginConfigType()
		cfg.AddItem("foo", ctypes.ConfigValueStr{Value: "foo"})
		names := []string{"foo1", "foo2"}
		result, err := GetGlobalConfigItems(cfg, names)
		So(err, ShouldNotBeNil)
		So(result, ShouldBeNil)
	})

	Convey("No item defined in Global Config", t, func() {
		cfg_empty := plugin.NewPluginConfigType()
		names := []string{"foo", "bar"}
		result, err := GetGlobalConfigItems(cfg_empty, names)
		So(err, ShouldNotBeNil)
		So(result, ShouldBeNil)
	})
}
Ejemplo n.º 10
0
func TestConfigItems(t *testing.T) {
	names := []string{"dummy_string", "dummy_bool", "dummy_int", "dummy_float"}

	Convey("Get values of configuration items with no error", t, func() {

		Convey("Source: global config", func() {
			//create global config and add item (different types)
			cfg := plugin.NewPluginConfigType()
			cfg.AddItem("dummy_string", ctypes.ConfigValueStr{Value: dummy_str})
			cfg.AddItem("dummy_bool", ctypes.ConfigValueBool{Value: dummy_bool})
			cfg.AddItem("dummy_int", ctypes.ConfigValueInt{Value: dummy_int})
			cfg.AddItem("dummy_float", ctypes.ConfigValueFloat{Value: dummy_float})

			result, err := GetConfigItems(cfg, names...)
			So(err, ShouldBeNil)
			for _, name := range names {
				So(result[name], ShouldNotBeEmpty)
			}
		})

		Convey("Source: metrics config", func() {
			// create metrics config
			config := cdata.NewNode()
			config.AddItem("dummy_string", ctypes.ConfigValueStr{Value: dummy_str})
			config.AddItem("dummy_bool", ctypes.ConfigValueBool{Value: dummy_bool})
			config.AddItem("dummy_int", ctypes.ConfigValueInt{Value: dummy_int})
			config.AddItem("dummy_float", ctypes.ConfigValueFloat{Value: dummy_float})

			// create metric and set config
			metric := plugin.MetricType{}
			metric.Config_ = config

			result, err := GetConfigItems(metric, names...)
			So(err, ShouldBeNil)
			for _, name := range names {
				So(result[name], ShouldNotBeEmpty)
			}
		})
	})

	Convey("Try to get values of items from invalid config (unsupported type)", t, func() {
		invalid_cfg := []string{"invalid", "config", "source"}
		result, err := GetConfigItems(invalid_cfg, names...)
		So(err, ShouldNotBeNil)
		So(result, ShouldBeNil)
	})

}
func TestGetMetricTypes(t *testing.T) {
	Convey("When having two devices with known smart attribute", t, func() {

		Convey("And system lets you to list devices", func() {
			provider := &fakeSysutilProvider2{}

			orgProvider := sysUtilProvider
			sysUtilProvider = provider

			collector := SmartCollector{
				logger:           log.New(),
				initializedMutex: new(sync.Mutex),
				proc_path:        "/proc",
				dev_path:         "/dev",
			}

			Convey("Both devices should be present in metric list", func() {

				new_hier, is_dynamic := false, false
				metrics, err := collector.GetMetricTypes(plugin.NewPluginConfigType())
				So(err, ShouldBeNil)

				for _, m := range metrics {
					switch m.Namespace().Strings()[2] {
					case "smart":
						new_hier = true
					}
					switch m.Namespace().Strings()[3] {
					case "*":
						is_dynamic = true
					}
				}

				So(new_hier, ShouldBeTrue)
				So(is_dynamic, ShouldBeTrue)

			})

			Reset(func() {
				sysUtilProvider = orgProvider
			})

		})

	})

}
Ejemplo n.º 12
0
func TestConfigItem(t *testing.T) {

	Convey("Get a value of item with no error", t, func() {

		Convey("Source: global config", func() {
			//create global config and add item (different types)
			cfg := plugin.NewPluginConfigType()
			cfg.AddItem("dummy_string", ctypes.ConfigValueStr{Value: dummy_str})
			cfg.AddItem("dummy_bool", ctypes.ConfigValueBool{Value: dummy_bool})
			cfg.AddItem("dummy_int", ctypes.ConfigValueInt{Value: dummy_int})
			cfg.AddItem("dummy_float", ctypes.ConfigValueFloat{Value: dummy_float})

			Convey("string type of item", func() {
				result, err := GetConfigItem(cfg, "dummy_string")
				So(err, ShouldBeNil)
				So(result, ShouldEqual, dummy_str)
			})

			Convey("bool type of item", func() {
				result, err := GetConfigItem(cfg, "dummy_bool")
				So(err, ShouldBeNil)
				So(result, ShouldEqual, dummy_bool)
			})

			Convey("int type of item", func() {
				result, err := GetConfigItem(cfg, "dummy_int")
				So(err, ShouldBeNil)
				So(result, ShouldEqual, dummy_int)
			})

			Convey("float type of itemr", func() {
				result, err := GetConfigItem(cfg, "dummy_float")
				So(err, ShouldBeNil)
				So(result, ShouldEqual, dummy_float)
			})
		})

		Convey("Source: metrics config", func() {
			// create metric's config
			config := cdata.NewNode()
			config.AddItem("dummy_string", ctypes.ConfigValueStr{Value: dummy_str})
			config.AddItem("dummy_bool", ctypes.ConfigValueBool{Value: dummy_bool})
			config.AddItem("dummy_int", ctypes.ConfigValueInt{Value: dummy_int})
			config.AddItem("dummy_float", ctypes.ConfigValueFloat{Value: dummy_float})

			// create metric and set config
			metric := plugin.MetricType{}
			metric.Config_ = config

			Convey("string type of item", func() {
				result, err := GetConfigItem(metric, "dummy_string")
				So(err, ShouldBeNil)
				So(result, ShouldEqual, dummy_str)
			})

			Convey("bool type of item", func() {
				result, err := GetConfigItem(metric, "dummy_bool")
				So(err, ShouldBeNil)
				So(result, ShouldEqual, dummy_bool)
			})

			Convey("int type of item", func() {
				result, err := GetConfigItem(metric, "dummy_int")
				So(err, ShouldBeNil)
				So(result, ShouldEqual, dummy_int)
			})

			Convey("float type of item", func() {
				result, err := GetConfigItem(metric, "dummy_float")
				So(err, ShouldBeNil)
				So(result, ShouldEqual, dummy_float)
			})
		})
	})

	Convey("Try to get a value of item not defined in config", t, func() {

		Convey("Source: metrics config", func() {
			config := cdata.NewNode()
			config.AddItem("foo", ctypes.ConfigValueStr{Value: "foo_val"})
			metric := plugin.MetricType{}
			metric.Config_ = config
			result, err := GetMetricConfigItem(metric, "foo_not_exist")
			So(err, ShouldNotBeNil)
			So(result, ShouldBeNil)
		})

		Convey("Source: global config", func() {
			cfg := plugin.NewPluginConfigType()
			cfg.AddItem("foo", ctypes.ConfigValueStr{Value: "foo"})
			names := []string{"foo1", "foo2"}
			result, err := GetGlobalConfigItems(cfg, names)
			So(err, ShouldNotBeNil)
			So(result, ShouldBeNil)
		})
	})

	Convey("No item defined in config", t, func() {

		Convey("Source: metrics config", func() {
			metric := plugin.MetricType{}
			metric.Config_ = cdata.NewNode()
			result, err := GetMetricConfigItem(metric, "foo")
			So(err, ShouldNotBeNil)
			So(result, ShouldBeNil)
		})

		Convey("Source: global config", func() {
			cfg_empty := plugin.NewPluginConfigType()
			names := []string{"foo", "bar"}
			result, err := GetGlobalConfigItems(cfg_empty, names)
			So(err, ShouldNotBeNil)
			So(result, ShouldBeNil)
		})
	})

	Convey("Try to get a value of item from invalid config (unsupported type)", t, func() {
		invalid_cfg := []string{"invalid", "config", "source"}
		result, err := GetConfigItem(invalid_cfg, "foo")
		So(err, ShouldNotBeNil)
		So(result, ShouldBeNil)
	})
}
Ejemplo n.º 13
0
func TestHTTPJSONRPC(t *testing.T) {
	log.SetLevel(log.DebugLevel)
	addr, session := startHTTPJSONRPC()
	time.Sleep(time.Millisecond * 100)

	Convey("Collector Client", t, func() {
		session.c = true
		c, err := NewCollectorHttpJSONRPCClient(fmt.Sprintf("http://%v", addr), 1*time.Second, &key.PublicKey, true)
		So(err, ShouldBeNil)
		So(c, ShouldNotBeNil)
		cl := c.(*httpJSONRPCClient)
		cl.encrypter.Key = symkey

		Convey("Ping", func() {
			err := c.Ping()
			So(err, ShouldBeNil)
		})

		Convey("Kill", func() {
			err := c.Kill("somereason")
			So(err, ShouldBeNil)
		})

		Convey("GetMetricTypes", func() {
			cfg := plugin.NewPluginConfigType()
			cfg.AddItem("test", ctypes.ConfigValueBool{Value: true})
			mts, err := c.GetMetricTypes(cfg)
			So(err, ShouldBeNil)
			So(mts, ShouldNotBeNil)
			So(mts, ShouldHaveSameTypeAs, []core.Metric{})
			So(len(mts), ShouldBeGreaterThan, 0)
			So(len(mts[0].Config().Table()), ShouldBeGreaterThan, 0)
		})

		Convey("CollectMetrics provided a valid config", func() {
			cdn := cdata.NewNode()
			cdn.AddItem("someInt", ctypes.ConfigValueInt{Value: 1})
			cdn.AddItem("password", ctypes.ConfigValueStr{Value: "secure"})

			time.Sleep(500 * time.Millisecond)
			mts, err := c.CollectMetrics([]core.Metric{
				&plugin.MetricType{
					Namespace_: core.NewNamespace("foo", "bar"),
					Config_:    cdn,
				},
			})
			So(err, ShouldBeNil)
			So(mts, ShouldNotBeNil)
			So(mts, ShouldHaveSameTypeAs, []core.Metric{})
			So(len(mts), ShouldBeGreaterThan, 0)
			So(mts[0].Config().Table(), ShouldNotBeEmpty)
			So(mts[0].Config().Table()["someInt"].Type(), ShouldResemble, "integer")

			Convey("Get and process the ConfigPolicy", func() {
				cp, err := c.GetConfigPolicy()
				So(err, ShouldBeNil)
				So(cp, ShouldNotBeNil)
				So(cp.Get([]string{"foo", "bar"}), ShouldNotBeNil)
				node := cp.Get([]string{"foo", "bar"})
				So(node, ShouldNotBeNil)
				cpn, cserrs := node.Process(mts[0].Config().Table())
				So(cpn, ShouldNotBeNil)
				So((*cpn)["somefloat"].Type(), ShouldResemble, "float")
				So((*cpn)["somefloat"].(ctypes.ConfigValueFloat).Value, ShouldResemble, 3.14)
				So(cserrs.Errors(), ShouldBeEmpty)
			})
		})

		Convey("CollectMetrics provided an invalid config", func() {
			cdn := cdata.NewNode()
			cdn.AddItem("someInt", ctypes.ConfigValueInt{Value: 1})

			time.Sleep(500 * time.Millisecond)
			mts, err := c.CollectMetrics([]core.Metric{
				&plugin.MetricType{
					Namespace_: core.NewNamespace("foo", "bar"),
					Config_:    cdn,
				},
			})
			So(err, ShouldBeNil)
			So(mts, ShouldNotBeNil)
			So(mts, ShouldHaveSameTypeAs, []core.Metric{})
			So(len(mts), ShouldBeGreaterThan, 0)
			So(mts[0].Config().Table(), ShouldNotBeEmpty)
			So(mts[0].Config().Table()["someInt"].Type(), ShouldResemble, "integer")

			Convey("Get and process the ConfigPolicy", func() {
				cp, err := c.GetConfigPolicy()
				So(err, ShouldBeNil)
				So(cp, ShouldNotBeNil)
				node := cp.Get([]string{"foo", "bar"})
				So(node, ShouldNotBeNil)
				So(err, ShouldBeNil)
				_, cserrs := node.Process(mts[0].Config().Table())
				//So(cpn, ShouldBeNil)
				So(cserrs.Errors(), ShouldNotBeEmpty)
				So(len(cserrs.Errors()), ShouldEqual, 1)
				So(cserrs.Errors()[0].Error(), ShouldContainSubstring, "password")
			})
		})
	})
}
func TestGetMetricTypes(t *testing.T) {

	Convey("getting exposed metric types", t, func() {

		Convey("when no configuration item available", func() {
			cfg := plugin.NewPluginConfigType()
			dbiPlugin := New()
			So(func() { dbiPlugin.GetMetricTypes(cfg) }, ShouldNotPanic)
			results, err := dbiPlugin.GetMetricTypes(cfg)
			So(err, ShouldNotBeNil)
			So(results, ShouldBeNil)
		})

		Convey("when path to setfile is incorrect", func() {
			cfg := plugin.NewPluginConfigType()
			dbiPlugin := New()
			cfg.AddItem("setfile", ctypes.ConfigValueStr{Value: "./noFile.json"})
			So(func() { dbiPlugin.GetMetricTypes(cfg) }, ShouldNotPanic)
			results, err := dbiPlugin.GetMetricTypes(cfg)
			So(err, ShouldNotBeNil)
			So(results, ShouldBeNil)
		})

		Convey("when setfile is empty", func() {
			cfg := plugin.NewPluginConfigType()
			dbiPlugin := New()
			os.Create(mockdata.FileName)
			defer os.Remove(mockdata.FileName)
			cfg.AddItem("setfile", ctypes.ConfigValueStr{Value: mockdata.FileName})

			So(func() { dbiPlugin.GetMetricTypes(cfg) }, ShouldNotPanic)
			results, err := dbiPlugin.GetMetricTypes(cfg)
			So(err, ShouldNotBeNil)
			So(results, ShouldBeNil)
		})

		Convey("when there is wrong driver typed", func() {
			cfg := plugin.NewPluginConfigType()
			dbiPlugin := New()
			cfg.AddItem("setfile", ctypes.ConfigValueStr{Value: mockdata.SetfileIncorr})

			So(func() { dbiPlugin.GetMetricTypes(cfg) }, ShouldNotPanic)
			results, err := dbiPlugin.GetMetricTypes(cfg)
			So(err, ShouldNotBeNil)
			So(results, ShouldBeNil)
		})

		Convey("when cannot open db", func() {
			cfg := plugin.NewPluginConfigType()
			dbiPlugin := New()
			cfg.AddItem("setfile", ctypes.ConfigValueStr{Value: mockdata.SetfileCorr})
			mc := &mcMock{stmts: make(map[string]*sql.Stmt)}

			//mockExecution outputs
			mc.mockExecution(
				errors.New("x"), // errOpen
				nil,             // errClose
				nil,             // errPing
				nil,             // errSwitchToDB
				nil,             // errQuery
				map[string][]interface{}{}, // outQuery
			)

			So(func() { dbiPlugin.GetMetricTypes(cfg) }, ShouldNotPanic)
			results, err := dbiPlugin.GetMetricTypes(cfg)
			So(err, ShouldNotBeNil)
			So(results, ShouldBeEmpty)
		})

		Convey("when cannot open, neither close db", func() {
			cfg := plugin.NewPluginConfigType()
			dbiPlugin := New()
			//createMockFile(correct)
			//defer deleteMockFile()
			cfg.AddItem("setfile", ctypes.ConfigValueStr{Value: mockdata.SetfileCorr})
			mc := &mcMock{stmts: make(map[string]*sql.Stmt)}

			//mockExecution outputs
			mc.mockExecution(
				errors.New("x"), // errOpen
				errors.New("x"), // errClose
				nil,             // errPing
				nil,             // errSwitchToDB
				nil,             // errQuery
				map[string][]interface{}{}, // outQuery
			)

			So(func() { dbiPlugin.GetMetricTypes(cfg) }, ShouldNotPanic)
			results, err := dbiPlugin.GetMetricTypes(cfg)
			So(err, ShouldNotBeNil)
			So(results, ShouldBeEmpty)
		})

		Convey("when cannot ping the open db", func() {
			cfg := plugin.NewPluginConfigType()
			dbiPlugin := New()
			cfg.AddItem("setfile", ctypes.ConfigValueStr{Value: mockdata.SetfileCorr})
			mc := &mcMock{stmts: make(map[string]*sql.Stmt)}

			//mockExecution outputs
			mc.mockExecution(
				nil,             // errOpen
				nil,             // errClose
				errors.New("x"), // errPing
				nil,             // errSwitchToDB
				nil,             // errQuery
				map[string][]interface{}{}, // outQuery
			)

			So(func() { dbiPlugin.GetMetricTypes(cfg) }, ShouldNotPanic)
			results, err := dbiPlugin.GetMetricTypes(cfg)
			So(err, ShouldNotBeNil)
			So(results, ShouldBeEmpty)
		})

		Convey("when cannot switch to selected db", func() {
			cfg := plugin.NewPluginConfigType()
			dbiPlugin := New()
			cfg.AddItem("setfile", ctypes.ConfigValueStr{Value: mockdata.SetfileCorr})
			mc := &mcMock{stmts: make(map[string]*sql.Stmt)}

			//mockExecution outputs
			mc.mockExecution(
				nil,             // errOpen
				nil,             // errClose
				nil,             // errPing
				errors.New("x"), // errSwitchToDB
				nil,             // errQuery
				map[string][]interface{}{}, // outQuery
			)

			So(func() { dbiPlugin.GetMetricTypes(cfg) }, ShouldNotPanic)
			results, err := dbiPlugin.GetMetricTypes(cfg)
			So(err, ShouldNotBeNil)
			So(results, ShouldBeEmpty)
		})

		Convey("when execution of query returns error", func() {
			cfg := plugin.NewPluginConfigType()
			dbiPlugin := New()
			cfg.AddItem("setfile", ctypes.ConfigValueStr{Value: mockdata.SetfileCorr})
			mc := &mcMock{stmts: make(map[string]*sql.Stmt)}

			//mockExecution outputs
			mc.mockExecution(
				nil,                        // errOpen
				nil,                        // errClose
				nil,                        // errPing
				nil,                        // errSwitchToDB
				errors.New("x"),            // errQuery
				map[string][]interface{}{}, // outQuery
			)

			So(func() { dbiPlugin.GetMetricTypes(cfg) }, ShouldNotPanic)
			results, err := dbiPlugin.GetMetricTypes(cfg)
			So(err, ShouldNotBeNil)
			So(results, ShouldBeEmpty)
		})

		Convey("when query returns empty output", func() {
			cfg := plugin.NewPluginConfigType()
			dbiPlugin := New()
			cfg.AddItem("setfile", ctypes.ConfigValueStr{Value: mockdata.SetfileCorr})

			mc := &mcMock{stmts: make(map[string]*sql.Stmt)}

			//mockExecution outputs
			mc.mockExecution(
				nil, // errOpen
				nil, // errClose
				nil, // errPing
				nil, // errSwitchToDB
				nil, // errQuery
				map[string][]interface{}{}, // outQuery
			)

			So(func() { dbiPlugin.GetMetricTypes(cfg) }, ShouldNotPanic)
			results, err := dbiPlugin.GetMetricTypes(cfg)
			So(err, ShouldNotBeNil)
			So(results, ShouldBeEmpty)

		})

		Convey("successfully obtain metrics name", func() {
			cfg := plugin.NewPluginConfigType()
			dbiPlugin := New()
			cfg.AddItem("setfile", ctypes.ConfigValueStr{Value: mockdata.SetfileCorr})

			mc := &mcMock{stmts: make(map[string]*sql.Stmt)}

			// prepare mock output data of query execution
			mockQueryOut := mockdata.QueryOutput

			//mockExecution outputs
			mc.mockExecution(nil, nil, nil, nil, nil, mockQueryOut)

			So(func() { dbiPlugin.GetMetricTypes(cfg) }, ShouldNotPanic)
			results, err := dbiPlugin.GetMetricTypes(cfg)
			So(err, ShouldBeNil)
			So(results, ShouldNotBeEmpty)
		})

	})
}
func TestGetMetricTypes(t *testing.T) {
	// Testing GetMetricTypes function covers checking initialization of Ceph plugin

	// mock ceph socket
	os.Mkdir("test", os.ModePerm)
	os.Create("test/ceph-mds.a.asok")
	os.Create("test/ceph-mds.b.asok")
	os.Create("test/ceph-mds.c.asok")

	// set ceph socket conf value
	cfg := plugin.NewPluginConfigType()
	cfg.AddItem("socket_path", ctypes.ConfigValueStr{Value: "./test"})
	cfg.AddItem("socket_prefix", ctypes.ConfigValueStr{Value: "ceph-"})
	cfg.AddItem("socket_ext", ctypes.ConfigValueStr{Value: "asok"})

	Convey("init ceph plugin and getting metric namespace", t, func() {
		ceph := &Ceph{}
		cmd = &TestCmd{out: mockOut}
		So(func() { ceph.GetMetricTypes(cfg) }, ShouldNotPanic)
		result, err := ceph.GetMetricTypes(cfg)
		So(result, ShouldNotBeNil)
		So(err, ShouldBeNil)
	})

	Convey("getting metric namespace with error - perf dump output is not valid", t, func() {
		ceph := &Ceph{}
		cmd = &TestCmd{out: mockOutInvalid}
		So(func() { ceph.GetMetricTypes(cfg) }, ShouldNotPanic)
		result, err := ceph.GetMetricTypes(cfg)
		So(result, ShouldBeEmpty)
		So(err, ShouldNotBeNil)
	})

	Convey("getting metric namespace with error - perf dump execution error", t, func() {
		ceph := &Ceph{}
		cmd = &TestCmd{err: errors.New("execution error")}
		So(func() { ceph.GetMetricTypes(cfg) }, ShouldNotPanic)
		result, err := ceph.GetMetricTypes(cfg)
		So(result, ShouldBeEmpty)
		So(err, ShouldNotBeNil)
	})

	Convey("getting metric namespace with error - perf dump output is empty", t, func() {
		ceph := &Ceph{}
		moi := []byte(fmt.Sprintf("\n\n\n\n"))
		cmd = &TestCmd{out: moi}
		So(func() { ceph.GetMetricTypes(cfg) }, ShouldNotPanic)
		result, err := ceph.GetMetricTypes(cfg)
		So(result, ShouldBeEmpty)
		So(err, ShouldNotBeNil)
	})

	Convey("getting metric namespace with error - none perf dump output", t, func() {
		ceph := &Ceph{}
		cmd = &TestCmd{}
		So(func() { ceph.GetMetricTypes(cfg) }, ShouldNotPanic)
		result, err := ceph.GetMetricTypes(cfg)
		So(result, ShouldBeEmpty)
		So(err, ShouldNotBeNil)
	})

	Convey("invalid path to ceph-daemon sockets", t, func() {
		ceph := &Ceph{}
		cmd = &TestCmd{out: mockOut}
		cfg_invalid := plugin.NewPluginConfigType()
		cfg_invalid.AddItem("socket_path", ctypes.ConfigValueStr{Value: "./test_invalid"})
		cfg_invalid.AddItem("socket_prefix", ctypes.ConfigValueStr{Value: "ceph-"})
		cfg_invalid.AddItem("socket_ext", ctypes.ConfigValueStr{Value: "asok"})
		So(func() { ceph.GetMetricTypes(cfg_invalid) }, ShouldPanic)
	})

	Convey("no ceph-daemon sockets available with set prefix", t, func() {
		ceph := &Ceph{}
		cmd = &TestCmd{out: mockOut}
		cfg_inv_prefix := plugin.NewPluginConfigType()
		cfg_inv_prefix.AddItem("socket_path", ctypes.ConfigValueStr{Value: "./test"})
		cfg_inv_prefix.AddItem("socket_prefix", ctypes.ConfigValueStr{Value: "ceph_inv-"})
		So(func() { ceph.GetMetricTypes(cfg_inv_prefix) }, ShouldNotPanic)
		result, err := ceph.GetMetricTypes(cfg_inv_prefix)
		So(result, ShouldBeNil)
		So(err, ShouldNotBeNil)
	})

	Convey("no ceph-daemon sockets available with set extension", t, func() {
		ceph := &Ceph{}
		cmd = &TestCmd{out: mockOut}
		cfg_inv_ext := plugin.NewPluginConfigType()
		cfg_inv_ext.AddItem("socket_path", ctypes.ConfigValueStr{Value: "./test"})
		cfg_inv_ext.AddItem("socket_ext", ctypes.ConfigValueStr{Value: "asok_inv"})
		So(func() { ceph.GetMetricTypes(cfg_inv_ext) }, ShouldNotPanic)
		result, err := ceph.GetMetricTypes(cfg_inv_ext)
		So(result, ShouldBeNil)
		So(err, ShouldNotBeNil)
	})

	os.RemoveAll("test/")
}
Ejemplo n.º 16
0
func TestHTTPJSONRPC(t *testing.T) {
	log.SetLevel(log.DebugLevel)
	addr, session := startHTTPJSONRPC()
	time.Sleep(time.Millisecond * 100)

	Convey("Collector Client", t, func() {
		session.c = true
		c, err := NewCollectorHttpJSONRPCClient(fmt.Sprintf("http://%v", addr), 1*time.Second, &key.PublicKey, true)
		So(err, ShouldBeNil)
		So(c, ShouldNotBeNil)
		cl := c.(*httpJSONRPCClient)
		cl.encrypter.Key = symkey

		Convey("Ping", func() {
			err := c.Ping()
			So(err, ShouldBeNil)
		})

		Convey("Kill", func() {
			err := c.Kill("somereason")
			So(err, ShouldBeNil)
		})

		Convey("GetMetricTypes", func() {
			cfg := plugin.NewPluginConfigType()
			cfg.AddItem("test", ctypes.ConfigValueBool{Value: true})
			mts, err := c.GetMetricTypes(cfg)
			So(err, ShouldBeNil)
			So(mts, ShouldNotBeNil)
			So(mts, ShouldHaveSameTypeAs, []core.Metric{})
			So(len(mts), ShouldBeGreaterThan, 0)
			So(len(mts[0].Config().Table()), ShouldBeGreaterThan, 0)
		})

		Convey("CollectMetrics provided a valid config", func() {
			cdn := cdata.NewNode()
			cdn.AddItem("someInt", ctypes.ConfigValueInt{Value: 1})
			cdn.AddItem("password", ctypes.ConfigValueStr{Value: "secure"})

			time.Sleep(500 * time.Millisecond)
			mts, err := c.CollectMetrics([]core.Metric{
				&plugin.PluginMetricType{
					Namespace_: []string{"foo", "bar"},
					Config_:    cdn,
				},
			})
			So(err, ShouldBeNil)
			So(mts, ShouldNotBeNil)
			So(mts, ShouldHaveSameTypeAs, []core.Metric{})
			So(len(mts), ShouldBeGreaterThan, 0)
			So(mts[0].Config().Table(), ShouldNotBeEmpty)
			So(mts[0].Config().Table()["someInt"].Type(), ShouldResemble, "integer")

			Convey("Get and process the ConfigPolicy", func() {
				cp, err := c.GetConfigPolicy()
				So(err, ShouldBeNil)
				So(cp, ShouldNotBeNil)
				So(cp.Get([]string{"foo", "bar"}), ShouldNotBeNil)
				node := cp.Get([]string{"foo", "bar"})
				So(node, ShouldNotBeNil)
				cpn, cserrs := node.Process(mts[0].Config().Table())
				So(cpn, ShouldNotBeNil)
				So((*cpn)["somefloat"].Type(), ShouldResemble, "float")
				So((*cpn)["somefloat"].(*ctypes.ConfigValueFloat).Value, ShouldResemble, 3.14)
				So(cserrs.Errors(), ShouldBeEmpty)
			})
		})

		Convey("CollectMetrics provided an invalid config", func() {
			cdn := cdata.NewNode()
			cdn.AddItem("someInt", ctypes.ConfigValueInt{Value: 1})

			time.Sleep(500 * time.Millisecond)
			mts, err := c.CollectMetrics([]core.Metric{
				&plugin.PluginMetricType{
					Namespace_: []string{"foo", "bar"},
					Config_:    cdn,
				},
			})
			So(err, ShouldBeNil)
			So(mts, ShouldNotBeNil)
			So(mts, ShouldHaveSameTypeAs, []core.Metric{})
			So(len(mts), ShouldBeGreaterThan, 0)
			So(mts[0].Config().Table(), ShouldNotBeEmpty)
			So(mts[0].Config().Table()["someInt"].Type(), ShouldResemble, "integer")

			Convey("Get and process the ConfigPolicy", func() {
				cp, err := c.GetConfigPolicy()
				So(err, ShouldBeNil)
				So(cp, ShouldNotBeNil)
				node := cp.Get([]string{"foo", "bar"})
				So(node, ShouldNotBeNil)
				So(err, ShouldBeNil)
				_, cserrs := node.Process(mts[0].Config().Table())
				//So(cpn, ShouldBeNil)
				So(cserrs.Errors(), ShouldNotBeEmpty)
				So(len(cserrs.Errors()), ShouldEqual, 1)
				So(cserrs.Errors()[0].Error(), ShouldContainSubstring, "password")
			})
		})
	})

	Convey("Processor Client", t, func() {
		session.c = false
		p, _ := NewProcessorHttpJSONRPCClient(fmt.Sprintf("http://%v", addr), 1*time.Second, &key.PublicKey, true)
		cl := p.(*httpJSONRPCClient)
		cl.encrypter.Key = symkey
		So(p, ShouldNotBeNil)

		Convey("GetConfigPolicy", func() {
			cp, err := p.GetConfigPolicy()
			So(err, ShouldBeNil)
			So(cp, ShouldNotBeNil)
			cp_ := cpolicy.New()
			cpn_ := cpolicy.NewPolicyNode()
			r1, err := cpolicy.NewIntegerRule("SomeRequiredInt", true, 1)
			r2, _ := cpolicy.NewStringRule("password", true)
			r3, _ := cpolicy.NewFloatRule("somefloat", false, 3.14)
			So(err, ShouldBeNil)
			cpn_.Add(r1, r2, r3)
			cp_.Add([]string{""}, cpn_)
			cpjson, _ := cp.MarshalJSON()
			cp_json, _ := cp_.MarshalJSON()
			So(string(cpjson), ShouldResemble, string(cp_json))
		})

		Convey("Process metrics", func() {
			pmt := plugin.NewPluginMetricType([]string{"foo", "bar"}, time.Now(), "", nil, nil, 1)
			b, _ := json.Marshal([]plugin.PluginMetricType{*pmt})
			contentType, content, err := p.Process(plugin.SnapJSONContentType, b, nil)
			So(contentType, ShouldResemble, plugin.SnapJSONContentType)
			So(content, ShouldNotBeNil)
			So(err, ShouldEqual, nil)
			var pmts []plugin.PluginMetricType
			err = json.Unmarshal(content, &pmts)
			So(err, ShouldBeNil)
			So(len(pmts), ShouldEqual, 1)
			So(pmts[0].Data(), ShouldEqual, 1)
			So(pmts[0].Namespace(), ShouldResemble, []string{"foo", "bar"})
		})
	})

	Convey("Publisher Client", t, func() {
		session.c = false
		p, _ := NewPublisherHttpJSONRPCClient(fmt.Sprintf("http://%v", addr), 1*time.Second, &key.PublicKey, true)
		cl := p.(*httpJSONRPCClient)
		cl.encrypter.Key = symkey
		So(p, ShouldNotBeNil)

		Convey("GetConfigPolicy", func() {
			cp, err := p.GetConfigPolicy()
			So(err, ShouldBeNil)
			So(cp, ShouldNotBeNil)
			cp_ := cpolicy.New()
			cpn_ := cpolicy.NewPolicyNode()
			r1, err := cpolicy.NewIntegerRule("SomeRequiredInt", true, 1)
			r2, _ := cpolicy.NewStringRule("password", true)
			r3, _ := cpolicy.NewFloatRule("somefloat", false, 3.14)
			So(err, ShouldBeNil)
			cpn_.Add(r1, r2, r3)
			cp_.Add([]string{""}, cpn_)
			cpjson, _ := cp.MarshalJSON()
			cp_json, _ := cp_.MarshalJSON()
			So(string(cpjson), ShouldResemble, string(cp_json))
		})

		Convey("Publish metrics", func() {
			pmt := plugin.NewPluginMetricType([]string{"foo", "bar"}, time.Now(), "", nil, nil, 1)
			b, _ := json.Marshal([]plugin.PluginMetricType{*pmt})
			err := p.Publish(plugin.SnapJSONContentType, b, nil)
			So(err, ShouldBeNil)
		})

	})
}
func TestGetMetricTypes(t *testing.T) {

	Convey("initialization fails", t, func() {

		Convey("when no config items available", func() {
			influxdbPlugin := New()
			cfg := plugin.NewPluginConfigType()

			So(func() { influxdbPlugin.GetMetricTypes(cfg) }, ShouldPanic)
		})

		Convey("when one of config item is not available", func() {
			influxdbPlugin := New()
			cfg := plugin.NewPluginConfigType()
			cfg.DeleteItem("user")

			So(func() { influxdbPlugin.GetMetricTypes(cfg) }, ShouldPanic)
		})

		Convey("when config item has different type than expected", func() {
			influxdbPlugin := New()
			cfg := plugin.NewPluginConfigType()
			cfg.DeleteItem("port")
			cfg.AddItem("port", ctypes.ConfigValueStr{Value: "1234"})

			So(func() { influxdbPlugin.GetMetricTypes(cfg) }, ShouldPanic)
		})

		Convey("when initialization of URLs returns error", func() {
			mc := &mcMock{}
			influxdbPlugin := New()
			influxdbPlugin.service = mc
			cfg := plugin.NewPluginConfigType()

			mc.On("InitURLs").Return(errors.New("x"))

			So(func() { influxdbPlugin.GetMetricTypes(cfg) }, ShouldPanic)
		})

	})

	Convey("Metrics are not available", t, func() {

		Convey("when cannot obtain any data", func() {
			mc := &mcMock{}
			influxdbPlugin := New()
			influxdbPlugin.service = mc
			cfg := getMockPluginConfig()

			mc.On("InitURLs").Return(nil)
			mc.On("GetStatistics").Return(dtype.Results{}, errors.New("x"))
			mc.On("GetDiagnostics").Return(dtype.Results{}, errors.New("x"))

			So(func() { influxdbPlugin.GetMetricTypes(cfg) }, ShouldNotPanic)
			results, err := influxdbPlugin.GetMetricTypes(cfg)

			So(results, ShouldBeEmpty)
			So(err, ShouldBeNil)
		})

		Convey("when cannot obtain statictics data", func() {
			mc := &mcMock{}
			influxdbPlugin := New()
			influxdbPlugin.service = mc
			cfg := getMockPluginConfig()

			mc.On("InitURLs").Return(nil)
			mc.On("GetStatistics").Return(dtype.Results{}, errors.New("x"))
			mc.On("GetDiagnostics").Return(mockDiagn, nil)

			So(func() { influxdbPlugin.GetMetricTypes(cfg) }, ShouldNotPanic)
			results, err := influxdbPlugin.GetMetricTypes(cfg)

			So(results, ShouldNotBeEmpty)
			So(err, ShouldBeNil)
		})

		Convey("when cannot obtain diagnostics data", func() {
			mc := &mcMock{}
			influxdbPlugin := New()
			influxdbPlugin.service = mc
			cfg := getMockPluginConfig()

			mc.On("InitURLs").Return(nil)
			mc.On("GetStatistics").Return(mockStats, nil)
			mc.On("GetDiagnostics").Return(dtype.Results{}, errors.New("x"))

			So(func() { influxdbPlugin.GetMetricTypes(cfg) }, ShouldNotPanic)

			So(func() { influxdbPlugin.GetMetricTypes(cfg) }, ShouldNotPanic)
			results, err := influxdbPlugin.GetMetricTypes(cfg)

			So(results, ShouldNotBeEmpty)
			So(err, ShouldBeNil)
		})
	})

	Convey("successfull getting metrics types", t, func() {
		mc := &mcMock{}
		influxdbPlugin := New()
		influxdbPlugin.service = mc
		cfg := getMockPluginConfig()

		mc.On("InitURLs").Return(nil)
		mc.On("GetStatistics").Return(mockStats, nil)
		mc.On("GetDiagnostics").Return(mockDiagn, nil)

		So(func() { influxdbPlugin.GetMetricTypes(cfg) }, ShouldNotPanic)

		So(func() { influxdbPlugin.GetMetricTypes(cfg) }, ShouldNotPanic)
		results, err := influxdbPlugin.GetMetricTypes(cfg)

		So(results, ShouldNotBeEmpty)
		So(err, ShouldBeNil)
	})

}