frostfs-node/services/public/object/ttl_test.go

378 lines
11 KiB
Go
Raw Normal View History

package object
import (
"context"
"math/rand"
"strconv"
"testing"
"github.com/multiformats/go-multiaddr"
"github.com/nspcc-dev/neofs-api-go/container"
"github.com/nspcc-dev/neofs-api-go/object"
"github.com/nspcc-dev/neofs-api-go/refs"
"github.com/nspcc-dev/neofs-api-go/service"
"github.com/nspcc-dev/neofs-node/internal"
"github.com/nspcc-dev/neofs-node/lib/implementations"
"github.com/stretchr/testify/require"
"go.uber.org/zap"
)
type (
// Entity for mocking interfaces.
// Implementation of any interface intercepts arguments via f (if not nil).
// If err is not nil, it returns as it is. Otherwise, casted to needed type res returns w/o error.
testTTLEntity struct {
// Set of interfaces which testCommonEntity must implement, but some methods from those does not call.
serviceRequest
Placer
// Argument interceptor. Used for ascertain of correct parameter passage between components.
f func(...interface{})
// Mocked result of any interface.
res interface{}
// Mocked error of any interface.
err error
}
)
var (
_ ttlConditionPreparer = (*testTTLEntity)(nil)
_ implementations.AddressStore = (*testTTLEntity)(nil)
_ containerAffiliationChecker = (*testTTLEntity)(nil)
_ Placer = (*testTTLEntity)(nil)
)
func (s *testTTLEntity) SelfAddr() (multiaddr.Multiaddr, error) {
if s.err != nil {
return nil, s.err
}
return s.res.(multiaddr.Multiaddr), nil
}
func (s *testTTLEntity) IsContainerNode(_ context.Context, m multiaddr.Multiaddr, c CID, b bool) (bool, error) {
if s.f != nil {
s.f(m, c, b)
}
if s.err != nil {
return false, s.err
}
return s.res.(bool), nil
}
func (s *testTTLEntity) CID() CID { return s.res.([]interface{})[0].(CID) }
func (s *testTTLEntity) AllowPreviousNetMap() bool { return s.res.([]interface{})[1].(bool) }
func (s *testTTLEntity) prepareTTLCondition(_ context.Context, req object.Request) service.TTLCondition {
if s.f != nil {
s.f(req)
}
return s.res.(service.TTLCondition)
}
func (s *testTTLEntity) affiliated(ctx context.Context, cid CID) containerAffiliationResult {
if s.f != nil {
s.f(cid)
}
return s.res.(containerAffiliationResult)
}
func Test_ttlPreProcessor_preProcess(t *testing.T) {
ctx := context.TODO()
// create custom request with forwarding TTL
req := &testTTLEntity{res: uint32(service.SingleForwardingTTL)}
t.Run("empty request", func(t *testing.T) {
require.PanicsWithValue(t, pmEmptyServiceRequest, func() {
// ascertain that nil request causes panic
_ = new(ttlPreProcessor).preProcess(ctx, nil)
})
})
t.Run("correct processing", func(t *testing.T) {
// create custom error
pErr := internal.Error("test error for processing func")
// create custom ttlConditionPreparer
condPreparer := &testTTLEntity{
f: func(items ...interface{}) {
t.Run("correct condition preparer params", func(t *testing.T) {
// ascertain that request argument of ttlPreProcessor and ttlConditionPreparer are the same
require.Equal(t, req, items[0].(object.Request))
})
},
res: service.TTLCondition(func(uint32) error { return nil }),
}
s := &ttlPreProcessor{
condPreps: []ttlConditionPreparer{condPreparer},
fProc: func(service.TTLSource, ...service.TTLCondition) error {
return pErr // force processing function to return created error
},
}
// ascertain error returns as expected
require.EqualError(t,
s.preProcess(ctx, req),
pErr.Error(),
)
})
}
func Test_coreTTLCondPreparer_prepareTTLCondition(t *testing.T) {
ctx := context.TODO()
// create container ID
cid := testObjectAddress(t).CID
// // create network address
// mAddr := testNode(t, 0)
//
// // create custom AddressStore
// as := &testTTLEntity{
// res: mAddr, // force AddressStore to return created address
// }
t.Run("empty request", func(t *testing.T) {
require.PanicsWithValue(t, pmEmptyServiceRequest, func() {
// ascertain that nil request causes panic
_ = new(coreTTLCondPreparer).prepareTTLCondition(ctx, nil)
})
})
t.Run("forwarding TTL", func(t *testing.T) {
s := &coreTTLCondPreparer{
curAffChecker: new(testTTLEntity),
prevAffChecker: new(testTTLEntity),
}
cond := s.prepareTTLCondition(ctx, new(testTTLEntity))
// ascertain that error returns as expected
require.NoError(t, cond(service.SingleForwardingTTL))
})
t.Run("non-forwarding TTL", func(t *testing.T) {
t.Run("container non-affiliation", func(t *testing.T) {
t.Run("disallow previous epoch affiliation", func(t *testing.T) {
// create custom serviceRequest for test
req := &testTTLEntity{res: []interface{}{
cid, // force serviceRequest to return cid
false, // force serviceRequest to disallow previous network map
}}
s := &coreTTLCondPreparer{
curAffChecker: &testTTLEntity{
f: func(items ...interface{}) {
t.Run("correct current epoch affiliation checker params", func(t *testing.T) {
require.Equal(t, cid, items[0].(CID))
})
},
res: affAbsence, // force current epoch containerAffiliationChecker to return affAbsence
},
prevAffChecker: &testTTLEntity{
f: func(items ...interface{}) {
t.Run("correct previous epoch affiliation checker params", func(t *testing.T) {
require.Equal(t, cid, items[0].(CID))
})
},
res: affPresence, // force previous epoch containerAffiliationChecker to return affPresence
},
}
cond := s.prepareTTLCondition(ctx, req)
// ascertain that error returns as expected
require.EqualError(t,
cond(service.SingleForwardingTTL-1), // pass any non-forwarding TTL
errNotLocalContainer.Error(),
)
})
t.Run("allow previous epoch affiliation", func(t *testing.T) {
// create custom serviceRequest for test
req := &testTTLEntity{res: []interface{}{
cid, // force serviceRequest to return cid
true, // force serviceRequest to allow previous network map
}}
s := &coreTTLCondPreparer{
curAffChecker: &testTTLEntity{
res: affAbsence, // force current epoch containerAffiliationChecker to return affAbsence
},
prevAffChecker: &testTTLEntity{
res: affAbsence, // force previous epoch containerAffiliationChecker to return affAbsence
},
}
cond := s.prepareTTLCondition(ctx, req)
// ascertain that error returns as expected
require.EqualError(t,
cond(service.SingleForwardingTTL-1), // pass any non-forwarding TTL
errNotLocalContainer.Error(),
)
})
})
t.Run("container affiliation", func(t *testing.T) {
t.Run("disallow previous epoch affiliation", func(t *testing.T) {
// create custom serviceRequest for test
req := &testTTLEntity{res: []interface{}{
cid, // force serviceRequest to return cid
false, // force serviceRequest to disallow previous network map
}}
s := &coreTTLCondPreparer{
curAffChecker: &testTTLEntity{
res: affPresence, // force current epoch containerAffiliationChecker to return affPresence
},
prevAffChecker: &testTTLEntity{
res: affAbsence, // force previous epoch containerAffiliationChecker to return affAbsence
},
}
cond := s.prepareTTLCondition(ctx, req)
// ascertain that error returns as expected
require.NoError(t,
cond(service.SingleForwardingTTL-1), // pass any non-forwarding TTL
)
})
t.Run("allow previous epoch affiliation", func(t *testing.T) {
// create custom serviceRequest for test
req := &testTTLEntity{res: []interface{}{
cid, // force serviceRequest to return cid
true, // force serviceRequest to allow previous network map
}}
s := &coreTTLCondPreparer{
curAffChecker: &testTTLEntity{
res: affAbsence, // force current epoch containerAffiliationChecker to return affAbsence
},
prevAffChecker: &testTTLEntity{
res: affPresence, // force previous epoch containerAffiliationChecker to return affPresence
},
}
cond := s.prepareTTLCondition(ctx, req)
// ascertain that error returns as expected
require.NoError(t,
cond(service.SingleForwardingTTL-1), // pass any non-forwarding TTL
)
})
})
})
}
func Test_coreCnrAffChecker_affiliated(t *testing.T) {
ctx := context.TODO()
// create container ID
cid := testObjectAddress(t).CID
log := zap.L()
t.Run("local network address store error", func(t *testing.T) {
// create custom error for test
saErr := internal.Error("test error for self addr store")
s := &corePlacementUtil{
localAddrStore: &testTTLEntity{
err: saErr, // force address store to return saErr
},
log: log,
}
require.Equal(t, affUnknown, s.affiliated(ctx, cid))
})
t.Run("placement build result", func(t *testing.T) {
// create network address
mAddr := testNode(t, 0)
// create custom AddressStore
as := &testTTLEntity{
res: mAddr, // force AddressStore to return created address
}
t.Run("error", func(t *testing.T) {
pb := &testTTLEntity{
f: func(items ...interface{}) {
t.Run("correct placement builder params", func(t *testing.T) {
require.Equal(t, mAddr, items[0].(multiaddr.Multiaddr))
require.Equal(t, cid, items[1].(CID))
require.Equal(t, true, items[2].(bool))
})
},
}
pb.err = internal.Error("") // force Placer to return some non-nil error
s := &corePlacementUtil{
prevNetMap: true,
localAddrStore: as,
placementBuilder: pb,
log: log,
}
require.Equal(t, affUnknown, s.affiliated(ctx, cid))
pb.err = container.ErrNotFound
require.Equal(t, affNotFound, s.affiliated(ctx, cid))
})
t.Run("no error", func(t *testing.T) {
t.Run("affiliation", func(t *testing.T) {
s := &corePlacementUtil{
localAddrStore: as,
placementBuilder: &testTTLEntity{
res: true, // force Placer to return true, nil
},
log: log,
}
require.Equal(t, affPresence, s.affiliated(ctx, cid))
})
t.Run("non-affiliation", func(t *testing.T) {
s := &corePlacementUtil{
localAddrStore: as,
placementBuilder: &testTTLEntity{
res: false, // force Placer to return false, nil
},
log: log,
}
require.Equal(t, affAbsence, s.affiliated(ctx, cid))
})
})
})
}
// testNode returns 0.0.0.0:(8000+num).
func testNode(t *testing.T, num int) multiaddr.Multiaddr {
mAddr, err := multiaddr.NewMultiaddr("/ip4/0.0.0.0/tcp/" + strconv.Itoa(8000+num))
require.NoError(t, err)
return mAddr
}
// testObjectAddress returns new random object address.
func testObjectAddress(t *testing.T) Address {
oid, err := refs.NewObjectID()
require.NoError(t, err)
return Address{CID: refs.CIDForBytes(testData(t, refs.CIDSize)), ObjectID: oid}
}
// testData returns size bytes of random data.
func testData(t *testing.T, size int) []byte {
res := make([]byte, size)
_, err := rand.Read(res)
require.NoError(t, err)
return res
}