go.charczuk.com@v0.0.0-20240327042549-bc490516bd1a/projects/nodes/pkg/dbmodel/manager_test.go

/*

Copyright (c) 2023 - Present. Will Charczuk. All rights reserved.
Use of this source code is governed by a MIT license that can be found in the LICENSE file at the root of the repository.

*/

package dbmodel

import (
	"context"
	"testing"
	"time"

	"go.charczuk.com/projects/nodes/pkg/types"
	"go.charczuk.com/sdk/apputil"
	"go.charczuk.com/sdk/assert"
	"go.charczuk.com/sdk/uuid"
)

func Test_Manager_Deserialize(t *testing.T) {
	ctx := context.Background()
	appMgr, done := apputil.NewTest(t)
	defer done()

	u0 := apputil.CreateTestUser(t, appMgr)

	g, _ := CreateTestGraph(t, &appMgr.BaseManager, u0)

	mgr := Manager{
		BaseManager: appMgr.BaseManager,
	}

	tg, err := mgr.Deserialize(ctx, g.ID, false, false)
	assert.ItsNil(t, err)
	assert.ItsEqual(t, g.ID, tg.Graph.ID)
}

func Test_Manager_PatchGraph(t *testing.T) {
	ctx := context.Background()
	appMgr, done := apputil.NewTest(t)
	defer done()

	u0 := apputil.CreateTestUser(t, appMgr)

	g, _ := CreateTestGraph(t, &appMgr.BaseManager, u0)

	mgr := Manager{
		BaseManager: appMgr.BaseManager,
	}

	found, err := mgr.PatchGraph(ctx, g.ID, types.PatchSet{
		"viewport_x":    2,
		"viewport_y":    3,
		"viewport_zoom": 4,
	})
	assert.ItsNil(t, err)
	assert.ItsEqual(t, true, found)

	verify, found, err := mgr.Graph(ctx, g.ID)
	assert.ItsNil(t, err)
	assert.ItsEqual(t, true, found)
	assert.ItsEqual(t, 2, verify.ViewportX)
	assert.ItsEqual(t, 3, verify.ViewportY)
	assert.ItsEqual(t, 4, verify.ViewportZoom)
}

func Test_Manager_TouchGraph(t *testing.T) {
	ctx := context.Background()
	appMgr, done := apputil.NewTest(t)
	defer done()

	u0 := apputil.CreateTestUser(t, appMgr)

	g, _ := CreateTestGraph(t, &appMgr.BaseManager, u0)

	mgr := Manager{
		BaseManager: appMgr.BaseManager,
	}

	err := mgr.TouchGraph(ctx, g.ID)
	assert.ItsNil(t, err)
}

func Test_Manager_NodeValues_empty(t *testing.T) {
	ctx := context.Background()
	appMgr, done := apputil.NewTest(t)
	defer done()

	u0 := apputil.CreateTestUser(t, appMgr)

	g, _ := CreateTestGraph(t, &appMgr.BaseManager, u0)

	mgr := Manager{
		BaseManager: appMgr.BaseManager,
	}

	nv, err := mgr.NodeValues(ctx, g.ID)
	assert.ItsNil(t, err)
	assert.ItsEqual(t, 2, len(nv))
}

func Test_Manager_NodeValues_specced(t *testing.T) {
	ctx := context.Background()
	appMgr, done := apputil.NewTest(t)
	defer done()

	u0 := apputil.CreateTestUser(t, appMgr)

	g, nodes := CreateTestGraph(t, &appMgr.BaseManager, u0)

	mgr := Manager{
		BaseManager: appMgr.BaseManager,
	}

	nv, err := mgr.NodeValues(ctx, g.ID, nodes[TestNodeV0Label].ID)
	assert.ItsNil(t, err)
	assert.ItsEqual(t, 1, len(nv))
}

func Test_Manager_NodeValue(t *testing.T) {
	ctx := context.Background()
	appMgr, done := apputil.NewTest(t)
	defer done()

	u0 := apputil.CreateTestUser(t, appMgr)

	g, nodes := CreateTestGraph(t, &appMgr.BaseManager, u0)

	mgr := Manager{
		BaseManager: appMgr.BaseManager,
	}

	nv, found, err := mgr.NodeValue(ctx, g.ID, nodes[TestNodeV0Label].ID)
	assert.ItsNil(t, err)
	assert.ItsEqual(t, true, found)
	assert.ItsEqual(t, "string", nv.ValueType)
	assert.ItsEqual(t, "hello", nv.Value)
}

