github.com/makyo/juju@v0.0.0-20160425123129-2608902037e9/state/backups/db_restore_test.go (about)

     1  // Copyright 2014 Canonical Ltd.
     2  // Licensed under the AGPLv3, see LICENCE file for details.
     3  
     4  package backups_test
     5  
     6  import (
     7  	"path/filepath"
     8  
     9  	jc "github.com/juju/testing/checkers"
    10  	"github.com/juju/version"
    11  	gc "gopkg.in/check.v1"
    12  
    13  	"github.com/juju/juju/agent"
    14  	"github.com/juju/juju/state/backups"
    15  	"github.com/juju/juju/testing"
    16  )
    17  
    18  var _ = gc.Suite(&mongoRestoreSuite{})
    19  
    20  type mongoRestoreSuite struct {
    21  	testing.BaseSuite
    22  }
    23  
    24  func (s *mongoRestoreSuite) TestMongoRestoreArgsForVersion121(c *gc.C) {
    25  	dir := filepath.Join(agent.DefaultPaths.DataDir, "db")
    26  	versionNumber := version.Number{}
    27  	versionNumber.Major = 1
    28  	versionNumber.Minor = 21
    29  	args, err := backups.MongoRestoreArgsForVersion(versionNumber, "/some/fake/path")
    30  	c.Assert(err, jc.ErrorIsNil)
    31  	c.Assert(args, gc.HasLen, 5)
    32  	c.Assert(args[0:5], jc.DeepEquals, []string{
    33  		"--drop",
    34  		"--journal",
    35  		"--dbpath",
    36  		dir,
    37  		"/some/fake/path",
    38  	})
    39  }
    40  
    41  func (s *mongoRestoreSuite) TestMongoRestoreArgsForVersion122(c *gc.C) {
    42  	dir := filepath.Join(agent.DefaultPaths.DataDir, "db")
    43  	versionNumber := version.Number{}
    44  	versionNumber.Major = 1
    45  	versionNumber.Minor = 22
    46  	args, err := backups.MongoRestoreArgsForVersion(versionNumber, "/some/fake/path")
    47  	c.Assert(err, jc.ErrorIsNil)
    48  	c.Assert(args, gc.HasLen, 6)
    49  	c.Assert(args[0:6], jc.DeepEquals, []string{
    50  		"--drop",
    51  		"--journal",
    52  		"--oplogReplay",
    53  		"--dbpath",
    54  		dir,
    55  		"/some/fake/path",
    56  	})
    57  }
    58  
    59  func (s *mongoRestoreSuite) TestMongoRestoreArgsForVersion2(c *gc.C) {
    60  	dir := filepath.Join(agent.DefaultPaths.DataDir, "db")
    61  	versionNumber := version.Number{}
    62  	versionNumber.Major = 2
    63  	versionNumber.Minor = 0
    64  	args, err := backups.MongoRestoreArgsForVersion(versionNumber, "/some/fake/path")
    65  	c.Assert(err, jc.ErrorIsNil)
    66  	c.Assert(args, gc.HasLen, 6)
    67  	c.Assert(args[0:6], jc.DeepEquals, []string{
    68  		"--drop",
    69  		"--journal",
    70  		"--oplogReplay",
    71  		"--dbpath",
    72  		dir,
    73  		"/some/fake/path",
    74  	})
    75  }
    76  
    77  func (s *mongoRestoreSuite) TestMongoRestoreArgsForOldVersion(c *gc.C) {
    78  	versionNumber := version.Number{}
    79  	versionNumber.Major = 0
    80  	versionNumber.Minor = 0
    81  	_, err := backups.MongoRestoreArgsForVersion(versionNumber, "/some/fake/path")
    82  	c.Assert(err, gc.ErrorMatches, "this backup file is incompatible with the current version of juju")
    83  }
    84  
    85  func (s *mongoRestoreSuite) TestPlaceNewMongo(c *gc.C) {
    86  	var argsVersion version.Number
    87  	var newMongoDumpPath string
    88  	ranArgs := make([][]string, 0, 3)
    89  	ranCommands := []string{}
    90  
    91  	restorePathCalled := false
    92  
    93  	runCommand := func(command string, mongoRestoreArgs ...string) error {
    94  		mgoArgs := make([]string, len(mongoRestoreArgs), len(mongoRestoreArgs))
    95  		for i, v := range mongoRestoreArgs {
    96  			mgoArgs[i] = v
    97  		}
    98  		ranArgs = append(ranArgs, mgoArgs)
    99  		ranCommands = append(ranCommands, command)
   100  		return nil
   101  	}
   102  	s.PatchValue(backups.RunCommand, runCommand)
   103  
   104  	restorePath := func() (string, error) {
   105  		restorePathCalled = true
   106  		return "/fake/mongo/restore/path", nil
   107  	}
   108  	s.PatchValue(backups.RestorePath, restorePath)
   109  
   110  	ver := version.Number{Major: 1, Minor: 22}
   111  	args := []string{"a", "set", "of", "args"}
   112  	restoreArgsForVersion := func(versionNumber version.Number, mongoDumpPath string) ([]string, error) {
   113  		newMongoDumpPath = mongoDumpPath
   114  		argsVersion = versionNumber
   115  		return args, nil
   116  	}
   117  	s.PatchValue(backups.RestoreArgsForVersion, restoreArgsForVersion)
   118  
   119  	err := backups.PlaceNewMongo("fakemongopath", ver)
   120  	c.Assert(restorePathCalled, jc.IsTrue)
   121  	c.Assert(err, jc.ErrorIsNil)
   122  	c.Assert(argsVersion, gc.DeepEquals, ver)
   123  	c.Assert(newMongoDumpPath, gc.Equals, "fakemongopath")
   124  	expectedCommands := []string{"/fake/mongo/restore/path"}
   125  	c.Assert(ranCommands, gc.DeepEquals, expectedCommands)
   126  	c.Assert(len(ranArgs), gc.Equals, 1)
   127  	expectedArgs := [][]string{{"a", "set", "of", "args"}}
   128  	c.Assert(ranArgs, gc.DeepEquals, expectedArgs)
   129  }