mirror of
https://github.com/ceph/go-ceph
synced 2024-12-24 15:13:11 +00:00
145 lines
3.5 KiB
Go
145 lines
3.5 KiB
Go
package rados
|
|
|
|
import (
|
|
"testing"
|
|
|
|
"github.com/stretchr/testify/assert"
|
|
)
|
|
|
|
func (suite *RadosTestSuite) TestReadOpAssertExists() {
|
|
suite.SetupConnection()
|
|
oid := "TestReadOpAssertExists"
|
|
|
|
wrop := CreateWriteOp()
|
|
defer wrop.Release()
|
|
wrop.Create(CreateIdempotent)
|
|
err := wrop.Operate(suite.ioctx, oid, OperationNoFlag)
|
|
assert.NoError(suite.T(), err)
|
|
|
|
op := CreateReadOp()
|
|
defer op.Release()
|
|
op.AssertExists()
|
|
err = op.Operate(suite.ioctx, oid, OperationNoFlag)
|
|
assert.NoError(suite.T(), err)
|
|
|
|
op2 := CreateReadOp()
|
|
defer op2.Release()
|
|
op2.AssertExists()
|
|
err = op2.Operate(suite.ioctx, oid+"junk", OperationNoFlag)
|
|
assert.Error(suite.T(), err)
|
|
|
|
// ensure a nil ioctx triggers a panic
|
|
assert.Panics(suite.T(), func() {
|
|
_ = op2.Operate(nil, "foo", OperationNoFlag)
|
|
})
|
|
}
|
|
|
|
func getAllMap(gos *GetOmapStep) map[string][]byte {
|
|
r := make(map[string][]byte)
|
|
for {
|
|
kv, err := gos.Next()
|
|
if err != nil {
|
|
panic(err)
|
|
}
|
|
if kv == nil {
|
|
break
|
|
}
|
|
r[kv.Key] = kv.Value
|
|
}
|
|
return r
|
|
}
|
|
|
|
func (suite *RadosTestSuite) TestReadOpGetOmapValues() {
|
|
suite.SetupConnection()
|
|
ta := assert.New(suite.T())
|
|
oid := "TestReadOpGetOmapValues"
|
|
|
|
wrop := CreateWriteOp()
|
|
defer wrop.Release()
|
|
wrop.Create(CreateIdempotent)
|
|
wrop.SetOmap(map[string][]byte{
|
|
"tos.captain": []byte("Kirk"),
|
|
"tos.first-officer": []byte("Spock"),
|
|
"tos.doctor": []byte("McCoy"),
|
|
"tng.captain": []byte("Picard"),
|
|
"tng.first-officer": []byte("Riker"),
|
|
"tng.doctor": []byte("Crusher"),
|
|
"random.value": []byte("foobar"),
|
|
"no.value": []byte(""),
|
|
})
|
|
err := wrop.Operate(suite.ioctx, oid, OperationNoFlag)
|
|
ta.NoError(err)
|
|
|
|
suite.T().Run("simple", func(t *testing.T) {
|
|
ta := assert.New(t)
|
|
op := CreateReadOp()
|
|
defer op.Release()
|
|
op.AssertExists()
|
|
gos := op.GetOmapValues("", "", 16)
|
|
err = op.Operate(suite.ioctx, oid, OperationNoFlag)
|
|
ta.NoError(err)
|
|
|
|
omap := getAllMap(gos)
|
|
ta.Len(omap, 8)
|
|
ta.Contains(omap, "tos.captain")
|
|
ta.Contains(omap, "tng.captain")
|
|
ta.False(gos.More())
|
|
})
|
|
|
|
suite.T().Run("twoIterations", func(t *testing.T) {
|
|
// test two iterations over different subsets of omap keys
|
|
ta := assert.New(t)
|
|
op := CreateReadOp()
|
|
defer op.Release()
|
|
op.AssertExists()
|
|
gos1 := op.GetOmapValues("", "tos", 16)
|
|
gos2 := op.GetOmapValues("", "tng", 16)
|
|
err = op.Operate(suite.ioctx, oid, OperationNoFlag)
|
|
ta.NoError(err)
|
|
|
|
omap1 := getAllMap(gos1)
|
|
ta.Len(omap1, 3)
|
|
ta.Contains(omap1, "tos.captain")
|
|
ta.Contains(omap1, "tos.first-officer")
|
|
ta.Contains(omap1, "tos.doctor")
|
|
omap2 := getAllMap(gos2)
|
|
ta.Len(omap2, 3)
|
|
ta.Contains(omap2, "tng.captain")
|
|
ta.Contains(omap2, "tng.first-officer")
|
|
ta.Contains(omap2, "tng.doctor")
|
|
})
|
|
|
|
suite.T().Run("checkForMore", func(t *testing.T) {
|
|
// test two iterations over different subsets of omap keys
|
|
ta := assert.New(t)
|
|
op := CreateReadOp()
|
|
defer op.Release()
|
|
op.AssertExists()
|
|
gos := op.GetOmapValues("", "", 6)
|
|
err = op.Operate(suite.ioctx, oid, OperationNoFlag)
|
|
ta.NoError(err)
|
|
|
|
omap1 := getAllMap(gos)
|
|
ta.Len(omap1, 6)
|
|
ta.True(gos.More())
|
|
})
|
|
|
|
suite.T().Run("iterateTooEarly", func(t *testing.T) {
|
|
// test two iterations over different subsets of omap keys
|
|
ta := assert.New(t)
|
|
op := CreateReadOp()
|
|
defer op.Release()
|
|
op.AssertExists()
|
|
gos := op.GetOmapValues("", "", 6)
|
|
_, err := gos.Next()
|
|
ta.Error(err)
|
|
ta.Equal(ErrOperationIncomplete, err)
|
|
})
|
|
}
|
|
|
|
func TestReadOpInvalid(t *testing.T) {
|
|
r := &ReadOp{}
|
|
err := r.Operate(&IOContext{}, "foo", 0)
|
|
assert.Error(t, err)
|
|
}
|