func Test_Manager_SetNodeValues(t *testing.T) {
	ctx := context.Background()
	appMgr, done := apputil.NewTest(t)
	defer done()

	u0 := apputil.CreateTestUser(t, appMgr)

	g, nodes := CreateTestGraph(t, &appMgr.BaseManager, u0)

	mgr := Manager{
		BaseManager: appMgr.BaseManager,
	}

	err := mgr.SetNodeValues(ctx, g.ID, u0.ID, map[uuid.UUID]any{
		nodes[TestNodeV0Label].ID: "not-hello",
		nodes[TestNodeV1Label].ID: "not-world",
		nodes[TestNodeM0Label].ID: "not-hello not-world",
		nodes[TestNodeO0Label].ID: "not-hello not-world",
	})
	assert.ItsNil(t, err)

	values, err := mgr.NodeValues(ctx, g.ID)
	assert.ItsNil(t, err)
	assert.ItsEqual(t, 4, len(values))
}

func Test_Manager_DeleteGraph(t *testing.T) {
	ctx := context.Background()
	appMgr, done := apputil.NewTest(t)
	defer done()

	u0 := apputil.CreateTestUser(t, appMgr)

	g, _ := CreateTestGraph(t, &appMgr.BaseManager, u0)

	mgr := Manager{
		BaseManager: appMgr.BaseManager,
	}

	found, err := mgr.DeleteGraph(ctx, g.ID)
	assert.ItsNil(t, err)
	assert.ItsEqual(t, true, found)
}

func Test_Manager_DeleteNode(t *testing.T) {
	ctx := context.Background()
	appMgr, done := apputil.NewTest(t)
	defer done()

	u0 := apputil.CreateTestUser(t, appMgr)

	g, nodes := CreateTestGraph(t, &appMgr.BaseManager, u0)

	mgr := Manager{
		BaseManager: appMgr.BaseManager,
	}

	foundNodes, err := mgr.Nodes(ctx, g.ID)
	assert.ItsNil(t, err)
	assert.ItsEqual(t, 4, len(foundNodes))

	found, err := mgr.DeleteNode(ctx, nodes[TestNodeV0Label].ID)
	assert.ItsNil(t, err)
	assert.ItsEqual(t, true, found)

	foundNodes, err = mgr.Nodes(ctx, g.ID)
	assert.ItsNil(t, err)
	assert.ItsEqual(t, 3, len(foundNodes))
}

func Test_Manager_DeleteEdge(t *testing.T) {
	ctx := context.Background()
	appMgr, done := apputil.NewTest(t)
	defer done()

	u0 := apputil.CreateTestUser(t, appMgr)

	g, nodes := CreateTestGraph(t, &appMgr.BaseManager, u0)

	mgr := Manager{
		BaseManager: appMgr.BaseManager,
	}

	edges, err := mgr.Edges(ctx, g.ID)
	assert.ItsNil(t, err)
	assert.ItsEqual(t, 3, len(edges))

	err = mgr.DeleteEdge(ctx, nodes[TestNodeV0Label].ID, nodes[TestNodeM0Label].ID, "")
	assert.ItsNil(t, err)

	edges, err = mgr.Edges(ctx, g.ID)
	assert.ItsNil(t, err)
	assert.ItsEqual(t, 2, len(edges))

	assert.ItsNone(t, edges, func(e Edge) bool {
		return e.ParentID == nodes[TestNodeV0Label].ID
	})
}

