mod/nodes: test connect accept

mod/nodes/src/module_test.go

@@ -0,0 +1,66 @@
+package nodes
+
+import (
+	"context"
+	"os"
+	"testing"
+	"time"
+
+	"github.com/cryptopunkscc/astrald/astral/log"
+	"github.com/cryptopunkscc/astrald/astral/term"
+	"github.com/cryptopunkscc/astrald/core/assets"
+	test "github.com/cryptopunkscc/astrald/mod/nodes/src/test"
+	"github.com/cryptopunkscc/astrald/resources"
+	"github.com/stretchr/testify/require"
+)
+
+func TestModule(t *testing.T) {
+	module1 := newTestModule(t)
+	module2 := newTestModule(t)
+	conn1, conn2 := test.PipeConn(&test.Endpoint{Addr: "1"}, &test.Endpoint{Addr: "2"})
+
+	t.Run("connect", func(t *testing.T) {
+		t.Parallel()
+		ctx, cancel := context.WithTimeout(context.Background(), 1*time.Second)
+		defer cancel()
+
+		require.NoError(t, module1.Connect(ctx, module2.node.Identity(), conn1))
+		require.True(t, module1.IsLinked(module2.node.Identity()))
+		require.NoError(t, conn1.Close())
+		time.Sleep(1 * time.Millisecond)
+		require.False(t, module1.IsLinked(module2.node.Identity()))
+	})
+
+	t.Run("accept", func(t *testing.T) {
+		t.Parallel()
+		ctx, cancel := context.WithTimeout(context.Background(), 1*time.Second)
+		defer cancel()
+
+		require.NoError(t, module2.Accept(ctx, conn2))
+		require.True(t, module2.IsLinked(module1.node.Identity()))
+		require.NoError(t, conn2.Close())
+		time.Sleep(1 * time.Millisecond)
+		require.False(t, module2.IsLinked(module1.node.Identity()))
+	})
+}
+
+func newTestModule(t *testing.T) *Module {
+	node := test.NewNode()
+
+	printer := term.NewBasicPrinter(os.Stdout, &term.DefaultTypeMap)
+	logger := log.NewLogger(printer, node.Identity(), "test")
+
+	memResources := resources.NewMemResources()
+	coreAssets, err := assets.NewCoreAssets(memResources, logger)
+	require.NoError(t, err)
+
+	loaded, err := Loader{}.Load(node, coreAssets, logger)
+	require.NoError(t, err)
+
+	module := loaded.(*Module)
+	require.NotNil(t, module)
+
+	module.Events = &test.EventsModule{T: t}
+	module.Objects = &test.ObjectsModule{T: t}
+	return module
+}

mod/nodes/src/test/conn.go

@@ -0,0 +1,36 @@
+package nodes
+
+import (
+	"io"
+
+	"github.com/cryptopunkscc/astrald/mod/exonet"
+	"github.com/cryptopunkscc/astrald/streams"
+)
+
+type Conn struct {
+	io.ReadWriteCloser
+	outbound       bool
+	localEndpoint  *Endpoint
+	remoteEndpoint *Endpoint
+}
+
+func PipeConn(localEndpoint, remoteEndpoint *Endpoint) (in *Conn, out *Conn) {
+	left, right := streams.Pipe()
+	out = &Conn{left, true, localEndpoint, remoteEndpoint}
+	in = &Conn{right, false, remoteEndpoint, localEndpoint}
+	return
+}
+
+var _ exonet.Conn = &Conn{}
+
+func (t Conn) Outbound() bool {
+	return t.outbound
+}
+
+func (t Conn) LocalEndpoint() exonet.Endpoint {
+	return t.localEndpoint
+}
+
+func (t Conn) RemoteEndpoint() exonet.Endpoint {
+	return t.remoteEndpoint
+}

mod/nodes/src/test/endpoint.go

@@ -0,0 +1,43 @@
+package nodes
+
+import (
+	"bytes"
+	"io"
+
+	"github.com/cryptopunkscc/astrald/astral"
+	"github.com/cryptopunkscc/astrald/mod/exonet"
+)
+
+type Endpoint struct {
+	Addr string
+}
+
+var _ exonet.Endpoint = &Endpoint{}
+
+func (t Endpoint) ObjectType() string {
+	return "test.endpoint"
+}
+
+func (t Endpoint) WriteTo(w io.Writer) (n int64, err error) {
+	return astral.Struct(t).WriteTo(w)
+}
+
+func (t *Endpoint) ReadFrom(r io.Reader) (n int64, err error) {
+	return astral.Struct(t).ReadFrom(r)
+}
+
+func (t Endpoint) Network() string {
+	return "test"
+}
+
+func (t Endpoint) Address() string {
+	return t.Addr
+}
+
+func (t Endpoint) Pack() []byte {
+	var b = &bytes.Buffer{}
+	if _, err := t.WriteTo(b); err != nil {
+		return nil
+	}
+	return b.Bytes()
+}

