chore: refactor client sdk tests

fix(module,net): add missing context to server message
fix #6
2023-03-03 11:42:20 +01:00 · 2023-03-03 10:43:13 +01:00 · 2023-03-01 15:15:47 +01:00 · 2023-03-01 14:39:45 +01:00 · 2023-03-01 13:06:32 +01:00 · 2023-03-01 13:04:40 +01:00
22 changed files with 276 additions and 156 deletions
--- a/doc/apps/server-api/store.md
+++ b/doc/apps/server-api/store.md
@ -178,6 +178,6 @@ var results = store.query(ctx, "myCollection", {
    limit: 10,
    offset: 5,
    orderBy: "foo",
-    orderDirection: store.ASC,
+    orderDirection: store.DIRECTION_ASC,
 });
 ```
--- a/misc/client-sdk-testsuite/src/public/index.html
+++ b/misc/client-sdk-testsuite/src/public/index.html
@ -4,7 +4,7 @@
    <meta charset="utf-8" />
    <title>Client SDK Test suite</title>
    <meta name="viewport" content="width=device-width, initial-scale=1.0" />
-    <link rel="stylesheet" href="vendor/mocha.css" />
+    <link rel="stylesheet" href="/vendor/mocha.css" />
    <style>
      body {
        background-color: white;
@ -13,15 +13,18 @@
  </head>
  <body>
    <div id="mocha"></div>
-    <script src="vendor/chai.js"></script>
-    <script src="vendor/mocha.js"></script>
+    <script src="/vendor/chai.js"></script>
+    <script src="/vendor/mocha.js"></script>
    <script class="mocha-init">
      mocha.setup('bdd');
      mocha.checkLeaks();
    </script>
    <script src="/edge/sdk/client.js"></script>
-    <script src="test/client-sdk.js"></script>
-    <script src="test/auth-module.js"></script>
+    <script src="/test/client-sdk.js"></script>
+    <script src="/test/auth-module.js"></script>
+    <script src="/test/net-module.js"></script>
+    <script src="/test/rpc-module.js"></script>
+    <script src="/test/file-module.js"></script>
    <script class="mocha-exec">
      mocha.run();
    </script>
--- a/misc/client-sdk-testsuite/src/public/test/client-sdk.js
+++ b/misc/client-sdk-testsuite/src/public/test/client-sdk.js
@ -22,127 +22,4 @@ describe('Edge', function() {
    });
  });
  
-  describe('#send()', function() {
-    this.timeout(5000);
-    
-    before(() => {
-      return Edge.connect();
-    });
-
-    after(() => {
-      Edge.disconnect();
-    });
-
-    it('should send a message to the server and echo back', function(done) {
-      const now = new Date();
-      const handler = evt => {
-        chai.assert.equal(evt.detail.now, now.toJSON());
-        Edge.removeEventListener('message', handler);
-        done();
-      }
-
-      // Server should echo back message
-      Edge.addEventListener('message', handler);
-
-      // Send message to server
-      Edge.send({ now });
-    });
-  });
-  
-});
-
-describe('Remote Procedure Call', function() {
-
-  before(() => {
-    return Edge.connect();
-  });
-
-  after(() => {
-    Edge.disconnect();
-  });
-
-  it('should call the remote echo() method and resolve the returned value', function() {
-    const foo = "bar";
-
-    return Edge.rpc('echo', { foo })
-      .then(result => {
-        chai.assert.equal(result.foo, foo);
-      });
-  });
-
-  it('should call the remote throwErrorFromClient() method and reject with an error', function() {
-    return Edge.rpc('throwErrorFromClient')
-      .catch(err => {
-        // Assert that it's an "internal" error
-        // See https://www.jsonrpc.org/specification#error_object
-        chai.assert.equal(err.code, -32603);
-      });
-  });
-
-  it('should call an unregistered method and reject with an error', function() {
-    return Edge.rpc('unregisteredMethod')
-      .catch(err => {
-        // Assert that it's an "method not found" error
-        // See https://www.jsonrpc.org/specification#error_object
-        chai.assert.equal(err.code, -32601);
-      });
-  });
-
-
-  it('should call the add() method repetitively and keep count of the sent values', function() {
-    this.timeout(10000);
-
-    const values = [];
-    for(let i = 0; i <= 1000; i++) {
-      values.push((Math.random() * 1000 | 0));
-    }
-    return Edge.rpc('reset')
-      .then(() => {
-        return Promise.all(values.map(v =>  Edge.rpc("add", {value: v})));
-      })
-      .then(() => Edge.rpc('total'))
-      .then(remoteTotal => {
-        const localTotal = values.reduce((t, v) => t+v);
-        console.log("Remote total:", remoteTotal, "Local total:", localTotal);
-        chai.assert.equal(remoteTotal, localTotal)
-      })
-  });
-
-});
-
-describe('File Module', function() {
-
-  before(() => {
-    return Edge.connect();
-  });
-
-  after(() => {
-    Edge.disconnect();
-  });
-
-  it('should upload then download a blob', function() {
-    const content = JSON.stringify({"date": new Date()});
-    const blob = new Blob([content], {type: "application/json"});
-
-    return Edge.upload(blob)
-      .then(upload => upload.result())
-      .then(result => {
-
-        chai.assert.isNotEmpty(result.blobId);
-        chai.assert.isNotEmpty(result.bucket);
-        
-        const blobUrl = Edge.blobUrl(result.bucket, result.blobId);
-        chai.assert.isNotEmpty(blobUrl);
-
-        return fetch(blobUrl)
-          .then(res => res.text())
-          .then(blobContent => {
-            chai.assert.equal(content, blobContent);
-          });
-      })
-      .catch(err => {
-        chai.assert.fail(err);
-      })
-  });
-
 });
--- a/misc/client-sdk-testsuite/src/public/test/file-module.js
+++ b/misc/client-sdk-testsuite/src/public/test/file-module.js
@ -0,0 +1,36 @@
+describe('File Module', function () {
+
+    before(() => {
+        return Edge.connect();
+    });
+
+    after(() => {
+        Edge.disconnect();
+    });
+
+    it('should upload then download a blob', function () {
+        const content = JSON.stringify({ "date": new Date() });
+        const blob = new Blob([content], { type: "application/json" });
+
+        return Edge.upload(blob)
+            .then(upload => upload.result())
+            .then(result => {
+
+                chai.assert.isNotEmpty(result.blobId);
+                chai.assert.isNotEmpty(result.bucket);
+
+                const blobUrl = Edge.blobUrl(result.bucket, result.blobId);
+                chai.assert.isNotEmpty(blobUrl);
+
+                return fetch(blobUrl)
+                    .then(res => res.text())
+                    .then(blobContent => {
+                        chai.assert.equal(content, blobContent);
+                    });
+            })
+            .catch(err => {
+                chai.assert.fail(err);
+            })
+    });
+
+});
--- a/misc/client-sdk-testsuite/src/public/test/net-module.js
+++ b/misc/client-sdk-testsuite/src/public/test/net-module.js
@ -0,0 +1,49 @@
+describe('Net Module', function () {
+    this.timeout(5000);
+
+    before(() => {
+        return Edge.connect();
+    });
+
+    after(() => {
+        Edge.disconnect();
+    });
+
+    it('should broadcast a message from server', function (done) {
+        const message = { test: 'broadcast', now: Date.now() };
+
+        const handler = (evt) => {
+            const receivedMessage = evt.detail;
+            if (receivedMessage.test !== 'broadcast') return;
+            
+            chai.assert.deepEqual(message, evt.detail);
+            
+            Edge.removeEventListener('message', handler);
+            done();
+        };
+
+        Edge.addEventListener("message", handler);
+        Edge.send(message);
+    });
+
+    it('should send a message to the server and echo back', function(done) {
+        const now = new Date();
+        
+        const handler = evt => {
+            const receivedMessage = evt.detail;
+            if (receivedMessage.test !== 'echo') return;
+
+            chai.assert.equal(receivedMessage.now, now.toJSON());
+            
+            Edge.removeEventListener('message', handler);
+            done();
+        }
+
+        // Server should echo back message
+        Edge.addEventListener('message', handler);
+
+        // Send message to server
+        Edge.send({ test: 'echo', now });
+    });
+
+});
--- a/misc/client-sdk-testsuite/src/public/test/rpc-module.js
+++ b/misc/client-sdk-testsuite/src/public/test/rpc-module.js
@ -0,0 +1,59 @@
+describe('Remote Procedure Call', function () {
+
+    before(() => {
+        return Edge.connect();
+    });
+
+    after(() => {
+        Edge.disconnect();
+    });
+
+    it('should call the remote echo() method and resolve the returned value', function () {
+        const foo = "bar";
+
+        return Edge.rpc('echo', { foo })
+            .then(result => {
+                console.log(result);
+                chai.assert.equal(result.foo, foo);
+            });
+    });
+
+    it('should call the remote throwErrorFromClient() method and reject with an error', function () {
+        return Edge.rpc('throwErrorFromClient')
+            .catch(err => {
+                // Assert that it's an "internal" error
+                // See https://www.jsonrpc.org/specification#error_object
+                chai.assert.equal(err.code, -32603);
+            });
+    });
+
+    it('should call an unregistered method and reject with an error', function () {
+        return Edge.rpc('unregisteredMethod')
+            .catch(err => {
+                // Assert that it's an "method not found" error
+                // See https://www.jsonrpc.org/specification#error_object
+                chai.assert.equal(err.code, -32601);
+            });
+    });
+
+
+    it('should call the add() method repetitively and keep count of the sent values', function () {
+        this.timeout(10000);
+
+        const values = [];
+        for (let i = 0; i <= 1000; i++) {
+            values.push((Math.random() * 1000 | 0));
+        }
+        return Edge.rpc('reset')
+            .then(() => {
+                return Promise.all(values.map(v => Edge.rpc("add", { value: v })));
+            })
+            .then(() => Edge.rpc('total'))
+            .then(remoteTotal => {
+                const localTotal = values.reduce((t, v) => t + v);
+                console.log("Remote total:", remoteTotal, "Local total:", localTotal);
+                chai.assert.equal(remoteTotal, localTotal)
+            })
+    });
+
+});
--- a/misc/client-sdk-testsuite/src/server/main.js
+++ b/misc/client-sdk-testsuite/src/server/main.js
@ -14,9 +14,16 @@ function onInit() {
 }

 // Called for each client message
-function onClientMessage(ctx, data) {
-  console.log("onClientMessage", data.now);
-  net.send(ctx, { now: data.now });
+function onClientMessage(ctx, message) {
+  console.log("onClientMessage", message);
+  
+  switch (message.test) {
+    case "broadcast":
+      net.broadcast(message);
+      break;
+    default:
+      net.send(ctx, message);
+  }
 }

 // Called for each blob upload request
--- a/modd.conf
+++ b/modd.conf
@ -1,6 +1,6 @@
 **/*.go
-pkg/app/sdk/client/src/**/*.js
-pkg/app/sdk/client/src/**/*.ts
+pkg/sdk/client/src/**/*.js
+pkg/sdk/client/src/**/*.ts
 misc/client-sdk-testsuite/src/**/*
 modd.conf
 {
--- a/pkg/app/server.go
+++ b/pkg/app/server.go
@ -1,15 +1,20 @@
 package app

 import (
+	"context"
 	"math/rand"
 	"sync"

 	"github.com/dop251/goja"
 	"github.com/dop251/goja_nodejs/eventloop"
 	"github.com/pkg/errors"
+	"gitlab.com/wpetit/goweb/logger"
 )

-var ErrFuncDoesNotExist = errors.New("function does not exist")
+var (
+	ErrFuncDoesNotExist = errors.New("function does not exist")
+	ErUnknownError      = errors.New("unknown error")
+)

 type Server struct {
 	runtime *goja.Runtime
@ -26,16 +31,18 @@ func (s *Server) Load(name string, src string) error {
 	return nil
 }

-func (s *Server) ExecFuncByName(funcName string, args ...interface{}) (goja.Value, error) {
+func (s *Server) ExecFuncByName(ctx context.Context, funcName string, args ...interface{}) (goja.Value, error) {
+	ctx = logger.With(ctx, logger.F("function", funcName), logger.F("args", args))
+
 	callable, ok := goja.AssertFunction(s.runtime.Get(funcName))
 	if !ok {
 		return nil, errors.WithStack(ErrFuncDoesNotExist)
 	}

-	return s.Exec(callable, args...)
+	return s.Exec(ctx, callable, args...)
 }

-func (s *Server) Exec(callable goja.Callable, args ...interface{}) (goja.Value, error) {
+func (s *Server) Exec(ctx context.Context, callable goja.Callable, args ...interface{}) (goja.Value, error) {
 	var (
 		wg    sync.WaitGroup
 		value goja.Value
@ -45,6 +52,25 @@ func (s *Server) Exec(callable goja.Callable, args ...interface{}) (goja.Value,
 	wg.Add(1)

 	s.loop.RunOnLoop(func(vm *goja.Runtime) {
+		logger.Debug(ctx, "executing callable")
+
+		defer wg.Done()
+
+		defer func() {
+			if recovered := recover(); recovered != nil {
+				revoveredErr, ok := recovered.(error)
+				if ok {
+					logger.Error(ctx, "recovered runtime error", logger.E(errors.WithStack(revoveredErr)))
+
+					err = errors.WithStack(ErUnknownError)
+
+					return
+				}
+
+				panic(recovered)
+			}
+		}()
+
 		jsArgs := make([]goja.Value, 0, len(args))
 		for _, a := range args {
 			jsArgs = append(jsArgs, vm.ToValue(a))
@ -54,8 +80,6 @@ func (s *Server) Exec(callable goja.Callable, args ...interface{}) (goja.Value,
 		if err != nil {
 			err = errors.WithStack(err)
 		}
-
-		wg.Done()
 	})

 	wg.Wait()
--- a/pkg/bundle/filesystem.go
+++ b/pkg/bundle/filesystem.go
@ -99,3 +99,5 @@ func (f *File) Readdir(count int) ([]os.FileInfo, error) {
 func (f *File) Stat() (os.FileInfo, error) {
 	return f.fi, nil
 }
+
+var _ http.FileSystem = &FileSystem{}
--- a/pkg/http/handler.go
+++ b/pkg/http/handler.go
@ -59,7 +59,7 @@ func (h *Handler) Load(bdle bundle.Bundle) error {
 	}

 	fs := bundle.NewFileSystem("public", bdle)
-	public := http.FileServer(fs)
+	public := HTML5Fileserver(fs)
 	sockjs := sockjs.NewHandler(sockJSPathPrefix, h.sockjsOpts, h.handleSockJSSession)

 	if h.server != nil {
--- a/pkg/http/html5_fileserver.go
+++ b/pkg/http/html5_fileserver.go
@ -0,0 +1,54 @@
+package http
+
+import (
+	"net/http"
+	"os"
+	"path"
+	"strings"
+
+	"github.com/pkg/errors"
+	"gitlab.com/wpetit/goweb/logger"
+)
+
+func HTML5Fileserver(fs http.FileSystem) http.Handler {
+	handler := http.FileServer(fs)
+
+	fn := func(w http.ResponseWriter, r *http.Request) {
+		urlPath := r.URL.Path
+		if !strings.HasPrefix(urlPath, "/") {
+			urlPath = "/" + urlPath
+			r.URL.Path = urlPath
+		}
+		urlPath = path.Clean(urlPath)
+
+		file, err := fs.Open(urlPath)
+		if err != nil {
+			if errors.Is(err, os.ErrNotExist) {
+				r.URL.Path = "/"
+
+				handler.ServeHTTP(w, r)
+
+				return
+			}
+
+			logger.Error(r.Context(), "could not open bundle file", logger.E(err))
+
+			http.Error(w, http.StatusText(http.StatusInternalServerError), http.StatusInternalServerError)
+			return
+		}
+
+		defer func() {
+			if err := file.Close(); err != nil {
+				logger.Error(r.Context(), "could not close file", logger.E(err))
+
+				http.Error(w, http.StatusText(http.StatusInternalServerError), http.StatusInternalServerError)
+
+				return
+			}
+		}()
+
+		handler.ServeHTTP(w, r)
+	}
+
+	return http.HandlerFunc(fn)
+}
--- a/pkg/module/auth/module_test.go
+++ b/pkg/module/auth/module_test.go
@ -65,7 +65,7 @@ func TestAuthModule(t *testing.T) {

 	ctx := context.WithValue(context.Background(), edgeHTTP.ContextKeyOriginRequest, req)

-	if _, err := server.ExecFuncByName("testAuth", ctx); err != nil {
+	if _, err := server.ExecFuncByName(ctx, "testAuth", ctx); err != nil {
 		t.Fatalf("%+v", errors.WithStack(err))
 	}
 }
@ -104,7 +104,7 @@ func TestAuthAnonymousModule(t *testing.T) {

 	ctx := context.WithValue(context.Background(), edgeHTTP.ContextKeyOriginRequest, req)

-	if _, err := server.ExecFuncByName("testAuth", ctx); err != nil {
+	if _, err := server.ExecFuncByName(ctx, "testAuth", ctx); err != nil {
 		t.Fatalf("%+v", errors.WithStack(err))
 	}
 }
--- a/pkg/module/blob.go
+++ b/pkg/module/blob.go
@ -88,7 +88,7 @@ func (m *BlobModule) handleUploadRequest(req *MessageUploadRequest) (*MessageUpl
 		"contentType": req.FileHeader.Header.Get("Content-Type"),
 	}

-	rawResult, err := m.server.ExecFuncByName("onBlobUpload", ctx, blobID, blobInfo, req.Metadata)
+	rawResult, err := m.server.ExecFuncByName(ctx, "onBlobUpload", ctx, blobID, blobInfo, req.Metadata)
 	if err != nil {
 		if errors.Is(err, app.ErrFuncDoesNotExist) {
 			res.Allow = false
@ -193,7 +193,7 @@ func (m *BlobModule) saveBlob(ctx context.Context, bucketName string, blobID sto
 func (m *BlobModule) handleDownloadRequest(req *MessageDownloadRequest) (*MessageDownloadResponse, error) {
 	res := NewMessageDownloadResponse(req.RequestID)

-	rawResult, err := m.server.ExecFuncByName("onBlobDownload", req.Context, req.Bucket, req.BlobID)
+	rawResult, err := m.server.ExecFuncByName(req.Context, "onBlobDownload", req.Context, req.Bucket, req.BlobID)
 	if err != nil {
 		if errors.Is(err, app.ErrFuncDoesNotExist) {
 			res.Allow = false
--- a/pkg/module/cast/module_test.go
+++ b/pkg/module/cast/module_test.go
@ -1,6 +1,7 @@
 package cast

 import (
+	"context"
 	"io/ioutil"
 	"os"
 	"testing"
@ -79,7 +80,7 @@ func TestCastModuleRefreshDevices(t *testing.T) {

 	defer server.Stop()

-	result, err := server.ExecFuncByName("refreshDevices")
+	result, err := server.ExecFuncByName(context.Background(), "refreshDevices")
 	if err != nil {
 		t.Error(errors.WithStack(err))
 	}
--- a/pkg/module/lifecycle.go
+++ b/pkg/module/lifecycle.go
@ -21,7 +21,7 @@ func (m *LifecycleModule) Export(export *goja.Object) {
 }

 func (m *LifecycleModule) OnInit() error {
-	if _, err := m.server.ExecFuncByName("onInit"); err != nil {
+	if _, err := m.server.ExecFuncByName(context.Background(), "onInit"); err != nil {
 		if errors.Is(err, app.ErrFuncDoesNotExist) {
 			logger.Warn(context.Background(), "could not find onInit() function", logger.E(errors.WithStack(err)))

--- a/pkg/module/net/module.go
+++ b/pkg/module/net/module.go
@ -38,9 +38,10 @@ func (m *Module) broadcast(call goja.FunctionCall, rt *goja.Runtime) goja.Value
 	}

 	data := call.Argument(0).Export()
+	ctx := context.Background()

-	msg := module.NewServerMessage(nil, data)
-	if err := m.bus.Publish(context.Background(), msg); err != nil {
+	msg := module.NewServerMessage(ctx, data)
+	if err := m.bus.Publish(ctx, msg); err != nil {
 		panic(rt.ToValue(errors.WithStack(err)))
 	}

@ -129,7 +130,7 @@ func (m *Module) handleClientMessages() {
 				logger.F("message", clientMessage),
 			)

-			if _, err := m.server.ExecFuncByName("onClientMessage", clientMessage.Context, clientMessage.Data); err != nil {
+			if _, err := m.server.ExecFuncByName(clientMessage.Context, "onClientMessage", clientMessage.Context, clientMessage.Data); err != nil {
 				if errors.Is(err, app.ErrFuncDoesNotExist) {
 					continue
 				}
--- a/pkg/module/rpc.go
+++ b/pkg/module/rpc.go
@ -161,7 +161,7 @@ func (m *RPCModule) handleMessages() {
 			continue
 		}

-		result, err := m.server.Exec(callable, clientMessage.Context, req.Params)
+		result, err := m.server.Exec(clientMessage.Context, callable, clientMessage.Context, req.Params)
 		if err != nil {
 			logger.Error(
 				ctx, "rpc call error",
--- a/pkg/module/store/module.go
+++ b/pkg/module/store/module.go
@ -102,7 +102,7 @@ func (m *Module) query(call goja.FunctionCall, rt *goja.Runtime) goja.Value {
 		}

 		if queryOptions.Offset != nil {
-			queryOptionsFuncs = append(queryOptionsFuncs, storage.WithOffset(*queryOptions.Limit))
+			queryOptionsFuncs = append(queryOptionsFuncs, storage.WithOffset(*queryOptions.Offset))
 		}

 		if queryOptions.OrderDirection != nil {
--- a/pkg/module/store/module_test.go
+++ b/pkg/module/store/module_test.go
@ -1,6 +1,7 @@
 package store

 import (
+	"context"
 	"io/ioutil"
 	"testing"

@ -34,7 +35,7 @@ func TestStoreModule(t *testing.T) {
 		t.Fatalf("%+v", errors.WithStack(err))
 	}

-	if _, err := server.ExecFuncByName("testStore"); err != nil {
+	if _, err := server.ExecFuncByName(context.Background(), "testStore"); err != nil {
 		t.Fatalf("%+v", errors.WithStack(err))
 	}

--- a/pkg/sdk/client/src/client.ts
+++ b/pkg/sdk/client/src/client.ts
@ -93,6 +93,7 @@ export class Client extends EventTarget {
    const { jsonrpc, id, error, result } = evt.detail;
    
    if (jsonrpc !== '2.0' || id === undefined) return;
+    if (!evt.detail.hasOwnProperty("error") && !evt.detail.hasOwnProperty("result")) return;

    // Prevent additional handlers to catch this event
    evt.stopImmediatePropagation();
--- a/pkg/storage/sqlite/document_store.go
+++ b/pkg/storage/sqlite/document_store.go
@ -127,7 +127,12 @@ func (s *DocumentStore) Query(ctx context.Context, collection string, filter *fi
 		args = append([]interface{}{collection}, args...)

 		if opts.OrderBy != nil {
-			query, args = withOrderByClause(query, args, *opts.OrderBy, *opts.OrderDirection)
+			direction := storage.OrderDirectionAsc
+			if opts.OrderDirection != nil {
+				direction = *opts.OrderDirection
+			}
+
+			query, args = withOrderByClause(query, args, *opts.OrderBy, direction)
 		}

 		if opts.Offset != nil || opts.Limit != nil {
Author	SHA1	Message	Date
William Petit	0bb7f2cd85	chore: refactor client sdk tests	2023-03-03 11:42:20 +01:00
William Petit	b61bf52df9	fix(module,net): add missing context to server message fix #6	2023-03-03 10:43:13 +01:00
William Petit	f1dd467c95	fix(doc): typo	2023-03-01 15:15:47 +01:00
William Petit	3136d71032	feat(http): handle html5 routing ref #5	2023-03-01 14:39:45 +01:00
William Petit	8680e139e7	fix(storage,document,sqlite): fix nil pointer exception in query options	2023-03-01 13:06:32 +01:00
William Petit	8789b85d92	feat(server): handle panic in runtime ref #2	2023-03-01 13:04:40 +01:00