func Test_Manager_SetViewport(t *testing.T) {
	ctx := context.Background()
	appMgr, done := apputil.NewTest(t)
	defer done()

	u0 := apputil.CreateTestUser(t, appMgr)

	g, _ := CreateTestGraph(t, &appMgr.BaseManager, u0)

	mgr := Manager{
		BaseManager: appMgr.BaseManager,
	}

	err := mgr.SetViewport(ctx, g.ID, types.Viewport{
		X:    5,
		Y:    6,
		Zoom: 7,
	})
	assert.ItsNil(t, err)

	verify, found, err := mgr.Graph(ctx, g.ID)
	assert.ItsNil(t, err)
	assert.ItsEqual(t, true, found)
	assert.ItsEqual(t, 5, verify.ViewportX)
	assert.ItsEqual(t, 6, verify.ViewportY)
	assert.ItsEqual(t, 7, verify.ViewportZoom)
}

func Test_Manager_GraphLogsLatest(t *testing.T) {
	ctx := context.Background()
	appMgr, done := apputil.NewTest(t)
	defer done()

	u0 := apputil.CreateTestUser(t, appMgr)

	g, _ := CreateTestGraph(t, &appMgr.BaseManager, u0)

	mgr := Manager{
		BaseManager: appMgr.BaseManager,
	}

	err := mgr.Invoke(ctx).Create(&GraphLogs{
		GraphID:          g.ID,
		UserID:           u0.ID,
		CreatedUTC:       time.Now().UTC().Add(-5 * time.Minute),
		StabilizationNum: 1,
		Logs:             "hello 5",
	})
	assert.ItsNil(t, err)

	err = mgr.Invoke(ctx).Create(&GraphLogs{
		GraphID:          g.ID,
		UserID:           u0.ID,
		CreatedUTC:       time.Now().UTC().Add(-3 * time.Minute),
		StabilizationNum: 2,
		Logs:             "hello 4",
	})
	assert.ItsNil(t, err)

	err = mgr.Invoke(ctx).Create(&GraphLogs{
		GraphID:          g.ID,
		UserID:           u0.ID,
		CreatedUTC:       time.Now().UTC().Add(-2 * time.Minute),
		StabilizationNum: 3,
		Logs:             "hello 3",
	})
	assert.ItsNil(t, err)

	err = mgr.Invoke(ctx).Create(&GraphLogs{
		GraphID:          g.ID,
		UserID:           u0.ID,
		CreatedUTC:       time.Now().UTC().Add(-1 * time.Minute),
		StabilizationNum: 4,
		Logs:             "hello 4",
	})
	assert.ItsNil(t, err)

	err = mgr.Invoke(ctx).Create(&GraphLogs{
		GraphID:          g.ID,
		UserID:           u0.ID,
		CreatedUTC:       time.Now().UTC().Add(-1 * time.Second),
		StabilizationNum: 5,
		Logs:             "hello 5",
	})
	assert.ItsNil(t, err)

	latest, found, err := mgr.GraphLogsLatest(ctx, g.ID)
	assert.ItsNil(t, err)
	assert.ItsEqual(t, true, found)
	assert.ItsEqual(t, "hello 5", latest.Logs)
}

func Test_Manager_PatchNodes(t *testing.T) {
	ctx := context.Background()
	appMgr, done := apputil.NewTest(t)
	defer done()

	u0 := apputil.CreateTestUser(t, appMgr)

	g, nodes := CreateTestGraph(t, &appMgr.BaseManager, u0)

	mgr := Manager{
		BaseManager: appMgr.BaseManager,
	}

	err := mgr.PatchNodes(ctx, g.ID, types.PatchSet{"collapsed": true, "watched": true})
	assert.ItsNil(t, err)

	verify, found, err := mgr.Node(ctx, nodes[TestNodeV0Label].ID)
	assert.ItsNil(t, err)
	assert.ItsEqual(t, true, found)
	assert.ItsEqual(t, true, verify.Collapsed)
	assert.ItsEqual(t, true, verify.Watched)

	verify, found, err = mgr.Node(ctx, nodes[TestNodeM0Label].ID)
	assert.ItsNil(t, err)
	assert.ItsEqual(t, true, found)
	assert.ItsEqual(t, true, verify.Collapsed)
	assert.ItsEqual(t, true, verify.Watched)
}

