frostfs-api-go/object/test/generate.go

754 lines
16 KiB
Go
Raw Normal View History

package objecttest
import (
"math/rand"
"time"
"git.frostfs.info/TrueCloudLab/frostfs-api-go/v2/object"
"git.frostfs.info/TrueCloudLab/frostfs-api-go/v2/refs"
refstest "git.frostfs.info/TrueCloudLab/frostfs-api-go/v2/refs/test"
sessiontest "git.frostfs.info/TrueCloudLab/frostfs-api-go/v2/session/test"
)
func GenerateShortHeader(empty bool) *object.ShortHeader {
m := new(object.ShortHeader)
if !empty {
m.SetObjectType(13)
m.SetCreationEpoch(100)
m.SetPayloadLength(12321)
m.SetOwnerID(refstest.GenerateOwnerID(false))
}
m.SetVersion(refstest.GenerateVersion(empty))
m.SetHomomorphicHash(refstest.GenerateChecksum(empty))
m.SetPayloadHash(refstest.GenerateChecksum(empty))
return m
}
func GenerateAttribute(empty bool) *object.Attribute {
m := new(object.Attribute)
if !empty {
m.SetKey("object key")
m.SetValue("object value")
}
return m
}
func GenerateAttributes(empty bool) []object.Attribute {
var res []object.Attribute
if !empty {
res = append(res,
*GenerateAttribute(false),
*GenerateAttribute(false),
)
}
return res
}
func GenerateSplitHeader(empty bool) *object.SplitHeader {
return generateSplitHeader(empty, true)
}
func generateSplitHeader(empty, withPar bool) *object.SplitHeader {
m := new(object.SplitHeader)
if !empty {
m.SetSplitID([]byte{1, 3, 5})
m.SetParent(refstest.GenerateObjectID(false))
m.SetPrevious(refstest.GenerateObjectID(false))
m.SetChildren(refstest.GenerateObjectIDs(false))
}
m.SetParentSignature(refstest.GenerateSignature(empty))
if withPar {
m.SetParentHeader(GenerateHeaderWithSplitHeader(empty))
}
return m
}
func GenerateHeaderWithSplitHeader(empty bool) *object.Header {
m := generateHeader(empty)
m.SetSplit(generateSplitHeader(empty, false))
return m
}
func GenerateHeaderWithECHeader(empty bool) *object.Header {
m := generateHeader(empty)
m.SetEC(GenerateECHeader(empty))
return m
}
func GenerateECHeader(empty bool) *object.ECHeader {
ech := new(object.ECHeader)
if !empty {
ech.Parent = refstest.GenerateObjectID(empty)
ech.ParentSplitID = []byte{1, 2, 3}
ech.ParentSplitParentID = refstest.GenerateObjectID(empty)
ech.ParentAttributes = GenerateAttributes(empty)
ech.Index = 0
ech.Total = 2
ech.Header = []byte("chunk of ec-encoded parent header")
ech.HeaderLength = uint32(2 * len(ech.Header))
}
return ech
}
func generateHeader(empty bool) *object.Header {
m := new(object.Header)
if !empty {
m.SetPayloadLength(777)
m.SetCreationEpoch(432)
m.SetObjectType(111)
m.SetOwnerID(refstest.GenerateOwnerID(false))
m.SetContainerID(refstest.GenerateContainerID(false))
m.SetAttributes(GenerateAttributes(false))
}
m.SetVersion(refstest.GenerateVersion(empty))
m.SetPayloadHash(refstest.GenerateChecksum(empty))
m.SetHomomorphicHash(refstest.GenerateChecksum(empty))
m.SetSessionToken(sessiontest.GenerateSessionToken(empty))
return m
}
func GenerateHeaderWithSignature(empty bool) *object.HeaderWithSignature {
m := new(object.HeaderWithSignature)
m.SetSignature(refstest.GenerateSignature(empty))
m.SetHeader(GenerateHeaderWithSplitHeader(empty))
return m
}
func GenerateObject(empty bool) *object.Object {
m := new(object.Object)
if !empty {
m.SetPayload([]byte{7, 8, 9})
m.SetObjectID(refstest.GenerateObjectID(false))
}
m.SetSignature(refstest.GenerateSignature(empty))
m.SetHeader(GenerateHeaderWithSplitHeader(empty))
return m
}
func GenerateSplitInfo(empty bool) *object.SplitInfo {
m := new(object.SplitInfo)
if !empty {
m.SetSplitID([]byte("splitID"))
m.SetLastPart(refstest.GenerateObjectID(false))
m.SetLink(refstest.GenerateObjectID(false))
}
return m
}
func GenerateECInfo(empty bool) *object.ECInfo {
m := new(object.ECInfo)
if !empty {
m.Chunks = make([]object.ECChunk, 2)
for i := range m.Chunks {
m.Chunks[i] = *GenerateECChunk(false)
}
}
return m
}
func GenerateECChunk(empty bool) *object.ECChunk {
m := new(object.ECChunk)
if !empty {
m.ID = *refstest.GenerateObjectID(false)
m.Index = 4
m.Total = 7
}
return m
}
func GenerateGetRequestBody(empty bool) *object.GetRequestBody {
m := new(object.GetRequestBody)
if !empty {
m.SetRaw(true)
m.SetAddress(refstest.GenerateAddress(false))
}
return m
}
func GenerateGetRequest(empty bool) *object.GetRequest {
m := new(object.GetRequest)
if !empty {
m.SetBody(GenerateGetRequestBody(false))
}
m.SetMetaHeader(sessiontest.GenerateRequestMetaHeader(empty))
m.SetVerificationHeader(sessiontest.GenerateRequestVerificationHeader(empty))
return m
}
func GenerateGetObjectPartInit(empty bool) *object.GetObjectPartInit {
m := new(object.GetObjectPartInit)
if !empty {
m.SetObjectID(refstest.GenerateObjectID(false))
}
m.SetSignature(refstest.GenerateSignature(empty))
m.SetHeader(GenerateHeaderWithSplitHeader(empty))
return m
}
func GenerateGetObjectPartChunk(empty bool) *object.GetObjectPartChunk {
m := new(object.GetObjectPartChunk)
if !empty {
m.SetChunk([]byte("get chunk"))
}
return m
}
func GenerateGetResponseBody(empty bool) *object.GetResponseBody {
m := new(object.GetResponseBody)
if !empty {
switch randomInt(3) {
case 0:
m.SetObjectPart(GenerateGetObjectPartInit(false))
case 1:
m.SetObjectPart(GenerateGetObjectPartChunk(false))
case 2:
m.SetObjectPart(GenerateSplitInfo(false))
}
}
return m
}
func GenerateGetResponse(empty bool) *object.GetResponse {
m := new(object.GetResponse)
if !empty {
m.SetBody(GenerateGetResponseBody(false))
}
m.SetMetaHeader(sessiontest.GenerateResponseMetaHeader(empty))
m.SetVerificationHeader(sessiontest.GenerateResponseVerificationHeader(empty))
return m
}
func GeneratePutObjectPartInit(empty bool) *object.PutObjectPartInit {
m := new(object.PutObjectPartInit)
if !empty {
m.SetCopiesNumber([]uint32{234})
m.SetObjectID(refstest.GenerateObjectID(false))
}
m.SetSignature(refstest.GenerateSignature(empty))
m.SetHeader(GenerateHeaderWithSplitHeader(empty))
return m
}
func GeneratePutObjectPartChunk(empty bool) *object.PutObjectPartChunk {
m := new(object.PutObjectPartChunk)
if !empty {
m.SetChunk([]byte("put chunk"))
}
return m
}
func GeneratePutRequestBody(empty bool) *object.PutRequestBody {
m := new(object.PutRequestBody)
if !empty {
switch randomInt(2) {
case 0:
m.SetObjectPart(GeneratePutObjectPartInit(false))
case 1:
m.SetObjectPart(GeneratePutObjectPartChunk(false))
}
}
return m
}
func GeneratePutRequest(empty bool) *object.PutRequest {
m := new(object.PutRequest)
if !empty {
m.SetBody(GeneratePutRequestBody(false))
}
m.SetMetaHeader(sessiontest.GenerateRequestMetaHeader(empty))
m.SetVerificationHeader(sessiontest.GenerateRequestVerificationHeader(empty))
return m
}
func GeneratePutResponseBody(empty bool) *object.PutResponseBody {
m := new(object.PutResponseBody)
if !empty {
m.SetObjectID(refstest.GenerateObjectID(false))
}
return m
}
func GeneratePutResponse(empty bool) *object.PutResponse {
m := new(object.PutResponse)
if !empty {
m.SetBody(GeneratePutResponseBody(false))
}
m.SetMetaHeader(sessiontest.GenerateResponseMetaHeader(empty))
m.SetVerificationHeader(sessiontest.GenerateResponseVerificationHeader(empty))
return m
}
func GenerateDeleteRequestBody(empty bool) *object.DeleteRequestBody {
m := new(object.DeleteRequestBody)
if !empty {
m.SetAddress(refstest.GenerateAddress(false))
}
return m
}
func GenerateDeleteRequest(empty bool) *object.DeleteRequest {
m := new(object.DeleteRequest)
if !empty {
m.SetBody(GenerateDeleteRequestBody(false))
}
m.SetMetaHeader(sessiontest.GenerateRequestMetaHeader(empty))
m.SetVerificationHeader(sessiontest.GenerateRequestVerificationHeader(empty))
return m
}
func GenerateDeleteResponseBody(empty bool) *object.DeleteResponseBody {
m := new(object.DeleteResponseBody)
if !empty {
m.SetTombstone(refstest.GenerateAddress(false))
}
return m
}
func GenerateDeleteResponse(empty bool) *object.DeleteResponse {
m := new(object.DeleteResponse)
if !empty {
m.SetBody(GenerateDeleteResponseBody(false))
}
m.SetMetaHeader(sessiontest.GenerateResponseMetaHeader(empty))
m.SetVerificationHeader(sessiontest.GenerateResponseVerificationHeader(empty))
return m
}
func GenerateHeadRequestBody(empty bool) *object.HeadRequestBody {
m := new(object.HeadRequestBody)
if !empty {
m.SetRaw(true)
m.SetMainOnly(true)
m.SetAddress(refstest.GenerateAddress(false))
}
return m
}
func GenerateHeadRequest(empty bool) *object.HeadRequest {
m := new(object.HeadRequest)
if !empty {
m.SetBody(GenerateHeadRequestBody(false))
}
m.SetMetaHeader(sessiontest.GenerateRequestMetaHeader(empty))
m.SetVerificationHeader(sessiontest.GenerateRequestVerificationHeader(empty))
return m
}
func GenerateHeadResponseBody(empty bool) *object.HeadResponseBody {
m := new(object.HeadResponseBody)
if !empty {
switch randomInt(3) {
case 0:
m.SetHeaderPart(GenerateHeaderWithSignature(false))
case 1:
m.SetHeaderPart(GenerateShortHeader(false))
case 2:
m.SetHeaderPart(GenerateSplitInfo(false))
}
}
return m
}
func GenerateHeadResponse(empty bool) *object.HeadResponse {
m := new(object.HeadResponse)
if !empty {
m.SetBody(GenerateHeadResponseBody(false))
}
m.SetMetaHeader(sessiontest.GenerateResponseMetaHeader(empty))
m.SetVerificationHeader(sessiontest.GenerateResponseVerificationHeader(empty))
return m
}
func GenerateSearchFilter(empty bool) *object.SearchFilter {
m := new(object.SearchFilter)
if !empty {
m.SetKey("search filter key")
m.SetValue("search filter val")
m.SetMatchType(987)
}
return m
}
func GenerateSearchFilters(empty bool) []object.SearchFilter {
var res []object.SearchFilter
if !empty {
res = append(res,
*GenerateSearchFilter(false),
*GenerateSearchFilter(false),
)
}
return res
}
func GenerateSearchRequestBody(empty bool) *object.SearchRequestBody {
m := new(object.SearchRequestBody)
if !empty {
m.SetVersion(555)
m.SetContainerID(refstest.GenerateContainerID(false))
m.SetFilters(GenerateSearchFilters(false))
}
return m
}
func GenerateSearchRequest(empty bool) *object.SearchRequest {
m := new(object.SearchRequest)
if !empty {
m.SetBody(GenerateSearchRequestBody(false))
}
m.SetMetaHeader(sessiontest.GenerateRequestMetaHeader(empty))
m.SetVerificationHeader(sessiontest.GenerateRequestVerificationHeader(empty))
return m
}
func GenerateSearchResponseBody(empty bool) *object.SearchResponseBody {
m := new(object.SearchResponseBody)
if !empty {
m.SetIDList(refstest.GenerateObjectIDs(false))
}
return m
}
func GenerateSearchResponse(empty bool) *object.SearchResponse {
m := new(object.SearchResponse)
if !empty {
m.SetBody(GenerateSearchResponseBody(false))
}
m.SetMetaHeader(sessiontest.GenerateResponseMetaHeader(empty))
m.SetVerificationHeader(sessiontest.GenerateResponseVerificationHeader(empty))
return m
}
func GenerateRange(empty bool) *object.Range {
m := new(object.Range)
if !empty {
m.SetLength(11)
m.SetOffset(22)
}
return m
}
func GenerateRanges(empty bool) []object.Range {
var res []object.Range
if !empty {
res = append(res,
*GenerateRange(false),
*GenerateRange(false),
)
}
return res
}
func GenerateGetRangeRequestBody(empty bool) *object.GetRangeRequestBody {
m := new(object.GetRangeRequestBody)
if !empty {
m.SetRaw(true)
m.SetAddress(refstest.GenerateAddress(empty))
m.SetRange(GenerateRange(empty))
}
return m
}
func GenerateGetRangeRequest(empty bool) *object.GetRangeRequest {
m := new(object.GetRangeRequest)
if !empty {
m.SetBody(GenerateGetRangeRequestBody(false))
}
m.SetMetaHeader(sessiontest.GenerateRequestMetaHeader(empty))
m.SetVerificationHeader(sessiontest.GenerateRequestVerificationHeader(empty))
return m
}
func GenerateGetRangePartChunk(empty bool) *object.GetRangePartChunk {
m := new(object.GetRangePartChunk)
if !empty {
m.SetChunk([]byte("get range chunk"))
}
return m
}
func GenerateGetRangeResponseBody(empty bool) *object.GetRangeResponseBody {
m := new(object.GetRangeResponseBody)
if !empty {
switch randomInt(2) {
case 0:
m.SetRangePart(GenerateGetRangePartChunk(false))
case 1:
m.SetRangePart(GenerateSplitInfo(false))
}
}
return m
}
func GenerateGetRangeResponse(empty bool) *object.GetRangeResponse {
m := new(object.GetRangeResponse)
if !empty {
m.SetBody(GenerateGetRangeResponseBody(false))
}
m.SetMetaHeader(sessiontest.GenerateResponseMetaHeader(empty))
m.SetVerificationHeader(sessiontest.GenerateResponseVerificationHeader(empty))
return m
}
func GenerateGetRangeHashRequestBody(empty bool) *object.GetRangeHashRequestBody {
m := new(object.GetRangeHashRequestBody)
if !empty {
m.SetSalt([]byte("range hash salt"))
m.SetType(455)
m.SetAddress(refstest.GenerateAddress(false))
m.SetRanges(GenerateRanges(false))
}
return m
}
func GenerateGetRangeHashRequest(empty bool) *object.GetRangeHashRequest {
m := new(object.GetRangeHashRequest)
if !empty {
m.SetBody(GenerateGetRangeHashRequestBody(false))
}
m.SetMetaHeader(sessiontest.GenerateRequestMetaHeader(empty))
m.SetVerificationHeader(sessiontest.GenerateRequestVerificationHeader(empty))
return m
}
func GenerateGetRangeHashResponseBody(empty bool) *object.GetRangeHashResponseBody {
m := new(object.GetRangeHashResponseBody)
if !empty {
m.SetType(678)
m.SetHashList([][]byte{{1}, {2}})
}
return m
}
func GenerateGetRangeHashResponse(empty bool) *object.GetRangeHashResponse {
m := new(object.GetRangeHashResponse)
if !empty {
m.SetBody(GenerateGetRangeHashResponseBody(false))
}
m.SetMetaHeader(sessiontest.GenerateResponseMetaHeader(empty))
m.SetVerificationHeader(sessiontest.GenerateResponseVerificationHeader(empty))
return m
}
func GenerateLock(empty bool) *object.Lock {
m := new(object.Lock)
if !empty {
m.SetMembers([]refs.ObjectID{
*refstest.GenerateObjectID(false),
*refstest.GenerateObjectID(false),
})
}
return m
}
func GeneratePutSingleRequest(empty bool) *object.PutSingleRequest {
m := new(object.PutSingleRequest)
if !empty {
m.SetBody(GeneratePutSingleRequestBody(false))
}
m.SetMetaHeader(sessiontest.GenerateRequestMetaHeader(empty))
m.SetVerificationHeader(sessiontest.GenerateRequestVerificationHeader(empty))
return m
}
func GeneratePutSingleRequestBody(empty bool) *object.PutSingleRequestBody {
b := new(object.PutSingleRequestBody)
if !empty {
b.SetObject(GenerateObject(empty))
b.SetCopiesNumber([]uint32{12345})
}
return b
}
func GeneratePutSingleResponse(empty bool) *object.PutSingleResponse {
m := new(object.PutSingleResponse)
if !empty {
m.SetBody(new(object.PutSingleResponseBody))
}
m.SetMetaHeader(sessiontest.GenerateResponseMetaHeader(empty))
m.SetVerificationHeader(sessiontest.GenerateResponseVerificationHeader(empty))
return m
}
func GeneratePatchRequestBodyPatch(empty bool) *object.PatchRequestBodyPatch {
m := new(object.PatchRequestBodyPatch)
if !empty {
m.Range = GenerateRange(false)
m.Chunk = []byte("GeneratePatchRequestBodyPatch")
}
return m
}
func GeneratePatchRequestBody(empty bool) *object.PatchRequestBody {
m := new(object.PatchRequestBody)
if !empty {
m.SetAddress(refstest.GenerateAddress(empty))
m.SetNewAttributes(GenerateAttributes(empty))
m.SetReplaceAttributes(false)
m.SetPatch(GeneratePatchRequestBodyPatch(empty))
}
return m
}
func GeneratePatchRequest(empty bool) *object.PatchRequest {
m := new(object.PatchRequest)
if !empty {
m.SetBody(GeneratePatchRequestBody(empty))
}
m.SetMetaHeader(sessiontest.GenerateRequestMetaHeader(empty))
m.SetVerificationHeader(sessiontest.GenerateRequestVerificationHeader(empty))
return m
}
func GeneratePatchResponseBody(empty bool) *object.PatchResponseBody {
m := new(object.PatchResponseBody)
if !empty {
m.ObjectID = refstest.GenerateObjectID(empty)
}
return m
}
func GeneratePatchResponse(empty bool) *object.PatchResponse {
m := new(object.PatchResponse)
if !empty {
m.Body = GeneratePatchResponseBody(empty)
}
return m
}
func randomInt(n int) int {
return rand.New(rand.NewSource(time.Now().UnixNano())).Intn(n)
}