Run tests for pull requests

.github/workflows/pre-commit.yml

@@ -19,4 +19,47 @@ jobs:
         go install honnef.co/go/tools/cmd/staticcheck@latest
     - uses: actions/checkout@v3
     - uses: actions/setup-python@v3
-    - uses: pre-commit/[email protected]
+    - uses: pre-commit/[email protected]
+
+  tests:
+    runs-on: ubuntu-latest
+    needs: pre-commit
+    services:
+      docker:
+        image: docker:19.03.12
+        options: --privileged # required for nested containers
+        ports:
+          - 2375:2375
+        volumes:
+          - /var/lib/docker
+    steps:
+    - name: Set up Docker environment
+      run: |
+        docker info
+    - name: Set up Go
+      uses: actions/setup-go@v4
+      with:
+        go-version: '1.22.0'
+    - name: Checkout code
+      uses: actions/checkout@v3
+    - name: Add entry to /etc/hosts
+      run: |
+        echo "127.0.0.1 hal.computers.com" | sudo tee -a /etc/hosts
+    - name: Run Go tests with retries
+      env:
+        TEST_GIT_TOKEN: ${{ secrets.TEST_GIT_TOKEN }}
+      run: |
+        max_attempts=3
+        attempt_num=1
+        until [ $attempt_num -gt $max_attempts ]
+        do
+          echo "Attempt $attempt_num of $max_attempts"
+          go test -p 1 ./... && break || echo "Test failed. Retrying..."
+          attempt_num=$((attempt_num + 1))
+          if [ $attempt_num -gt $max_attempts ]
+          then
+            echo "All test attempts failed."
+            exit 1
+          fi
+          sleep 5
+        done

pkg/vm/backend/dfs/backend_test.go