func Test_Manager_PatchNodes_bogusColumn(t *testing.T) {
	ctx := context.Background()
	appMgr, done := apputil.NewTest(t)
	defer done()

	u0 := apputil.CreateTestUser(t, appMgr)

	g, nodes := CreateTestGraph(t, &appMgr.BaseManager, u0)

	mgr := Manager{
		BaseManager: appMgr.BaseManager,
	}

	err := mgr.PatchNodes(ctx, g.ID, types.PatchSet{"collapsed'; DROP TABLE users --": true})
	assert.ItsNil(t, err)

	verify, found, err := mgr.Node(ctx, nodes[TestNodeV0Label].ID)
	assert.ItsNil(t, err)
	assert.ItsEqual(t, true, found)
	assert.ItsEqual(t, false, verify.Collapsed)

	verify, found, err = mgr.Node(ctx, nodes[TestNodeM0Label].ID)
	assert.ItsNil(t, err)
	assert.ItsEqual(t, true, found)
	assert.ItsEqual(t, false, verify.Collapsed)
}

func Test_Manager_PatchNode(t *testing.T) {
	ctx := context.Background()
	appMgr, done := apputil.NewTest(t)
	defer done()

	u0 := apputil.CreateTestUser(t, appMgr)

	_, nodes := CreateTestGraph(t, &appMgr.BaseManager, u0)

	mgr := Manager{
		BaseManager: appMgr.BaseManager,
	}

	found, err := mgr.PatchNode(ctx, nodes[TestNodeV0Label].ID, types.PatchSet{"collapsed": true})
	assert.ItsNil(t, err)
	assert.ItsEqual(t, true, found)

	verify, found, err := mgr.Node(ctx, nodes[TestNodeV0Label].ID)
	assert.ItsNil(t, err)
	assert.ItsEqual(t, true, found)
	assert.ItsEqual(t, true, verify.Collapsed)

	verify, found, err = mgr.Node(ctx, nodes[TestNodeM0Label].ID)
	assert.ItsNil(t, err)
	assert.ItsEqual(t, true, found)
	assert.ItsEqual(t, false, verify.Collapsed)
}

func Test_Manager_PatchNode_bogusColumn(t *testing.T) {
	ctx := context.Background()
	appMgr, done := apputil.NewTest(t)
	defer done()

	u0 := apputil.CreateTestUser(t, appMgr)

	_, nodes := CreateTestGraph(t, &appMgr.BaseManager, u0)

	mgr := Manager{
		BaseManager: appMgr.BaseManager,
	}

	found, err := mgr.PatchNode(ctx, nodes[TestNodeV0Label].ID, types.PatchSet{"collapsed'; DROP TABLE USERS --": true})
	assert.ItsNil(t, err)
	assert.ItsEqual(t, false, found)
}

func Test_Manager_MarkNodeStale(t *testing.T) {
	ctx := context.Background()
	appMgr, done := apputil.NewTest(t)
	defer done()

	u0 := apputil.CreateTestUser(t, appMgr)

	g, nodes := CreateTestGraph(t, &appMgr.BaseManager, u0)

	mgr := Manager{
		BaseManager: appMgr.BaseManager,
	}

	err := mgr.UpdateGraphPostStabilization(ctx, g.ID, 123)
	assert.ItsNil(t, err)

	found, err := mgr.MarkNodeStale(ctx, g.ID, u0.ID, nodes[TestNodeM0Label].ID)
	assert.ItsNil(t, err)
	assert.ItsEqual(t, true, found)

	rh, err := mgr.RecomputeHeap(ctx, g.ID)
	assert.ItsNil(t, err)

	assert.ItsEqual(t, 3, len(rh))
	assert.ItsAny(t, rh, func(v GraphRecomputeHeap) bool {
		return v.NodeID == nodes[TestNodeV0Label].ID
	})
	assert.ItsAny(t, rh, func(v GraphRecomputeHeap) bool {
		return v.NodeID == nodes[TestNodeV1Label].ID
	})
	assert.ItsAny(t, rh, func(v GraphRecomputeHeap) bool {
		return v.NodeID == nodes[TestNodeM0Label].ID
	})

	verify, found, err := mgr.Node(ctx, nodes[TestNodeM0Label].ID)
	assert.ItsNil(t, err)
	assert.ItsEqual(t, true, found)
	assert.ItsEqual(t, 123, verify.SetAt)
}

