go.charczuk.com@v0.0.0-20240327042549-bc490516bd1a/projects/nodes/pkg/dbmodel/main_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 (
	"bytes"
	"context"
	"fmt"
	"os"
	"os/exec"
	"path/filepath"
	"testing"
	"time"

	"github.com/wcharczuk/go-incr"
	"go.charczuk.com/sdk/apputil"
	"go.charczuk.com/sdk/assert"
	"go.charczuk.com/sdk/db"
	"go.charczuk.com/sdk/db/dbutil"
	"go.charczuk.com/sdk/logutil"
	"go.charczuk.com/sdk/testutil"
	"go.charczuk.com/sdk/uuid"
)

func TestMain(m *testing.M) {
	testutil.New(m,
		testutil.OptWithDefaultDB(
			ifDebug(db.OptLog(logutil.New())),
		),
		testutil.OptBefore(
			func(ctx context.Context) error {
				return Migrations().Apply(ctx, testutil.DefaultDB())
			},
		),
	).Run()
}

func ifDebug(opt db.Option) db.Option {
	return func(s *db.Connection) error {
		if os.Getenv("DEBUG") != "" {
			opt(s)
		}
		return nil
	}
}

const (
	TestNodeV0Label = "test-var-00"
	TestNodeV1Label = "test-var-01"
	TestNodeM0Label = "test-expression"
	TestNodeO0Label = "test-observer"
)

// CreateTestGraph creates a test graph.
func CreateTestGraph(t *testing.T, mgr *dbutil.BaseManager, user *apputil.User) (*Graph, map[string]*Node) {
	ctx := context.Background()
	g := NewGraph()
	g.UserID = user.ID
	var err error
	err = mgr.Invoke(ctx).Create(g)
	assert.ItsNil(t, err)

	v0 := Node{
		ID:         uuid.V4(),
		CreatedUTC: time.Now().UTC(),
		GraphID:    g.ID,
		UserID:     user.ID,
		Label:      TestNodeV0Label,
		NodeType:   "var",
		OutputType: "string",
	}

	err = mgr.Invoke(ctx).Create(v0)
	assert.ItsNil(t, err)

	err = mgr.Invoke(ctx).Create(NodeValue{
		GraphID:   g.ID,
		NodeID:    v0.ID,
		UserID:    user.ID,
		ValueType: "string",
		Value:     "hello",
	})
	assert.ItsNil(t, err)

	v1 := Node{
		ID:         uuid.V4(),
		CreatedUTC: time.Now().UTC(),
		GraphID:    g.ID,
		UserID:     user.ID,
		Label:      TestNodeV1Label,
		NodeType:   "var",
		OutputType: "string",
	}

	err = mgr.Invoke(ctx).Create(v1)
	assert.ItsNil(t, err)

	err = mgr.Invoke(ctx).Create(NodeValue{
		GraphID:   g.ID,
		NodeID:    v1.ID,
		UserID:    user.ID,
		ValueType: "string",
		Value:     "world",
	})
	assert.ItsNil(t, err)

	m0 := Node{
		ID:         uuid.V4(),
		CreatedUTC: time.Now().UTC(),
		GraphID:    g.ID,
		UserID:     user.ID,
		Label:      TestNodeM0Label,
		NodeType:   "expression",
		InputType:  "string",
		OutputType: "string",
		Expression: `output = input(0) + " " + input(1)`,
	}

	err = mgr.Invoke(ctx).Create(m0)
	assert.ItsNil(t, err)

	o0 := Node{
		ID:         uuid.V4(),
		CreatedUTC: time.Now().UTC(),
		GraphID:    g.ID,
		UserID:     user.ID,
		NodeType:   "observer",
		Label:      TestNodeO0Label,
		InputType:  "string",
	}

	err = mgr.Invoke(ctx).Create(o0)
	assert.ItsNil(t, err)

	err = mgr.Invoke(ctx).Create(Edge{
		GraphID:  g.ID,
		UserID:   user.ID,
		ParentID: v0.ID,
		ChildID:  m0.ID,
	})
	assert.ItsNil(t, err)

	err = mgr.Invoke(ctx).Create(Edge{
		GraphID:  g.ID,
		UserID:   user.ID,
		ParentID: v1.ID,
		ChildID:  m0.ID,
	})
	assert.ItsNil(t, err)

	err = mgr.Invoke(ctx).Create(Edge{
		GraphID:  g.ID,
		UserID:   user.ID,
		ParentID: m0.ID,
		ChildID:  o0.ID,
	})
	assert.ItsNil(t, err)

	err = mgr.Invoke(ctx).Create(GraphRecomputeHeap{
		GraphID: g.ID,
		UserID:  user.ID,
		NodeID:  v0.ID,
	})
	assert.ItsNil(t, err)

	err = mgr.Invoke(ctx).Create(GraphRecomputeHeap{
		GraphID: g.ID,
		UserID:  user.ID,
		NodeID:  v1.ID,
	})
	assert.ItsNil(t, err)

	return g, map[string]*Node{
		v0.Label: &v0,
		v1.Label: &v1,
		m0.Label: &m0,
		o0.Label: &o0,
	}
}

func homedir(filename string) string {
	var rootDir string
	if rootDir = os.Getenv("INCR_DEBUG_DOT_ROOT"); rootDir == "" {
		rootDir = os.ExpandEnv("$HOME/Desktop")
	}
	return filepath.Join(rootDir, filename)
}

func dumpDot(g *incr.Graph, path string) error {
	if os.Getenv("INCR_DEBUG_DOT") != "true" {
		return nil
	}

	dotContents := new(bytes.Buffer)
	if err := incr.Dot(dotContents, g); err != nil {
		return err
	}
	dotOutput, err := os.Create(os.ExpandEnv(path))
	if err != nil {
		return err
	}
	defer func() { _ = dotOutput.Close() }()
	dotFullPath, err := exec.LookPath("dot")
	if err != nil {
		return fmt.Errorf("there was an issue finding `dot` in your path; you may need to install the `graphviz` package or similar on your platform: %w", err)
	}

	errOut := new(bytes.Buffer)
	cmd := exec.Command(dotFullPath, "-Tpng")
	cmd.Stdin = dotContents
	cmd.Stdout = dotOutput
	cmd.Stderr = errOut
	if err := cmd.Run(); err != nil {
		return fmt.Errorf("%v; %w", errOut.String(), err)
	}
	return nil
}