func (s *commonMachineSuite) SetUpTest(c *gc.C) {
s.agentSuite.SetUpTest(c)
s.TestSuite.SetUpTest(c)
os.Remove(jujuRun) // ignore error; may not exist
// Fake $HOME, and ssh user to avoid touching ~ubuntu/.ssh/authorized_keys.
fakeHome := coretesting.MakeEmptyFakeHomeWithoutJuju(c)
s.AddCleanup(func(*gc.C) { fakeHome.Restore() })
s.PatchValue(&authenticationworker.SSHUser, "")
testpath := c.MkDir()
s.PatchEnvPathPrepend(testpath)
// mock out the start method so we can fake install services without sudo
fakeCmd(filepath.Join(testpath, "start"))
fakeCmd(filepath.Join(testpath, "stop"))
s.PatchValue(&upstart.InitDir, c.MkDir())
s.singularRecord = &singularRunnerRecord{}
testing.PatchValue(&newSingularRunner, s.singularRecord.newSingularRunner)
testing.PatchValue(&peergrouperNew, func(st *state.State) (worker.Worker, error) {
return newDummyWorker(), nil
})
s.fakeEnsureMongo = fakeEnsure{}
s.PatchValue(&ensureMongoServer, s.fakeEnsureMongo.fakeEnsureMongo)
s.PatchValue(&maybeInitiateMongoServer, s.fakeEnsureMongo.fakeInitiateMongo)
}
func PatchHostAndCertPool(host string, certPool *x509.CertPool) func() {
restoreHost := testing.PatchValue(&metricsHost, host)
restoreCertsPool := testing.PatchValue(&metricsCertsPool, certPool)
return func() {
restoreHost()
restoreCertsPool()
}
}
func (s *agreeSuite) SetUpTest(c *gc.C) {
s.client = &mockClient{}
jujutesting.PatchValue(agree.ClientNew, func(...terms.ClientOption) (terms.Client, error) {
return s.client, nil
})
}
func (s *DeploySuite) TestDeployCharmsEndpointNotImplemented(c *gc.C) {
setter := &testMetricCredentialsSetter{
assert: func(serviceName string, data []byte) {},
err: ¶ms.Error{
Message: "IsMetered",
Code: params.CodeNotImplemented,
},
}
cleanup := jujutesting.PatchValue(&getMetricCredentialsAPI, func(_ api.Connection) (metricCredentialsAPI, error) {
return setter, nil
})
defer cleanup()
stub := &jujutesting.Stub{}
handler := &testMetricsRegistrationHandler{Stub: stub}
server := httptest.NewServer(handler)
defer server.Close()
testcharms.Repo.ClonedDirPath(s.SeriesPath, "metered")
deploy := &DeployCommand{Steps: []DeployStep{&RegisterMeteredCharm{RegisterURL: server.URL, QueryURL: server.URL}}}
_, err := coretesting.RunCommand(c, envcmd.Wrap(deploy), "local:quantal/metered-1", "--plan", "someplan")
c.Assert(err, jc.ErrorIsNil)
c.Check(c.GetTestLog(), jc.Contains, "current state server version does not support charm metering")
}
func (s *DeploySuite) TestAddMetricCredentialsHttp(c *gc.C) {
handler := &testMetricsRegistrationHandler{}
server := httptest.NewServer(handler)
defer server.Close()
var called bool
setter := &testMetricCredentialsSetter{
assert: func(serviceName string, data []byte) {
called = true
c.Assert(serviceName, gc.DeepEquals, "metered")
var b []byte
err := json.Unmarshal(data, &b)
c.Assert(err, gc.IsNil)
c.Assert(string(b), gc.Equals, "hello registration")
},
}
cleanup := jujutesting.PatchValue(&getMetricCredentialsAPI, func(_ api.Connection) (metricCredentialsAPI, error) {
return setter, nil
})
defer cleanup()
testcharms.Repo.ClonedDirPath(s.SeriesPath, "metered")
_, err := coretesting.RunCommand(c, envcmd.Wrap(&deployCommand{RegisterURL: server.URL}), "local:quantal/metered-1")
c.Assert(err, jc.ErrorIsNil)
curl := charm.MustParseURL("local:quantal/metered-1")
s.AssertService(c, "metered", curl, 1, 0)
c.Assert(called, jc.IsTrue)
c.Assert(handler.registrationCalls, gc.HasLen, 1)
c.Assert(handler.registrationCalls[0].CharmURL, gc.DeepEquals, "local:quantal/metered-1")
c.Assert(handler.registrationCalls[0].ServiceName, gc.DeepEquals, "metered")
}
func (*PatchValueSuite) TestSetInt(c *gc.C) {
i := 99
restore := testing.PatchValue(&i, 88)
c.Assert(i, gc.Equals, 88)
restore()
c.Assert(i, gc.Equals, 99)
}
func (s *storageSuite) SetUpSuite(c *gc.C) {
s.LoggingSuite.SetUpSuite(c)
var err error
flockBin, err = exec.LookPath("flock")
c.Assert(err, gc.IsNil)
s.bin = c.MkDir()
s.PatchEnvPathPrepend(s.bin)
// Create a "sudo" command which shifts away the "-n", sets
// SUDO_UID/SUDO_GID, and executes the remaining args.
err = ioutil.WriteFile(filepath.Join(s.bin, "sudo"), []byte(
"#!/bin/sh\nshift; export SUDO_UID=`id -u` SUDO_GID=`id -g`; exec \"$@\"",
), 0755)
c.Assert(err, gc.IsNil)
restoreSshCommand := testing.PatchValue(&sshCommand, func(host string, command ...string) *ssh.Cmd {
return s.sshCommand(c, host, command...)
})
s.AddSuiteCleanup(func(*gc.C) { restoreSshCommand() })
// Create a new "flock" which calls the original, but in non-blocking mode.
data := []byte(fmt.Sprintf("#!/bin/sh\nexec %s --nonblock \"$@\"", flockBin))
err = ioutil.WriteFile(filepath.Join(s.bin, "flock"), data, 0755)
c.Assert(err, gc.IsNil)
}
func checkArgs(c *gc.C, args *CheckArgs, facade string, version int, id, method string, inArgs, outResults interface{}) {
if args == nil {
c.Logf("checkArgs: args is nil!")
return
} else {
if args.Facade != "" {
c.Check(facade, gc.Equals, args.Facade)
}
if args.Version != 0 {
c.Check(version, gc.Equals, args.Version)
} else if args.VersionIsZero {
c.Check(version, gc.Equals, 0)
}
if args.Id != "" {
c.Check(id, gc.Equals, args.Id)
} else if args.IdIsEmpty {
c.Check(id, gc.Equals, "")
}
if args.Method != "" {
c.Check(method, gc.Equals, args.Method)
}
if args.Args != nil {
c.Check(inArgs, jc.DeepEquals, args.Args)
}
if args.Results != nil {
c.Check(outResults, gc.NotNil)
testing.PatchValue(outResults, args.Results)
}
}
}
func (s *BaseActionSuite) patchAPIClient(client *fakeAPIClient) func() {
return jujutesting.PatchValue(action.NewActionAPIClient,
func(c *action.ActionCommandBase) (action.APIClient, error) {
return client, nil
},
)
}
func (s *senderSuite) SetUpTest(c *gc.C) {
s.spoolDir = c.MkDir()
s.socketDir = c.MkDir()
s.metricfactory = &stubMetricFactory{
&testing.Stub{},
s.spoolDir,
}
declaredMetrics := map[string]corecharm.Metric{
"pings": corecharm.Metric{Description: "test pings", Type: corecharm.MetricTypeAbsolute},
}
recorder, err := s.metricfactory.Recorder(declaredMetrics, "local:trusty/testcharm", "testcharm/0")
c.Assert(err, jc.ErrorIsNil)
err = recorder.AddMetric("pings", "50", time.Now())
c.Assert(err, jc.ErrorIsNil)
err = recorder.Close()
c.Assert(err, jc.ErrorIsNil)
reader, err := s.metricfactory.Reader()
c.Assert(err, jc.ErrorIsNil)
batches, err := reader.Read()
c.Assert(err, jc.ErrorIsNil)
c.Assert(batches, gc.HasLen, 1)
testing.PatchValue(sender.SocketName, func(_, _ string) string {
return sockPath(c)
})
}
func mockAPICaller(c *gc.C, callNumber *int32, apiCalls ...apiCall) apitesting.APICallerFunc {
apiCaller := apitesting.APICallerFunc(func(objType string, version int, id, request string, arg, result interface{}) error {
switch objType {
case "NotifyWatcher":
return nil
case "Uniter":
index := int(atomic.AddInt32(callNumber, 1)) - 1
c.Check(index < len(apiCalls), jc.IsTrue)
call := apiCalls[index]
c.Logf("request %d, %s", index, request)
c.Check(version, gc.Equals, 4)
c.Check(id, gc.Equals, "")
c.Check(request, gc.Equals, call.request)
c.Check(arg, jc.DeepEquals, call.args)
if call.err != nil {
return common.ServerError(call.err)
}
testing.PatchValue(result, call.result)
default:
c.Fail()
}
return nil
})
return apiCaller
}
// DisableFinishBootstrap disables common.FinishBootstrap so that tests
// do not attempt to SSH to non-existent machines. The result is a function
// that restores finishBootstrap.
func DisableFinishBootstrap() func() {
f := func(environs.BootstrapContext, ssh.Client, instance.Instance, *cloudinit.MachineConfig) error {
logger.Warningf("provider/common.FinishBootstrap is disabled")
return nil
}
return testing.PatchValue(&common.FinishBootstrap, f)
}
func (s *listAgreementsSuite) SetUpTest(c *gc.C) {
s.FakeJujuXDGDataHomeSuite.SetUpTest(c)
s.client = &mockClient{}
jujutesting.PatchValue(listagreements.NewClient, func(_ *httpbakery.Client) (listagreements.TermsServiceClient, error) {
return s.client, nil
})
}
func (*PatchValueSuite) TestSetErrorToNil(c *gc.C) {
oldErr := errors.New("foo")
err := oldErr
restore := testing.PatchValue(&err, nil)
c.Assert(err, gc.Equals, nil)
restore()
c.Assert(err, gc.Equals, oldErr)
}
func (*PatchValueSuite) TestSetMapToNil(c *gc.C) {
oldMap := map[string]int{"foo": 1234}
m := oldMap
restore := testing.PatchValue(&m, nil)
c.Assert(m, gc.IsNil)
restore()
c.Assert(m, gc.DeepEquals, oldMap)
}
func (s *agreeSuite) SetUpTest(c *gc.C) {
s.FakeJujuXDGDataHomeSuite.SetUpTest(c)
s.client = &mockClient{}
jujutesting.PatchValue(agree.ClientNew, func(...api.ClientOption) (api.Client, error) {
return s.client, nil
})
}
func lifeTest(c *gc.C, stub *testing.Stub, life apiagent.Life, test func() (api.Connection, error)) (api.Connection, error) {
newFacade := func(apiCaller base.APICaller) (apiagent.ConnFacade, error) {
c.Check(apiCaller, gc.FitsTypeOf, (*mockConn)(nil))
return newMockConnFacade(stub, life), nil
}
unpatch := testing.PatchValue(apicaller.NewConnFacade, newFacade)
defer unpatch()
return test()
}
func (s *RsyslogSuite) SetUpSuite(c *gc.C) {
s.JujuConnSuite.SetUpSuite(c)
// TODO(waigani) 2014-03-19 bug 1294462
// Add patch for suite functions
restore := testing.PatchValue(rsyslog.LookupUser, func(username string) (uid, gid int, err error) {
// worker will not attempt to chown files if uid/gid is 0
return 0, 0, nil
})
s.AddSuiteCleanup(func(*gc.C) { restore() })
}
func (s *WindowsHookSuite) TestHookCommandNotPowerShellScripts(c *gc.C) {
restorer := envtesting.PatchValue(&version.Current.OS, version.Windows)
defer restorer()
cmdhook := "somehook.cmd"
c.Assert(runner.HookCommand(cmdhook), gc.DeepEquals, []string{cmdhook})
bathook := "somehook.bat"
c.Assert(runner.HookCommand(bathook), gc.DeepEquals, []string{bathook})
}
func (s *unitSuite) TestWatchActionsNoResults(c *gc.C) {
restore := testing.PatchValue(uniter.Call, func(st *uniter.State, method string, params, results interface{}) error {
return nil
})
defer restore()
_, err := s.apiUnit.WatchActions()
c.Assert(err.Error(), gc.Equals, "expected 1 result, got 0")
}
func (s *unitSuite) TestWatchActionsError(c *gc.C) {
restore := testing.PatchValue(uniter.Call, func(st *uniter.State, method string, params, results interface{}) error {
return fmt.Errorf("Test error")
})
defer restore()
_, err := s.apiUnit.WatchActions()
c.Assert(err.Error(), gc.Equals, "Test error")
}
func lifeTest(c *gc.C, stub *testing.Stub, life apiagent.Life, test func() (api.Connection, error)) (api.Connection, error) {
expectConn := &mockConn{stub: stub}
newFacade := func(apiCaller base.APICaller) (apiagent.ConnFacade, error) {
c.Check(apiCaller, jc.DeepEquals, expectConn)
return newMockConnFacade(stub, life), nil
}
unpatch := testing.PatchValue(apicaller.NewConnFacade, newFacade)
defer unpatch()
return test()
}
func (s *WindowsHookSuite) TestHookCommandNotPowerShellScripts(c *gc.C) {
restorer := envtesting.PatchValue(&os.HostOS, func() os.OSType { return os.Windows })
defer restorer()
cmdhook := "somehook.cmd"
c.Assert(runner.HookCommand(cmdhook), gc.DeepEquals, []string{cmdhook})
bathook := "somehook.bat"
c.Assert(runner.HookCommand(bathook), gc.DeepEquals, []string{bathook})
}
func (s *WindowsHookSuite) TestSearchHookWindowsError(c *gc.C) {
charmDir, _ := makeCharm(c, hookSpec{
name: "something-happened.linux",
perm: 0755,
})
restorer := envtesting.PatchValue(&version.Current.OS, version.Windows)
defer restorer()
obtained, err := uniter.SearchHook(charmDir, filepath.Join("hooks", "something-happened"))
c.Assert(err, gc.ErrorMatches, "hooks/something-happened does not exist")
c.Assert(obtained, gc.Equals, "")
}
// AddBackupMetadataID adds the metadata to storage, using the given
// backup ID.
func AddBackupMetadataID(st *state.State, meta *Metadata, id string) error {
restore := testing.PatchValue(&newStorageID, func(*storageMetaDoc) string {
return id
})
defer restore()
db := getBackupDBWrapper(st)
defer db.Close()
doc := newStorageMetaDoc(meta)
_, err := addStorageMetadata(db, &doc)
return errors.Trace(err)
}
func (s prepareGitUniter) step(c *gc.C, ctx *context) {
c.Assert(ctx.uniter, gc.IsNil, gc.Commentf("please don't try to patch stuff while the uniter's running"))
newDeployer := func(charmPath, dataPath string, bundles charm.BundleReader) (charm.Deployer, error) {
return charm.NewGitDeployer(charmPath, dataPath, bundles), nil
}
restoreNewDeployer := gt.PatchValue(&charm.NewDeployer, newDeployer)
defer restoreNewDeployer()
fixDeployer := func(deployer *charm.Deployer) error {
return nil
}
restoreFixDeployer := gt.PatchValue(&charm.FixDeployer, fixDeployer)
defer restoreFixDeployer()
for _, prepStep := range s.prepSteps {
step(c, ctx, prepStep)
}
if ctx.uniter != nil {
step(c, ctx, stopUniter{})
}
}
func (s *WindowsHookSuite) TestSearchHookWindows(c *gc.C) {
charmDir, _ := makeCharm(c, hookSpec{
name: "something-happened.ps1",
perm: 0755,
})
restorer := envtesting.PatchValue(&version.Current.OS, version.Windows)
defer restorer()
obtained, err := uniter.SearchHook(charmDir, filepath.Join("hooks", "something-happened"))
c.Assert(err, gc.IsNil)
c.Assert(obtained, gc.Equals, filepath.Join(charmDir, "hooks", "something-happened.ps1"))
}
func (s *unitSuite) TestWatchActionsMoreResults(c *gc.C) {
restore := testing.PatchValue(uniter.Call, func(st *uniter.State, method string, args, results interface{}) error {
if results, ok := results.(*params.StringsWatchResults); ok {
results.Results = make([]params.StringsWatchResult, 2)
}
return nil
})
defer restore()
_, err := s.apiUnit.WatchActions()
c.Assert(err.Error(), gc.Equals, "expected 1 result, got 2")
}
func strategyTest(stub *testing.Stub, strategy utils.AttemptStrategy, test func(api.OpenFunc) (api.Connection, error)) (api.Connection, error) {
unpatch := testing.PatchValue(apicaller.Strategy, strategy)
defer unpatch()
return test(func(info *api.Info, opts api.DialOpts) (api.Connection, error) {
// copy because I don't trust what might happen to info
stub.AddCall("apiOpen", *info, opts)
err := stub.NextErr()
if err != nil {
return nil, err
}
return &mockConn{stub: stub}, nil
})
}
func (s *agreeSuite) TestAgreementNothingToSign(c *gc.C) {
jujutesting.PatchValue(agree.UserAnswer, func() (string, error) {
return "y", nil
})
s.client.user = "******"
s.client.setUnsignedTerms([]terms.GetTermsResponse{})
ctx, err := cmdtesting.RunCommand(c, agree.NewAgreeCommand(), "test-term/1")
c.Assert(err, jc.ErrorIsNil)
c.Assert(cmdtesting.Stdout(ctx), gc.Equals, `Already agreed
`)
}