func (s *MongoSuite) TestMakeJournalDirs(c *gc.C) { dir := c.MkDir() err := mongo.MakeJournalDirs(dir) c.Assert(err, gc.IsNil) testJournalDirs(dir, c) }
func extBundleDirPath(c *gc.C, dirpath string) string { path := filepath.Join(c.MkDir(), "bundle.charm") cmd := exec.Command("/bin/sh", "-c", fmt.Sprintf("cd %s; zip --fifo --symlinks -r %s .", dirpath, path)) output, err := cmd.CombinedOutput() c.Assert(err, gc.IsNil, gc.Commentf("Command output: %s", output)) return path }
func (s *preallocSuite) TestPreallocFilesWriteErrors(c *gc.C) { dir := c.MkDir() prefix := filepath.Join(dir, "test.") err := ioutil.WriteFile(prefix+"0", nil, 0644) c.Assert(err, gc.IsNil) err = ioutil.WriteFile(prefix+"1", nil, 0644) c.Assert(err, gc.IsNil) var called int s.PatchValue(mongo.PreallocFile, func(filename string, size int) (bool, error) { var created bool var err error called++ if called == 2 { created = true err = fmt.Errorf("failed to zero test.1") } return created, err }) err = mongo.PreallocFiles(prefix, 4096, 8192) c.Assert(err, gc.ErrorMatches, "failed to zero test.1") // test.0 still exists because we said we didn't // create it (i.e. it already existed) _, err = os.Stat(prefix + "0") c.Assert(err, gc.IsNil) // test.1 no longer exists because we said we created // it, but then failed to write to it. _, err = os.Stat(prefix + "1") c.Assert(err, jc.Satisfies, os.IsNotExist) }
func (s *ValidateImageMetadataSuite) SetUpTest(c *gc.C) { s.FakeJujuHomeSuite.SetUpTest(c) s.metadataDir = c.MkDir() coretesting.WriteEnvironments(c, metadataTestEnvConfig) s.PatchEnvironment("AWS_ACCESS_KEY_ID", "access") s.PatchEnvironment("AWS_SECRET_ACCESS_KEY", "secret") }
func (*scriptSuite) TestDumpFileOnErrorScript(c *gc.C) { tempdir := c.MkDir() filename := filepath.Join(tempdir, "log.txt") err := ioutil.WriteFile(filename, []byte("abc"), 0644) c.Assert(err, gc.IsNil) dumpScript := shell.DumpFileOnErrorScript(filename) c.Logf("%s", dumpScript) run := func(command string) (stdout, stderr string) { var stdoutBuf, stderrBuf bytes.Buffer cmd := exec.Command("/bin/bash", "-s") cmd.Stdin = strings.NewReader(dumpScript + command) cmd.Stdout = &stdoutBuf cmd.Stderr = &stderrBuf cmd.Run() return stdoutBuf.String(), stderrBuf.String() } stdout, stderr := run("exit 0") c.Assert(stdout, gc.Equals, "") c.Assert(stderr, gc.Equals, "") stdout, stderr = run("exit 1") c.Assert(stdout, gc.Equals, "") c.Assert(stderr, gc.Equals, "abc") err = os.Remove(filename) c.Assert(err, gc.IsNil) stdout, stderr = run("exit 1") c.Assert(stdout, gc.Equals, "") c.Assert(stderr, gc.Equals, "") }
func (s *PublishSuite) TestUnknownPushLocation(c *gc.C) { addMeta(c, s.branch, "") err := s.branch.Push(&bzr.PushAttr{Location: c.MkDir() + "/foo", Remember: true}) c.Assert(err, gc.IsNil) _, err = s.runPublish(c) c.Assert(err, gc.ErrorMatches, `cannot infer charm URL from branch location: ".*/foo"`) }
func (s *ServerSuite) TestBadCommandName(c *gc.C) { dir := c.MkDir() _, err := s.Call(c, jujuc.Request{"validCtx", dir, "", nil}) c.Assert(err, gc.ErrorMatches, "bad request: command not specified") _, err = s.Call(c, jujuc.Request{"validCtx", dir, "witchcraft", nil}) c.Assert(err, gc.ErrorMatches, `bad request: unknown command "witchcraft"`) }
func (*metadataHelperSuite) TestResolveMetadata(c *gc.C) { var versionStrings = []string{"1.2.3-precise-amd64"} dir := c.MkDir() ttesting.MakeTools(c, dir, "releases", versionStrings) toolsList := coretools.List{{ Version: version.MustParseBinary(versionStrings[0]), Size: 123, SHA256: "abc", }} stor, err := filestorage.NewFileStorageReader(dir) c.Assert(err, gc.IsNil) err = tools.ResolveMetadata(stor, nil) c.Assert(err, gc.IsNil) // We already have size/sha256, so ensure that storage isn't consulted. countingStorage := &countingStorage{StorageReader: stor} metadata := tools.MetadataFromTools(toolsList) err = tools.ResolveMetadata(countingStorage, metadata) c.Assert(err, gc.IsNil) c.Assert(countingStorage.counter, gc.Equals, 0) // Now clear size/sha256, and check that it is called, and // the size/sha256 sum are updated. metadata[0].Size = 0 metadata[0].SHA256 = "" err = tools.ResolveMetadata(countingStorage, metadata) c.Assert(err, gc.IsNil) c.Assert(countingStorage.counter, gc.Equals, 1) c.Assert(metadata[0].Size, gc.Not(gc.Equals), 0) c.Assert(metadata[0].SHA256, gc.Not(gc.Equals), "") }
func (*metadataHelperSuite) TestReadWriteMetadata(c *gc.C) { metadata := []*tools.ToolsMetadata{{ Release: "precise", Version: "1.2.3", Arch: "amd64", Path: "path1", }, { Release: "raring", Version: "1.2.3", Arch: "amd64", Path: "path2", }} stor, err := filestorage.NewFileStorageWriter(c.MkDir()) c.Assert(err, gc.IsNil) out, err := tools.ReadMetadata(stor) c.Assert(out, gc.HasLen, 0) c.Assert(err, gc.IsNil) // non-existence is not an error err = tools.WriteMetadata(stor, metadata, tools.DoNotWriteMirrors) c.Assert(err, gc.IsNil) out, err = tools.ReadMetadata(stor) for _, md := range out { // FullPath is set by ReadMetadata. c.Assert(md.FullPath, gc.Not(gc.Equals), "") md.FullPath = "" } c.Assert(out, gc.DeepEquals, metadata) }
func (s *simplestreamsSuite) assertWriteMetadata(c *gc.C, withMirrors bool) { var versionStrings = []string{ "1.2.3-precise-amd64", "2.0.1-raring-amd64", } dir := c.MkDir() ttesting.MakeTools(c, dir, "releases", versionStrings) toolsList := coretools.List{ { // If sha256/size is already known, do not recalculate Version: version.MustParseBinary("1.2.3-precise-amd64"), Size: 123, SHA256: "abcd", }, { Version: version.MustParseBinary("2.0.1-raring-amd64"), // The URL is not used for generating metadata. URL: "bogus://", }, } writer, err := filestorage.NewFileStorageWriter(dir) c.Assert(err, gc.IsNil) writeMirrors := tools.DoNotWriteMirrors if withMirrors { writeMirrors = tools.WriteMirrors } err = tools.MergeAndWriteMetadata(writer, toolsList, writeMirrors) c.Assert(err, gc.IsNil) metadata := ttesting.ParseMetadataFromDir(c, dir, withMirrors) assertMetadataMatches(c, dir, toolsList, metadata) }
func (s *simplestreamsSuite) TestWriteMetadataMergeWithExisting(c *gc.C) { dir := c.MkDir() existingToolsList := coretools.List{ { Version: version.MustParseBinary("1.2.3-precise-amd64"), Size: 123, SHA256: "abc", }, { Version: version.MustParseBinary("2.0.1-raring-amd64"), Size: 456, SHA256: "xyz", }, } writer, err := filestorage.NewFileStorageWriter(dir) c.Assert(err, gc.IsNil) err = tools.MergeAndWriteMetadata(writer, existingToolsList, tools.DoNotWriteMirrors) c.Assert(err, gc.IsNil) newToolsList := coretools.List{ existingToolsList[0], { Version: version.MustParseBinary("2.1.0-raring-amd64"), Size: 789, SHA256: "def", }, } err = tools.MergeAndWriteMetadata(writer, newToolsList, tools.DoNotWriteMirrors) c.Assert(err, gc.IsNil) requiredToolsList := append(existingToolsList, newToolsList[1]) metadata := ttesting.ParseMetadataFromDir(c, dir, false) assertMetadataMatches(c, dir, requiredToolsList, metadata) }
func (s *ManifestDeployerSuite) SetUpTest(c *gc.C) { s.BaseSuite.SetUpTest(c) s.bundles = &bundleReader{} s.targetPath = filepath.Join(c.MkDir(), "target") deployerPath := filepath.Join(c.MkDir(), "deployer") s.deployer = charm.NewManifestDeployer(s.targetPath, deployerPath, s.bundles) }
// mockShellCommand creates a new command with the given // name and contents, and patches $PATH so that it will be // executed by preference. It returns the name of a file // that is written by each call to the command - mockShellCalls // can be used to retrieve the calls. func mockShellCommand(c *gc.C, s *testing.CleanupSuite, name string) string { dir := c.MkDir() s.PatchEnvPathPrepend(dir) // Note the shell script produces output of the form: // +arg1+\n // +arg2+\n // ... // +argn+\n // - // // It would be nice if there was a simple way of unambiguously // quoting shell arguments, but this will do as long // as no argument contains a newline character. outputFile := filepath.Join(dir, name+".out") contents := `#!/bin/sh { for i in "$@"; do echo +"$i"+ done echo - } >> ` + utils.ShQuote(outputFile) + ` ` err := ioutil.WriteFile(filepath.Join(dir, name), []byte(contents), 0755) c.Assert(err, gc.IsNil) return outputFile }
func (s *MongoSuite) TestUpstartServiceIPv6(c *gc.C) { dataDir := c.MkDir() svc, err := mongo.UpstartService("", dataDir, dataDir, mongo.JujuMongodPath, 1234, 1024) c.Assert(err, gc.IsNil) c.Assert(strings.Contains(svc.Conf.Cmd, "--ipv6"), jc.IsTrue) }
func (b *buildSuite) SetUpTest(c *gc.C) { b.BaseSuite.SetUpTest(c) dir1 := c.MkDir() dir2 := c.MkDir() c.Log(dir1) c.Log(dir2) path := os.Getenv("PATH") os.Setenv("PATH", fmt.Sprintf("%s:%s:%s", dir1, dir2, path)) // Make an executable file called "juju-test" in dir2. b.filePath = filepath.Join(dir2, "juju-test") err := ioutil.WriteFile( b.filePath, []byte("doesn't matter, we don't execute it"), 0755) c.Assert(err, gc.IsNil) cwd, err := os.Getwd() c.Assert(err, gc.IsNil) b.cwd = c.MkDir() err = os.Chdir(b.cwd) c.Assert(err, gc.IsNil) b.restore = func() { os.Setenv("PATH", path) os.Chdir(cwd) } }
func (s *GitDirSuite) TestClone(c *gc.C) { repo, err := newRepo(c).Clone(c.MkDir()) c.Assert(err, gc.IsNil) _, err = os.Stat(filepath.Join(repo.Path(), "some-file")) c.Assert(err, jc.Satisfies, os.IsNotExist) _, err = os.Stat(filepath.Join(repo.Path(), "some-dir")) c.Assert(err, jc.Satisfies, os.IsNotExist) dirty, err := repo.Dirty() c.Assert(err, gc.IsNil) c.Assert(dirty, jc.IsTrue) err = repo.AddAll() c.Assert(err, gc.IsNil) dirty, err = repo.Dirty() c.Assert(err, gc.IsNil) c.Assert(dirty, jc.IsTrue) err = repo.Commitf("blank overwrite") c.Assert(err, gc.IsNil) dirty, err = repo.Dirty() c.Assert(err, gc.IsNil) c.Assert(dirty, jc.IsFalse) lines, err := repo.Log() c.Assert(err, gc.IsNil) c.Assert(lines, gc.HasLen, 2) c.Assert(lines[0], gc.Matches, "[a-f0-9]{7} blank overwrite") c.Assert(lines[1], gc.Matches, "[a-f0-9]{7} im in ur repo committin ur files") }
func (s *LocalRepoSuite) SetUpTest(c *gc.C) { s.FakeHomeSuite.SetUpTest(c) root := c.MkDir() s.repo = &charm.LocalRepository{Path: root} s.seriesPath = filepath.Join(root, "quantal") c.Assert(os.Mkdir(s.seriesPath, 0777), gc.IsNil) }
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) }
// installFakeSSH creates a fake "ssh" command in a new $PATH, // updates $PATH, and returns a function to reset $PATH to its // original value when called. // // input may be: // - nil (ignore input) // - a string (match input exactly) // output may be: // - nil (no output) // - a string (stdout) // - a slice of strings, of length two (stdout, stderr) func installFakeSSH(c *gc.C, input, output interface{}, rc int) testing.Restorer { fakebin := c.MkDir() ssh := filepath.Join(fakebin, "ssh") switch input := input.(type) { case nil: case string: sshexpectedinput := ssh + ".expected-input" err := ioutil.WriteFile(sshexpectedinput, []byte(input), 0644) c.Assert(err, gc.IsNil) default: c.Errorf("input has invalid type: %T", input) } var stdout, stderr string switch output := output.(type) { case nil: case string: stdout = fmt.Sprintf("cat<<EOF\n%s\nEOF", output) case []string: c.Assert(output, gc.HasLen, 2) stdout = fmt.Sprintf("cat<<EOF\n%s\nEOF", output[0]) stderr = fmt.Sprintf("cat>&2<<EOF\n%s\nEOF", output[1]) } script := fmt.Sprintf(sshscript, stdout, stderr, rc) err := ioutil.WriteFile(ssh, []byte(script), 0777) c.Assert(err, gc.IsNil) return testing.PatchEnvPathPrepend(fakebin) }
func (*diskStoreSuite) TestWriteSmallerFile(c *gc.C) { dir := c.MkDir() store, err := configstore.NewDisk(dir) c.Assert(err, gc.IsNil) info := store.CreateInfo("someenv") endpoint := configstore.APIEndpoint{ Addresses: []string{"this", "is", "never", "validated", "here"}, EnvironUUID: "90168e4c-2f10-4e9c-83c2-feedfacee5a9", } info.SetAPIEndpoint(endpoint) err = info.Write() c.Assert(err, gc.IsNil) newInfo, err := store.ReadInfo("someenv") c.Assert(err, gc.IsNil) // Now change the number of addresses to be shorter. endpoint.Addresses = []string{"just one"} newInfo.SetAPIEndpoint(endpoint) err = newInfo.Write() c.Assert(err, gc.IsNil) // We should be able to read in in fine. yaInfo, err := store.ReadInfo("someenv") c.Assert(err, gc.IsNil) c.Assert(yaInfo.APIEndpoint().Addresses, gc.DeepEquals, []string{"just one"}) }
func (s *BootstrapSuite) SetUpTest(c *gc.C) { s.BaseSuite.SetUpTest(c) s.MgoSuite.SetUpTest(c) s.dataDir = c.MkDir() s.logDir = c.MkDir() s.fakeEnsureMongo = fakeEnsure{} }
func (*diskStoreSuite) TestCreate(c *gc.C) { dir := c.MkDir() store, err := configstore.NewDisk(dir) c.Assert(err, gc.IsNil) // Create some new environment info. info, err := store.CreateInfo("someenv") c.Assert(err, gc.IsNil) c.Assert(info.APIEndpoint(), gc.DeepEquals, configstore.APIEndpoint{}) c.Assert(info.APICredentials(), gc.DeepEquals, configstore.APICredentials{}) c.Assert(info.Initialized(), jc.IsFalse) data, err := ioutil.ReadFile(storePath(dir, "someenv")) c.Assert(err, gc.IsNil) c.Assert(data, gc.HasLen, 0) // Check that we can't create it twice. info, err = store.CreateInfo("someenv") c.Assert(err, gc.Equals, configstore.ErrEnvironInfoAlreadyExists) c.Assert(info, gc.IsNil) // Check that we can read it again. info, err = store.ReadInfo("someenv") c.Assert(err, gc.IsNil) c.Assert(info.Initialized(), jc.IsFalse) }
func (s *clientSuite) TestAddLocalCharm(c *gc.C) { charmArchive := charmtesting.Charms.CharmArchive(c.MkDir(), "dummy") curl := charm.MustParseURL( fmt.Sprintf("local:quantal/%s-%d", charmArchive.Meta().Name, charmArchive.Revision()), ) client := s.APIState.Client() // Test the sanity checks first. _, err := client.AddLocalCharm(charm.MustParseURL("cs:quantal/wordpress-1"), nil) c.Assert(err, gc.ErrorMatches, `expected charm URL with local: schema, got "cs:quantal/wordpress-1"`) // Upload an archive with its original revision. savedURL, err := client.AddLocalCharm(curl, charmArchive) c.Assert(err, gc.IsNil) c.Assert(savedURL.String(), gc.Equals, curl.String()) // Upload a charm directory with changed revision. charmDir := charmtesting.Charms.ClonedDir(c.MkDir(), "dummy") charmDir.SetDiskRevision(42) savedURL, err = client.AddLocalCharm(curl, charmDir) c.Assert(err, gc.IsNil) c.Assert(savedURL.Revision, gc.Equals, 42) // Upload a charm directory again, revision should be bumped. savedURL, err = client.AddLocalCharm(curl, charmDir) c.Assert(err, gc.IsNil) c.Assert(savedURL.String(), gc.Equals, curl.WithRevision(43).String()) }
func (*diskStoreSuite) TestRead(c *gc.C) { dir := c.MkDir() err := os.Mkdir(storePath(dir, ""), 0700) c.Assert(err, gc.IsNil) err = ioutil.WriteFile(storePath(dir, "someenv"), []byte(sampleInfo), 0666) c.Assert(err, gc.IsNil) store, err := configstore.NewDisk(dir) c.Assert(err, gc.IsNil) info, err := store.ReadInfo("someenv") c.Assert(err, gc.IsNil) c.Assert(info.Initialized(), jc.IsTrue) c.Assert(info.APICredentials(), gc.DeepEquals, configstore.APICredentials{ User: "******", Password: "******", }) c.Assert(info.APIEndpoint(), gc.DeepEquals, configstore.APIEndpoint{ Addresses: []string{"example.com", "kremvax.ru"}, CACert: "first line\nsecond line", }) c.Assert(info.Location(), gc.Equals, fmt.Sprintf("file %q", dir+"/environments/someenv.jenv")) c.Assert(info.BootstrapConfig(), gc.DeepEquals, map[string]interface{}{ "secret": "blah", "arble": "bletch", }) }
func (s *BundleSuite) TestBundleRevisionFile(c *gc.C) { charmDir := charmtesting.Charms.ClonedDirPath(c.MkDir(), "dummy") revPath := filepath.Join(charmDir, "revision") // Missing revision file err := os.Remove(revPath) c.Assert(err, gc.IsNil) bundle := extBundleDir(c, charmDir) c.Assert(bundle.Revision(), gc.Equals, 0) // Missing revision file with old revision in metadata file, err := os.OpenFile(filepath.Join(charmDir, "metadata.yaml"), os.O_WRONLY|os.O_APPEND, 0) c.Assert(err, gc.IsNil) _, err = file.Write([]byte("\nrevision: 1234\n")) c.Assert(err, gc.IsNil) bundle = extBundleDir(c, charmDir) c.Assert(bundle.Revision(), gc.Equals, 1234) // Revision file with bad content err = ioutil.WriteFile(revPath, []byte("garbage"), 0666) c.Assert(err, gc.IsNil) path := extBundleDirPath(c, charmDir) bundle, err = charm.ReadBundle(path) c.Assert(err, gc.ErrorMatches, "invalid revision file") c.Assert(bundle, gc.IsNil) }
func (s *commonMachineSuite) SetUpTest(c *gc.C) { s.agentSuite.SetUpTest(c) s.TestSuite.SetUpTest(c) os.Remove(jujuRun) // ignore error; may not exist // Patch ssh user to avoid touching ~ubuntu/.ssh/authorized_keys. s.agentSuite.PatchValue(&authenticationworker.SSHUser, "") testpath := c.MkDir() s.agentSuite.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.agentSuite.PatchValue(&upstart.InitDir, c.MkDir()) s.singularRecord = &singularRunnerRecord{} s.agentSuite.PatchValue(&newSingularRunner, s.singularRecord.newSingularRunner) s.agentSuite.PatchValue(&peergrouperNew, func(st *state.State) (worker.Worker, error) { return newDummyWorker(), nil }) s.fakeEnsureMongo = fakeEnsure{} s.agentSuite.PatchValue(&ensureMongoServer, s.fakeEnsureMongo.fakeEnsureMongo) s.agentSuite.PatchValue(&maybeInitiateMongoServer, s.fakeEnsureMongo.fakeInitiateMongo) }
func (s *StateFileSuite) TestStates(c *gc.C) { for i, t := range stateTests { c.Logf("test %d", i) path := filepath.Join(c.MkDir(), "uniter") file := uniter.NewStateFile(path) _, err := file.Read() c.Assert(err, gc.Equals, uniter.ErrNoStateFile) write := func() { err := file.Write(t.st.Started, t.st.Op, t.st.OpStep, t.st.Hook, t.st.CharmURL) c.Assert(err, gc.IsNil) } if t.err != "" { c.Assert(write, gc.PanicMatches, "invalid uniter state: "+t.err) err := utils.WriteYaml(path, &t.st) c.Assert(err, gc.IsNil) _, err = file.Read() c.Assert(err, gc.ErrorMatches, "cannot read charm state at .*: invalid uniter state: "+t.err) continue } write() st, err := file.Read() c.Assert(err, gc.IsNil) c.Assert(*st, gc.DeepEquals, t.st) } }
func (s *MachineSuite) TestMachineEnvironWorker(c *gc.C) { proxyDir := c.MkDir() s.agentSuite.PatchValue(&machineenvironmentworker.ProxyDirectory, proxyDir) s.agentSuite.PatchValue(&apt.ConfFile, filepath.Join(proxyDir, "juju-apt-proxy")) s.primeAgent(c, version.Current, state.JobHostUnits) // Make sure there are some proxy settings to write. proxySettings := proxy.Settings{ Http: "http proxy", Https: "https proxy", Ftp: "ftp proxy", } updateAttrs := config.ProxyConfigMap(proxySettings) err := s.State.UpdateEnvironConfig(updateAttrs, nil, nil) c.Assert(err, gc.IsNil) s.assertJobWithAPI(c, state.JobHostUnits, func(conf agent.Config, st *api.State) { for { select { case <-time.After(coretesting.LongWait): c.Fatalf("timeout while waiting for proxy settings to change") case <-time.After(10 * time.Millisecond): _, err := os.Stat(apt.ConfFile) if os.IsNotExist(err) { continue } c.Assert(err, gc.IsNil) return } } }) }
func (s *RelationerSuite) SetUpTest(c *gc.C) { s.JujuConnSuite.SetUpTest(c) var err error s.svc = s.AddTestingService(c, "u", s.AddTestingCharm(c, "riak")) c.Assert(err, gc.IsNil) rels, err := s.svc.Relations() c.Assert(err, gc.IsNil) c.Assert(rels, gc.HasLen, 1) s.rel = rels[0] _, unit := s.AddRelationUnit(c, "u/0") s.dirPath = c.MkDir() s.dir, err = relation.ReadStateDir(s.dirPath, s.rel.Id()) c.Assert(err, gc.IsNil) s.hooks = make(chan hook.Info) password, err := utils.RandomPassword() c.Assert(err, gc.IsNil) err = unit.SetPassword(password) c.Assert(err, gc.IsNil) s.st = s.OpenAPIAs(c, unit.Tag(), password) s.uniter = s.st.Uniter() c.Assert(s.uniter, gc.NotNil) apiUnit, err := s.uniter.Unit(unit.Tag()) c.Assert(err, gc.IsNil) apiRel, err := s.uniter.Relation(s.rel.Tag()) c.Assert(err, gc.IsNil) s.apiRelUnit, err = apiRel.Unit(apiUnit) c.Assert(err, gc.IsNil) }
func (s *identitySuite) TestWriteSystemIdentityFile(c *gc.C) { params := attributeParams params.DataDir = c.MkDir() conf, err := NewStateMachineConfig(params, servingInfo) c.Assert(err, gc.IsNil) err = WriteSystemIdentityFile(conf) c.Assert(err, gc.IsNil) contents, err := ioutil.ReadFile(conf.SystemIdentityPath()) c.Assert(err, gc.IsNil) c.Check(string(contents), gc.Equals, servingInfo.SystemIdentity) fi, err := os.Stat(conf.SystemIdentityPath()) c.Assert(err, gc.IsNil) c.Check(fi.Mode().Perm(), gc.Equals, os.FileMode(0600)) // ensure that file is deleted when SystemIdentity is empty info := servingInfo info.SystemIdentity = "" conf, err = NewStateMachineConfig(params, info) c.Assert(err, gc.IsNil) err = WriteSystemIdentityFile(conf) c.Assert(err, gc.IsNil) fi, err = os.Stat(conf.SystemIdentityPath()) c.Assert(err, gc.ErrorMatches, `stat .*: no such file or directory`) }