@@ -3,6 +3,7 @@ package dfs_test
 import (
 	"bytes"
 	"compress/lzw"
+	"context"
 	"io"
 	"testing"
 
@@ -14,7 +15,10 @@ import (
 )
 
 func TestBackEnd(t *testing.T) {
-	backend, err := test_utils.DFSBackend().Inject(bytes.NewReader(fixtures.Recursive))
+	ctx, ctxC := context.WithCancel(context.Background())
+	defer ctxC()
+
+	backend, err := test_utils.DFSBackend(ctx).Inject(bytes.NewReader(fixtures.Recursive))
 	assert.NilError(t, err)
 	assert.Equal(t, backend.Scheme(), dfs.Scheme)
 

pkg/vm/loaders/wazero/loader_test.go

@@ -2,6 +2,7 @@ package loader_test
 
 import (
 	"bytes"
+	"context"
 	"io"
 	"testing"
 
@@ -15,15 +16,18 @@ import (
 func TestLoader(t *testing.T) {
 	test.ResetVars()
 
-	cid, loader, resolver, _, simple, err := test.Loader(bytes.NewReader(fixtures.Recursive))
+	ctx, ctxC := context.WithCancel(context.Background())
+	defer ctxC()
+
+	cid, loader, resolver, _, simple, err := test.Loader(ctx, bytes.NewReader(fixtures.Recursive))
 	assert.NilError(t, err)
 
-	ctx, err := test.Context()
+	tctx, err := test.Context()
 	assert.NilError(t, err)
 
 	moduleName := functionSpec.ModuleName(test.TestFunc.Name)
 
-	reader, err := loader.Load(ctx, moduleName)
+	reader, err := loader.Load(tctx, moduleName)
 	assert.NilError(t, err)
 
 	source, err := io.ReadAll(reader)
@@ -38,19 +42,19 @@ func TestLoader(t *testing.T) {
 	assert.NilError(t, err)
 
 	// No Reader Error: All backends have been checked, but all returned nil readers.
-	if _, err = loader.Load(ctx, moduleName); err == nil {
+	if _, err = loader.Load(tctx, moduleName); err == nil {
 		t.Error("expected error")
 	}
 
 	// New Loader with no backends
 	loader = loaders.New(resolver)
 	// Backend Error: Creating a loader with no backends results in failure
-	if _, err = loader.Load(ctx, moduleName); err == nil {
+	if _, err = loader.Load(tctx, moduleName); err == nil {
 		t.Error("expected error")
 	}
 
 	// Lookup Error: Attempting to load module that does not follow convention of <type>/<name>
-	if _, err = loader.Load(ctx, test.TestFunc.Name); err == nil {
+	if _, err = loader.Load(tctx, test.TestFunc.Name); err == nil {
 		t.Error("expected error")
 	}
 

pkg/vm/service/wazero/utils_test.go

@@ -51,18 +51,22 @@ var (
 
 func newService() (vm.Context, vm.Service, error) {
 	test_utils.ResetVars()
-	_, loader, _, _, _, err := test_utils.Loader(bytes.NewReader(fixtures.Artifact))
+
+	ctx, ctxC := context.WithCancel(context.Background())
+	defer ctxC()
+
+	_, loader, _, _, _, err := test_utils.Loader(ctx, bytes.NewReader(fixtures.Artifact))
 	if err != nil {
 		return nil, nil, err
 	}
 
 	source := sources.New(loader)
-	ctx, err := test_utils.Context()
+	tctx, err := test_utils.Context()
 	if err != nil {
 		return nil, nil, err
 	}
 
-	return ctx, New(ctx.Context(), source), nil
+	return tctx, New(tctx.Context(), source), nil
 }
 
 func newInstance() (vm.Instance, error) {

pkg/vm/sources/taubyte/source_test.go

@@ -2,6 +2,7 @@ package source
 
 import (
 	"bytes"
+	"context"
 	"testing"
 
 	functionSpec "github.com/taubyte/tau/pkg/specs/function"
@@ -13,15 +14,18 @@ import (
 func TestSource(t *testing.T) {
 	test_utils.ResetVars()
 
-	_, loader, _, _, _, err := test_utils.Loader(bytes.NewReader(fixtures.Recursive))
+	ctx, ctxC := context.WithCancel(context.Background())
+	defer ctxC()
+
+	_, loader, _, _, _, err := test_utils.Loader(ctx, bytes.NewReader(fixtures.Recursive))
 	assert.NilError(t, err)
 
 	source := New(loader)
 
-	ctx, err := test_utils.Context()
+	tctx, err := test_utils.Context()
 	assert.NilError(t, err)
 
-	sourceModule, err := source.Module(ctx, functionSpec.ModuleName(test_utils.TestFunc.Name))
+	sourceModule, err := source.Module(tctx, functionSpec.ModuleName(test_utils.TestFunc.Name))
 	assert.NilError(t, err)
 
 	sourceData := []byte(sourceModule)
@@ -30,7 +34,7 @@ func TestSource(t *testing.T) {
 	// Test Failures
 
 	// Load Failure: invalid module name does not follow convention <type>/<name>
-	if _, err = source.Module(ctx, test_utils.TestFunc.Name); err == nil {
+	if _, err = source.Module(tctx, test_utils.TestFunc.Name); err == nil {
 		t.Error("expected error")
 	}
 }

pkg/vm/test_utils/backend.go

@@ -2,10 +2,15 @@ package test_utils
 
 import (
 	"context"
+	"fmt"
 	"io"
 
 	"github.com/taubyte/tau/core/vm"
+	"github.com/taubyte/tau/p2p/keypair"
 	peer "github.com/taubyte/tau/p2p/peer"
+
+	"github.com/taubyte/tau/services/common"
+
 	"github.com/taubyte/tau/pkg/vm/backend/dfs"
 	"github.com/taubyte/tau/pkg/vm/backend/file"
 	"github.com/taubyte/tau/pkg/vm/backend/url"
@@ -17,8 +22,29 @@ type testBackend struct {
 	Cid    string
 }
 
-func DFSBackend() *testBackend {
-	simpleNode := peer.MockNode(context.Background())
+func DFSBackend(ctx context.Context) *testBackend {
+	simpleNode := peer.MockNode(ctx)
+
+	return &testBackend{
+		Backend: dfs.New(simpleNode),
+		simple:  simpleNode,
+	}
+}
+
+func DFSBackendWithNode(ctx context.Context) *testBackend {
+	simpleNode, err := peer.New( // consumer
+		ctx,
+		nil,
+		keypair.NewRaw(),
+		common.SwarmKey(),
+		[]string{fmt.Sprintf("/ip4/127.0.0.1/tcp/%d", 11912)},
+		nil,
+		true,
+		false,
+	)
+	if err != nil {
+		panic(err)
+	}
 
 	return &testBackend{
 		Backend: dfs.New(simpleNode),
@@ -40,8 +66,8 @@ func HTTPBackend() vm.Backend {
 	return url.New()
 }
 
-func AllBackends(injectReader io.Reader) (cid string, simpleNode peer.Node, backends []vm.Backend, err error) {
-	dfsBe := DFSBackend()
+func AllBackends(ctx context.Context, injectReader io.Reader) (cid string, simpleNode peer.Node, backends []vm.Backend, err error) {
+	dfsBe := DFSBackendWithNode(ctx)
 	if injectReader != nil {
 		if dfsBe, err = dfsBe.Inject(injectReader); err != nil {
 			return

pkg/vm/test_utils/loader.go

@@ -1,6 +1,7 @@
 package test_utils
 
 import (
+	"context"
 	"io"
 
 	"github.com/taubyte/tau/core/vm"
@@ -9,9 +10,9 @@ import (
 	tns "github.com/taubyte/tau/services/tns/mocks"
 )
 
-func Loader(injectReader io.Reader) (cid string, loader vm.Loader, resolver vm.Resolver, tns tns.MockedTns, simple peer.Node, err error) {
+func Loader(ctx context.Context, injectReader io.Reader) (cid string, loader vm.Loader, resolver vm.Resolver, tns tns.MockedTns, simple peer.Node, err error) {
 	var backends []vm.Backend
-	cid, simple, backends, err = AllBackends(injectReader)
+	cid, simple, backends, err = AllBackends(ctx, injectReader)
 	if err != nil {
 		return
 	}