github.com/cloudbase/juju-core@v0.0.0-20140504232958-a7271ac7912f/worker/uniter/charm/git_test.go (about)

     1  // Copyright 2012, 2013 Canonical Ltd.
     2  // Licensed under the AGPLv3, see LICENCE file for details.
     3  
     4  package charm_test
     5  
     6  import (
     7  	"io/ioutil"
     8  	"os"
     9  	"os/exec"
    10  	"path/filepath"
    11  
    12  	gc "launchpad.net/gocheck"
    13  
    14  	corecharm "launchpad.net/juju-core/charm"
    15  	"launchpad.net/juju-core/testing"
    16  	jc "launchpad.net/juju-core/testing/checkers"
    17  	"launchpad.net/juju-core/testing/testbase"
    18  	"launchpad.net/juju-core/worker/uniter/charm"
    19  )
    20  
    21  var curl = corecharm.MustParseURL("cs:series/blah-blah-123")
    22  
    23  type GitDirSuite struct {
    24  	testing.GitSuite
    25  	LoggingSuite testbase.LoggingSuite
    26  }
    27  
    28  var _ = gc.Suite(&GitDirSuite{})
    29  
    30  func (s *GitDirSuite) SetUpTest(c *gc.C) {
    31  	s.GitSuite.SetUpTest(c)
    32  	s.LoggingSuite.SetUpTest(c)
    33  	s.LoggingSuite.PatchEnvironment("LC_ALL", "en_US")
    34  }
    35  
    36  func (s *GitDirSuite) TearDownTest(c *gc.C) {
    37  	s.LoggingSuite.TearDownTest(c)
    38  	s.GitSuite.TearDownTest(c)
    39  }
    40  
    41  func (s *GitDirSuite) TestInitConfig(c *gc.C) {
    42  	base := c.MkDir()
    43  	repo := charm.NewGitDir(filepath.Join(base, "repo"))
    44  	err := repo.Init()
    45  	c.Assert(err, gc.IsNil)
    46  
    47  	cmd := exec.Command("git", "config", "--list", "--local")
    48  	cmd.Dir = repo.Path()
    49  	out, err := cmd.Output()
    50  	c.Assert(err, gc.IsNil)
    51  	outstr := string(out)
    52  	c.Assert(outstr, jc.Contains, "user.email=juju@localhost")
    53  	c.Assert(outstr, jc.Contains, "user.name=juju")
    54  }
    55  
    56  func (s *GitDirSuite) TestCreate(c *gc.C) {
    57  	base := c.MkDir()
    58  	repo := charm.NewGitDir(filepath.Join(base, "repo"))
    59  	exists, err := repo.Exists()
    60  	c.Assert(err, gc.IsNil)
    61  	c.Assert(exists, jc.IsFalse)
    62  
    63  	err = ioutil.WriteFile(repo.Path(), nil, 0644)
    64  	c.Assert(err, gc.IsNil)
    65  	_, err = repo.Exists()
    66  	c.Assert(err, gc.ErrorMatches, `".*/repo" is not a directory`)
    67  	err = os.Remove(repo.Path())
    68  	c.Assert(err, gc.IsNil)
    69  
    70  	err = os.Chmod(base, 0555)
    71  	c.Assert(err, gc.IsNil)
    72  	defer os.Chmod(base, 0755)
    73  	err = repo.Init()
    74  	c.Assert(err, gc.ErrorMatches, ".* permission denied")
    75  	exists, err = repo.Exists()
    76  	c.Assert(err, gc.IsNil)
    77  	c.Assert(exists, jc.IsFalse)
    78  
    79  	err = os.Chmod(base, 0755)
    80  	c.Assert(err, gc.IsNil)
    81  	err = repo.Init()
    82  	c.Assert(err, gc.IsNil)
    83  	exists, err = repo.Exists()
    84  	c.Assert(err, gc.IsNil)
    85  	c.Assert(exists, jc.IsTrue)
    86  
    87  	_, err = charm.ReadCharmURL(repo)
    88  	c.Assert(err, jc.Satisfies, os.IsNotExist)
    89  
    90  	err = repo.Init()
    91  	c.Assert(err, gc.IsNil)
    92  }
    93  
    94  func (s *GitDirSuite) TestAddCommitPullRevert(c *gc.C) {
    95  	target := charm.NewGitDir(c.MkDir())
    96  	err := target.Init()
    97  	c.Assert(err, gc.IsNil)
    98  	err = ioutil.WriteFile(filepath.Join(target.Path(), "initial"), []byte("initial"), 0644)
    99  	c.Assert(err, gc.IsNil)
   100  	err = charm.WriteCharmURL(target, curl)
   101  	c.Assert(err, gc.IsNil)
   102  	err = target.AddAll()
   103  	c.Assert(err, gc.IsNil)
   104  	dirty, err := target.Dirty()
   105  	c.Assert(err, gc.IsNil)
   106  	c.Assert(dirty, jc.IsTrue)
   107  	err = target.Commitf("initial")
   108  	c.Assert(err, gc.IsNil)
   109  	dirty, err = target.Dirty()
   110  	c.Assert(err, gc.IsNil)
   111  	c.Assert(dirty, jc.IsFalse)
   112  
   113  	source := newRepo(c)
   114  	err = target.Pull(source)
   115  	c.Assert(err, gc.IsNil)
   116  	url, err := charm.ReadCharmURL(target)
   117  	c.Assert(err, gc.IsNil)
   118  	c.Assert(url, gc.DeepEquals, curl)
   119  	fi, err := os.Stat(filepath.Join(target.Path(), "some-dir"))
   120  	c.Assert(err, gc.IsNil)
   121  	c.Assert(fi, jc.Satisfies, os.FileInfo.IsDir)
   122  	data, err := ioutil.ReadFile(filepath.Join(target.Path(), "some-file"))
   123  	c.Assert(err, gc.IsNil)
   124  	c.Assert(string(data), gc.Equals, "hello")
   125  	dirty, err = target.Dirty()
   126  	c.Assert(err, gc.IsNil)
   127  	c.Assert(dirty, jc.IsFalse)
   128  
   129  	err = ioutil.WriteFile(filepath.Join(target.Path(), "another-file"), []byte("blah"), 0644)
   130  	c.Assert(err, gc.IsNil)
   131  	dirty, err = target.Dirty()
   132  	c.Assert(err, gc.IsNil)
   133  	c.Assert(dirty, jc.IsTrue)
   134  	err = source.AddAll()
   135  	c.Assert(err, gc.IsNil)
   136  	dirty, err = target.Dirty()
   137  	c.Assert(err, gc.IsNil)
   138  	c.Assert(dirty, jc.IsTrue)
   139  
   140  	err = target.Revert()
   141  	c.Assert(err, gc.IsNil)
   142  	_, err = os.Stat(filepath.Join(target.Path(), "some-file"))
   143  	c.Assert(err, jc.Satisfies, os.IsNotExist)
   144  	_, err = os.Stat(filepath.Join(target.Path(), "some-dir"))
   145  	c.Assert(err, jc.Satisfies, os.IsNotExist)
   146  	data, err = ioutil.ReadFile(filepath.Join(target.Path(), "initial"))
   147  	c.Assert(err, gc.IsNil)
   148  	c.Assert(string(data), gc.Equals, "initial")
   149  	dirty, err = target.Dirty()
   150  	c.Assert(err, gc.IsNil)
   151  	c.Assert(dirty, jc.IsFalse)
   152  }
   153  
   154  func (s *GitDirSuite) TestClone(c *gc.C) {
   155  	repo, err := newRepo(c).Clone(c.MkDir())
   156  	c.Assert(err, gc.IsNil)
   157  	_, err = os.Stat(filepath.Join(repo.Path(), "some-file"))
   158  	c.Assert(err, jc.Satisfies, os.IsNotExist)
   159  	_, err = os.Stat(filepath.Join(repo.Path(), "some-dir"))
   160  	c.Assert(err, jc.Satisfies, os.IsNotExist)
   161  	dirty, err := repo.Dirty()
   162  	c.Assert(err, gc.IsNil)
   163  	c.Assert(dirty, jc.IsTrue)
   164  
   165  	err = repo.AddAll()
   166  	c.Assert(err, gc.IsNil)
   167  	dirty, err = repo.Dirty()
   168  	c.Assert(err, gc.IsNil)
   169  	c.Assert(dirty, jc.IsTrue)
   170  	err = repo.Commitf("blank overwrite")
   171  	c.Assert(err, gc.IsNil)
   172  	dirty, err = repo.Dirty()
   173  	c.Assert(err, gc.IsNil)
   174  	c.Assert(dirty, jc.IsFalse)
   175  
   176  	lines, err := repo.Log()
   177  	c.Assert(err, gc.IsNil)
   178  	c.Assert(lines, gc.HasLen, 2)
   179  	c.Assert(lines[0], gc.Matches, "[a-f0-9]{7} blank overwrite")
   180  	c.Assert(lines[1], gc.Matches, "[a-f0-9]{7} im in ur repo committin ur files")
   181  }
   182  
   183  func (s *GitDirSuite) TestConflictRevert(c *gc.C) {
   184  	source := newRepo(c)
   185  	updated, err := source.Clone(c.MkDir())
   186  	c.Assert(err, gc.IsNil)
   187  	err = ioutil.WriteFile(filepath.Join(updated.Path(), "some-dir"), []byte("hello"), 0644)
   188  	c.Assert(err, gc.IsNil)
   189  	err = updated.Snapshotf("potential conflict src")
   190  	c.Assert(err, gc.IsNil)
   191  	conflicted, err := updated.Conflicted()
   192  	c.Assert(err, gc.IsNil)
   193  	c.Assert(conflicted, jc.IsFalse)
   194  
   195  	target := charm.NewGitDir(c.MkDir())
   196  	err = target.Init()
   197  	c.Assert(err, gc.IsNil)
   198  	err = target.Pull(source)
   199  	c.Assert(err, gc.IsNil)
   200  	err = ioutil.WriteFile(filepath.Join(target.Path(), "some-dir", "conflicting-file"), []byte("hello"), 0644)
   201  	c.Assert(err, gc.IsNil)
   202  	err = target.Snapshotf("potential conflict dst")
   203  	c.Assert(err, gc.IsNil)
   204  	conflicted, err = target.Conflicted()
   205  	c.Assert(err, gc.IsNil)
   206  	c.Assert(conflicted, jc.IsFalse)
   207  
   208  	err = target.Pull(updated)
   209  	c.Assert(err, gc.Equals, charm.ErrConflict)
   210  	conflicted, err = target.Conflicted()
   211  	c.Assert(err, gc.IsNil)
   212  	c.Assert(conflicted, jc.IsTrue)
   213  	dirty, err := target.Dirty()
   214  	c.Assert(err, gc.IsNil)
   215  	c.Assert(dirty, jc.IsTrue)
   216  
   217  	err = target.Revert()
   218  	c.Assert(err, gc.IsNil)
   219  	conflicted, err = target.Conflicted()
   220  	c.Assert(err, gc.IsNil)
   221  	c.Assert(conflicted, jc.IsFalse)
   222  	dirty, err = target.Dirty()
   223  	c.Assert(err, gc.IsNil)
   224  	c.Assert(dirty, jc.IsFalse)
   225  }
   226  
   227  func newRepo(c *gc.C) *charm.GitDir {
   228  	repo := charm.NewGitDir(c.MkDir())
   229  	err := repo.Init()
   230  	c.Assert(err, gc.IsNil)
   231  	err = os.Mkdir(filepath.Join(repo.Path(), "some-dir"), 0755)
   232  	c.Assert(err, gc.IsNil)
   233  	err = ioutil.WriteFile(filepath.Join(repo.Path(), "some-file"), []byte("hello"), 0644)
   234  	c.Assert(err, gc.IsNil)
   235  	err = repo.AddAll()
   236  	c.Assert(err, gc.IsNil)
   237  	err = repo.Commitf("im in ur repo committin ur %s", "files")
   238  	c.Assert(err, gc.IsNil)
   239  	return repo
   240  }