Merge remote-tracking branch 'origin/add-content-with-validator' into GO-3996-add-tree-transactions

# Conflicts:
#	commonspace/object/tree/objecttree/change.go
#	commonspace/object/tree/objecttree/objecttree.go
#	commonspace/object/tree/synctree/synctree_test.go

commonspace/object/tree/objecttree/objecttree_test.go

@@ -132,6 +132,7 @@ func genBuildFilterableTestableTree(filterFunc func(ch *Change) bool) func(treeS
 			rawChangeLoader: loader,
 			validator:       &noOpTreeValidator{filterFunc: filterFunc},
 			aclList:         aclList,
+			flusher:         &defaultFlusher{},
 		}
 
 		return buildObjectTree(deps)
@@ -796,6 +797,76 @@ func TestObjectTree(t *testing.T) {
 		}
 	})
 
+	t.Run("add new snapshot simple with newChangeFlusher", func(t *testing.T) {
+		ctx := prepareTreeContext(t, aclList)
+		treeStorage := ctx.treeStorage
+		changeCreator := ctx.changeCreator
+		objTree := ctx.objTree.(*objectTree)
+		objTree.flusher = &newChangeFlusher{}
+
+		rawChanges := []*treechangeproto.RawTreeChangeWithId{
+			changeCreator.CreateRaw("1", aclList.Head().Id, "0", false, "0"),
+			changeCreator.CreateRaw("2", aclList.Head().Id, "0", false, "1"),
+			changeCreator.CreateRaw("3", aclList.Head().Id, "0", true, "2"),
+			changeCreator.CreateRaw("4", aclList.Head().Id, "3", false, "3"),
+		}
+		payload := RawChangesPayload{
+			NewHeads:   []string{rawChanges[len(rawChanges)-1].Id},
+			RawChanges: rawChanges,
+		}
+
+		res, err := objTree.AddRawChanges(context.Background(), payload)
+		require.NoError(t, err, "adding changes should be without error")
+
+		// check result
+		assert.Equal(t, []string{"0"}, res.OldHeads)
+		assert.Equal(t, []string{"4"}, res.Heads)
+		assert.Equal(t, len(rawChanges), len(res.Added))
+		assert.Equal(t, Append, res.Mode)
+
+		// check tree heads
+		assert.Equal(t, []string{"4"}, objTree.Heads())
+
+		// check tree iterate
+		var iterChangesId []string
+		err = objTree.IterateRoot(nil, func(change *Change) bool {
+			iterChangesId = append(iterChangesId, change.Id)
+			return true
+		})
+		require.NoError(t, err, "iterate should be without error")
+		assert.Equal(t, []string{"0", "1", "2", "3", "4"}, iterChangesId)
+		// before Flush
+		assert.Equal(t, "0", objTree.Root().Id)
+
+		// check storage
+		heads, _ := treeStorage.Heads()
+		assert.Equal(t, []string{"4"}, heads)
+
+		for _, ch := range rawChanges {
+			treeCh, err := objTree.GetChange(ch.Id)
+			require.NoError(t, err)
+			require.True(t, treeCh.IsNew)
+			raw, err := treeStorage.GetRawChange(context.Background(), ch.Id)
+			assert.NoError(t, err, "storage should have all the changes")
+			assert.Equal(t, ch, raw, "the changes in the storage should be the same")
+		}
+
+		err = objTree.Flush()
+		require.NoError(t, err)
+
+		// after Flush
+		assert.Equal(t, "3", objTree.Root().Id)
+		for _, ch := range rawChanges {
+			treeCh, err := objTree.GetChange(ch.Id)
+			if ch.Id == "3" || ch.Id == "4" {
+				require.NoError(t, err)
+				require.False(t, treeCh.IsNew)
+				continue
+			}
+			require.Error(t, err)
+		}
+	})
+
 	t.Run("snapshot path", func(t *testing.T) {
 		ctx := prepareTreeContext(t, aclList)
 		changeCreator := ctx.changeCreator