func (s *createSuite) TestLegacy(c *gc.C) {
if runtime.GOOS == "windows" {
c.Skip("bug 1403084: Currently does not work on windows, see comments inside backups.create function")
}
meta := backupstesting.NewMetadataStarted()
metadataFile, err := meta.AsJSONBuffer()
c.Assert(err, jc.ErrorIsNil)
_, testFiles, expected := s.createTestFiles(c)
dumper := &TestDBDumper{}
args := backups.NewTestCreateArgs(testFiles, dumper, metadataFile)
result, err := backups.Create(args)
c.Assert(err, jc.ErrorIsNil)
c.Assert(result, gc.NotNil)
archiveFile, size, checksum := backups.ExposeCreateResult(result)
c.Assert(archiveFile, gc.NotNil)
// Check the result.
file, ok := archiveFile.(*os.File)
c.Assert(ok, jc.IsTrue)
s.checkSize(c, file, size)
s.checkChecksum(c, file, checksum)
s.checkArchive(c, file, expected)
}
func (s *backupsSuite) setStored(id string) *time.Time {
s.Storage.ID = id
s.Storage.Meta = backupstesting.NewMetadataStarted()
s.Storage.Meta.SetID(id)
stored := time.Now().UTC()
s.Storage.Meta.SetStored(&stored)
return &stored
}
func (s *backupsSuite) SetUpTest(c *gc.C) {
s.JujuConnSuite.SetUpTest(c)
s.resources = common.NewResources()
s.resources.RegisterNamed("dataDir", common.StringResource("/var/lib/juju"))
tag := names.NewLocalUserTag("spam")
s.authorizer = &apiservertesting.FakeAuthorizer{Tag: tag}
var err error
s.api, err = backupsAPI.NewAPI(s.State, s.resources, s.authorizer)
c.Assert(err, jc.ErrorIsNil)
s.meta = backupstesting.NewMetadataStarted()
}
func (s *backupsSuite) checkFailure(c *gc.C, expected string) {
s.PatchValue(backups.GetDBDumper, func(*backups.DBInfo) (backups.DBDumper, error) {
return &fakeDumper{}, nil
})
paths := backups.Paths{DataDir: "/var/lib/juju"}
targets := set.NewStrings("juju", "admin")
dbInfo := backups.DBInfo{"a", "b", "c", targets}
meta := backupstesting.NewMetadataStarted()
meta.Notes = "some notes"
err := s.api.Create(meta, &paths, &dbInfo)
c.Check(err, gc.ErrorMatches, expected)
}
func (s *backupsSuite) TestStoreArchive(c *gc.C) {
stored := s.setStored("spam")
meta := backupstesting.NewMetadataStarted()
c.Assert(meta.ID(), gc.Equals, "")
c.Assert(meta.Stored(), gc.IsNil)
archive := &bytes.Buffer{}
err := backups.StoreArchive(s.Storage, meta, archive)
c.Assert(err, jc.ErrorIsNil)
s.Storage.CheckCalled(c, "spam", meta, archive, "Add", "Metadata")
c.Assert(meta.ID(), gc.Equals, "spam")
c.Assert(meta.Stored(), jc.DeepEquals, stored)
}
func (s *backupsSuite) TestCreateOkay(c *gc.C) {
// Patch the internals.
archiveFile := ioutil.NopCloser(bytes.NewBufferString("<compressed tarball>"))
result := backups.NewTestCreateResult(archiveFile, 10, "<checksum>")
received, testCreate := backups.NewTestCreate(result)
s.PatchValue(backups.RunCreate, testCreate)
rootDir := "<was never set>"
s.PatchValue(backups.TestGetFilesToBackUp, func(root string, paths *backups.Paths, oldmachine string) ([]string, error) {
rootDir = root
return []string{"<some file>"}, nil
})
var receivedDBInfo *backups.DBInfo
s.PatchValue(backups.GetDBDumper, func(info *backups.DBInfo) (backups.DBDumper, error) {
receivedDBInfo = info
return nil, nil
})
stored := s.setStored("spam")
// Run the backup.
paths := backups.Paths{DataDir: "/var/lib/juju"}
targets := set.NewStrings("juju", "admin")
dbInfo := backups.DBInfo{"a", "b", "c", targets}
meta := backupstesting.NewMetadataStarted()
backupstesting.SetOrigin(meta, "<env ID>", "<machine ID>", "<hostname>")
meta.Notes = "some notes"
err := s.api.Create(meta, &paths, &dbInfo)
// Test the call values.
s.Storage.CheckCalled(c, "spam", meta, archiveFile, "Add", "Metadata")
filesToBackUp, _ := backups.ExposeCreateArgs(received)
c.Check(filesToBackUp, jc.SameContents, []string{"<some file>"})
c.Check(receivedDBInfo.Address, gc.Equals, "a")
c.Check(receivedDBInfo.Username, gc.Equals, "b")
c.Check(receivedDBInfo.Password, gc.Equals, "c")
c.Check(receivedDBInfo.Targets, gc.DeepEquals, targets)
c.Check(rootDir, gc.Equals, "")
// Check the resulting metadata.
c.Check(meta, gc.Equals, s.Storage.MetaArg)
c.Check(meta.ID(), gc.Equals, "spam")
c.Check(meta.Size(), gc.Equals, int64(10))
c.Check(meta.Checksum(), gc.Equals, "<checksum>")
c.Check(meta.Stored().Unix(), gc.Equals, stored.Unix())
c.Check(meta.Origin.Environment, gc.Equals, "<env ID>")
c.Check(meta.Origin.Machine, gc.Equals, "<machine ID>")
c.Check(meta.Origin.Hostname, gc.Equals, "<hostname>")
c.Check(meta.Notes, gc.Equals, "some notes")
// Check the file storage.
s.Storage.Meta = meta
s.Storage.File = archiveFile
storedMeta, storedFile, err := s.Storage.Get(meta.ID())
c.Check(err, jc.ErrorIsNil)
c.Check(storedMeta, gc.DeepEquals, meta)
data, err := ioutil.ReadAll(storedFile)
c.Assert(err, jc.ErrorIsNil)
c.Check(string(data), gc.Equals, "<compressed tarball>")
}