worker/uniter/charm: git config user.email on init

worker/uniter/charm/git_test.go

 // Copyright 2012, 2013 Canonical Ltd.
 // Licensed under the AGPLv3, see LICENCE file for details.
 
 package charm_test
 
 import (
-        "fmt"
         "io/ioutil"
-        . "launchpad.net/gocheck"
+        "os"
+        "os/exec"
+        "path/filepath"
+
+        gc "launchpad.net/gocheck"
+
         corecharm "launchpad.net/juju-core/charm"
         "launchpad.net/juju-core/testing"
         "launchpad.net/juju-core/testing/checkers"
         "launchpad.net/juju-core/worker/uniter/charm"
-        "os"
-        "os/exec"
-        "path/filepath"
-        "regexp"

[natefinch, 2013/08/15 13:00:54]

Does this compile? fmt and regexp aren't used as far as I can tell.

Also, can you sort the imports while you're up there?

 )
 
 var curl = corecharm.MustParseURL("cs:series/blah-blah-123")
 
 type GitDirSuite struct {
         testing.GitSuite
         LoggingSuite testing.LoggingSuite
-        oldLcAll     string
-}
-
-var _ = Suite(&GitDirSuite{})
-
-func (s *GitDirSuite) SetUpTest(c *C) {
+        resetLcAll   func()
+}
+
+var _ = gc.Suite(&GitDirSuite{})
+
+func (s *GitDirSuite) SetUpTest(c *gc.C) {
         s.GitSuite.SetUpTest(c)
         s.LoggingSuite.SetUpTest(c)
-        s.oldLcAll = os.Getenv("LC_ALL")
-        os.Setenv("LC_ALL", "en_US")
-}
-
-func (s *GitDirSuite) TearDownTest(c *C) {
-        os.Setenv("LC_ALL", s.oldLcAll)
+        s.resetLcAll = testing.PatchEnvironment("LC_ALL", "en_US")
+}
+
+func (s *GitDirSuite) TearDownTest(c *gc.C) {
+        s.resetLcAll()
         s.LoggingSuite.TearDownTest(c)
         s.GitSuite.TearDownTest(c)
 }
 
