func (s *getSuite) TestGetTests(c *C) {
for _, test := range getTests {
c.Logf("Test: %s", test.args)
mockHandler := hooktest.NewMockHandler()
state := state.New(nil)
state.Lock()
task := state.NewTask("test-task", "my test task")
setup := &hookstate.HookSetup{Snap: "test-snap", Revision: snap.R(1), Hook: "test-hook"}
var err error
mockContext, err := hookstate.NewContext(task, setup, mockHandler)
c.Check(err, IsNil)
// Initialize configuration
t := configstate.NewTransaction(state)
t.Set("test-snap", "test-key1", "test-value1")
t.Set("test-snap", "test-key2", 2)
t.Commit()
state.Unlock()
stdout, stderr, err := ctlcmd.Run(mockContext, strings.Fields(test.args))
if test.error != "" {
c.Check(err, ErrorMatches, test.error)
} else {
c.Check(err, IsNil)
c.Check(string(stderr), Equals, "")
c.Check(string(stdout), Equals, test.stdout)
}
}
}
func (s *setSuite) SetUpTest(c *C) {
s.mockHandler = hooktest.NewMockHandler()
state := state.New(nil)
state.Lock()
defer state.Unlock()
task := state.NewTask("test-task", "my test task")
setup := &hookstate.HookSetup{Snap: "test-snap", Revision: snap.R(1), Hook: "test-hook"}
var err error
s.mockContext, err = hookstate.NewContext(task, setup, s.mockHandler)
c.Assert(err, IsNil)
}
func (s *tasksetsSuite) TestConfigure(c *C) {
for _, test := range configureTests {
s.state.Lock()
taskset := configstate.Configure(s.state, "test-snap", test.patch)
s.state.Unlock()
tasks := taskset.Tasks()
c.Assert(tasks, HasLen, 1)
task := tasks[0]
c.Assert(task.Kind(), Equals, "run-hook")
summary := `Run configure hook of "test-snap" snap`
if test.optional {
summary += " if present"
}
c.Assert(task.Summary(), Equals, summary)
var hooksup hookstate.HookSetup
s.state.Lock()
err := task.Get("hook-setup", &hooksup)
s.state.Unlock()
c.Check(err, IsNil)
c.Assert(hooksup.Snap, Equals, "test-snap")
c.Assert(hooksup.Hook, Equals, "configure")
c.Assert(hooksup.Optional, Equals, test.optional)
context, err := hookstate.NewContext(task, &hooksup, nil)
c.Check(err, IsNil)
c.Check(context.SnapName(), Equals, "test-snap")
c.Check(context.SnapRevision(), Equals, snap.Revision{})
c.Check(context.HookName(), Equals, "configure")
var patch map[string]interface{}
context.Lock()
err = context.Get("patch", &patch)
context.Unlock()
if len(test.patch) > 0 {
c.Check(err, IsNil)
c.Check(patch, DeepEquals, test.patch)
} else {
c.Check(err, Equals, state.ErrNoState)
c.Check(patch, IsNil)
}
}
}
func (s *getSuite) SetUpTest(c *C) {
s.mockHandler = hooktest.NewMockHandler()
state := state.New(nil)
state.Lock()
defer state.Unlock()
task := state.NewTask("test-task", "my test task")
setup := &hookstate.HookSetup{Snap: "test-snap", Revision: snap.R(1), Hook: "test-hook"}
var err error
s.mockContext, err = hookstate.NewContext(task, setup, s.mockHandler)
c.Assert(err, IsNil)
// Initialize configuration
transaction := configstate.NewTransaction(state)
transaction.Set("test-snap", "initial-key", "initial-value")
transaction.Commit()
}