func TestHANAPublish(t *testing.T) { var buf bytes.Buffer metrics := []plugin.PluginMetricType{ *plugin.NewPluginMetricType([]string{"test_string"}, time.Now(), "", "example_string"), *plugin.NewPluginMetricType([]string{"test_int"}, time.Now(), "", 1), *plugin.NewPluginMetricType([]string{"test_string_slice"}, time.Now(), "", []string{"str1", "str2"}), *plugin.NewPluginMetricType([]string{"test_string_slice"}, time.Now(), "", []int{1, 2}), *plugin.NewPluginMetricType([]string{"test_uint8"}, time.Now(), "", uint8(1)), } config := make(map[string]ctypes.ConfigValue) enc := gob.NewEncoder(&buf) enc.Encode(metrics) Convey("TestHANAPublish", t, func() { config["username"] = ctypes.ConfigValueStr{Value: "root"} config["password"] = ctypes.ConfigValueStr{Value: "root"} config["database"] = ctypes.ConfigValueStr{Value: "SNAP_TEST"} config["host"] = ctypes.ConfigValueStr{Value: "localhost"} config["port"] = ctypes.ConfigValueStr{Value: "1433"} config["table name"] = ctypes.ConfigValueStr{Value: "info"} sp := NewHANAPublisher() cp, _ := sp.GetConfigPolicy() cfg, _ := cp.Get([]string{""}).Process(config) err := sp.Publish("", buf.Bytes(), *cfg) Convey("So not passing in a content type should result in an error", func() { So(err, ShouldResemble, errors.New("Unknown content type ''")) }) err = sp.Publish(plugin.SnapGOBContentType, buf.Bytes(), *cfg) Convey("So publishing metrics should not result in an error", func() { So(err, ShouldBeNil) }) }) }
// integration test func TestRiemannPublish(t *testing.T) { // This integration test requires a Riemann Server broker := os.Getenv("SNAP_TEST_RIEMANN") if broker == "" { fmt.Println("Skipping integration tests") return } var buf bytes.Buffer buf.Reset() r := NewRiemannPublisher() config := make(map[string]ctypes.ConfigValue) config["broker"] = ctypes.ConfigValueStr{Value: broker} cp, _ := r.GetConfigPolicy() cfg, _ := cp.Get([]string{""}).Process(config) metrics := []plugin.PluginMetricType{ *plugin.NewPluginMetricType([]string{"intel", "cpu", "temp"}, time.Now(), "bacon-powered", nil, nil, 100), } enc := gob.NewEncoder(&buf) enc.Encode(metrics) err := r.Publish(plugin.SnapGOBContentType, buf.Bytes(), *cfg) Convey("Publish metric to Riemann", t, func() { Convey("So err should not be returned", func() { So(err, ShouldBeNil) }) Convey("So metric retrieved equals metric published", func() { c, _ := raidman.Dial("tcp", broker) events, _ := c.Query("host = \"bacon-powered\"") So(len(events), ShouldBeGreaterThan, 0) }) }) }
func TestPostgreSQLPublish(t *testing.T) { var buf bytes.Buffer //mock.ExpectBegin() expTime := time.Now() metrics := []plugin.PluginMetricType{ *plugin.NewPluginMetricType([]string{"test_string"}, expTime, "", nil, nil, "example_string"), *plugin.NewPluginMetricType([]string{"test_int"}, expTime, "", nil, nil, 1), *plugin.NewPluginMetricType([]string{"test_int"}, expTime, "", nil, nil, true), *plugin.NewPluginMetricType([]string{"test_float"}, expTime, "", nil, nil, 1.12), *plugin.NewPluginMetricType([]string{"test_string_slice"}, expTime, "", nil, nil, []string{"str1", "str2"}), *plugin.NewPluginMetricType([]string{"test_string_slice"}, expTime, "", nil, nil, []int{1, 2}), *plugin.NewPluginMetricType([]string{"test_uint8"}, expTime, "", nil, nil, uint8(1)), } config := make(map[string]ctypes.ConfigValue) enc := gob.NewEncoder(&buf) enc.Encode(metrics) Convey("TestPostgreSQLPublish", t, func() { config["hostname"] = ctypes.ConfigValueStr{Value: "localhost"} config["port"] = ctypes.ConfigValueInt{Value: 5432} config["username"] = ctypes.ConfigValueStr{Value: "postgres"} config["password"] = ctypes.ConfigValueStr{Value: ""} config["database"] = ctypes.ConfigValueStr{Value: "snap_test"} config["table_name"] = ctypes.ConfigValueStr{Value: "info"} sp := NewPostgreSQLPublisher() So(sp, ShouldNotBeNil) err := sp.Publish("", buf.Bytes(), config) So(err, ShouldResemble, errors.New("Unknown content type ''")) err = sp.Publish(plugin.SnapGOBContentType, buf.Bytes(), config) meta := Meta() So(meta, ShouldNotBeNil) }) }
func TestPublishMetrics(t *testing.T) { Convey("Given an available file publisher plugin", t, func() { // adjust HB timeouts for test plugin.PingTimeoutLimit = 1 plugin.PingTimeoutDurationDefault = time.Second * 1 // Create controller config := NewConfig() c := New(OptSetConfig(config)) lpe := newListenToPluginEvent() c.eventManager.RegisterHandler("TestPublishMetrics", lpe) c.pluginRunner.(*runner).monitor.duration = time.Millisecond * 100 c.Start() time.Sleep(1 * time.Second) // Load plugin _, err := load(c, path.Join(SnapPath, "plugin", "snap-publisher-file")) <-lpe.done So(err, ShouldBeNil) So(len(c.pluginManager.all()), ShouldEqual, 1) lp, err2 := c.pluginManager.get("publisher:file:3") So(err2, ShouldBeNil) So(lp.Name(), ShouldResemble, "file") So(lp.ConfigPolicy, ShouldNotBeNil) Convey("Subscribe to file publisher with good config", func() { n := cdata.NewNode() config.Plugins.Publisher.Plugins[lp.Name()] = newPluginConfigItem(optAddPluginConfigItem("file", ctypes.ConfigValueStr{Value: "/tmp/snap-TestPublishMetrics.out"})) pool, errp := c.pluginRunner.AvailablePlugins().getOrCreatePool("publisher:file:3") So(errp, ShouldBeNil) pool.subscribe("1", unboundSubscriptionType) err := c.pluginRunner.runPlugin(lp.Details) So(err, ShouldBeNil) time.Sleep(2500 * time.Millisecond) Convey("Publish to file", func() { metrics := []plugin.PluginMetricType{ *plugin.NewPluginMetricType([]string{"foo"}, time.Now(), "", nil, nil, 1), } var buf bytes.Buffer enc := gob.NewEncoder(&buf) enc.Encode(metrics) contentType := plugin.SnapGOBContentType errs := c.PublishMetrics(contentType, buf.Bytes(), "file", 3, n.Table()) So(errs, ShouldBeNil) ap := c.AvailablePlugins() So(ap, ShouldNotBeEmpty) }) }) c.Stop() time.Sleep(100 * time.Millisecond) }) }
func TestOpentsdbPublish(t *testing.T) { config := make(map[string]ctypes.ConfigValue) Convey("Snap Plugin integration testing with OpenTSDB", t, func() { var buf bytes.Buffer buf.Reset() enc := gob.NewEncoder(&buf) config["host"] = ctypes.ConfigValueStr{Value: os.Getenv("SNAP_OPENTSDB_HOST")} config["port"] = ctypes.ConfigValueInt{Value: 4242} op := NewOpentsdbPublisher() cp, _ := op.GetConfigPolicy() cfg, _ := cp.Get([]string{""}).Process(config) Convey("Publish float metrics to OpenTSDB", func() { metrics := []plugin.PluginMetricType{ *plugin.NewPluginMetricType([]string{"/psutil/load/load15"}, time.Now(), "mac1", nil, nil, 23.1), *plugin.NewPluginMetricType([]string{"/psutil/vm/available"}, time.Now().Add(2*time.Second), "mac2", nil, nil, 23.2), *plugin.NewPluginMetricType([]string{"/psutil/load/load1"}, time.Now().Add(3*time.Second), "linux3", nil, nil, 23.3), } enc.Encode(metrics) err := op.Publish(plugin.SnapGOBContentType, buf.Bytes(), *cfg) So(err, ShouldBeNil) }) Convey("Publish int metrics to OpenTSDB", func() { metrics := []plugin.PluginMetricType{ *plugin.NewPluginMetricType([]string{"/psutil/vm/free"}, time.Now().Add(5*time.Second), "linux7", nil, nil, 23), } enc.Encode(metrics) err := op.Publish(plugin.SnapGOBContentType, buf.Bytes(), *cfg) So(err, ShouldBeNil) }) }) }
func TestMySQLPublish(t *testing.T) { var buf bytes.Buffer metrics := []plugin.PluginMetricType{ *plugin.NewPluginMetricType([]string{"test", "string"}, time.Now(), "127.0.0.1", nil, nil, "example_string"), *plugin.NewPluginMetricType([]string{"test", "int"}, time.Now(), "127.0.0.1", nil, nil, 1), *plugin.NewPluginMetricType([]string{"test", "string", "slice"}, time.Now(), "localhost", nil, nil, []string{"str1", "str2"}), *plugin.NewPluginMetricType([]string{"test", "string", "slice"}, time.Now(), "localhost", nil, nil, []int{1, 2}), } config := make(map[string]ctypes.ConfigValue) enc := gob.NewEncoder(&buf) enc.Encode(metrics) config["username"] = ctypes.ConfigValueStr{Value: "root"} config["password"] = ctypes.ConfigValueStr{Value: ""} config["database"] = ctypes.ConfigValueStr{Value: "snap_test"} config["tablename"] = ctypes.ConfigValueStr{Value: "info"} mp := NewMySQLPublisher() cp, _ := mp.GetConfigPolicy() cfg, _ := cp.Get([]string{""}).Process(config) Convey("Publish metrics to MySQL instance should succeed and not throw an error", t, func() { err := mp.Publish(plugin.SnapGOBContentType, buf.Bytes(), *cfg) So(err, ShouldBeNil) }) }
// Collect collects metrics from external binary a returns them in form // acceptable by Snap, only returns collects that were asked for and return nothing when asked for none // the order of requested and received metrics isn't guaranted func (f *Facter) CollectMetrics(metricTypes []plugin.PluginMetricType) ([]plugin.PluginMetricType, error) { // parse and check requested names of metrics names := []string{} for _, metricType := range metricTypes { namespace := metricType.Namespace() err := validateNamespace(namespace) if err != nil { return nil, err } // name of fact - last part of namespace name := namespace[2] names = append(names, name) } if len(names) == 0 { // nothing request, none returned // !because returned by value, it would return nil slice return nil, nil } // facts composed of entries facts, err := f.getFacts(names, f.facterTimeout, nil) if err != nil { return nil, err } // make sure that recevied len of names equals asked if len(facts) != len(names) { return nil, errors.New("assertion: getFacts returns more/less than asked!") } host, _ := os.Hostname() // convert facts into PluginMetrics metrics := make([]plugin.PluginMetricType, 0, len(facts)) for name, value := range facts { namespace := createNamespace(name) metric := *plugin.NewPluginMetricType(namespace, time.Now(), host, nil, nil, value) metrics = append(metrics, metric) } return metrics, nil }
func (m *mockCollectorProxy) CollectMetrics(args []byte, reply *[]byte) error { rand.Seed(time.Now().Unix()) var dargs plugin.CollectMetricsArgs err := m.e.Decode(args, &dargs) if err != nil { return err } var mts []plugin.PluginMetricType for _, i := range dargs.PluginMetricTypes { p := plugin.NewPluginMetricType(i.Namespace(), time.Now(), "", nil, nil, rand.Intn(100)) p.Config_ = i.Config() mts = append(mts, *p) } cmr := &plugin.CollectMetricsReply{PluginMetrics: mts} *reply, err = m.e.Encode(cmr) if err != nil { return err } return nil }
func TestFilePublish(t *testing.T) { var buf bytes.Buffer metrics := []plugin.PluginMetricType{ *plugin.NewPluginMetricType([]string{"foo"}, time.Now(), "", nil, nil, 99), } config := make(map[string]ctypes.ConfigValue) enc := gob.NewEncoder(&buf) enc.Encode(metrics) Convey("TestFilePublish", t, func() { config["file"] = ctypes.ConfigValueStr{Value: "/tmp/pub.out"} fp := NewFilePublisher() So(fp, ShouldNotBeNil) err := fp.Publish("", buf.Bytes(), config) So(err, ShouldResemble, errors.New("Unknown content type ''")) err = fp.Publish(plugin.SnapGOBContentType, buf.Bytes(), config) So(err, ShouldBeNil) _, err = os.Stat(config["file"].(ctypes.ConfigValueStr).Value) So(err, ShouldBeNil) meta := Meta() So(meta, ShouldNotBeNil) }) }
func TestInfluxPublish(t *testing.T) { config := make(map[string]ctypes.ConfigValue) Convey("snap plugin InfluxDB integration testing with Influx", t, func() { var buf bytes.Buffer config["host"] = ctypes.ConfigValueStr{Value: os.Getenv("SNAP_INFLUXDB_HOST")} config["port"] = ctypes.ConfigValueInt{Value: 8086} config["user"] = ctypes.ConfigValueStr{Value: "root"} config["password"] = ctypes.ConfigValueStr{Value: "root"} config["database"] = ctypes.ConfigValueStr{Value: "test"} config["debug"] = ctypes.ConfigValueBool{Value: false} config["log-level"] = ctypes.ConfigValueStr{Value: "debug"} ip := NewInfluxPublisher() cp, _ := ip.GetConfigPolicy() cfg, _ := cp.Get([]string{""}).Process(config) tags := map[string]string{"zone": "red"} labels := []core.Label{} Convey("Publish integer metric", func() { metrics := []plugin.PluginMetricType{ *plugin.NewPluginMetricType([]string{"foo"}, time.Now(), "127.0.0.1", tags, labels, 99), } buf.Reset() enc := gob.NewEncoder(&buf) enc.Encode(metrics) err := ip.Publish(plugin.SnapGOBContentType, buf.Bytes(), *cfg) So(err, ShouldBeNil) }) Convey("Publish float metric", func() { metrics := []plugin.PluginMetricType{ *plugin.NewPluginMetricType([]string{"bar"}, time.Now(), "127.0.0.1", tags, labels, 3.141), } buf.Reset() enc := gob.NewEncoder(&buf) enc.Encode(metrics) err := ip.Publish(plugin.SnapGOBContentType, buf.Bytes(), *cfg) So(err, ShouldBeNil) }) Convey("Publish string metric", func() { metrics := []plugin.PluginMetricType{ *plugin.NewPluginMetricType([]string{"qux"}, time.Now(), "127.0.0.1", tags, labels, "bar"), } buf.Reset() enc := gob.NewEncoder(&buf) enc.Encode(metrics) err := ip.Publish(plugin.SnapGOBContentType, buf.Bytes(), *cfg) So(err, ShouldBeNil) }) Convey("Publish boolean metric", func() { metrics := []plugin.PluginMetricType{ *plugin.NewPluginMetricType([]string{"baz"}, time.Now(), "127.0.0.1", tags, labels, true), } buf.Reset() enc := gob.NewEncoder(&buf) enc.Encode(metrics) err := ip.Publish(plugin.SnapGOBContentType, buf.Bytes(), *cfg) So(err, ShouldBeNil) }) Convey("Publish multiple metrics", func() { metrics := []plugin.PluginMetricType{ *plugin.NewPluginMetricType([]string{"foo"}, time.Now(), "127.0.0.1", tags, labels, 101), *plugin.NewPluginMetricType([]string{"bar"}, time.Now(), "127.0.0.1", tags, labels, 5.789), } buf.Reset() enc := gob.NewEncoder(&buf) enc.Encode(metrics) err := ip.Publish(plugin.SnapGOBContentType, buf.Bytes(), *cfg) So(err, ShouldBeNil) }) }) }
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 TestProcessMetrics(t *testing.T) { Convey("Given an available file processor plugin", t, func() { // adjust HB timeouts for test plugin.PingTimeoutLimit = 1 plugin.PingTimeoutDurationDefault = time.Second * 1 // Create controller c := New() lpe := newListenToPluginEvent() c.eventManager.RegisterHandler("TestProcessMetrics", lpe) c.pluginRunner.(*runner).monitor.duration = time.Millisecond * 100 c.Start() time.Sleep(1 * time.Second) c.Config.Plugins.Processor.Plugins["passthru"] = newPluginConfigItem(optAddPluginConfigItem("test", ctypes.ConfigValueBool{Value: true})) // Load plugin _, err := load(c, path.Join(SnapPath, "plugin", "snap-processor-passthru")) <-lpe.done So(err, ShouldBeNil) So(len(c.pluginManager.all()), ShouldEqual, 1) lp, err2 := c.pluginManager.get("processor:passthru:1") So(err2, ShouldBeNil) So(lp.Name(), ShouldResemble, "passthru") So(lp.ConfigPolicy, ShouldNotBeNil) Convey("Subscribe to passthru processor with good config", func() { n := cdata.NewNode() pool, errp := c.pluginRunner.AvailablePlugins().getOrCreatePool("processor:passthru:1") So(errp, ShouldBeNil) pool.subscribe("1", unboundSubscriptionType) err := c.pluginRunner.runPlugin(lp.Details) So(err, ShouldBeNil) time.Sleep(2500 * time.Millisecond) Convey("process metrics", func() { metrics := []plugin.PluginMetricType{ *plugin.NewPluginMetricType([]string{"foo"}, time.Now(), "", nil, nil, 1), } var buf bytes.Buffer enc := gob.NewEncoder(&buf) enc.Encode(metrics) contentType := plugin.SnapGOBContentType _, ct, errs := c.ProcessMetrics(contentType, buf.Bytes(), "passthru", 1, n.Table()) So(errs, ShouldBeEmpty) mts := []plugin.PluginMetricType{} dec := gob.NewDecoder(bytes.NewBuffer(ct)) err := dec.Decode(&mts) So(err, ShouldBeNil) So(mts[0].Data_, ShouldEqual, 2) So(errs, ShouldBeNil) }) }) Convey("Count()", func() { pmt := &pluginMetricTypes{} count := pmt.Count() So(count, ShouldResemble, 0) }) c.Stop() time.Sleep(100 * time.Millisecond) }) }
func TestPostgresPublish(t *testing.T) { config := make(map[string]ctypes.ConfigValue) Convey("Snap Plugin PostgreSQL integration testing with PostgreSQL", t, func() { var buf bytes.Buffer config["hostname"] = ctypes.ConfigValueStr{Value: os.Getenv("SNAP_POSTGRESQL_HOST")} config["port"] = ctypes.ConfigValueInt{Value: 5432} config["username"] = ctypes.ConfigValueStr{Value: "postgres"} config["password"] = ctypes.ConfigValueStr{Value: ""} config["database"] = ctypes.ConfigValueStr{Value: "snap_test"} config["table_name"] = ctypes.ConfigValueStr{Value: "info"} ip := NewPostgreSQLPublisher() cp, _ := ip.GetConfigPolicy() cfg, _ := cp.Get([]string{""}).Process(config) Convey("Publish integer metric", func() { metrics := []plugin.PluginMetricType{ *plugin.NewPluginMetricType([]string{"foo"}, time.Now(), "", nil, nil, 99), } buf.Reset() enc := gob.NewEncoder(&buf) enc.Encode(metrics) err := ip.Publish(plugin.SnapGOBContentType, buf.Bytes(), *cfg) So(err, ShouldBeNil) }) Convey("Publish float metric", func() { metrics := []plugin.PluginMetricType{ *plugin.NewPluginMetricType([]string{"bar"}, time.Now(), "", nil, nil, 3.141), } buf.Reset() enc := gob.NewEncoder(&buf) enc.Encode(metrics) err := ip.Publish(plugin.SnapGOBContentType, buf.Bytes(), *cfg) So(err, ShouldBeNil) }) Convey("Publish string metric", func() { metrics := []plugin.PluginMetricType{ *plugin.NewPluginMetricType([]string{"qux"}, time.Now(), "", nil, nil, "bar"), } buf.Reset() enc := gob.NewEncoder(&buf) enc.Encode(metrics) err := ip.Publish(plugin.SnapGOBContentType, buf.Bytes(), *cfg) So(err, ShouldBeNil) }) Convey("Publish boolean metric", func() { metrics := []plugin.PluginMetricType{ *plugin.NewPluginMetricType([]string{"baz"}, time.Now(), "", nil, nil, true), } buf.Reset() enc := gob.NewEncoder(&buf) enc.Encode(metrics) err := ip.Publish(plugin.SnapGOBContentType, buf.Bytes(), *cfg) So(err, ShouldBeNil) }) Convey("Publish multiple metrics", func() { metrics := []plugin.PluginMetricType{ *plugin.NewPluginMetricType([]string{"foo"}, time.Now(), "", nil, nil, 101), *plugin.NewPluginMetricType([]string{"bar"}, time.Now(), "", nil, nil, 5.789), } buf.Reset() enc := gob.NewEncoder(&buf) enc.Encode(metrics) err := ip.Publish(plugin.SnapGOBContentType, buf.Bytes(), *cfg) So(err, ShouldBeNil) }) }) }