From 698acad3bd6d3929e1da66fc28f2bfbc92532844 Mon Sep 17 00:00:00 2001 From: Sergey Cherepanov Date: Thu, 8 Sep 2022 00:24:19 +0300 Subject: [PATCH] remotediff test --- service/space/remotediff/remotediff.go | 81 +++++++-------------- service/space/remotediff/remotediff_test.go | 41 +++++++++++ 2 files changed, 68 insertions(+), 54 deletions(-) create mode 100644 service/space/remotediff/remotediff_test.go diff --git a/service/space/remotediff/remotediff.go b/service/space/remotediff/remotediff.go index 0bab5350..df10aec6 100644 --- a/service/space/remotediff/remotediff.go +++ b/service/space/remotediff/remotediff.go @@ -2,75 +2,55 @@ package remotediff import ( "context" - "fmt" "github.com/anytypeio/go-anytype-infrastructure-experiments/pkg/ldiff" - "github.com/anytypeio/go-anytype-infrastructure-experiments/service/net/pool" "github.com/anytypeio/go-anytype-infrastructure-experiments/service/space/spacesync" - "github.com/anytypeio/go-anytype-infrastructure-experiments/syncproto" ) -func NewRemoteDiff(p pool.Pool, peerId, spaceId string) ldiff.Remote { +type Client interface { + HeadSync(ctx context.Context, in *spacesync.HeadSyncRequest) (*spacesync.HeadSyncResponse, error) +} + +func NewRemoteDiff(spaceId string, client Client) ldiff.Remote { return remote{ - pool: p, - peerId: peerId, spaceId: spaceId, + client: client, } } type remote struct { - pool pool.Pool - peerId string spaceId string + client Client } func (r remote) Ranges(ctx context.Context, ranges []ldiff.Range, resBuf []ldiff.RangeResult) (results []ldiff.RangeResult, err error) { results = resBuf[:0] - pbRanges := make([]*spacesync.DiffRange_Request_Range, 0, len(ranges)) + pbRanges := make([]*spacesync.HeadSyncRange, 0, len(ranges)) for _, rg := range ranges { - pbRanges = append(pbRanges, &spacesync.DiffRange_Request_Range{ + pbRanges = append(pbRanges, &spacesync.HeadSyncRange{ From: rg.From, To: rg.To, Limit: uint32(rg.Limit), }) } - req := &spacesync.Space{ + req := &spacesync.HeadSyncRequest{ SpaceId: r.spaceId, - Message: &spacesync.Space_Content{ - Value: &spacesync.Space_Content_DiffRange{ - DiffRange: &spacesync.DiffRange{ - Request: &spacesync.DiffRange_Request{ - Ranges: pbRanges, - }, - }, - }, - }, + Ranges: pbRanges, } - msg, err := req.Marshal() + resp, err := r.client.HeadSync(ctx, req) if err != nil { return } - resp, err := r.pool.SendAndWaitResponse(ctx, r.peerId, &syncproto.Message{ - Header: &syncproto.Header{ - Type: syncproto.MessageType_MessageTypeSpace, - }, - Data: msg, - }) - if err != nil { - return - } - var spaceResp = &spacesync.Space{} - if err = resp.UnmarshalData(spaceResp); err != nil { - return - } - rangeResp := spaceResp.GetMessage().GetDiffRange().GetResponse() - if rangeResp != nil { - return nil, fmt.Errorf("got nil response") - } - for _, rr := range rangeResp.Results { + for _, rr := range resp.Results { var elms []ldiff.Element if len(rr.Elements) > 0 { elms = make([]ldiff.Element, 0, len(rr.Elements)) } + for _, e := range rr.Elements { + elms = append(elms, ldiff.Element{ + Id: e.Id, + Head: e.Head, + }) + } results = append(results, ldiff.RangeResult{ Hash: rr.Hash, Elements: elms, @@ -80,12 +60,7 @@ func (r remote) Ranges(ctx context.Context, ranges []ldiff.Range, resBuf []ldiff return } -func HandlerRangeRequest(ctx context.Context, d ldiff.Diff, diffRange *spacesync.DiffRange) (resp *spacesync.DiffRange, err error) { - req := diffRange.GetRequest() - if req != nil { - return nil, fmt.Errorf("received nil request") - } - +func HandlerRangeRequest(ctx context.Context, d ldiff.Diff, req *spacesync.HeadSyncRequest) (resp *spacesync.HeadSyncResponse, err error) { ranges := make([]ldiff.Range, 0, len(req.Ranges)) for _, reqRange := range req.Ranges { ranges = append(ranges, ldiff.Range{ @@ -99,27 +74,25 @@ func HandlerRangeRequest(ctx context.Context, d ldiff.Diff, diffRange *spacesync return } - var rangeResp = &spacesync.DiffRange_Response{ - Results: make([]*spacesync.DiffRange_Response_Result, len(res)), + var rangeResp = &spacesync.HeadSyncResponse{ + Results: make([]*spacesync.HeadSyncResult, 0, len(res)), } for _, rangeRes := range res { - var elements []*spacesync.DiffRange_Response_Result_Element + var elements []*spacesync.HeadSyncResultElement if len(rangeRes.Elements) > 0 { - elements = make([]*spacesync.DiffRange_Response_Result_Element, 0, len(rangeRes.Elements)) + elements = make([]*spacesync.HeadSyncResultElement, 0, len(rangeRes.Elements)) for _, el := range rangeRes.Elements { - elements = append(elements, &spacesync.DiffRange_Response_Result_Element{ + elements = append(elements, &spacesync.HeadSyncResultElement{ Id: el.Id, Head: el.Head, }) } } - rangeResp.Results = append(rangeResp.Results, &spacesync.DiffRange_Response_Result{ + rangeResp.Results = append(rangeResp.Results, &spacesync.HeadSyncResult{ Hash: rangeRes.Hash, Elements: elements, Count: uint32(rangeRes.Count), }) } - return &spacesync.DiffRange{ - Response: rangeResp, - }, nil + return rangeResp, nil } diff --git a/service/space/remotediff/remotediff_test.go b/service/space/remotediff/remotediff_test.go new file mode 100644 index 00000000..e1cf96ed --- /dev/null +++ b/service/space/remotediff/remotediff_test.go @@ -0,0 +1,41 @@ +package remotediff + +import ( + "context" + "fmt" + "github.com/anytypeio/go-anytype-infrastructure-experiments/pkg/ldiff" + "github.com/anytypeio/go-anytype-infrastructure-experiments/service/space/spacesync" + "github.com/stretchr/testify/assert" + "github.com/stretchr/testify/require" + "testing" +) + +func TestRemote(t *testing.T) { + ldLocal := ldiff.New(8, 8) + ldRemote := ldiff.New(8, 8) + for i := 0; i < 100; i++ { + el := ldiff.Element{ + Id: fmt.Sprint(i), + Head: fmt.Sprint(i), + } + ldRemote.Set(el) + if i%10 != 0 { + ldLocal.Set(el) + } + } + + rd := NewRemoteDiff("1", &mockClient{l: ldRemote}) + newIds, changedIds, removedIds, err := ldLocal.Diff(context.Background(), rd) + require.NoError(t, err) + assert.Len(t, newIds, 10) + assert.Len(t, changedIds, 0) + assert.Len(t, removedIds, 0) +} + +type mockClient struct { + l ldiff.Diff +} + +func (m *mockClient) HeadSync(ctx context.Context, in *spacesync.HeadSyncRequest) (*spacesync.HeadSyncResponse, error) { + return HandlerRangeRequest(ctx, m.l, in) +}