From e87510fe99a1fca76108d788b69e6aa47d28a958 Mon Sep 17 00:00:00 2001 From: Doug MacEachern Date: Wed, 17 Oct 2012 16:51:26 -0700 Subject: [PATCH] migrate from 'assert' to 'gocheck' for unit tests Change-Id: I26c47429b7f83d22bd7893d82c00a07115e8066f --- api_test.go | 122 +++++++++++++++------------ cli_test.go | 41 ++++----- configmanager_test.go | 111 +++++++++++++------------ control_test.go | 160 +++++++++++++++++------------------ eventmonitor_test.go | 179 +++++++++++++++++++++------------------- gonit_test.go | 10 ++- log_test.go | 44 +++++----- process_test.go | 131 +++++++++++++++-------------- resourcemanager_test.go | 92 +++++++++++---------- rpc_test.go | 47 ++++++----- test/helper/helper.go | 8 -- 11 files changed, 497 insertions(+), 448 deletions(-) diff --git a/api_test.go b/api_test.go index 5417825..4137f86 100644 --- a/api_test.go +++ b/api_test.go @@ -4,10 +4,11 @@ package gonit_test import ( "bytes" - "github.com/bmizerany/assert" + "flag" . "github.com/cloudfoundry/gonit" "github.com/cloudfoundry/gonit/test/helper" "io/ioutil" + . "launchpad.net/gocheck" "math" "net/rpc" "os" @@ -15,6 +16,19 @@ import ( "testing" ) +type ApiSuite struct{} + +var _ = Suite(&ApiSuite{}) + +// Hook up gocheck into the gotest runner. +func Test(t *testing.T) { + // propagate 'go test -v' to '-gocheck.v' + if flag.Lookup("test.v").Value.String() == "true" { + flag.Lookup("gocheck.v").Value.Set("true") + } + TestingT(t) +} + var rpcName = "TestAPI" var config = &ConfigManager{} @@ -26,71 +40,71 @@ func isActionError(err error) bool { return strings.HasPrefix(err.Error(), "ActionError") } -func TestActionsNoConfig(t *testing.T) { - err := helper.WithRpcServer(func(c *rpc.Client) { +func (s *ApiSuite) TestActionsNoConfig(c *C) { + err := helper.WithRpcServer(func(client *rpc.Client) { reply := &ActionResult{} - err := c.Call(rpcName+".StartAll", "", reply) - assert.Equal(t, nil, err) + err := client.Call(rpcName+".StartAll", "", reply) + c.Check(err, IsNil) // Total == 0 since no processes are configured - assert.Equal(t, 0, reply.Total) - assert.Equal(t, 0, reply.Errors) + c.Check(0, Equals, reply.Total) + c.Check(0, Equals, reply.Errors) reply = &ActionResult{} - err = c.Call(rpcName+".StartProcess", "foo", reply) - assert.NotEqual(t, nil, err) - assert.Equal(t, true, isActionError(err)) + err = client.Call(rpcName+".StartProcess", "foo", reply) + c.Check(err, NotNil) + c.Check(true, Equals, isActionError(err)) reply = &ActionResult{} - err = c.Call(rpcName+".StartGroup", "bar", reply) - assert.NotEqual(t, nil, err) - assert.Equal(t, true, isActionError(err)) + err = client.Call(rpcName+".StartGroup", "bar", reply) + c.Check(err, NotNil) + c.Check(true, Equals, isActionError(err)) }) - assert.Equal(t, nil, err) + c.Check(err, IsNil) } -func TestAbout(t *testing.T) { - err := helper.WithRpcServer(func(c *rpc.Client) { +func (s *ApiSuite) TestAbout(c *C) { + err := helper.WithRpcServer(func(client *rpc.Client) { params := struct{}{} about := About{} - err := c.Call(rpcName+".About", ¶ms, &about) - assert.Equal(t, nil, err) + err := client.Call(rpcName+".About", ¶ms, &about) + c.Check(err, IsNil) - assert.Equal(t, VERSION, about.Version) + c.Check(VERSION, Equals, about.Version) // need not be same type, just requires same fields var gabout struct { Version string } - err = c.Call(rpcName+".About", ¶ms, &gabout) - assert.Equal(t, nil, err) + err = client.Call(rpcName+".About", ¶ms, &gabout) + c.Check(err, IsNil) - assert.Equal(t, VERSION, gabout.Version) + c.Check(VERSION, Equals, gabout.Version) }) - assert.Equal(t, nil, err) + c.Check(err, IsNil) } -func tmpPidFile(t *testing.T, pid int) string { +func tmpPidFile(c *C, pid int) string { file, err := ioutil.TempFile("", "api_test") if err != nil { - t.Error(err) + c.Error(err) } if err := WritePidFile(pid, file.Name()); err != nil { - t.Fatal(err) + c.Fatal(err) } return file.Name() } // simple exercise of CliFormatters -func testCliPrint(t *testing.T, value CliFormatter) { +func testCliPrint(c *C, value CliFormatter) { buf := new(bytes.Buffer) value.Print(buf) - assert.NotEqual(t, 0, buf.Len()) + c.Check(0, Not(Equals), buf.Len()) } -func TestStatus(t *testing.T) { +func (s *ApiSuite) TestStatus(c *C) { nprocesses := 0 type testProcess struct { @@ -127,7 +141,7 @@ func TestStatus(t *testing.T) { for _, group := range groups { for _, process := range group.processes { // write pidfile for use by process.IsRunning() - pidfile := tmpPidFile(t, process.pid) + pidfile := tmpPidFile(c, process.pid) defer os.Remove(pidfile) config.AddProcess(group.name, &Process{ @@ -139,55 +153,55 @@ func TestStatus(t *testing.T) { } } - err := helper.WithRpcServer(func(c *rpc.Client) { + err := helper.WithRpcServer(func(client *rpc.Client) { statusGroup := rpcName + ".StatusGroup" statusProcess := rpcName + ".StatusProcess" // should get an error if group does not exist - err := c.Call(statusGroup, "enogroup", &ProcessGroupStatus{}) - assert.NotEqual(t, nil, err) + err := client.Call(statusGroup, "enogroup", &ProcessGroupStatus{}) + c.Check(err, NotNil) // should get an error if process does not exist - err = c.Call(statusProcess, "enoprocess", &ProcessStatus{}) - assert.NotEqual(t, nil, err) + err = client.Call(statusProcess, "enoprocess", &ProcessStatus{}) + c.Check(err, NotNil) for _, group := range groups { gstat := &ProcessGroupStatus{} - err := c.Call(statusGroup, group.name, gstat) - assert.Equal(t, nil, err) - assert.Equal(t, len(group.processes), len(gstat.Group)) - testCliPrint(t, gstat) + err := client.Call(statusGroup, group.name, gstat) + c.Check(err, IsNil) + c.Check(len(group.processes), Equals, len(gstat.Group)) + testCliPrint(c, gstat) for _, process := range group.processes { stat := &ProcessStatus{} - err := c.Call(statusProcess, process.name, stat) - assert.Equal(t, nil, err) + err := client.Call(statusProcess, process.name, stat) + c.Check(err, IsNil) running := stat.Summary.Running - assert.Equal(t, process.running, running) - testCliPrint(t, stat) + c.Check(process.running, Equals, running) + testCliPrint(c, stat) if !running { continue } - assert.Equal(t, process.pid, stat.Pid) - assert.Equal(t, process.ppid, stat.State.Ppid) + c.Check(process.pid, Equals, stat.Pid) + c.Check(process.ppid, Equals, stat.State.Ppid) } } all := &ProcessGroupStatus{} - err = c.Call(rpcName+".StatusAll", "", all) - assert.Equal(t, nil, err) - assert.Equal(t, nprocesses, len(all.Group)) - testCliPrint(t, all) + err = client.Call(rpcName+".StatusAll", "", all) + c.Check(err, IsNil) + c.Check(nprocesses, Equals, len(all.Group)) + testCliPrint(c, all) summary := &Summary{} - err = c.Call(rpcName+".Summary", "", summary) - assert.Equal(t, nil, err) - assert.Equal(t, nprocesses, len(summary.Processes)) - testCliPrint(t, summary) + err = client.Call(rpcName+".Summary", "", summary) + c.Check(err, IsNil) + c.Check(nprocesses, Equals, len(summary.Processes)) + testCliPrint(c, summary) }) - assert.Equal(t, nil, err) + c.Check(err, IsNil) } diff --git a/cli_test.go b/cli_test.go index aaf5adc..c7a1a94 100644 --- a/cli_test.go +++ b/cli_test.go @@ -4,13 +4,16 @@ package gonit_test import ( "fmt" - "github.com/bmizerany/assert" . "github.com/cloudfoundry/gonit" "github.com/cloudfoundry/gonit/test/helper" + . "launchpad.net/gocheck" "net/rpc" - "testing" ) +type CliSuite struct{} + +var _ = Suite(&CliSuite{}) + var mockAPI = &MockAPI{api: &API{}} func init() { @@ -44,49 +47,49 @@ func (m *MockAPI) About(args interface{}, about *About) error { } // run tests via RPC or local reflection -func runTests(t *testing.T, client CliClient) { +func runTests(c *C, client CliClient) { method, name := RpcArgs("stop", "foo", false) _, err := client.Call(method, name) - assert.Equal(t, nil, err) + c.Check(err, IsNil) method, name = RpcArgs("stop", "bar", false) _, err = client.Call(method, name) - assert.NotEqual(t, nil, err) + c.Check(err, NotNil) method, name = RpcArgs("unmonitor", "all", false) _, err = client.Call(method, name) - assert.Equal(t, nil, err) + c.Check(err, IsNil) method, name = RpcArgs("start", "vcap", true) _, err = client.Call(method, name) - assert.Equal(t, nil, err) + c.Check(err, IsNil) method, name = RpcArgs("start", "bar", true) _, err = client.Call(method, name) - assert.NotEqual(t, nil, err) + c.Check(err, NotNil) method, name = RpcArgs("about", "", false) reply, err := client.Call(method, name) - assert.Equal(t, nil, err) + c.Check(err, IsNil) about, ok := reply.(*About) - assert.Equal(t, true, ok) - assert.Equal(t, VERSION, about.Version) + c.Check(true, Equals, ok) + c.Check(VERSION, Equals, about.Version) reply, err = client.Call("ENOENT", "") - assert.NotEqual(t, nil, err) + c.Check(err, NotNil) } -func TestRemote(t *testing.T) { - err := helper.WithRpcServer(func(c *rpc.Client) { - client := NewRemoteClient(c, mockAPI) - runTests(t, client) +func (s *CliSuite) TestRemote(c *C) { + err := helper.WithRpcServer(func(rc *rpc.Client) { + client := NewRemoteClient(rc, mockAPI) + runTests(c, client) }) - assert.Equal(t, nil, err) + c.Check(err, IsNil) } -func TestLocal(t *testing.T) { +func (s *CliSuite) TestLocal(c *C) { client := NewLocalClient(mockAPI) - runTests(t, client) + runTests(c, client) } diff --git a/configmanager_test.go b/configmanager_test.go index 9b885fe..77297c2 100644 --- a/configmanager_test.go +++ b/configmanager_test.go @@ -3,83 +3,86 @@ package gonit import ( - "github.com/bmizerany/assert" "io/ioutil" + . "launchpad.net/gocheck" "os" - "testing" ) -func assertFileParsed(t *testing.T, configManager *ConfigManager) { - assert.Equal(t, 1, len(configManager.ProcessGroups)) +type ConfigSuite struct{} + +var _ = Suite(&ConfigSuite{}) + +func assertFileParsed(c *C, configManager *ConfigManager) { + c.Check(1, Equals, len(configManager.ProcessGroups)) pg := configManager.ProcessGroups["dashboard"] - assert.NotEqual(t, ProcessGroup{}, pg) - assert.Equal(t, "dashboard", pg.Name) + c.Check(ProcessGroup{}, Not(Equals), pg) + c.Check("dashboard", Equals, pg.Name) - assert.Equal(t, 4, len(pg.Events)) + c.Check(4, Equals, len(pg.Events)) opentsdb := pg.Processes["opentsdb"] - assert.NotEqual(t, Process{}, opentsdb) + c.Check(Process{}, Not(Equals), opentsdb) dashboard := pg.Processes["dashboard"] - assert.NotEqual(t, Process{}, dashboard) - assert.Equal(t, 2, len(opentsdb.Actions["alert"])) - assert.Equal(t, 1, len(opentsdb.Actions["restart"])) - assert.Equal(t, 1, len(dashboard.Actions["alert"])) - assert.Equal(t, "memory_used > 5mb", pg.EventByName("memory_over_5").Rule) - assert.Equal(t, (*Event)(nil), pg.EventByName("blah")) - - assert.Equal(t, "none", configManager.Settings.AlertTransport) - assert.NotEqual(t, "", configManager.Settings.RpcServerUrl) - assert.Equal(t, 0, configManager.Settings.PollInterval) - assert.NotEqual(t, nil, configManager.Settings.Daemon) - assert.Equal(t, "lolnit", configManager.Settings.Daemon.Name) - assert.NotEqual(t, nil, configManager.Settings.Logging) - assert.Equal(t, "debug", configManager.Settings.Logging.Level) + c.Check(Process{}, Not(Equals), dashboard) + c.Check(2, Equals, len(opentsdb.Actions["alert"])) + c.Check(1, Equals, len(opentsdb.Actions["restart"])) + c.Check(1, Equals, len(dashboard.Actions["alert"])) + c.Check("memory_used > 5mb", Equals, pg.EventByName("memory_over_5").Rule) + c.Check((*Event)(nil), Equals, pg.EventByName("blah")) + + c.Check("none", Equals, configManager.Settings.AlertTransport) + c.Check("", Not(Equals), configManager.Settings.RpcServerUrl) + c.Check(0, Equals, configManager.Settings.PollInterval) + c.Check(configManager.Settings.Daemon, NotNil) + c.Check("lolnit", Equals, configManager.Settings.Daemon.Name) + c.Check(configManager.Settings.Logging, NotNil) + c.Check("debug", Equals, configManager.Settings.Logging.Level) } -func TestGetPid(t *testing.T) { +func (s *ConfigSuite) TestGetPid(c *C) { file, err := ioutil.TempFile("", "pid") if err != nil { - t.Error(err) + c.Error(err) } path := file.Name() defer os.Remove(path) if _, err := file.Write([]byte("1234")); err != nil { - t.Fatal(err) + c.Fatal(err) } process := Process{Pidfile: file.Name()} process.Pidfile = file.Name() pid, err := process.Pid() if err != nil { - t.Fatal(err) + c.Fatal(err) } - assert.Equal(t, 1234, pid) + c.Check(1234, Equals, pid) } -func TestParseDir(t *testing.T) { +func (s *ConfigSuite) TestParseDir(c *C) { configManager := &ConfigManager{} err := configManager.LoadConfig("test/config/") if err != nil { - t.Fatal(err) + c.Fatal(err) } - assertFileParsed(t, configManager) + assertFileParsed(c, configManager) } -func TestNoSettingsLoadsDefaults(t *testing.T) { +func (s *ConfigSuite) TestNoSettingsLoadsDefaults(c *C) { configManager := &ConfigManager{} err := configManager.LoadConfig("test/config/dashboard-gonit.yml") if err != nil { - t.Fatal(err) + c.Fatal(err) } - assert.Equal(t, "none", configManager.Settings.AlertTransport) + c.Check("none", Equals, configManager.Settings.AlertTransport) } -func TestLoadBadDir(t *testing.T) { +func (s *ConfigSuite) TestLoadBadDir(c *C) { configManager := &ConfigManager{} err := configManager.LoadConfig("Bad/Dir") - assert.NotEqual(t, nil, err) - assert.Equal(t, "Error stating path 'Bad/Dir'.", err.Error()) + c.Check(err, NotNil) + c.Check("Error stating path 'Bad/Dir'.", Equals, err.Error()) } -func TestRequiredFieldsExist(t *testing.T) { +func (s *ConfigSuite) TestRequiredFieldsExist(c *C) { process := &Process{} processes := map[string]*Process{} processes["foobar"] = process @@ -88,23 +91,23 @@ func TestRequiredFieldsExist(t *testing.T) { eventsErr := "some_event must have name, description, rule, and actions." err := pg.validateRequiredFieldsExist() - assert.Equal(t, processErr, err.Error()) + c.Check(processErr, Equals, err.Error()) process.Name = "foobar" err = pg.validateRequiredFieldsExist() - assert.Equal(t, processErr, err.Error()) + c.Check(processErr, Equals, err.Error()) process.Description = "Some description." err = pg.validateRequiredFieldsExist() - assert.Equal(t, processErr, err.Error()) + c.Check(processErr, Equals, err.Error()) process.Pidfile = "pidfile" err = pg.validateRequiredFieldsExist() - assert.Equal(t, processErr, err.Error()) + c.Check(processErr, Equals, err.Error()) process.Start = "startscript" err = pg.validateRequiredFieldsExist() - assert.Equal(t, nil, nil) + c.Check(nil, IsNil) event := &Event{} events := map[string]*Event{} @@ -112,30 +115,30 @@ func TestRequiredFieldsExist(t *testing.T) { pg.Events = events err = pg.validateRequiredFieldsExist() - assert.Equal(t, eventsErr, err.Error()) + c.Check(eventsErr, Equals, err.Error()) event.Name = "some_event" err = pg.validateRequiredFieldsExist() - assert.Equal(t, eventsErr, err.Error()) + c.Check(eventsErr, Equals, err.Error()) event.Description = "some description" err = pg.validateRequiredFieldsExist() - assert.Equal(t, eventsErr, err.Error()) + c.Check(eventsErr, Equals, err.Error()) event.Rule = "some rule" err = pg.validateRequiredFieldsExist() - assert.Equal(t, nil, nil) + c.Check(nil, IsNil) } -func TestValidatePersistErr(t *testing.T) { - s := &Settings{PersistFile: "/does/not/exist"} - err := s.validatePersistFile() - assert.NotEqual(t, nil, err) +func (s *ConfigSuite) TestValidatePersistErr(c *C) { + settings := &Settings{PersistFile: "/does/not/exist"} + err := settings.validatePersistFile() + c.Check(err, NotNil) } -func TestValidatePersistGood(t *testing.T) { +func (s *ConfigSuite) TestValidatePersistGood(c *C) { persistFile := os.Getenv("PWD") + "/test/config/expected_persist_file.yml" - s := &Settings{PersistFile: persistFile} - err := s.validatePersistFile() - assert.Equal(t, nil, err) + settings := &Settings{PersistFile: persistFile} + err := settings.validatePersistFile() + c.Check(err, IsNil) } diff --git a/control_test.go b/control_test.go index 90214ea..9a43cdb 100644 --- a/control_test.go +++ b/control_test.go @@ -4,13 +4,16 @@ package gonit_test import ( "fmt" - "github.com/bmizerany/assert" . "github.com/cloudfoundry/gonit" "github.com/cloudfoundry/gonit/test/helper" + . "launchpad.net/gocheck" "os" - "testing" ) +type ControlSuite struct{} + +var _ = Suite(&ControlSuite{}) + var groupName = "controlTest" type FakeEventMonitor struct { @@ -27,50 +30,50 @@ func (fem *FakeEventMonitor) Start(configManager *ConfigManager, func (fem *FakeEventMonitor) Stop() {} -func TestActions(t *testing.T) { +func (s *ControlSuite) TestActions(c *C) { fem := &FakeEventMonitor{} configManager := &ConfigManager{Settings: &Settings{}} - c := &Control{ConfigManager: configManager, EventMonitor: fem} + ctl := &Control{ConfigManager: configManager, EventMonitor: fem} name := "simple" process := helper.NewTestProcess(name, nil, false) defer helper.Cleanup(process) - err := c.Config().AddProcess(groupName, process) - assert.Equal(t, nil, err) - assert.Equal(t, MONITOR_NOT, c.State(process).Monitor) - assert.Equal(t, 0, c.State(process).Starts) + err := ctl.Config().AddProcess(groupName, process) + c.Check(err, IsNil) + c.Check(MONITOR_NOT, Equals, ctl.State(process).Monitor) + c.Check(0, Equals, ctl.State(process).Starts) - rv := c.DoAction(name, ACTION_START) - assert.Equal(t, 1, fem.numStartMonitoringCalled) - assert.Equal(t, nil, rv) + rv := ctl.DoAction(name, ACTION_START) + c.Check(1, Equals, fem.numStartMonitoringCalled) + c.Check(rv, IsNil) - assert.Equal(t, MONITOR_INIT, c.State(process).Monitor) - assert.Equal(t, 1, c.State(process).Starts) + c.Check(MONITOR_INIT, Equals, ctl.State(process).Monitor) + c.Check(1, Equals, ctl.State(process).Starts) - assert.Equal(t, true, process.IsRunning()) + c.Check(true, Equals, process.IsRunning()) - rv = c.DoAction(name, ACTION_RESTART) - assert.Equal(t, 2, fem.numStartMonitoringCalled) - assert.Equal(t, nil, rv) + rv = ctl.DoAction(name, ACTION_RESTART) + c.Check(2, Equals, fem.numStartMonitoringCalled) + c.Check(rv, IsNil) - assert.Equal(t, 2, c.State(process).Starts) + c.Check(2, Equals, ctl.State(process).Starts) - rv = c.DoAction(name, ACTION_STOP) - assert.Equal(t, nil, rv) + rv = ctl.DoAction(name, ACTION_STOP) + c.Check(rv, IsNil) - assert.Equal(t, MONITOR_NOT, c.State(process).Monitor) + c.Check(MONITOR_NOT, Equals, ctl.State(process).Monitor) - rv = c.DoAction(name, ACTION_MONITOR) - assert.Equal(t, 3, fem.numStartMonitoringCalled) - assert.Equal(t, nil, rv) + rv = ctl.DoAction(name, ACTION_MONITOR) + c.Check(3, Equals, fem.numStartMonitoringCalled) + c.Check(rv, IsNil) - assert.Equal(t, MONITOR_INIT, c.State(process).Monitor) + c.Check(MONITOR_INIT, Equals, ctl.State(process).Monitor) } -func TestDepends(t *testing.T) { +func (s *ControlSuite) TestDepends(c *C) { configManager := &ConfigManager{Settings: &Settings{}} - c := &Control{ConfigManager: configManager, EventMonitor: &FakeEventMonitor{}} + ctl := &Control{ConfigManager: configManager, EventMonitor: &FakeEventMonitor{}} name := "depsimple" process := helper.NewTestProcess(name, nil, false) @@ -84,8 +87,8 @@ func TestDepends(t *testing.T) { dprocess := helper.NewTestProcess(dname, nil, false) defer helper.Cleanup(dprocess) - err := c.Config().AddProcess(groupName, dprocess) - assert.Equal(t, nil, err) + err := ctl.Config().AddProcess(groupName, dprocess) + c.Check(err, IsNil) if i%2 == 0 { process.DependsOn = append(process.DependsOn, dname) } else { @@ -93,98 +96,98 @@ func TestDepends(t *testing.T) { } } - err := c.Config().AddProcess(groupName, process) - assert.Equal(t, nil, err) + err := ctl.Config().AddProcess(groupName, process) + c.Check(err, IsNil) // start main process - rv := c.DoAction(name, ACTION_START) - assert.Equal(t, nil, rv) + rv := ctl.DoAction(name, ACTION_START) + c.Check(rv, IsNil) - assert.Equal(t, true, process.IsRunning()) + c.Check(true, Equals, process.IsRunning()) // stop main process - rv = c.DoAction(name, ACTION_STOP) - assert.Equal(t, nil, rv) - assert.Equal(t, false, process.IsRunning()) + rv = ctl.DoAction(name, ACTION_STOP) + c.Check(rv, IsNil) + c.Check(false, Equals, process.IsRunning()) // save pids to verify deps are not restarted var dpids = make([]int, len(process.DependsOn)) // dependencies should still be running for i, dname := range process.DependsOn { - dprocess, _ := c.Config().FindProcess(dname) - assert.Equal(t, true, dprocess.IsRunning()) + dprocess, _ := ctl.Config().FindProcess(dname) + c.Check(true, Equals, dprocess.IsRunning()) dpids[i], err = dprocess.Pid() - assert.Equal(t, nil, err) + c.Check(err, IsNil) } // check start count for main process and deps - assert.Equal(t, 1, c.State(process).Starts) + c.Check(1, Equals, ctl.State(process).Starts) for _, dname := range process.DependsOn { - dprocess, _ := c.Config().FindProcess(dname) - assert.NotEqual(t, nil, dprocess) - assert.Equal(t, 1, c.State(dprocess).Starts) + dprocess, _ := ctl.Config().FindProcess(dname) + c.Check(dprocess, NotNil) + c.Check(1, Equals, ctl.State(dprocess).Starts) } // other processes should not have been started for _, oname := range oprocesses { - oprocess, _ := c.Config().FindProcess(oname) - assert.NotEqual(t, nil, oprocess) - assert.Equal(t, 0, c.State(oprocess).Starts) + oprocess, _ := ctl.Config().FindProcess(oname) + c.Check(oprocess, NotNil) + c.Check(0, Equals, ctl.State(oprocess).Starts) } // test start/stop of dependant // start main sevice - rv = c.DoAction(name, ACTION_START) - assert.Equal(t, nil, rv) - assert.Equal(t, true, process.IsRunning()) - assert.Equal(t, 2, c.State(process).Starts) + rv = ctl.DoAction(name, ACTION_START) + c.Check(rv, IsNil) + c.Check(true, Equals, process.IsRunning()) + c.Check(2, Equals, ctl.State(process).Starts) // dependencies should still be running w/ same pids for i, dname := range process.DependsOn { - dprocess, _ := c.Config().FindProcess(dname) - assert.Equal(t, true, dprocess.IsRunning()) + dprocess, _ := ctl.Config().FindProcess(dname) + c.Check(true, Equals, dprocess.IsRunning()) pid, err := dprocess.Pid() - assert.Equal(t, nil, err) - assert.Equal(t, dpids[i], pid) + c.Check(err, IsNil) + c.Check(dpids[i], Equals, pid) } // stop a dependency - rv = c.DoAction(process.DependsOn[0], ACTION_STOP) - assert.Equal(t, nil, rv) + rv = ctl.DoAction(process.DependsOn[0], ACTION_STOP) + c.Check(rv, IsNil) // dependent will also stop - assert.Equal(t, false, process.IsRunning()) + c.Check(false, Equals, process.IsRunning()) // start a dependency - rv = c.DoAction(process.DependsOn[0], ACTION_START) - assert.Equal(t, nil, rv) + rv = ctl.DoAction(process.DependsOn[0], ACTION_START) + c.Check(rv, IsNil) // main process will come back up - assert.Equal(t, true, process.IsRunning()) + c.Check(true, Equals, process.IsRunning()) - c.DoAction(process.Name, ACTION_STOP) + ctl.DoAction(process.Name, ACTION_STOP) - assert.Equal(t, 3, c.State(process).Starts) + c.Check(3, Equals, ctl.State(process).Starts) - assert.Equal(t, MONITOR_NOT, c.State(process).Monitor) + c.Check(MONITOR_NOT, Equals, ctl.State(process).Monitor) // stop all dependencies for _, dname := range process.DependsOn { - c.DoAction(dname, ACTION_STOP) + ctl.DoAction(dname, ACTION_STOP) } // verify every process has been stopped - c.Config().VisitProcesses(func(p *Process) bool { - assert.Equal(t, false, p.IsRunning()) + ctl.Config().VisitProcesses(func(p *Process) bool { + c.Check(false, Equals, p.IsRunning()) return true }) } -func TestLoadPersistState(t *testing.T) { +func (s *ControlSuite) TestLoadPersistState(c *C) { configManager := &ConfigManager{Settings: &Settings{}} control := &Control{ConfigManager: configManager} testPersistFile := os.Getenv("PWD") + "/test/config/expected_persist_file.yml" @@ -196,12 +199,12 @@ func TestLoadPersistState(t *testing.T) { configManager.ProcessGroups = pgs configManager.Settings.PersistFile = testPersistFile control.LoadPersistState() - assert.NotEqual(t, nil, control.States["MyProcess"]) - assert.Equal(t, 2, control.States["MyProcess"].Starts) - assert.Equal(t, 2, control.States["MyProcess"].Monitor) + c.Check(control.States["MyProcess"], NotNil) + c.Check(2, Equals, control.States["MyProcess"].Starts) + c.Check(2, Equals, control.States["MyProcess"].Monitor) } -func TestPersistData(t *testing.T) { +func (s *ControlSuite) TestPersistData(c *C) { configManager := &ConfigManager{Settings: &Settings{}} control := &Control{ConfigManager: configManager} testPersistFile := os.Getenv("PWD") + "/test/config/test_persist_file.yml" @@ -214,16 +217,15 @@ func TestPersistData(t *testing.T) { configManager.ProcessGroups = pgs configManager.Settings.PersistFile = testPersistFile control.LoadPersistState() - var noState map[string]*ProcessState - assert.Equal(t, noState, control.States) + c.Check(control.States, IsNil) processState := &ProcessState{Monitor: 0x2, Starts: 3} states := map[string]*ProcessState{} states["MyProcess"] = processState err := control.PersistStates(states) - assert.Equal(t, nil, err) + c.Check(err, IsNil) err = control.LoadPersistState() - assert.Equal(t, nil, err) - assert.NotEqual(t, nil, control.States["MyProcess"]) - assert.Equal(t, 3, control.States["MyProcess"].Starts) - assert.Equal(t, 2, control.States["MyProcess"].Monitor) + c.Check(err, IsNil) + c.Check(control.States["MyProcess"], NotNil) + c.Check(3, Equals, control.States["MyProcess"].Starts) + c.Check(2, Equals, control.States["MyProcess"].Monitor) } diff --git a/eventmonitor_test.go b/eventmonitor_test.go index 08d16a5..68d9bd3 100644 --- a/eventmonitor_test.go +++ b/eventmonitor_test.go @@ -3,10 +3,13 @@ package gonit import ( - "github.com/bmizerany/assert" - "testing" + . "launchpad.net/gocheck" ) +type EventSuite struct{} + +var _ = Suite(&EventSuite{}) + var eventMonitor EventMonitor const TWO_GB = uint64(2147483648) @@ -21,32 +24,32 @@ func RegisterNewFakeControl() *FakeControl { return fc } -func TestIsAnOperatorChar(t *testing.T) { - assert.Equal(t, true, isAnOperatorChar("=")) - assert.Equal(t, true, isAnOperatorChar(">")) - assert.Equal(t, true, isAnOperatorChar("<")) - assert.Equal(t, false, isAnOperatorChar("!=")) - assert.Equal(t, false, isAnOperatorChar("==")) +func (s *EventSuite) TestIsAnOperatorChar(c *C) { + c.Check(true, Equals, isAnOperatorChar("=")) + c.Check(true, Equals, isAnOperatorChar(">")) + c.Check(true, Equals, isAnOperatorChar("<")) + c.Check(false, Equals, isAnOperatorChar("!=")) + c.Check(false, Equals, isAnOperatorChar("==")) } -func TestCompareUint64(t *testing.T) { +func (s *EventSuite) TestCompareUint64(c *C) { sixty := uint64(60) fiftyNine := uint64(59) - assert.Equal(t, true, compareUint64(sixty, EQ_OPERATOR, 60)) - assert.Equal(t, false, compareUint64(sixty, EQ_OPERATOR, 61)) + c.Check(true, Equals, compareUint64(sixty, EQ_OPERATOR, 60)) + c.Check(false, Equals, compareUint64(sixty, EQ_OPERATOR, 61)) - assert.Equal(t, true, compareUint64(sixty, NEQ_OPERATOR, 50)) + c.Check(true, Equals, compareUint64(sixty, NEQ_OPERATOR, 50)) - assert.Equal(t, false, compareUint64(sixty, LT_OPERATOR, 50)) - assert.Equal(t, false, compareUint64(sixty, LT_OPERATOR, 60)) - assert.Equal(t, true, compareUint64(fiftyNine, LT_OPERATOR, 60)) + c.Check(false, Equals, compareUint64(sixty, LT_OPERATOR, 50)) + c.Check(false, Equals, compareUint64(sixty, LT_OPERATOR, 60)) + c.Check(true, Equals, compareUint64(fiftyNine, LT_OPERATOR, 60)) - assert.Equal(t, true, compareUint64(sixty, GT_OPERATOR, 50)) - assert.Equal(t, false, compareUint64(sixty, GT_OPERATOR, 60)) - assert.Equal(t, false, compareUint64(fiftyNine, GT_OPERATOR, 60)) + c.Check(true, Equals, compareUint64(sixty, GT_OPERATOR, 50)) + c.Check(false, Equals, compareUint64(sixty, GT_OPERATOR, 60)) + c.Check(false, Equals, compareUint64(fiftyNine, GT_OPERATOR, 60)) } -func TestCheckRuleUint(t *testing.T) { +func (s *EventSuite) TestCheckRuleUint(c *C) { parsedEvent := &ParsedEvent{ operator: EQ_OPERATOR, ruleAmount: uint64(7), @@ -54,10 +57,10 @@ func TestCheckRuleUint(t *testing.T) { } resourceVal := uint64(7) triggering := checkRule(parsedEvent, resourceVal) - assert.Equal(t, true, triggering) + c.Check(true, Equals, triggering) } -func TestCheckRuleFalseUint(t *testing.T) { +func (s *EventSuite) TestCheckRuleFalseUint(c *C) { parsedEvent := &ParsedEvent{ operator: EQ_OPERATOR, ruleAmount: uint64(8), @@ -65,72 +68,73 @@ func TestCheckRuleFalseUint(t *testing.T) { } resourceVal := uint64(7) triggering := checkRule(parsedEvent, resourceVal) - assert.Equal(t, false, triggering) + c.Check(false, Equals, triggering) } -func TestParseRuleForwards(t *testing.T) { +func (s *EventSuite) TestParseRuleForwards(c *C) { ruleAmount, operator, resourceName, err := eventMonitor.parseRule("memory_used==2gb") if err != nil { - t.Fatal(err) + c.Fatal(err) } - assert.Equal(t, TWO_GB, ruleAmount) - assert.Equal(t, EQ_OPERATOR, operator) - assert.Equal(t, "memory_used", resourceName) + c.Check(TWO_GB, Equals, ruleAmount) + c.Check(EQ_OPERATOR, Equals, operator) + c.Check("memory_used", Equals, resourceName) } -func TestParseRuleBackwards(t *testing.T) { +func (s *EventSuite) TestParseRuleBackwards(c *C) { ruleAmount, operator, resourceName, err := eventMonitor.parseRule("2gb==memory_used") if err != nil { - t.Fatal(err) + c.Fatal(err) } - assert.Equal(t, TWO_GB, ruleAmount) - assert.Equal(t, EQ_OPERATOR, operator) - assert.Equal(t, "memory_used", resourceName) + c.Check(TWO_GB, Equals, ruleAmount) + c.Check(EQ_OPERATOR, Equals, operator) + c.Check("memory_used", Equals, resourceName) } -func TestParseRuleSpaces(t *testing.T) { +func (s *EventSuite) TestParseRuleSpaces(c *C) { ruleAmount, operator, resourceName, err := eventMonitor.parseRule(" 2gb == memory_used ") if err != nil { - t.Fatal(err) + c.Fatal(err) } - assert.Equal(t, TWO_GB, ruleAmount) - assert.Equal(t, EQ_OPERATOR, operator) - assert.Equal(t, "memory_used", resourceName) + c.Check(TWO_GB, Equals, ruleAmount) + c.Check(EQ_OPERATOR, Equals, operator) + c.Check("memory_used", Equals, resourceName) } -func TestParseRuleGt(t *testing.T) { +func (s *EventSuite) TestParseRuleGt(c *C) { ruleAmount, operator, resourceName, err := eventMonitor.parseRule("2gb>memory_used") if err != nil { - t.Fatal(err) + c.Fatal(err) } - assert.Equal(t, TWO_GB, ruleAmount) - assert.Equal(t, GT_OPERATOR, operator) - assert.Equal(t, "memory_used", resourceName) + c.Check(TWO_GB, Equals, ruleAmount) + c.Check(GT_OPERATOR, Equals, operator) + c.Check("memory_used", Equals, resourceName) } -func TestParseRuleLt(t *testing.T) { +func (s *EventSuite) TestParseRuleLt(c *C) { ruleAmount, operator, resourceName, err := eventMonitor.parseRule("2gb2gb", Duration: "10s", @@ -140,14 +144,14 @@ func TestParseEvent(t *testing.T) { parsedEvent, err := eventMonitor.parseEvent(&event, "GroupName", "ProcessName", "alert") if err != nil { - t.Fatal(err) + c.Fatal(err) } - assert.Equal(t, GT_OPERATOR, parsedEvent.operator) - assert.Equal(t, "memory_used", parsedEvent.resourceName) - assert.Equal(t, TWO_GB, parsedEvent.ruleAmount) + c.Check(GT_OPERATOR, Equals, parsedEvent.operator) + c.Check("memory_used", Equals, parsedEvent.resourceName) + c.Check(TWO_GB, Equals, parsedEvent.ruleAmount) } -func TestParseBadIntervalEvents(t *testing.T) { +func (s *EventSuite) TestParseBadIntervalEvents(c *C) { event1 := Event{ Rule: "memory_used>2gb", Duration: "8s", @@ -163,15 +167,20 @@ func TestParseBadIntervalEvents(t *testing.T) { _, err := eventMonitor.parseEvent(&event1, "GroupName", "ProcessName", "alert") if err != nil { - assert.Equal(t, - "Rule 'memory_used>2gb' duration / interval must be an integer.", + c.Check( + "Rule 'memory_used>2gb' duration / interval must be an integer.", Equals, + err.Error()) + } _, err = eventMonitor.parseEvent(&event2, "GroupName", "ProcessName", "alert") if err != nil { - assert.Equal(t, + c.Check( "Rule 'cpu_percent>60' duration / interval must be greater than 1. It "+ - "is '10 / 10'.", err.Error()) + "is '10 / 10'.", Equals, + + err.Error()) + } } @@ -191,7 +200,7 @@ func (fc *FakeControl) IsMonitoring(process *Process) bool { return fc.isMonitoring } -func TestActionTriggers(t *testing.T) { +func (s *EventSuite) TestActionTriggers(c *C) { fc := RegisterNewFakeControl() fc.isMonitoring = true eventMonitor.configManager = &ConfigManager{} @@ -210,49 +219,51 @@ func TestActionTriggers(t *testing.T) { eventMonitor.parseEvent(&event, "GroupName", "ProcessName", "stop") err := eventMonitor.triggerAction(process, parsedEvent, 0) if err != nil { - t.Fatal(err) + c.Fatal(err) } - assert.Equal(t, 1, fc.numDoActionCalled) - assert.Equal(t, ACTION_STOP, fc.lastActionCalled) + c.Check(1, Equals, fc.numDoActionCalled) + c.Check(ACTION_STOP, Equals, fc.lastActionCalled) parsedEvent, _ = eventMonitor.parseEvent(&event, "GroupName", "ProcessName", "start") err = eventMonitor.triggerAction(process, parsedEvent, 0) if err != nil { - t.Fatal(err) + c.Fatal(err) } - assert.Equal(t, 2, fc.numDoActionCalled) - assert.Equal(t, ACTION_START, fc.lastActionCalled) + c.Check(2, Equals, fc.numDoActionCalled) + c.Check(ACTION_START, Equals, fc.lastActionCalled) parsedEvent, _ = eventMonitor.parseEvent(&event, "GroupName", "ProcessName", "restart") err = eventMonitor.triggerAction(process, parsedEvent, 0) if err != nil { - t.Fatal(err) + c.Fatal(err) } - assert.Equal(t, 3, fc.numDoActionCalled) - assert.Equal(t, ACTION_RESTART, fc.lastActionCalled) + c.Check(3, Equals, fc.numDoActionCalled) + c.Check(ACTION_RESTART, Equals, fc.lastActionCalled) parsedEvent, _ = eventMonitor.parseEvent(&event, "GroupName", "ProcessName", "alert") err = eventMonitor.triggerAction(process, parsedEvent, 0) if err != nil { - t.Fatal(err) + c.Fatal(err) } - assert.Equal(t, 3, fc.numDoActionCalled) + c.Check(3, Equals, fc.numDoActionCalled) _, err = eventMonitor.parseEvent(&event, "GroupName", "ProcessName", "doesntexist") - assert.Equal(t, "No event action 'doesntexist' exists. Valid actions are "+ - "[stop, start, restart, alert].", err.Error()) + c.Check("No event action 'doesntexist' exists. Valid actions are "+ + "[stop, start, restart, alert].", Equals, + err.Error()) + parsedEvent.action = "doesntexist" err = eventMonitor.triggerAction(process, parsedEvent, 0) - assert.Equal(t, "No event action 'doesntexist' exists.", err.Error()) + c.Check("No event action 'doesntexist' exists.", Equals, err.Error()) eventMonitor = EventMonitor{} } -func TestMonitoringModes(t *testing.T) { +func (s *EventSuite) TestMonitoringModes(c *C) { fc := RegisterNewFakeControl() fc.isMonitoring = true eventMonitor.configManager = &ConfigManager{} @@ -271,10 +282,10 @@ func TestMonitoringModes(t *testing.T) { eventMonitor.parseEvent(&event, "GroupName", "ProcessName", "stop") err := eventMonitor.triggerAction(process, parsedEvent, 0) if err != nil { - t.Fatal(err) + c.Fatal(err) } - assert.Equal(t, 1, fc.numDoActionCalled) - assert.Equal(t, ACTION_STOP, fc.lastActionCalled) + c.Check(1, Equals, fc.numDoActionCalled) + c.Check(ACTION_STOP, Equals, fc.lastActionCalled) // We shoudn't trigger the action in passive mode. process.MonitorMode = "passive" @@ -282,10 +293,10 @@ func TestMonitoringModes(t *testing.T) { eventMonitor.parseEvent(&event, "GroupName", "ProcessName", "start") err = eventMonitor.triggerAction(process, parsedEvent, 0) if err != nil { - t.Fatal(err) + c.Fatal(err) } - assert.Equal(t, 1, fc.numDoActionCalled) - assert.Equal(t, ACTION_STOP, fc.lastActionCalled) + c.Check(1, Equals, fc.numDoActionCalled) + c.Check(ACTION_STOP, Equals, fc.lastActionCalled) // We shouldn't trigger the action in manual mode. process.MonitorMode = "manual" @@ -293,10 +304,10 @@ func TestMonitoringModes(t *testing.T) { eventMonitor.parseEvent(&event, "GroupName", "ProcessName", "start") err = eventMonitor.triggerAction(process, parsedEvent, 0) if err != nil { - t.Fatal(err) + c.Fatal(err) } - assert.Equal(t, 1, fc.numDoActionCalled) - assert.Equal(t, ACTION_STOP, fc.lastActionCalled) + c.Check(1, Equals, fc.numDoActionCalled) + c.Check(ACTION_STOP, Equals, fc.lastActionCalled) eventMonitor = EventMonitor{} } diff --git a/gonit_test.go b/gonit_test.go index 524c3e4..f309bd1 100644 --- a/gonit_test.go +++ b/gonit_test.go @@ -3,14 +3,18 @@ package gonit import ( + . "launchpad.net/gocheck" "regexp" - "testing" ) -func TestVersion(t *testing.T) { +type GonitSuite struct{} + +var _ = Suite(&GonitSuite{}) + +func (s *GonitSuite) TestVersion(c *C) { pattern := regexp.MustCompile(`^\d+\.\d+\.\d+$`) if !pattern.MatchString(VERSION) { - t.Errorf("Invalid VERSION=%s", VERSION) + c.Errorf("Invalid VERSION=%s", VERSION) } } diff --git a/log_test.go b/log_test.go index 39312bf..cfa4fb3 100644 --- a/log_test.go +++ b/log_test.go @@ -3,17 +3,20 @@ package gonit import ( - "github.com/bmizerany/assert" "io/ioutil" + . "launchpad.net/gocheck" "os" - "testing" ) func reInitLogger() { (&LoggerConfig{}).Init() // reset to defaults } -func TestLogInit(t *testing.T) { +type LogSuite struct{} + +var _ = Suite(&LogSuite{}) + +func (s *LogSuite) TestLogInit(c *C) { defer reInitLogger() config := &LoggerConfig{ @@ -21,14 +24,13 @@ func TestLogInit(t *testing.T) { } err := config.Init() - assert.Equal(t, nil, err) - var empty *os.File - assert.Equal(t, empty, config.file) + c.Check(err, IsNil) + c.Check(config.file, IsNil) err = config.Close() - assert.Equal(t, nil, err) + c.Check(err, IsNil) } -func TestInvalidLogLevel(t *testing.T) { +func (s *LogSuite) TestInvalidLogLevel(c *C) { defer reInitLogger() config := &LoggerConfig{ @@ -36,14 +38,14 @@ func TestInvalidLogLevel(t *testing.T) { } err := config.Init() - assert.NotEqual(t, nil, err) + c.Check(err, NotNil) } -func TestLogFile(t *testing.T) { +func (s *LogSuite) TestLogFile(c *C) { defer reInitLogger() file, err := ioutil.TempFile("", "gonit_log") - assert.Equal(t, nil, err) + c.Check(err, IsNil) defer os.Remove(file.Name()) config := &LoggerConfig{ @@ -52,30 +54,30 @@ func TestLogFile(t *testing.T) { } err = config.Init() - assert.Equal(t, nil, err) + c.Check(err, IsNil) fi, err := os.Stat(config.FileName) - assert.Equal(t, nil, err) - assert.Equal(t, fi.Size(), int64(0)) + c.Check(err, IsNil) + c.Check(fi.Size(), Equals, int64(0)) // info message should be written to the log file Log.Info("testing") fi, err = os.Stat(config.FileName) - assert.Equal(t, nil, err) - assert.NotEqual(t, fi.Size(), int64(0)) + c.Check(err, IsNil) + c.Check(fi.Size(), Not(Equals), int64(0)) // info message should not Log.Debug("another test") fi2, err := os.Stat(config.FileName) - assert.Equal(t, nil, err) - assert.Equal(t, fi.Size(), fi2.Size()) + c.Check(err, IsNil) + c.Check(fi.Size(), Equals, fi2.Size()) err = config.Close() - assert.Equal(t, nil, err) + c.Check(err, IsNil) // make log file read-only and check Init returns an error err = os.Chmod(config.FileName, 0444) - assert.Equal(t, nil, err) + c.Check(err, IsNil) err = config.Init() - assert.NotEqual(t, nil, err) + c.Check(err, NotNil) } diff --git a/process_test.go b/process_test.go index 18bd0a7..b916e4c 100644 --- a/process_test.go +++ b/process_test.go @@ -3,18 +3,21 @@ package gonit_test import ( - "github.com/bmizerany/assert" . "github.com/cloudfoundry/gonit" "github.com/cloudfoundry/gonit/test/helper" + . "launchpad.net/gocheck" "log" "os" "path/filepath" "sort" "strings" - "testing" "time" ) +type ProcessSuite struct{} + +var _ = Suite(&ProcessSuite{}) + // absolute path to the json encoded helper.ProcessInfo // written by goprocess, read by the following Tests. func processJsonFile(p *Process) string { @@ -29,7 +32,7 @@ func processInfo(p *Process) *helper.ProcessInfo { } // these assertions apply to any daemon process -func assertProcessInfo(t *testing.T, process *Process, info *helper.ProcessInfo) { +func assertProcessInfo(c *C, process *Process, info *helper.ProcessInfo) { selfInfo := helper.CurrentProcessInfo() var ppid int @@ -39,47 +42,47 @@ func assertProcessInfo(t *testing.T, process *Process, info *helper.ProcessInfo) ppid = selfInfo.Pid } - assert.Equal(t, ppid, info.Ppid) // parent pid + c.Check(ppid, Equals, info.Ppid) // parent pid - assert.NotEqual(t, selfInfo.Pgrp, info.Pgrp) // process group will change + c.Check(selfInfo.Pgrp, Not(Equals), info.Pgrp) // process group will change - assert.NotEqual(t, selfInfo.Sid, info.Sid) // session id will change + c.Check(selfInfo.Sid, Not(Equals), info.Sid) // session id will change - assert.Equal(t, false, info.HasTty) // no controling terminal + c.Check(false, Equals, info.HasTty) // no controling terminal sort.Strings(selfInfo.Env) sort.Strings(info.Env) - assert.NotEqual(t, selfInfo.Env, info.Env) // sanitized env will differ + c.Check(selfInfo.Env, Not(DeepEquals), info.Env) // sanitized env will differ // check expected process working directory // (and follow symlinks, e.g. darwin) ddir, _ := filepath.EvalSymlinks(process.Dir) idir, _ := filepath.EvalSymlinks(info.Dir) - assert.Equal(t, ddir, idir) + c.Check(ddir, Equals, idir) // spawned process argv[] should be the same as the process.Start command - assert.Equal(t, process.Start, strings.Join(info.Args, " ")) + c.Check(process.Start, Equals, strings.Join(info.Args, " ")) // check when configured to run as different user and/or group if process.Uid == "" { - assert.Equal(t, selfInfo.Uid, info.Uid) - assert.Equal(t, selfInfo.Euid, info.Euid) + c.Check(selfInfo.Uid, Equals, info.Uid) + c.Check(selfInfo.Euid, Equals, info.Euid) } else { - assert.NotEqual(t, selfInfo.Uid, info.Uid) - assert.NotEqual(t, selfInfo.Euid, info.Euid) + c.Check(selfInfo.Uid, Not(Equals), info.Uid) + c.Check(selfInfo.Euid, Not(Equals), info.Euid) } if process.Gid == "" { if process.Uid == "" { - assert.Equal(t, selfInfo.Gid, info.Gid) - assert.Equal(t, selfInfo.Egid, info.Egid) + c.Check(selfInfo.Gid, Equals, info.Gid) + c.Check(selfInfo.Egid, Equals, info.Egid) } else { - assert.NotEqual(t, selfInfo.Gid, info.Gid) - assert.NotEqual(t, selfInfo.Egid, info.Egid) + c.Check(selfInfo.Gid, Not(Equals), info.Gid) + c.Check(selfInfo.Egid, Not(Equals), info.Egid) } } else { - assert.NotEqual(t, selfInfo.Gid, info.Gid) - assert.NotEqual(t, selfInfo.Egid, info.Egid) + c.Check(selfInfo.Gid, Not(Equals), info.Gid) + c.Check(selfInfo.Egid, Not(Equals), info.Egid) } } @@ -90,7 +93,7 @@ func pause() { } // start + stop of gonit daemonized process -func TestSimple(t *testing.T) { +func (s *ProcessSuite) TestSimple(c *C) { process := helper.NewTestProcess("simple", nil, false) defer helper.Cleanup(process) @@ -101,28 +104,36 @@ func TestSimple(t *testing.T) { pause() - assert.Equal(t, true, process.IsRunning()) + c.Check(true, Equals, process.IsRunning()) info := processInfo(process) if process.Detached { - assert.Equal(t, true, grandArgs(info.Args)) + c.Check(true, Equals, grandArgs(info.Args)) } else { - assert.Equal(t, pid, info.Pid) + c.Check(pid, Equals, info.Pid) } - assertProcessInfo(t, process, info) + assertProcessInfo(c, process, info) err = process.StopProcess() - assert.Equal(t, nil, err) + c.Check(err, IsNil) pause() - assert.Equal(t, false, process.IsRunning()) + c.Check(false, Equals, process.IsRunning()) +} + +func skipUnlessRoot(c *C) bool { + if os.Getuid() != 0 { + c.Skip("test must be run as root") + return true + } + return false } // start + stop of gonit daemonized process w/ setuid -func TestSimpleSetuid(t *testing.T) { - if helper.NotRoot() { +func (s *ProcessSuite) TestSimpleSetuid(c *C) { + if skipUnlessRoot(c) { return } @@ -136,23 +147,23 @@ func TestSimpleSetuid(t *testing.T) { pid, err := process.StartProcess() if err != nil { - t.Fatal(err) + c.Fatal(err) } pause() - assert.Equal(t, true, process.IsRunning()) + c.Check(true, Equals, process.IsRunning()) info := processInfo(process) - assertProcessInfo(t, process, info) - assert.Equal(t, pid, info.Pid) + assertProcessInfo(c, process, info) + c.Check(pid, Equals, info.Pid) err = process.StopProcess() - assert.Equal(t, nil, err) + c.Check(err, IsNil) pause() - assert.Equal(t, false, process.IsRunning()) + c.Check(false, Equals, process.IsRunning()) } // check that -F flag has been rewritten to -G @@ -169,7 +180,7 @@ func grandArgs(args []string) bool { } // start / restart / stop self-daemonized process -func TestDetached(t *testing.T) { +func (s *ProcessSuite) TestDetached(c *C) { // start process process := helper.NewTestProcess("detached", nil, true) defer helper.Cleanup(process) @@ -181,42 +192,42 @@ func TestDetached(t *testing.T) { pause() - assert.Equal(t, true, process.IsRunning()) + c.Check(true, Equals, process.IsRunning()) info := processInfo(process) - assert.Equal(t, true, grandArgs(info.Args)) - assertProcessInfo(t, process, info) - assert.NotEqual(t, pid, info.Pid) + c.Check(true, Equals, grandArgs(info.Args)) + assertProcessInfo(c, process, info) + c.Check(pid, Not(Equals), info.Pid) pid, err = process.Pid() if err != nil { log.Fatal(err) } - assert.Equal(t, pid, info.Pid) + c.Check(pid, Equals, info.Pid) // restart via SIGHUP prevPid := info.Pid - assert.Equal(t, 0, info.Restarts) + c.Check(0, Equals, info.Restarts) for i := 1; i < 3; i++ { err = process.RestartProcess() pause() - assert.Equal(t, true, process.IsRunning()) + c.Check(true, Equals, process.IsRunning()) pid, err = process.Pid() if err != nil { log.Fatal(err) } - assert.Equal(t, prevPid, pid) + c.Check(prevPid, Equals, pid) info = processInfo(process) - assert.Equal(t, true, grandArgs(info.Args)) - assertProcessInfo(t, process, info) + c.Check(true, Equals, grandArgs(info.Args)) + assertProcessInfo(c, process, info) // SIGHUP increments restarts counter - assert.Equal(t, i, info.Restarts) + c.Check(i, Equals, info.Restarts) } // restart via full stop+start @@ -227,29 +238,29 @@ func TestDetached(t *testing.T) { err = process.RestartProcess() pause() - assert.Equal(t, true, process.IsRunning()) + c.Check(true, Equals, process.IsRunning()) pid, err = process.Pid() if err != nil { log.Fatal(err) } - assert.NotEqual(t, prevPid, pid) + c.Check(prevPid, Not(Equals), pid) info = processInfo(process) - assert.Equal(t, true, grandArgs(info.Args)) - assertProcessInfo(t, process, info) + c.Check(true, Equals, grandArgs(info.Args)) + assertProcessInfo(c, process, info) err = process.StopProcess() - assert.Equal(t, nil, err) + c.Check(err, IsNil) pause() - assert.Equal(t, false, process.IsRunning()) + c.Check(false, Equals, process.IsRunning()) } // test invalid uid -func TestFailSetuid(t *testing.T) { - if helper.NotRoot() { +func (s *ProcessSuite) TestFailSetuid(c *C) { + if skipUnlessRoot(c) { return } @@ -260,16 +271,16 @@ func TestFailSetuid(t *testing.T) { _, err := process.StartProcess() if err == nil { - t.Fatalf("user.LookupId(%q) should have failed", process.Uid) + c.Fatalf("user.LookupId(%q) should have failed", process.Uid) } pause() - assert.Equal(t, false, process.IsRunning()) + c.Check(false, Equals, process.IsRunning()) } // test invalid executable -func TestFailExe(t *testing.T) { +func (s *ProcessSuite) TestFailExe(c *C) { process := helper.NewTestProcess("fail_exe", nil, false) defer helper.Cleanup(process) @@ -279,9 +290,9 @@ func TestFailExe(t *testing.T) { } _, err = process.StartProcess() - assert.NotEqual(t, nil, err) + c.Check(err, NotNil) pause() - assert.Equal(t, false, process.IsRunning()) + c.Check(false, Equals, process.IsRunning()) } diff --git a/resourcemanager_test.go b/resourcemanager_test.go index 678ca56..a5989fc 100644 --- a/resourcemanager_test.go +++ b/resourcemanager_test.go @@ -3,12 +3,15 @@ package gonit import ( - "github.com/bmizerany/assert" + . "launchpad.net/gocheck" "os" - "testing" "time" ) +type ResourceSuite struct{} + +var _ = Suite(&ResourceSuite{}) + type FakeSigarGetter struct { memResident uint64 procUsed uint64 @@ -33,7 +36,7 @@ func Setup() { } } -func TestCalculateProcPercent(t *testing.T) { +func (s *ResourceSuite) TestCalculateProcPercent(c *C) { Setup() first := &DataTimestamp{ data: 2886, nanoTimestamp: 1.342471447022575e+18} @@ -45,12 +48,12 @@ func TestCalculateProcPercent(t *testing.T) { resourceHolder := ResourceHolder{dataTimestamps: data, maxDataToStore: 3} proc, err := resourceHolder.calculateProcPercent(second, first) if err != nil { - t.Fatal(err) + c.Fatal(err) } - assert.Equal(t, uint64(48), proc) + c.Check(uint64(48), Equals, proc) } -func TestGatherMem(t *testing.T) { +func (s *ResourceSuite) TestGatherMem(c *C) { Setup() duration, _ := time.ParseDuration("0s") interval, _ := time.ParseDuration("1s") @@ -62,21 +65,21 @@ func TestGatherMem(t *testing.T) { } resourceVal, err := r.GetResource(pe, 1234) if err != nil { - t.Fatal(err) + c.Fatal(err) } - assert.Equal(t, uint64(1024), resourceVal) + c.Check(uint64(1024), Equals, resourceVal) } -func TestgetMemResident(t *testing.T) { +func (s *ResourceSuite) TestgetMemResident(c *C) { Setup() pid := os.Getpid() val, err := r.sigarInterface.getMemResident(pid) - assert.Equal(t, nil, err) - assert.NotEqual(t, 0, val) + c.Check(err, IsNil) + c.Check(0, Not(Equals), val) } // When we have gotten proc percent twice, then we can get the proc time. -func TestGatherProcPercent(t *testing.T) { +func (s *ResourceSuite) TestGatherProcPercent(c *C) { Setup() duration, _ := time.ParseDuration("2s") interval, _ := time.ParseDuration("1s") @@ -89,7 +92,7 @@ func TestGatherProcPercent(t *testing.T) { } resourceVal, err := r.GetResource(pe, 1234) if err != nil { - t.Fatal(err) + c.Fatal(err) } fsg.procUsed = 3849 r.SetSigarInterface(&fsg) @@ -99,51 +102,52 @@ func TestGatherProcPercent(t *testing.T) { r.ClearCachedResources() resourceVal, err = r.GetResource(pe, 1234) if err != nil { - t.Fatal(err) + c.Fatal(err) } - assert.NotEqual(t, uint64(0), resourceVal) + c.Check(uint64(0), Not(Equals), resourceVal) } -func TestParseAmountErrors(t *testing.T) { +func (s *ResourceSuite) TestParseAmountErrors(c *C) { Setup() _, err := r.ParseAmount(MEMORY_USED_NAME, "2k") - assert.Equal(t, "memory_used '2k' is not the correct format.", err.Error()) + c.Check("memory_used '2k' is not the correct format.", Equals, err.Error()) _, err = r.ParseAmount(MEMORY_USED_NAME, "$kb") - assert.Equal(t, "strconv.ParseUint: parsing \"$\": invalid syntax", + c.Check("strconv.ParseUint: parsing \"$\": invalid syntax", Equals, err.Error()) _, err = r.ParseAmount(MEMORY_USED_NAME, "5zb") - assert.Equal(t, "Invalid units 'zb' on 'memory_used'.", err.Error()) + c.Check("Invalid units 'zb' on 'memory_used'.", Equals, err.Error()) _, err = r.ParseAmount(CPU_PERCENT_NAME, "5zb") - assert.Equal(t, "strconv.ParseUint: parsing \"5zb\": invalid syntax", + c.Check("strconv.ParseUint: parsing \"5zb\": invalid syntax", Equals, err.Error()) + } -func TestIsValidResourceName(t *testing.T) { +func (s *ResourceSuite) TestIsValidResourceName(c *C) { Setup() - assert.Equal(t, true, r.IsValidResourceName(MEMORY_USED_NAME)) - assert.Equal(t, true, r.IsValidResourceName(CPU_PERCENT_NAME)) - assert.Equal(t, true, r.IsValidResourceName(CPU_PERCENT_NAME)) + c.Check(true, Equals, r.IsValidResourceName(MEMORY_USED_NAME)) + c.Check(true, Equals, r.IsValidResourceName(CPU_PERCENT_NAME)) + c.Check(true, Equals, r.IsValidResourceName(CPU_PERCENT_NAME)) } -func TestSaveDataReusesSlice(t *testing.T) { +func (s *ResourceSuite) TestSaveDataReusesSlice(c *C) { rh := &ResourceHolder{} rh.maxDataToStore = 3 for i := int64(0); i < rh.maxDataToStore; i++ { rh.saveData(uint64(i)) } data := rh.dataTimestamps - assert.Equal(t, uint64(0), data[0].data) - assert.Equal(t, uint64(rh.maxDataToStore-1), data[len(data)-1].data) + c.Check(uint64(0), Equals, data[0].data) + c.Check(uint64(rh.maxDataToStore-1), Equals, data[len(data)-1].data) rh.saveData(1337) - assert.Equal(t, uint64(1337), data[0].data) + c.Check(uint64(1337), Equals, data[0].data) rh.saveData(1338) - assert.Equal(t, uint64(1338), data[1].data) + c.Check(uint64(1338), Equals, data[1].data) } -func TestCircularProcData(t *testing.T) { +func (s *ResourceSuite) TestCircularProcData(c *C) { Setup() duration, _ := time.ParseDuration("3s") interval, _ := time.ParseDuration("1s") @@ -162,14 +166,14 @@ func TestCircularProcData(t *testing.T) { r.ClearCachedResources() _, err := r.GetResource(pe, 1234) if err != nil { - t.Fatal(err) + c.Fatal(err) } } rh := r.getResourceHolder(pe) // Assert we have what we expect. - assert.Equal(t, uint64(2886), rh.dataTimestamps[0].data) - assert.Equal(t, uint64(2888), + c.Check(uint64(2886), Equals, rh.dataTimestamps[0].data) + c.Check(uint64(2888), Equals, rh.dataTimestamps[len(rh.dataTimestamps)-1].data) // Now, make sure that we loop on the data slice. @@ -180,13 +184,13 @@ func TestCircularProcData(t *testing.T) { r.ClearCachedResources() _, err := r.GetResource(pe, 1234) if err != nil { - t.Fatal(err) + c.Fatal(err) } // Assert that we looped. - assert.Equal(t, uint64(2897), rh.dataTimestamps[0].data) + c.Check(uint64(2897), Equals, rh.dataTimestamps[0].data) } -func TestDuration(t *testing.T) { +func (s *ResourceSuite) TestDuration(c *C) { Setup() duration, _ := time.ParseDuration("3s") interval, _ := time.ParseDuration("1s") @@ -204,7 +208,7 @@ func TestDuration(t *testing.T) { r.ClearCachedResources() _, err := r.GetResource(pe, 1234) if err != nil { - t.Fatal(err) + c.Fatal(err) } } rh := r.getResourceHolder(pe) @@ -220,16 +224,16 @@ func TestDuration(t *testing.T) { r.ClearCachedResources() resourceVal, err := r.GetResource(pe, 1234) if err != nil { - t.Fatal(err) + c.Fatal(err) } timeDiff := float64(rh.dataTimestamps[2].nanoTimestamp- rh.dataTimestamps[0].nanoTimestamp) / NANO_TO_MILLI valDiff := rh.dataTimestamps[2].data - rh.dataTimestamps[0].data expectedPercent := uint64(100 * (float64(valDiff) / float64(timeDiff))) - assert.Equal(t, expectedPercent, resourceVal) + c.Check(expectedPercent, Equals, resourceVal) } -func TestCleanProcData(t *testing.T) { +func (s *ResourceSuite) TestCleanProcData(c *C) { Setup() dts := &DataTimestamp{ data: 1, @@ -243,9 +247,9 @@ func TestCleanProcData(t *testing.T) { } proc := &Process{Name: "process"} r.resourceHolders = append(r.resourceHolders, rh) - assert.Equal(t, 1, len(r.resourceHolders[0].dataTimestamps)) - assert.Equal(t, int64(1), r.resourceHolders[0].firstEntryIndex) + c.Check(1, Equals, len(r.resourceHolders[0].dataTimestamps)) + c.Check(int64(1), Equals, r.resourceHolders[0].firstEntryIndex) r.CleanDataForProcess(proc) - assert.Equal(t, 0, len(r.resourceHolders[0].dataTimestamps)) - assert.Equal(t, int64(0), r.resourceHolders[0].firstEntryIndex) + c.Check(0, Equals, len(r.resourceHolders[0].dataTimestamps)) + c.Check(int64(0), Equals, r.resourceHolders[0].firstEntryIndex) } diff --git a/rpc_test.go b/rpc_test.go index 7332805..cbe6dbc 100644 --- a/rpc_test.go +++ b/rpc_test.go @@ -3,15 +3,18 @@ package gonit import ( - "github.com/bmizerany/assert" "io/ioutil" + . "launchpad.net/gocheck" "net" "net/rpc" "net/rpc/jsonrpc" "os" - "testing" ) +type RpcSuite struct{} + +var _ = Suite(&RpcSuite{}) + // simple RPC interface just for testing var info = &RpcTest{ Version: VERSION, @@ -32,10 +35,10 @@ func (info *RpcTest) Info(args interface{}, reply *RpcTest) error { return nil } -func TestUnixServer(t *testing.T) { +func (s *RpcSuite) UnixServer(c *C) { file, err := ioutil.TempFile("", "gonit-rpc") if err != nil { - t.Error(err) + c.Error(err) } path := file.Name() defer os.Remove(path) @@ -44,12 +47,12 @@ func TestUnixServer(t *testing.T) { server, err := NewRpcServer(url) - assert.Equal(t, nil, err) + c.Check(err, IsNil) // check file exists and is a unix socket fi, err := os.Stat(path) - assert.Equal(t, nil, err) - assert.Equal(t, os.ModeSocket, fi.Mode()&os.ModeSocket) + c.Check(err, IsNil) + c.Check(os.ModeSocket, Equals, fi.Mode()&os.ModeSocket) // start the server in a goroutine (Accept blocks) go server.Serve() @@ -58,16 +61,16 @@ func TestUnixServer(t *testing.T) { // make some client rpcs for i := 0; i <= 2; i++ { client, err := jsonrpc.Dial("unix", path) - assert.Equal(t, nil, err) + c.Check(err, IsNil) info := &RpcTest{} for j := 1; j < 2; j++ { err = client.Call("RpcTest.Info", nil, info) - assert.Equal(t, nil, err) + c.Check(err, IsNil) - assert.Equal(t, uint64(i+j), info.Requests) - assert.Equal(t, VERSION, info.Version) + c.Check(uint64(i+j), Equals, info.Requests) + c.Check(VERSION, Equals, info.Version) } client.Close() @@ -77,15 +80,15 @@ func TestUnixServer(t *testing.T) { server.Shutdown() fi, err = os.Stat(path) // should be gone after Shutdown() - assert.NotEqual(t, nil, err) + c.Check(err, NotNil) } -func TestTcpServer(t *testing.T) { +func (s *RpcSuite) TcpServer(c *C) { host := "localhost:9999" url := "tcp://" + host server, err := NewRpcServer(url) - assert.Equal(t, nil, err) + c.Check(err, IsNil) // start the server in a goroutine (Accept blocks) go server.Serve() @@ -93,28 +96,28 @@ func TestTcpServer(t *testing.T) { info.Requests = 0 client, err := jsonrpc.Dial("tcp", host) - assert.Equal(t, nil, err) + c.Check(err, IsNil) info := &RpcTest{} err = client.Call("RpcTest.Info", nil, info) - assert.Equal(t, uint64(1), info.Requests) - assert.Equal(t, VERSION, info.Version) + c.Check(uint64(1), Equals, info.Requests) + c.Check(VERSION, Equals, info.Version) client.Close() // shutdown + cleanup server.Shutdown() } -func TestInvalidURL(t *testing.T) { +func (s *RpcSuite) InvalidURL(c *C) { _, err := NewRpcServer("no://way") // unsupported scheme - assert.NotEqual(t, nil, err) + c.Check(err, NotNil) _, ok := err.(*net.UnknownNetworkError) - assert.NotEqual(t, true, ok) + c.Check(true, Not(Equals), ok) _, err = NewRpcServer("/") // directory - assert.NotEqual(t, nil, err) + c.Check(err, NotNil) _, err = NewRpcServer("tcp:whoops") // wups - assert.NotEqual(t, nil, err) + c.Check(err, NotNil) } diff --git a/test/helper/helper.go b/test/helper/helper.go index 71eb935..f532637 100644 --- a/test/helper/helper.go +++ b/test/helper/helper.go @@ -148,14 +148,6 @@ func CopyFile(srcName, dstName string, mode os.FileMode) { } } -func NotRoot() bool { - if os.Getuid() == 0 { - return false - } - log.Println("SKIP: test must be run as root") - return true -} - func WithRpcServer(f func(c *rpc.Client)) error { file, err := ioutil.TempFile("", "gonit-rpc") if err != nil {