gof3/tree/generic/node_test.go

// Copyright Earl Warren <contact@earl-warren.org>
// Copyright Loïc Dachary <loic@dachary.org>
// SPDX-License-Identifier: MIT

package generic

import (
	"context"
	"fmt"
	"testing"

	"github.com/stretchr/testify/assert"
)

func TestNodeInit(t *testing.T) {
	node := NewNode()
	assert.NotNil(t, node)
}

func TestNodeIsNil(t *testing.T) {
	node := NewNode()
	assert.True(t, node.GetIsNil())

	node.SetIsNil(false)
	assert.False(t, node.GetIsNil())

	node.SetIsNil(true)
	assert.True(t, node.GetIsNil())
}

func TestNodeCompare(t *testing.T) {
	ctx := context.Background()
	tree := NewTestTree()
	one := tree.Factory(ctx, KindTestNodeLevelOne)
	one.(*TestNodeLevelOne).v = 1
	assert.True(t, one.Equals(ctx, one))
	two := tree.Factory(ctx, KindTestNodeLevelOne)
	two.(*TestNodeLevelOne).v = 2
	assert.False(t, one.Equals(ctx, two))
}

func TestNodeParent(t *testing.T) {
	node := NewNode()
	assert.True(t, node.GetParent().GetIsNil())
	parent := NewNode()
	node.SetParent(parent)
	assert.True(t, parent == node.GetParent())
}

func TestNodeKind(t *testing.T) {
	node := NewNode()
	assert.EqualValues(t, KindNil, node.GetKind())
	kind := Kind("something")
	node.SetKind(kind)
	assert.True(t, kind == node.GetKind())
}

func TestNodeMappedID(t *testing.T) {
	node := NewNode()
	node.SetDriver(NewNullDriver())
	assert.EqualValues(t, NilID, node.GetMappedID())
	mapped := NodeID("mapped")
	node.SetMappedID(mapped)
	assert.True(t, mapped == node.GetMappedID())
}

func TestNodeID(t *testing.T) {
	node := NewNode()
	assert.EqualValues(t, NilID, node.GetID())
	id := NodeID("1234")
	node.SetID(id)
	assert.True(t, id == node.GetID())
}

func TestNodeTree(t *testing.T) {
	node := NewNode()
	assert.Nil(t, node.GetTree())
	tree := NewTree(newTestOptions())
	node.SetTree(tree)
	assert.True(t, tree == node.GetTree())
}

type driverChildren struct {
	NullDriver
}

func (o *driverChildren) ListPage(cxt context.Context, page int) ChildrenSlice {
	node := o.GetNode()
	tree := node.GetTree()
	count := tree.GetPageSize()
	if page > 1 {
		count = 1
	}

	offset := (page - 1) * tree.GetPageSize()
	children := NewChildrenSlice(0)
	for i := 0; i < count; i++ {
		child := tree.GetSelf().Factory(cxt, KindNil)
		child.SetID(NodeID(fmt.Sprintf("%d", i+offset)))
		children = append(children, child)
	}

	return children
}

type driverTreeChildren struct {
	NullTreeDriver
}

func (o *driverTreeChildren) Factory(ctx context.Context, kind Kind) NodeDriverInterface {
	return &driverChildren{}
}

type treeChildren struct {
	Tree
}

func NewTreeChildren() TreeInterface {
	tree := &treeChildren{}
	tree.Init(tree, newTestOptions())
	treeDriver := &driverTreeChildren{}
	treeDriver.Init()
	tree.SetDriver(treeDriver)
	tree.Register(KindNil, func(ctx context.Context, kind Kind) NodeInterface {
		node := NewNode()
		node.SetIsNil(false)
		return node
	})
	return tree
}

func TestNodeListPage(t *testing.T) {
	tree := NewTreeChildren()

	ctx := context.Background()
	node := tree.Factory(ctx, KindNil)

	children := node.ListPage(context.Background(), int(1))
	assert.NotNil(t, children)
	assert.EqualValues(t, tree.GetPageSize(), len(children))

	children = node.ListPage(context.Background(), int(2))
	assert.NotNil(t, children)
	assert.EqualValues(t, 1, len(children))
}

func TestNodeList(t *testing.T) {
	tree := NewTreeChildren()

	ctx := context.Background()
	node := tree.Factory(ctx, KindNil)
	children := node.List(ctx)
	assert.EqualValues(t, tree.GetPageSize()+1, len(children))

	idThree := NodeID("3")
	childThree := node.GetChild(idThree)
	assert.False(t, childThree.GetIsNil())
	assert.EqualValues(t, idThree, childThree.GetID())
	node.DeleteChild(idThree)
	childThree = node.GetChild(idThree)
	assert.True(t, childThree.GetIsNil())
}

type nodeGetIDFromName struct {
	Node
	name string
}

func (o *nodeGetIDFromName) GetIDFromName(ctx context.Context, name string) NodeID {
	for _, child := range o.GetChildren() {
		if child.(*nodeGetIDFromName).name == name {
			return child.GetID()
		}
	}
	return NilID
}

func newNodeGetIDFromName(id, name string) NodeInterface {
	node := &nodeGetIDFromName{}
	node.Init(node)
	node.SetIsNil(false)
	node.SetID(NodeID(id))
	node.name = name
	return node
}

func TestNodeGetIDFromName(t *testing.T) {
	id := "1243"
	name := "NAME"
	node := newNodeGetIDFromName(id, name)

	ctx := context.Background()
	parent := newNodeGetIDFromName("parent", "PARENT")
	parent.SetChild(node)

	r := parent.GetIDFromName(ctx, "OTHERNAME")
	assert.EqualValues(t, NilID, r)

	r = parent.GetIDFromName(ctx, name)
	assert.True(t, r == NodeID(id))
}