// TestAvailability tests that the charmdir resource is properly checked. func (s *ManifoldSuite) TestAvailability(c *gc.C) { recorder := &dummyRecorder{ charmURL: "cs:wordpress-37", unitTag: "wp/0", isDeclaredMetric: true, } s.PatchValue(collect.NewRecorder, func(_ names.UnitTag, _ context.Paths, _ collect.UnitCharmLookup, _ spool.MetricFactory) (spool.MetricRecorder, error) { return recorder, nil }) charmdir := &dummyCharmdir{available: false} s.dummyResources["charmdir-name"] = dt.StubResource{Output: charmdir} getResource := dt.StubGetResource(s.dummyResources) collectEntity, err := (*collect.NewCollect)(s.manifoldConfig, getResource) c.Assert(err, jc.ErrorIsNil) err = collectEntity.Do(nil) c.Assert(err, jc.ErrorIsNil) c.Assert(recorder.batches, gc.HasLen, 0) charmdir = &dummyCharmdir{available: true} s.dummyResources["charmdir-name"] = dt.StubResource{Output: charmdir} getResource = dt.StubGetResource(s.dummyResources) collectEntity, err = (*collect.NewCollect)(s.manifoldConfig, getResource) c.Assert(err, jc.ErrorIsNil) err = collectEntity.Do(nil) c.Assert(err, jc.ErrorIsNil) c.Assert(recorder.closed, jc.IsTrue) c.Assert(recorder.batches, gc.HasLen, 1) }
// TestAvailability tests that the charmdir resource is properly checked. func (s *ManifoldSuite) TestAvailability(c *gc.C) { recorder := &dummyRecorder{ charmURL: "cs:wordpress-37", unitTag: "wp/0", isDeclaredMetric: true, } s.PatchValue(collect.NewRecorder, func(_ names.UnitTag, _ context.Paths, _ spool.MetricFactory) (spool.MetricRecorder, error) { return recorder, nil }) s.PatchValue(collect.ReadCharm, func(_ names.UnitTag, _ context.Paths) (*corecharm.URL, map[string]corecharm.Metric, error) { return corecharm.MustParseURL("cs:wordpress-37"), map[string]corecharm.Metric{"pings": corecharm.Metric{Description: "test metric", Type: corecharm.MetricTypeAbsolute}}, nil }) charmdir := &dummyCharmdir{aborted: true} s.dummyResources["charmdir-name"] = dt.StubResource{Output: charmdir} getResource := dt.StubGetResource(s.dummyResources) collectEntity, err := collect.NewCollect(s.manifoldConfig, getResource) c.Assert(err, jc.ErrorIsNil) err = collectEntity.Do(nil) c.Assert(err, jc.ErrorIsNil) c.Assert(recorder.batches, gc.HasLen, 0) charmdir = &dummyCharmdir{aborted: false} s.dummyResources["charmdir-name"] = dt.StubResource{Output: charmdir} getResource = dt.StubGetResource(s.dummyResources) collectEntity, err = collect.NewCollect(s.manifoldConfig, getResource) c.Assert(err, jc.ErrorIsNil) err = collectEntity.Do(nil) c.Assert(err, jc.ErrorIsNil) c.Assert(recorder.closed, jc.IsTrue) c.Assert(recorder.batches, gc.HasLen, 1) }
func (s *ManifoldSuite) TestNoAgent(c *gc.C) { getResource := dt.StubGetResource(dt.StubResources{ "agent": dt.StubResource{Error: dependency.ErrMissing}, }) _, err := s.manifold.Start(getResource) c.Assert(err, gc.Equals, dependency.ErrMissing) }
func (s *ManifoldSuite) TestOutput(c *gc.C) { stepsLock := gate.NewLock() checkLock := gate.NewLock() getResource := dt.StubGetResource(dt.StubResources{ "steps-waiter": dt.StubResource{Output: stepsLock}, "check-waiter": dt.StubResource{Output: checkLock}, }) w, err := s.manifold.Start(getResource) c.Assert(err, jc.ErrorIsNil) // Upgrades not completed yet so output is false. s.assertOutputFalse(c, w) // Unlock one of the upgrade gates, output should still be false. stepsLock.Unlock() s.assertOutputFalse(c, w) // Unlock the other gate, output should now be true. checkLock.Unlock() s.assertOutputTrue(c, w) // .. and the worker should exit with ErrBounce. checkStopWithError(c, w, dependency.ErrBounce) // Restarting the worker should result in the output immediately // being true. w2, err := s.manifold.Start(getResource) c.Assert(err, jc.ErrorIsNil) s.assertOutputTrue(c, w) checkStop(c, w2) }
func (s *ManifoldSuite) SetUpSuite(c *gc.C) { s.IsolationSuite.SetUpSuite(c) s.stubAgentApiManifoldConfig = util.AgentApiManifoldConfig{ AgentName: "wut", APICallerName: "exactly", } s.fakeAgent = &fakeAgent{tag: fakeTag} s.fakeCaller = &fakeCaller{} s.getResource = dt.StubGetResource(dt.StubResources{ "wut": dt.StubResource{Output: s.fakeAgent}, "exactly": dt.StubResource{Output: s.fakeCaller}, }) s.newFacade = func(facade machineactions.Facade) func(base.APICaller) machineactions.Facade { s.fakeFacade = facade return func(apiCaller base.APICaller) machineactions.Facade { c.Assert(apiCaller, gc.Equals, s.fakeCaller) return facade } } s.newWorker = func(w worker.Worker, err error) func(machineactions.WorkerConfig) (worker.Worker, error) { s.fakeWorker = w return func(wc machineactions.WorkerConfig) (worker.Worker, error) { c.Assert(wc.Facade, gc.Equals, s.fakeFacade) c.Assert(wc.MachineTag, gc.Equals, fakeTag) c.Assert(wc.HandleAction, gc.Equals, fakeHandleAction) return w, err } } }
func (s *ManifoldSuite) TestStartOpenStateNil(c *gc.C) { s.config.OpenState = nil manifold := workerstate.Manifold(s.config) w, err := manifold.Start(dt.StubGetResource(s.resources)) c.Check(w, gc.IsNil) c.Check(err, gc.ErrorMatches, "OpenState is nil in config") }
func (s *ManifoldSuite) SetUpTest(c *gc.C) { s.IsolationSuite.SetUpTest(c) s.Stub = testing.Stub{} s.manifold = apicaller.Manifold(apicaller.ManifoldConfig{ AgentName: "agent-name", }) s.agent = &mockAgent{ stub: &s.Stub, env: coretesting.EnvironmentTag, } s.getResource = dt.StubGetResource(dt.StubResources{ "agent-name": dt.StubResource{Output: s.agent}, }) // Watch out for this: it uses its own Stub because Close calls are made from // the worker's loop goroutine. You should make sure to stop the worker before // checking the mock conn's calls (unless you know the connection will outlive // the test -- see setupMutatorTest). s.conn = &mockConn{ stub: &testing.Stub{}, broken: make(chan struct{}), } s.PatchValue(apicaller.OpenConnection, func(a agent.Agent) (api.Connection, error) { s.AddCall("openConnection", a) if err := s.NextErr(); err != nil { return nil, err } return s.conn, nil }) }
func (s *ManifoldSuite) SetUpTest(c *gc.C) { s.BaseSuite.SetUpTest(c) s.stub = &testing.Stub{} s.manifoldConfig = meterstatus.ManifoldConfig{ AgentName: "agent-name", APICallerName: "apicaller-name", MachineLockName: "machine-lock-name", NewHookRunner: meterstatus.NewHookRunner, NewMeterStatusAPIClient: msapi.NewClient, NewConnectedStatusWorker: meterstatus.NewConnectedStatusWorker, NewIsolatedStatusWorker: meterstatus.NewIsolatedStatusWorker, } s.manifold = meterstatus.Manifold(s.manifoldConfig) s.dataDir = c.MkDir() locksDir := c.MkDir() lock, err := fslock.NewLock(locksDir, "machine-lock", fslock.Defaults()) c.Assert(err, jc.ErrorIsNil) s.dummyResources = dt.StubResources{ "agent-name": dt.StubResource{Output: &dummyAgent{dataDir: s.dataDir}}, "apicaller-name": dt.StubResource{Output: &dummyAPICaller{}}, "machine-lock-name": dt.StubResource{Output: lock}, } s.getResource = dt.StubGetResource(s.dummyResources) }
func (s *PatchedManifoldSuite) TestStatusWorkerDoesNotRerunAfterRestart(c *gc.C) { getResource := dt.StubGetResource(s.dummyResources) worker, err := s.manifold.Start(getResource) c.Assert(err, jc.ErrorIsNil) c.Assert(worker, gc.NotNil) s.msClient.changes <- struct{}{} // Kill worker. worker.Kill() err = worker.Wait() c.Assert(err, jc.ErrorIsNil) // Restart it. worker, err = s.manifold.Start(getResource) c.Assert(err, jc.ErrorIsNil) c.Assert(worker, gc.NotNil) running := make(chan struct{}) meterstatus.PatchInit(worker, func() { close(running) }) select { case <-running: case <-time.After(coretesting.LongWait): c.Fatal("timed out waiting for signal") } worker.Kill() err = worker.Wait() s.stub.CheckCallNames(c, "MeterStatus", "RunHook", "WatchMeterStatus", "MeterStatus", "MeterStatus", "WatchMeterStatus") c.Assert(err, jc.ErrorIsNil) }
func (s *ManifoldSuite) startManifold(c *gc.C) (worker.Worker, error) { w, err := s.manifold.Start(dt.StubGetResource(s.resources)) if w != nil { s.AddCleanup(func(*gc.C) { worker.Stop(w) }) } return w, err }
func (s *ManifoldSuite) TestStartNewWorkerError(c *gc.C) { expectFacade := &fakeFacade{} manifold := singular.Manifold(singular.ManifoldConfig{ ClockName: "clock", APICallerName: "api-caller", AgentName: "agent", Duration: time.Minute, NewFacade: func(_ base.APICaller, _ names.MachineTag) (singular.Facade, error) { return expectFacade, nil }, NewWorker: func(config singular.FlagConfig) (worker.Worker, error) { c.Check(config.Facade, gc.Equals, expectFacade) err := config.Validate() c.Check(err, jc.ErrorIsNil) return nil, errors.New("blomp tik") }, }) getResource := dt.StubGetResource(dt.StubResources{ "clock": dt.StubResource{Output: &fakeClock{}}, "api-caller": dt.StubResource{Output: &fakeAPICaller{}}, "agent": dt.StubResource{Output: &mockAgent{}}, }) worker, err := manifold.Start(getResource) c.Check(err, gc.ErrorMatches, "blomp tik") c.Check(worker, gc.IsNil) }
func (s *StateWorkersSuite) TestNoStartStateWorkers(c *gc.C) { manifold := machine.StateWorkersManifold(machine.StateWorkersConfig{}) worker, err := manifold.Start(dt.StubGetResource(nil)) c.Check(worker, gc.IsNil) c.Check(err, gc.ErrorMatches, "StartStateWorkers not specified") c.Check(s.startCalled, jc.IsFalse) }
func (s *ManifoldSuite) TestStatusWorkerRunsHookOnChanges(c *gc.C) { msClient := &stubMeterStatusClient{stub: s.stub, changes: make(chan struct{})} s.PatchValue(meterstatus.NewMeterStatusClient, func(_ base.APICaller, _ names.UnitTag) msapi.MeterStatusClient { return msClient }) s.PatchValue(meterstatus.NewRunner, func(_ runner.Context, _ context.Paths) runner.Runner { return &stubRunner{stub: s.stub} }) getResource := dt.StubGetResource(s.dummyResources) worker, err := s.manifold.Start(getResource) c.Assert(err, jc.ErrorIsNil) c.Assert(worker, gc.NotNil) running := make(chan struct{}) meterstatus.PatchInit(worker, func() { close(running) }) select { case <-running: case <-time.After(coretesting.LongWait): c.Fatal("timed out waiting for signal") } msClient.changes <- struct{}{} msClient.code = "RED" worker.Kill() err = worker.Wait() c.Assert(err, jc.ErrorIsNil) s.stub.CheckCallNames(c, "MeterStatus", "RunHook", "WatchMeterStatus", "MeterStatus", "RunHook") }
func (s *ManifoldSuite) TestNewWorkerError(c *gc.C) { fakeClock := &fakeClock{} fakeFacade := &fakeFacade{} fakeAPICaller := &fakeAPICaller{} stub := testing.Stub{} manifold := charmrevisionmanifold.Manifold(charmrevisionmanifold.ManifoldConfig{ APICallerName: "api-caller", ClockName: "clock", NewFacade: func(apiCaller base.APICaller) (charmrevisionmanifold.Facade, error) { stub.AddCall("NewFacade", apiCaller) return fakeFacade, nil }, NewWorker: func(config charmrevision.Config) (worker.Worker, error) { stub.AddCall("NewWorker", config) return nil, errors.New("snrght") }, }) _, err := manifold.Start(dt.StubGetResource(dt.StubResources{ "api-caller": dt.StubResource{Output: fakeAPICaller}, "clock": dt.StubResource{Output: fakeClock}, })) c.Check(err, gc.ErrorMatches, "cannot create worker: snrght") stub.CheckCalls(c, []testing.StubCall{{ "NewFacade", []interface{}{fakeAPICaller}, }, { "NewWorker", []interface{}{charmrevision.Config{ RevisionUpdater: fakeFacade, Clock: fakeClock, }}, }}) }
func (s *ServingInfoSetterSuite) checkNotStateServer(c *gc.C, job multiwatcher.MachineJob) { a := &mockAgent{} apiCaller := basetesting.APICallerFunc( func(objType string, version int, id, request string, args, response interface{}) error { c.Assert(objType, gc.Equals, "Agent") switch request { case "GetEntities": c.Assert(args.(params.Entities).Entities, gc.HasLen, 1) result := response.(*params.AgentGetEntitiesResults) result.Entities = []params.AgentGetEntitiesResult{{ Jobs: []multiwatcher.MachineJob{job}, }} default: c.Fatalf("not sure how to handle: %q", request) } return nil }, ) w, err := s.manifold.Start(dt.StubGetResource(dt.StubResources{ "agent": dt.StubResource{Output: a}, "api-caller": dt.StubResource{Output: apiCaller}, })) c.Assert(w, gc.IsNil) c.Assert(err, gc.Equals, dependency.ErrUninstall) // State serving info shouldn't have been set for this job type. c.Assert(a.conf.ssiSet, jc.IsFalse) }
func (s *ServingInfoSetterSuite) TestEntityLookupFailure(c *gc.C) { // Set up a fake Agent and APICaller a := &mockAgent{} apiCaller := basetesting.APICallerFunc( func(objType string, version int, id, request string, args, response interface{}) error { c.Assert(objType, gc.Equals, "Agent") switch request { case "GetEntities": c.Assert(args.(params.Entities).Entities, gc.HasLen, 1) result := response.(*params.AgentGetEntitiesResults) result.Entities = []params.AgentGetEntitiesResult{{ Error: ¶ms.Error{Message: "boom"}, }} default: c.Fatalf("not sure how to handle: %q", request) } return nil }, ) // Call the manifold's start func with a fake resource getter that // returns the fake Agent and APICaller w, err := s.manifold.Start(dt.StubGetResource(dt.StubResources{ "agent": dt.StubResource{Output: a}, "api-caller": dt.StubResource{Output: apiCaller}, })) c.Assert(w, gc.IsNil) c.Assert(err, gc.ErrorMatches, "boom") }
func (s *ManifoldSuite) SetUpTest(c *gc.C) { spoolDir := c.MkDir() s.IsolationSuite.SetUpTest(c) s.factory = &stubMetricFactory{ &testing.Stub{}, spoolDir, } testAPIClient := func(apiCaller base.APICaller) metricsadder.MetricsAdderClient { return newTestAPIMetricSender() } s.PatchValue(&sender.NewMetricAdderClient, testAPIClient) s.manifold = sender.Manifold(sender.ManifoldConfig{ AgentName: "agent", APICallerName: "api-caller", MetricSpoolName: "metric-spool", }) dataDir := c.MkDir() // create unit agent base dir so that hooks can run. err := os.MkdirAll(filepath.Join(dataDir, "agents", "unit-u-0"), 0777) c.Assert(err, jc.ErrorIsNil) s.getResource = dt.StubGetResource(dt.StubResources{ "agent": dt.StubResource{Output: &dummyAgent{dataDir: dataDir}}, "api-caller": dt.StubResource{Output: &stubAPICaller{&testing.Stub{}}}, "metric-spool": dt.StubResource{Output: s.factory}, }) }
func (s *ManifoldSuite) TestStartMissingAgent(c *gc.C) { getResource := dt.StubGetResource(dt.StubResources{ "agent-name": dt.StubResource{Error: dependency.ErrMissing}, }) worker, err := s.manifold.Start(getResource) c.Check(worker, gc.IsNil) c.Check(err, gc.Equals, dependency.ErrMissing) }
func (*ManifoldSuite) TestUnlockerMissing(c *gc.C) { resources := resourcesMissing("unlocker") manifold := discoverspaces.Manifold(namesConfig()) worker, err := manifold.Start(dt.StubGetResource(resources)) c.Check(errors.Cause(err), gc.Equals, dependency.ErrMissing) c.Check(worker, gc.IsNil) }
func (*ManifoldSuite) TestClockMissing(c *gc.C) { resources := resourcesMissing("clock") manifold := undertaker.Manifold(namesConfig()) worker, err := manifold.Start(dt.StubGetResource(resources)) c.Check(errors.Cause(err), gc.Equals, dependency.ErrMissing) c.Check(worker, gc.IsNil) }
func (s *ServingInfoSetterSuite) TestStartAgentMissing(c *gc.C) { getResource := dt.StubGetResource(dt.StubResources{ "agent": dt.StubResource{Error: dependency.ErrMissing}, }) worker, err := s.manifold.Start(getResource) c.Check(worker, gc.IsNil) c.Check(err, gc.Equals, dependency.ErrMissing) }
func (s *PostUpgradeManifoldSuite) TestUpgradeWaiterMissing(c *gc.C) { getResource := dt.StubGetResource(dt.StubResources{ "upgradewaiter-name": dt.StubResource{Error: dependency.ErrMissing}, }) worker, err := s.manifold.Start(getResource) c.Check(worker, gc.IsNil) c.Check(err, gc.Equals, dependency.ErrMissing) }
func (s *FlagSuite) TestStartFalseFlag(c *gc.C) { wrapped := dependency.WithFlag(dependency.Manifold{}, "foo") getResource := dt.StubGetResource(dt.StubResources{ "foo": dt.StubResource{Output: stubFlag(false)}, }) worker, err := wrapped.Start(getResource) c.Check(worker, gc.IsNil) c.Check(errors.Cause(err), gc.Equals, dependency.ErrMissing) }
// TestCollectWorkerStarts ensures that the manifold correctly sets up the worker. func (s *ManifoldSuite) TestCollectWorkerStarts(c *gc.C) { getResource := dt.StubGetResource(s.dummyResources) worker, err := s.manifold.Start(getResource) c.Assert(err, jc.ErrorIsNil) c.Assert(worker, gc.NotNil) worker.Kill() err = worker.Wait() c.Assert(err, jc.ErrorIsNil) }
func (s *FlagSuite) TestStartNotFlag(c *gc.C) { wrapped := dependency.WithFlag(dependency.Manifold{}, "foo") getResource := dt.StubGetResource(dt.StubResources{ "foo": dt.StubResource{Output: true}, }) worker, err := wrapped.Start(getResource) c.Check(worker, gc.IsNil) c.Check(err, gc.ErrorMatches, `cannot set true into \*dependency.Flag`) }
func (s *StateWorkersSuite) TestStateMissing(c *gc.C) { getResource := dt.StubGetResource(dt.StubResources{ "state": dt.StubResource{Error: dependency.ErrMissing}, }) worker, err := s.manifold.Start(getResource) c.Check(worker, gc.IsNil) c.Check(err, gc.Equals, dependency.ErrMissing) c.Check(s.startCalled, jc.IsFalse) }
func (s *ManifoldSuite) TestStartSuccess(c *gc.C) { getResource := dt.StubGetResource(dt.StubResources{ "steps-waiter": dt.StubResource{Output: gate.NewLock()}, "check-waiter": dt.StubResource{Output: gate.NewLock()}, }) w, err := s.manifold.Start(getResource) c.Assert(err, jc.ErrorIsNil) checkStop(c, w) }
func (s *ManifoldSuite) TestStartNoCheckWaiter(c *gc.C) { getResource := dt.StubGetResource(dt.StubResources{ "steps-waiter": dt.StubResource{Output: gate.NewLock()}, "check-waiter": dt.StubResource{Error: dependency.ErrMissing}, }) w, err := s.manifold.Start(getResource) c.Assert(w, gc.IsNil) c.Assert(err, gc.Equals, dependency.ErrMissing) }
func (s *ManifoldSuite) TestStartMissingAPICaller(c *gc.C) { getResource := dt.StubGetResource(dt.StubResources{ "api-caller": dt.StubResource{Error: dependency.ErrMissing}, "metric-spool": dt.StubResource{Output: s.factory}, }) worker, err := s.manifold.Start(getResource) c.Check(worker, gc.IsNil) c.Check(err, gc.ErrorMatches, dependency.ErrMissing.Error()) }
// TestStatusWorkerStarts ensures that the manifold correctly sets up the worker. func (s *PatchedManifoldSuite) TestStatusWorkerStarts(c *gc.C) { getResource := dt.StubGetResource(s.dummyResources) worker, err := s.manifold.Start(getResource) c.Assert(err, jc.ErrorIsNil) c.Assert(worker, gc.NotNil) worker.Kill() err = worker.Wait() c.Assert(err, jc.ErrorIsNil) s.stub.CheckCallNames(c, "MeterStatus", "RunHook", "WatchMeterStatus") }