go-ceph/rados/snapshot_test.go

313 lines
7.8 KiB
Go

package rados
import (
"testing"
"github.com/stretchr/testify/assert"
"github.com/stretchr/testify/require"
)
func (suite *RadosTestSuite) TestCreateRemoveSnapshot() {
suite.SetupConnection()
suite.T().Run("invalidIOCtx", func(t *testing.T) {
ioctx := &IOContext{}
err := ioctx.CreateSnap("someSnap")
assert.Error(t, err)
err = ioctx.RemoveSnap("someSnap")
assert.Error(t, err)
assert.Equal(t, err, ErrInvalidIOContext)
})
suite.T().Run("NewSnap", func(t *testing.T) {
ioctx, err := suite.conn.OpenIOContext(suite.pool)
require.NoError(suite.T(), err)
snapName := "mySnap"
err = ioctx.CreateSnap(snapName)
assert.NoError(t, err)
err = ioctx.RemoveSnap(snapName)
assert.NoError(t, err)
})
suite.T().Run("ExistingSnap", func(t *testing.T) {
ioctx, err := suite.conn.OpenIOContext(suite.pool)
require.NoError(suite.T(), err)
snapName := "mySnap"
err = ioctx.CreateSnap(snapName)
assert.NoError(t, err)
defer func() {
assert.NoError(t, ioctx.RemoveSnap(snapName))
}()
err = ioctx.CreateSnap(snapName)
assert.Error(t, err)
})
suite.T().Run("NonExistingSnap", func(t *testing.T) {
ioctx, err := suite.conn.OpenIOContext(suite.pool)
require.NoError(suite.T(), err)
err = ioctx.RemoveSnap("someSnapName")
assert.Error(t, err)
})
// Strangely, this works!!
suite.T().Run("EmptySnapNameString", func(t *testing.T) {
ioctx, err := suite.conn.OpenIOContext(suite.pool)
require.NoError(suite.T(), err)
err = ioctx.CreateSnap("")
assert.NoError(t, err)
err = ioctx.RemoveSnap("")
assert.NoError(t, err)
})
}
func (suite *RadosTestSuite) TestSnapshotIDFunctions() {
suite.SetupConnection()
suite.T().Run("invalidIOCtx", func(t *testing.T) {
ioctx := &IOContext{}
_, err := ioctx.LookupSnap("")
assert.Error(t, err)
assert.Equal(t, err, ErrInvalidIOContext)
var snapID SnapID
snapID = 22 // some random number
_, err = ioctx.GetSnapName(snapID)
assert.Error(t, err)
assert.Equal(t, err, ErrInvalidIOContext)
_, err = ioctx.GetSnapStamp(snapID)
assert.Error(t, err)
assert.Equal(t, err, ErrInvalidIOContext)
})
// Invalid args
suite.T().Run("InvalidArgs", func(t *testing.T) {
ioctx, err := suite.conn.OpenIOContext(suite.pool)
require.NoError(suite.T(), err)
err = ioctx.CreateSnap("")
assert.NoError(t, err)
defer func() {
assert.NoError(t, ioctx.RemoveSnap(""))
}()
// Again, this works!!
_, err = ioctx.LookupSnap("")
assert.NoError(t, err)
// Non-existing Snap
_, err = ioctx.LookupSnap("someSnapName")
assert.Error(t, err)
var snapID SnapID
snapID = 22 // some random number
_, err = ioctx.GetSnapName(snapID)
assert.Error(t, err)
_, err = ioctx.GetSnapStamp(snapID)
assert.Error(t, err)
})
// Valid SnapID operations.
suite.T().Run("ValidSnapIDOps", func(t *testing.T) {
ioctx, err := suite.conn.OpenIOContext(suite.pool)
require.NoError(suite.T(), err)
snapName := "mySnap"
err = ioctx.CreateSnap(snapName)
assert.NoError(t, err)
defer func() {
assert.NoError(t, ioctx.RemoveSnap(snapName))
}()
snapID, err := ioctx.LookupSnap(snapName)
assert.NoError(t, err)
retName, err := ioctx.GetSnapName(snapID)
assert.NoError(t, err)
assert.Equal(t, snapName, retName)
_, err = ioctx.GetSnapStamp(snapID)
assert.NoError(t, err)
})
}
func (suite *RadosTestSuite) TestListSnapshot() {
suite.SetupConnection()
ioctx, err := suite.conn.OpenIOContext(suite.pool)
require.NoError(suite.T(), err)
snapName := []string{"snap1", "snap2", "snap3"}
err = ioctx.CreateSnap(snapName[0])
assert.NoError(suite.T(), err)
defer func() {
assert.NoError(suite.T(), ioctx.RemoveSnap(snapName[0]))
}()
err = ioctx.CreateSnap(snapName[1])
assert.NoError(suite.T(), err)
defer func() {
assert.NoError(suite.T(), ioctx.RemoveSnap(snapName[1]))
}()
err = ioctx.CreateSnap(snapName[2])
assert.NoError(suite.T(), err)
defer func() {
assert.NoError(suite.T(), ioctx.RemoveSnap(snapName[2]))
}()
suite.T().Run("invalidIOContext", func(t *testing.T) {
ioctx := &IOContext{}
_, err := ioctx.ListSnaps()
assert.Error(t, err)
assert.Equal(t, err, ErrInvalidIOContext)
})
snapList, err := ioctx.ListSnaps()
assert.NoError(suite.T(), err)
assert.NotNil(suite.T(), snapList)
listLen := len(snapList)
suite.T().Run("NumberOfSnapshots", func(t *testing.T) {
assert.Equal(t, 3, listLen)
})
suite.T().Run("MatchSnapNamesWithID", func(t *testing.T) {
for _, id := range snapList[0 : listLen-1] {
retName, err := ioctx.GetSnapName(id)
assert.NoError(t, err)
assert.NotNil(t, retName)
assert.Contains(t, snapName, retName)
}
})
}
func (suite *RadosTestSuite) TestRollbackSnapshot() {
suite.SetupConnection()
suite.T().Run("InvalidArgs", func(t *testing.T) {
ioctx, err := suite.conn.OpenIOContext(suite.pool)
require.NoError(suite.T(), err)
oid := suite.GenObjectName()
defer suite.ioctx.Delete(oid)
err = ioctx.RollbackSnap(oid, "someName")
assert.Error(t, err)
err = ioctx.CreateSnap("")
assert.NoError(t, err)
defer func() {
assert.NoError(t, ioctx.RemoveSnap(""))
}()
err = ioctx.RollbackSnap("someObj", "")
assert.NoError(t, err)
})
suite.T().Run("invalidIOContext", func(t *testing.T) {
ioctx := &IOContext{}
err := ioctx.RollbackSnap("someObj", "someName")
assert.Error(t, err)
assert.Equal(t, err, ErrInvalidIOContext)
})
suite.T().Run("WriteAndRollback", func(t *testing.T) {
ioctx, err := suite.conn.OpenIOContext(suite.pool)
require.NoError(suite.T(), err)
oid := suite.GenObjectName()
defer suite.ioctx.Delete(oid)
bytesIn := []byte("Harry Potter")
err = suite.ioctx.Write(oid, bytesIn, 0)
assert.NoError(t, err)
// Take snap.
err = ioctx.CreateSnap("mySnap")
assert.NoError(t, err)
defer func() {
assert.NoError(t, ioctx.RemoveSnap("mySnap"))
}()
// Overwrite.
bytesOver := []byte("Potter Harry")
err = suite.ioctx.Write(oid, bytesOver, 0)
assert.NoError(t, err)
// Before rollback.
bytesOut := make([]byte, len(bytesOver))
nOut, err := suite.ioctx.Read(oid, bytesOut, 0)
assert.NoError(t, err)
assert.Equal(t, nOut, len(bytesOver))
assert.Equal(t, bytesOver, bytesOut)
// Rollback.
err = ioctx.RollbackSnap(oid, "mySnap")
assert.NoError(t, err)
// After Rollback.
nOut, err = suite.ioctx.Read(oid, bytesOut, 0)
assert.NoError(t, err)
assert.Equal(t, nOut, len(bytesIn))
assert.Equal(t, bytesOut, bytesIn)
})
}
func (suite *RadosTestSuite) TestSetReadSnapshot() {
suite.SetupConnection()
ioctx, err := suite.conn.OpenIOContext(suite.pool)
require.NoError(suite.T(), err)
bytesIn := []byte("The Order of the Phoenix")
err = ioctx.Write("obj", bytesIn, 0)
assert.NoError(suite.T(), err)
// Take snap.
err = ioctx.CreateSnap("mySnap")
assert.NoError(suite.T(), err)
defer func() {
assert.NoError(suite.T(), ioctx.RemoveSnap("mySnap"))
}()
// Get Snap ID.
snapID, err := ioctx.LookupSnap("mySnap")
assert.NoError(suite.T(), err)
assert.NotNil(suite.T(), snapID)
// Overwrite the object.
bytesOver := []byte("The Half blood Prince")
err = ioctx.Write("obj", bytesOver, 0)
assert.NoError(suite.T(), err)
// Set read to mySnap.
err = ioctx.SetReadSnap(snapID)
assert.NoError(suite.T(), err)
// Read the object.
bytesOut := make([]byte, len(bytesIn))
nOut, err := ioctx.Read("obj", bytesOut, 0)
assert.NoError(suite.T(), err)
assert.Equal(suite.T(), nOut, len(bytesIn))
assert.Equal(suite.T(), bytesOut, bytesIn)
// Set read to SnapHead (back to normal).
err = ioctx.SetReadSnap(SnapHead)
assert.NoError(suite.T(), err)
// Read the same object.
bytesOut = make([]byte, len(bytesOver))
nOut, err = ioctx.Read("obj", bytesOut, 0)
assert.NoError(suite.T(), err)
assert.Equal(suite.T(), nOut, len(bytesOver))
assert.Equal(suite.T(), bytesOut, bytesOver)
suite.T().Run("invalidIOContext", func(t *testing.T) {
ioctx := &IOContext{}
err := ioctx.SetReadSnap(SnapHead)
assert.Error(t, err)
assert.Equal(t, err, ErrInvalidIOContext)
})
}