func Test_Manager_UpdateGraphPostStabilization(t *testing.T) {
	ctx := context.Background()
	appMgr, done := apputil.NewTest(t)
	defer done()

	u0 := apputil.CreateTestUser(t, appMgr)

	g, _ := CreateTestGraph(t, &appMgr.BaseManager, u0)

	mgr := Manager{
		BaseManager: appMgr.BaseManager,
	}

	err := mgr.UpdateGraphPostStabilization(ctx, g.ID, 123)
	assert.ItsNil(t, err)

	verify, found, err := mgr.Graph(ctx, g.ID)
	assert.ItsNil(t, err)
	assert.ItsEqual(t, true, found)

	assert.ItsEqual(t, 123, verify.StabilizationNum)
}

func Test_Manager_SetRecomputeHeap(t *testing.T) {
	ctx := context.Background()
	appMgr, done := apputil.NewTest(t)
	defer done()

	u0 := apputil.CreateTestUser(t, appMgr)

	g, nodes := CreateTestGraph(t, &appMgr.BaseManager, u0)

	mgr := Manager{
		BaseManager: appMgr.BaseManager,
	}

	rh, err := mgr.RecomputeHeap(ctx, g.ID)
	assert.ItsNil(t, err)

	assert.ItsEqual(t, 2, len(rh))

	err = mgr.SetRecomputeHeap(ctx, g.ID, u0.ID, nodes[TestNodeV0Label].ID)
	assert.ItsNil(t, err)

	rh, err = mgr.RecomputeHeap(ctx, g.ID)
	assert.ItsNil(t, err)

	assert.ItsEqual(t, 1, len(rh))
	assert.ItsEqual(t, nodes[TestNodeV0Label].ID, rh[0].NodeID)

	err = mgr.SetRecomputeHeap(ctx, g.ID, u0.ID)
	assert.ItsNil(t, err)

	rh, err = mgr.RecomputeHeap(ctx, g.ID)
	assert.ItsNil(t, err)
	assert.ItsEqual(t, 0, len(rh))
}

func Test_Manager_SetNodeHeights(t *testing.T) {
	ctx := context.Background()
	appMgr, done := apputil.NewTest(t)
	defer done()

	u0 := apputil.CreateTestUser(t, appMgr)

	g, nodes := CreateTestGraph(t, &appMgr.BaseManager, u0)

	mgr := Manager{
		BaseManager: appMgr.BaseManager,
	}

	newHeights := make(map[uuid.UUID]int)
	for _, node := range nodes {
		newHeights[node.ID] = len(nodes) + len(newHeights)
	}

	err := mgr.SetNodeHeights(ctx, g.ID, newHeights)
	assert.ItsNil(t, err)

	verifyNodes, err := mgr.Nodes(ctx, g.ID)
	assert.ItsNil(t, err)
	assert.ItsAll(t, verifyNodes, func(n Node) bool {
		return n.Height >= len(nodes)
	})
}

func Test_Manager_SetNodeMetadata(t *testing.T) {
	ctx := context.Background()
	appMgr, done := apputil.NewTest(t)
	defer done()

	u0 := apputil.CreateTestUser(t, appMgr)

	g, nodes := CreateTestGraph(t, &appMgr.BaseManager, u0)

	mgr := Manager{
		BaseManager: appMgr.BaseManager,
	}

	newMeta := make(map[uuid.UUID]Node)
	for _, node := range nodes {
		newMeta[node.ID] = Node{
			SetAt:        uint64(len(nodes) + 1),
			ChangedAt:    uint64(len(nodes) + 3),
			RecomputedAt: uint64(len(nodes) + 4),
		}
	}

	err := mgr.SetNodeMetadata(ctx, g.ID, newMeta)
	assert.ItsNil(t, err)

	verifyNodes, err := mgr.Nodes(ctx, g.ID)
	assert.ItsNil(t, err)
	assert.ItsAll(t, verifyNodes, func(n Node) bool {
		return n.SetAt > uint64(len(nodes))
	})
	assert.ItsAll(t, verifyNodes, func(n Node) bool {
		return n.ChangedAt > uint64(len(nodes)+2)
	})
	assert.ItsAll(t, verifyNodes, func(n Node) bool {
		return n.RecomputedAt > uint64(len(nodes)+3)
	})
}