-func (s *GitDirSuite) TestInitConfig(c *C) {
+func (s *GitDirSuite) TestInitConfig(c *gc.C) {
         base := c.MkDir()
         repo := charm.NewGitDir(filepath.Join(base, "repo"))
         err := repo.Init()
-        c.Assert(err, IsNil)
+        c.Assert(err, gc.IsNil)
 
         cmd := exec.Command("git", "config", "--list", "--local")
         cmd.Dir = repo.Path()
         out, err := cmd.Output()
-        c.Assert(err, IsNil)
-        c.Assert(string(out), Matches, "(.|\n)*user.email=juju@localhost.\nuser.name=juju(.|\n)*")
-}
-
-func (s *GitDirSuite) TestCreate(c *C) {
+        c.Assert(err, gc.IsNil)
+        outstr := string(out)
+        c.Assert(outstr, checkers.Contains, "user.email=juju@localhost")
+        c.Assert(outstr, checkers.Contains, "user.name=juju")
+}
+
+func (s *GitDirSuite) TestCreate(c *gc.C) {
         base := c.MkDir()
         repo := charm.NewGitDir(filepath.Join(base, "repo"))
         exists, err := repo.Exists()
-        c.Assert(err, IsNil)
-        c.Assert(exists, Equals, false)
+        c.Assert(err, gc.IsNil)
+        c.Assert(exists, checkers.IsFalse)
 
         err = ioutil.WriteFile(repo.Path(), nil, 0644)
-        c.Assert(err, IsNil)
+        c.Assert(err, gc.IsNil)
         _, err = repo.Exists()
-        c.Assert(err, ErrorMatches, `".*/repo" is not a directory`)
+        c.Assert(err, gc.ErrorMatches, `".*/repo" is not a directory`)
         err = os.Remove(repo.Path())
-        c.Assert(err, IsNil)
+        c.Assert(err, gc.IsNil)
 
         err = os.Chmod(base, 0555)
-        c.Assert(err, IsNil)
+        c.Assert(err, gc.IsNil)
         defer os.Chmod(base, 0755)
         err = repo.Init()
-        c.Assert(err, ErrorMatches, ".* permission denied")
+        c.Assert(err, gc.ErrorMatches, ".* permission denied")
         exists, err = repo.Exists()
-        c.Assert(err, IsNil)
-        c.Assert(exists, Equals, false)
+        c.Assert(err, gc.IsNil)
+        c.Assert(exists, checkers.IsFalse)
 
         err = os.Chmod(base, 0755)
-        c.Assert(err, IsNil)
+        c.Assert(err, gc.IsNil)
         err = repo.Init()
-        c.Assert(err, IsNil)
+        c.Assert(err, gc.IsNil)
         exists, err = repo.Exists()
-        c.Assert(err, IsNil)
-        c.Assert(exists, Equals, true)
+        c.Assert(err, gc.IsNil)
+        c.Assert(exists, checkers.IsTrue)
 
         _, err = charm.ReadCharmURL(repo)
         c.Assert(err, checkers.Satisfies, os.IsNotExist)
 
         err = repo.Init()
-        c.Assert(err, IsNil)
-}
-
-func (s *GitDirSuite) TestAddCommitPullRevert(c *C) {
+        c.Assert(err, gc.IsNil)
+}
+
+func (s *GitDirSuite) TestAddCommitPullRevert(c *gc.C) {
         target := charm.NewGitDir(c.MkDir())
         err := target.Init()
-        c.Assert(err, IsNil)
+        c.Assert(err, gc.IsNil)
         err = ioutil.WriteFile(filepath.Join(target.Path(), "initial"), []byte("initial"), 0644)
-        c.Assert(err, IsNil)
+        c.Assert(err, gc.IsNil)
         err = charm.WriteCharmURL(target, curl)
-        c.Assert(err, IsNil)
+        c.Assert(err, gc.IsNil)
         err = target.AddAll()
-        c.Assert(err, IsNil)
+        c.Assert(err, gc.IsNil)
         dirty, err := target.Dirty()
-        c.Assert(err, IsNil)
-        c.Assert(dirty, Equals, true)
+        c.Assert(err, gc.IsNil)
+        c.Assert(dirty, checkers.IsTrue)
         err = target.Commitf("initial")
-        c.Assert(err, IsNil)
-        dirty, err = target.Dirty()
-        c.Assert(err, IsNil)
-        c.Assert(dirty, Equals, false)
+        c.Assert(err, gc.IsNil)
+        dirty, err = target.Dirty()
+        c.Assert(err, gc.IsNil)
+        c.Assert(dirty, checkers.IsFalse)
 
         source := newRepo(c)
         err = target.Pull(source)
-        c.Assert(err, IsNil)
+        c.Assert(err, gc.IsNil)
         url, err := charm.ReadCharmURL(target)
-        c.Assert(err, IsNil)
-        c.Assert(url, DeepEquals, curl)
+        c.Assert(err, gc.IsNil)
+        c.Assert(url, gc.DeepEquals, curl)
         fi, err := os.Stat(filepath.Join(target.Path(), "some-dir"))
-        c.Assert(err, IsNil)
+        c.Assert(err, gc.IsNil)
         c.Assert(fi, checkers.Satisfies, os.FileInfo.IsDir)
         data, err := ioutil.ReadFile(filepath.Join(target.Path(), "some-file"))
-        c.Assert(err, IsNil)
-        c.Assert(string(data), Equals, "hello")
-        dirty, err = target.Dirty()
-        c.Assert(err, IsNil)
-        c.Assert(dirty, Equals, false)
+        c.Assert(err, gc.IsNil)
+        c.Assert(string(data), gc.Equals, "hello")
+        dirty, err = target.Dirty()
+        c.Assert(err, gc.IsNil)
+        c.Assert(dirty, checkers.IsFalse)
 
         err = ioutil.WriteFile(filepath.Join(target.Path(), "another-file"), []byte("blah"), 0644)
-        c.Assert(err, IsNil)
-        dirty, err = target.Dirty()
-        c.Assert(err, IsNil)
-        c.Assert(dirty, Equals, true)
+        c.Assert(err, gc.IsNil)
+        dirty, err = target.Dirty()
+        c.Assert(err, gc.IsNil)
+        c.Assert(dirty, checkers.IsTrue)
         err = source.AddAll()
-        c.Assert(err, IsNil)
-        dirty, err = target.Dirty()
-        c.Assert(err, IsNil)
-        c.Assert(dirty, Equals, true)
+        c.Assert(err, gc.IsNil)
+        dirty, err = target.Dirty()
+        c.Assert(err, gc.IsNil)
+        c.Assert(dirty, checkers.IsTrue)
 
         err = target.Revert()
-        c.Assert(err, IsNil)
+        c.Assert(err, gc.IsNil)
         _, err = os.Stat(filepath.Join(target.Path(), "some-file"))
         c.Assert(err, checkers.Satisfies, os.IsNotExist)
         _, err = os.Stat(filepath.Join(target.Path(), "some-dir"))
         c.Assert(err, checkers.Satisfies, os.IsNotExist)
         data, err = ioutil.ReadFile(filepath.Join(target.Path(), "initial"))
-        c.Assert(err, IsNil)
-        c.Assert(string(data), Equals, "initial")
-        dirty, err = target.Dirty()
-        c.Assert(err, IsNil)
-        c.Assert(dirty, Equals, false)
-}
-
-func (s *GitDirSuite) TestClone(c *C) {
+        c.Assert(err, gc.IsNil)
+        c.Assert(string(data), gc.Equals, "initial")
+        dirty, err = target.Dirty()
+        c.Assert(err, gc.IsNil)
+        c.Assert(dirty, checkers.IsFalse)
+}
+
+func (s *GitDirSuite) TestClone(c *gc.C) {
         repo, err := newRepo(c).Clone(c.MkDir())
-        c.Assert(err, IsNil)
+        c.Assert(err, gc.IsNil)
         _, err = os.Stat(filepath.Join(repo.Path(), "some-file"))
         c.Assert(err, checkers.Satisfies, os.IsNotExist)
         _, err = os.Stat(filepath.Join(repo.Path(), "some-dir"))
         c.Assert(err, checkers.Satisfies, os.IsNotExist)
         dirty, err := repo.Dirty()
-        c.Assert(err, IsNil)
-        c.Assert(dirty, Equals, true)
+        c.Assert(err, gc.IsNil)
+        c.Assert(dirty, checkers.IsTrue)
 
         err = repo.AddAll()
-        c.Assert(err, IsNil)
+        c.Assert(err, gc.IsNil)
         dirty, err = repo.Dirty()
-        c.Assert(err, IsNil)
-        c.Assert(dirty, Equals, true)
+        c.Assert(err, gc.IsNil)
+        c.Assert(dirty, checkers.IsTrue)
         err = repo.Commitf("blank overwrite")
-        c.Assert(err, IsNil)
+        c.Assert(err, gc.IsNil)
         dirty, err = repo.Dirty()
-        c.Assert(err, IsNil)
-        c.Assert(dirty, Equals, false)
+        c.Assert(err, gc.IsNil)
+        c.Assert(dirty, checkers.IsFalse)
 
         lines, err := repo.Log()
-        c.Assert(err, IsNil)
-        c.Assert(lines, HasLen, 2)
-        c.Assert(lines[0], Matches, "[a-f0-9]{7} blank overwrite")
-        c.Assert(lines[1], Matches, "[a-f0-9]{7} im in ur repo committin ur files")
-}
-
-func (s *GitDirSuite) TestConflictRevert(c *C) {
+        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 *GitDirSuite) TestConflictRevert(c *gc.C) {
         source := newRepo(c)
         updated, err := source.Clone(c.MkDir())
-        c.Assert(err, IsNil)
+        c.Assert(err, gc.IsNil)
         err = ioutil.WriteFile(filepath.Join(updated.Path(), "some-dir"), []byte("hello"), 0644)
-        c.Assert(err, IsNil)
+        c.Assert(err, gc.IsNil)
         err = updated.Snapshotf("potential conflict src")
-        c.Assert(err, IsNil)
+        c.Assert(err, gc.IsNil)
         conflicted, err := updated.Conflicted()
-        c.Assert(err, IsNil)
-        c.Assert(conflicted, Equals, false)
+        c.Assert(err, gc.IsNil)
+        c.Assert(conflicted, checkers.IsFalse)
 
         target := charm.NewGitDir(c.MkDir())
         err = target.Init()
-        c.Assert(err, IsNil)
+        c.Assert(err, gc.IsNil)
         err = target.Pull(source)
-        c.Assert(err, IsNil)
+        c.Assert(err, gc.IsNil)
         err = ioutil.WriteFile(filepath.Join(target.Path(), "some-dir", "conflicting-file"), []byte("hello"), 0644)
-        c.Assert(err, IsNil)
+        c.Assert(err, gc.IsNil)
         err = target.Snapshotf("potential conflict dst")
-        c.Assert(err, IsNil)
+        c.Assert(err, gc.IsNil)
         conflicted, err = target.Conflicted()
-        c.Assert(err, IsNil)
-        c.Assert(conflicted, Equals, false)
+        c.Assert(err, gc.IsNil)
+        c.Assert(conflicted, checkers.IsFalse)
 
         err = target.Pull(updated)
-        c.Assert(err, Equals, charm.ErrConflict)
+        c.Assert(err, gc.Equals, charm.ErrConflict)
         conflicted, err = target.Conflicted()
-        c.Assert(err, IsNil)
-        c.Assert(conflicted, Equals, true)
+        c.Assert(err, gc.IsNil)
+        c.Assert(conflicted, checkers.IsTrue)
         dirty, err := target.Dirty()
-        c.Assert(err, IsNil)
-        c.Assert(dirty, Equals, true)
+        c.Assert(err, gc.IsNil)
+        c.Assert(dirty, checkers.IsTrue)
 
         err = target.Revert()
-        c.Assert(err, IsNil)
+        c.Assert(err, gc.IsNil)
         conflicted, err = target.Conflicted()
-        c.Assert(err, IsNil)
-        c.Assert(conflicted, Equals, false)
-        dirty, err = target.Dirty()
-        c.Assert(err, IsNil)
-        c.Assert(dirty, Equals, false)
-}
-
-func newRepo(c *C) *charm.GitDir {
+        c.Assert(err, gc.IsNil)
+        c.Assert(conflicted, checkers.IsFalse)
+        dirty, err = target.Dirty()
+        c.Assert(err, gc.IsNil)
+        c.Assert(dirty, checkers.IsFalse)
+}
+
+func newRepo(c *gc.C) *charm.GitDir {
         repo := charm.NewGitDir(c.MkDir())
         err := repo.Init()
-        c.Assert(err, IsNil)
+        c.Assert(err, gc.IsNil)
         err = os.Mkdir(filepath.Join(repo.Path(), "some-dir"), 0755)
-        c.Assert(err, IsNil)
+        c.Assert(err, gc.IsNil)
         err = ioutil.WriteFile(filepath.Join(repo.Path(), "some-file"), []byte("hello"), 0644)
-        c.Assert(err, IsNil)
+        c.Assert(err, gc.IsNil)
         err = repo.AddAll()
-        c.Assert(err, IsNil)
+        c.Assert(err, gc.IsNil)
         err = repo.Commitf("im in ur repo committin ur %s", "files")
-        c.Assert(err, IsNil)
+        c.Assert(err, gc.IsNil)
         return repo
 }