| // Copyright 2015 The Vanadium Authors. All rights reserved. |
| // Use of this source code is governed by a BSD-style |
| // license that can be found in the LICENSE file. |
| |
| package vsync |
| |
| import ( |
| "testing" |
| |
| wire "v.io/v23/services/syncbase" |
| "v.io/x/ref/services/syncbase/store" |
| "v.io/x/ref/services/syncbase/store/watchable" |
| ) |
| |
| // Test setup: |
| // |
| // iSt.updObjects contains oids: x, y, b, c, a, p, q |
| // There are 5 batches: |
| // xzb : local |
| // xy : remote |
| // bc : remote |
| // pq(L) : local |
| // pq(R) : remote |
| // |
| // a is not a part of any batch. |
| // z does not have any remote changes (hence not a part of iSt.updObjects) |
| // |
| // Result: |
| // The following closures will be created: |
| // group1: {x, y, z, b, c} |
| // group2: {a} |
| // group3: {p, q} |
| |
| var ( |
| updObjects map[string]*objConflictState |
| zVer = string(watchable.NewVersion()) |
| |
| batchxzbId = rand64() |
| batchxzb = createBatch(true /*local*/, x, z, b) |
| |
| batchxyId = rand64() |
| batchxy = createBatch(false /*remote*/, x, y) |
| |
| batchbcId = rand64() |
| batchbc = createBatch(false /*remote*/, b, c) |
| |
| batchpqLocalId = rand64() |
| batchpqLocal = createBatch(true /*local*/, p, q) |
| |
| batchpqRemoteId = rand64() |
| batchpqRemote = createBatch(false /*remote*/, p, q) |
| ) |
| |
| func createUpdObjectsMap() map[string]*objConflictState { |
| return map[string]*objConflictState{ |
| //Group1 |
| x: createObjConflictState(true /*isConflict*/, true /*hasLocal*/, true /*hasRemote*/, true /*hasAncestor*/), |
| y: createObjConflictState(false /*isConflict*/, true /*hasLocal*/, true /*hasRemote*/, false /*hasAncestor*/), |
| // z has local change only and is not present in updObjects |
| b: createObjConflictState(true /*isConflict*/, true /*hasLocal*/, true /*hasRemote*/, true /*hasAncestor*/), |
| c: createObjConflictState(false /*isConflict*/, true /*hasLocal*/, true /*hasRemote*/, false /*hasAncestor*/), |
| |
| // Group2 |
| a: createObjConflictState(false /*isConflict*/, true /*hasLocal*/, true /*hasRemote*/, false /*hasAncestor*/), |
| |
| // Group3 |
| p: createObjConflictState(true /*isConflict*/, true /*hasLocal*/, true /*hasRemote*/, true /*hasAncestor*/), |
| q: createObjConflictState(true /*isConflict*/, true /*hasLocal*/, true /*hasRemote*/, true /*hasAncestor*/), |
| } |
| } |
| |
| func createAndSaveNodeAndBatchData(iSt *initiationState) { |
| createAndSaveNode(iSt.tx, batchxzbId, x, updObjects[x].oldHead) |
| createAndSaveNode(iSt.tx, batchxzbId, z, zVer) |
| //watchable.PutVersion(nil, iSt.tx, []byte(z), []byte(zVer)) |
| setHead(nil, iSt.tx, z, zVer) |
| createAndSaveNode(iSt.tx, batchxzbId, b, updObjects[b].oldHead) |
| setBatch(nil, iSt.tx, batchxzbId, batchxzb) |
| |
| createAndSaveNode(iSt.tx, batchxyId, x, updObjects[x].newHead) |
| createAndSaveNode(iSt.tx, batchxyId, y, updObjects[y].newHead) |
| setBatch(nil, iSt.tx, batchxyId, batchxy) |
| |
| createAndSaveNode(iSt.tx, batchbcId, b, updObjects[b].newHead) |
| createAndSaveNode(iSt.tx, batchbcId, c, updObjects[c].newHead) |
| setBatch(nil, iSt.tx, batchbcId, batchbc) |
| |
| createAndSaveNode(iSt.tx, NoBatchId, a, updObjects[a].newHead) |
| |
| createAndSaveNode(iSt.tx, batchpqLocalId, p, updObjects[p].oldHead) |
| createAndSaveNode(iSt.tx, batchpqLocalId, q, updObjects[q].oldHead) |
| setBatch(nil, iSt.tx, batchpqLocalId, batchpqLocal) |
| |
| createAndSaveNode(iSt.tx, batchpqRemoteId, p, updObjects[p].newHead) |
| createAndSaveNode(iSt.tx, batchpqRemoteId, q, updObjects[q].newHead) |
| setBatch(nil, iSt.tx, batchpqRemoteId, batchpqRemote) |
| } |
| |
| func TestGroupFor(t *testing.T) { |
| service := createService(t) |
| defer destroyService(t, service) |
| |
| updObjects = createUpdObjectsMap() |
| iSt := &initiationState{updObjects: updObjects, tx: createDatabase(t, service).St().NewWatchableTransaction()} |
| createAndSaveNodeAndBatchData(iSt) |
| |
| // Group1 is a closure of batches xzb, xy, bc containing oids x, y, z, b, c. |
| // Following tests run groupFor() method on each of the oids and expects |
| // the same group (Group1) to be returned regardless of which oid the |
| // closure was innitiated with. |
| group := initCrGroup() |
| iSt.groupFor(nil, group, x) |
| verifyGroup1(t, group) |
| |
| group = initCrGroup() |
| iSt.groupFor(nil, group, y) |
| verifyGroup1(t, group) |
| |
| group = initCrGroup() |
| iSt.groupFor(nil, group, b) |
| verifyGroup1(t, group) |
| |
| group = initCrGroup() |
| iSt.groupFor(nil, group, c) |
| verifyGroup1(t, group) |
| |
| // Group2 is a closure of oid "a" only. Since a is not part of any batches, |
| // Group2 does not have any batches in it. |
| group = initCrGroup() |
| iSt.groupFor(nil, group, a) |
| verifyGroup2(t, group) |
| |
| // Group3 is a closure of batches pqLocal and pqRemote containing oids p, q. |
| // Following tests run groupFor() method on each of the oids and expects |
| // the same group (Group3) to be returned regardless of which oid the |
| // closure was innitiated with. |
| group = initCrGroup() |
| iSt.groupFor(nil, group, p) |
| verifyGroup3(t, group) |
| |
| group = initCrGroup() |
| iSt.groupFor(nil, group, q) |
| verifyGroup3(t, group) |
| } |
| |
| func TestGroupConflicts(t *testing.T) { |
| service := createService(t) |
| defer destroyService(t, service) |
| |
| updObjects = createUpdObjectsMap() |
| iSt := &initiationState{updObjects: updObjects, tx: createDatabase(t, service).St().NewWatchableTransaction()} |
| createAndSaveNodeAndBatchData(iSt) |
| |
| // Assuming that all objects in updObjects are to be resolved by app. |
| crGroups := iSt.groupConflicts(nil, updObjects) |
| |
| for _, group := range crGroups.groups { |
| batchCount := len(group.batchSource) |
| if batchCount == 3 { |
| verifyGroup1(t, group) |
| } else if batchCount == 0 { |
| verifyGroup2(t, group) |
| } else if batchCount == 2 { |
| verifyGroup3(t, group) |
| } else { |
| t.Errorf("Encountered unexpected group: %v", group) |
| } |
| } |
| if len(crGroups.oids) != 8 { |
| t.Errorf("Size of groupedCrData.oids expected: %d actual: %d", 8, len(crGroups.oids)) |
| } |
| verifyOidList(t, crGroups, x, y, z, a, b, c, p, q) |
| } |
| |
| func verifyOidList(t *testing.T, crGroups *groupedCrData, oids ...string) { |
| for _, oid := range oids { |
| if !crGroups.oids[oid] { |
| t.Errorf("Oid %s missing in groupedCrData.oids map", oid) |
| } |
| } |
| } |
| |
| func verifyGroup1(t *testing.T, group *crGroup) { |
| verifyBatchSource(t, group, batchxzbId, "xzb", wire.BatchSourceLocal) |
| verifyBatchSource(t, group, batchxyId, "xy", wire.BatchSourceRemote) |
| verifyBatchSource(t, group, batchbcId, "bc", wire.BatchSourceRemote) |
| |
| verifyBatchesByOid(t, group, x, batchxzbId, batchxyId) |
| verifyBatchesByOid(t, group, z, batchxzbId) |
| verifyBatchesByOid(t, group, b, batchxzbId, batchbcId) |
| verifyBatchesByOid(t, group, y, batchxyId) |
| verifyBatchesByOid(t, group, c, batchbcId) |
| |
| objSt := updObjects[z] |
| if (objSt == nil) || (objSt.oldHead != zVer) || objSt.isConflict || !objSt.isAddedByCr { |
| t.Errorf("Unexpected value of objConflictState for z: %#v", objSt) |
| } |
| } |
| |
| func verifyGroup2(t *testing.T, group *crGroup) { |
| if len(group.batchSource) != 0 { |
| t.Errorf("Non empty batchSource map found for Group2: %v", group.batchSource) |
| } |
| _, present := group.batchesByOid[a] |
| if len(group.batchesByOid) != 1 || !present { |
| t.Errorf("Unexpected batchesByOid map found for Group2: %v", group.batchesByOid) |
| } |
| } |
| |
| func verifyGroup3(t *testing.T, group *crGroup) { |
| verifyBatchSource(t, group, batchpqLocalId, "pqLocal", wire.BatchSourceLocal) |
| verifyBatchSource(t, group, batchpqRemoteId, "pqRemote", wire.BatchSourceRemote) |
| |
| verifyBatchesByOid(t, group, p, batchpqLocalId, batchpqRemoteId) |
| verifyBatchesByOid(t, group, q, batchpqLocalId, batchpqRemoteId) |
| } |
| |
| func verifyBatchSource(t *testing.T, group *crGroup, batchId uint64, batchName string, source wire.BatchSource) { |
| if v, ok := group.batchSource[batchId]; !ok || (v != source) { |
| t.Errorf("Missing or incorrect source for batchId: %s", batchName) |
| } |
| } |
| |
| func verifyBatchesByOid(t *testing.T, group *crGroup, oid string, batchIds ...uint64) { |
| batchesInOid := group.batchesByOid[oid] |
| batchMap := map[uint64]bool{} |
| for _, batchId := range batchesInOid { |
| batchMap[batchId] = true |
| } |
| for _, batchId := range batchIds { |
| if !batchMap[batchId] { |
| t.Errorf("Batch %v expected to be associated with oid %v but missing.", batchId, oid) |
| } |
| } |
| } |
| |
| func createBatch(isLocal bool, oids ...string) *BatchInfo { |
| batch := &BatchInfo{ |
| Count: uint64(len(oids)), |
| Objects: map[string]string{}, |
| } |
| for _, oid := range oids { |
| if _, present := batch.Objects[oid]; !present { |
| batch.Objects[oid] = zVer |
| continue |
| } |
| if isLocal { |
| batch.Objects[oid] = updObjects[oid].oldHead |
| } else { |
| batch.Objects[oid] = updObjects[oid].newHead |
| } |
| } |
| return batch |
| } |
| |
| func createAndSaveNode(tx store.Transaction, batchId uint64, oid, version string) { |
| node := &DagNode{ |
| BatchId: batchId, |
| } |
| setNode(nil, tx, oid, version, node) |
| } |