mod/nodes/src/test/events_module.go

@@ -0,0 +1,17 @@
+package nodes
+
+import (
+	"testing"
+
+	"github.com/cryptopunkscc/astrald/astral"
+	"github.com/cryptopunkscc/astrald/mod/events"
+)
+
+type EventsModule struct{ *testing.T }
+
+var _ events.Module = &EventsModule{}
+
+func (e *EventsModule) Emit(data astral.Object) *events.Event {
+	e.T.Logf("%T.Emit(%+v)", e, data)
+	return nil
+}

mod/nodes/src/test/node.go

@@ -0,0 +1,23 @@
+package nodes
+
+import (
+	"io"
+
+	"github.com/cryptopunkscc/astrald/astral"
+)
+
+type Node struct {
+	identity *astral.Identity
+}
+
+var _ astral.Node = &Node{}
+
+func NewNode() (n *Node) {
+	return &Node{identity: astral.GenerateIdentity()}
+}
+
+func (t Node) Identity() *astral.Identity { return t.identity }
+
+func (t Node) RouteQuery(ctx *astral.Context, q *astral.Query, w io.WriteCloser) (io.WriteCloser, error) {
+	panic("implement me")
+}

mod/nodes/src/test/objects_module.go

@@ -0,0 +1,89 @@
+package nodes
+
+import (
+	"testing"
+
+	"github.com/cryptopunkscc/astrald/astral"
+	"github.com/cryptopunkscc/astrald/mod/objects"
+)
+
+type ObjectsModule struct{ *testing.T }
+
+var _ objects.Module = &ObjectsModule{}
+
+func (o *ObjectsModule) Push(ctx *astral.Context, target *astral.Identity, obj astral.Object) error {
+	o.T.Logf("%T.Push(%+v, %+v)", o, target, obj)
+	return nil
+}
+
+func (o *ObjectsModule) AddRepository(id string, repo objects.Repository) error {
+	panic("implement me")
+}
+
+func (o *ObjectsModule) Root() (repo objects.Repository) {
+	panic("implement me")
+}
+
+func (o *ObjectsModule) AddDescriber(describer objects.Describer) error {
+	panic("implement me")
+}
+
+func (o *ObjectsModule) Describe(context *astral.Context, id *astral.ObjectID, scope *astral.Scope) (<-chan *objects.SourcedObject, error) {
+	panic("implement me")
+}
+
+func (o *ObjectsModule) AddPurger(purger objects.Purger) error {
+	panic("implement me")
+}
+
+func (o *ObjectsModule) Purge(id *astral.ObjectID, opts *objects.PurgeOpts) (int, error) {
+	panic("implement me")
+}
+
+func (o *ObjectsModule) Search(ctx *astral.Context, query string, opts *objects.SearchOpts) (<-chan *objects.SearchResult, error) {
+	panic("implement me")
+}
+
+func (o *ObjectsModule) AddSearcher(searcher objects.Searcher) error {
+	panic("implement me")
+}
+
+func (o *ObjectsModule) AddSearchPreprocessor(preprocessor objects.SearchPreprocessor) error {
+	panic("implement me")
+}
+
+func (o *ObjectsModule) AddFinder(finder objects.Finder) error {
+	panic("implement me")
+}
+
+func (o *ObjectsModule) Find(context *astral.Context, id *astral.ObjectID) []*astral.Identity {
+	panic("implement me")
+}
+
+func (o *ObjectsModule) AddHolder(holder objects.Holder) error {
+	panic("implement me")
+}
+
+func (o *ObjectsModule) Holders(objectID *astral.ObjectID) []objects.Holder {
+	panic("implement me")
+}
+
+func (o *ObjectsModule) AddReceiver(receiver objects.Receiver) error {
+	panic("implement me")
+}
+
+func (o *ObjectsModule) Receive(object astral.Object, identity *astral.Identity) error {
+	panic("implement me")
+}
+
+func (o *ObjectsModule) Blueprints() *astral.Blueprints {
+	panic("implement me")
+}
+
+func (o *ObjectsModule) GetType(ctx *astral.Context, objectID *astral.ObjectID) (objectType string, err error) {
+	panic("implement me")
+}
+
+func (o *ObjectsModule) On(target *astral.Identity, caller *astral.Identity) (objects.Consumer, error) {
+	panic("implement me")
+}