Implemented dop.getRequest

Author: Josema

package.json

@@ -1,6 +1,6 @@
 {
     "name": "dop",
-    "version": "0.40.1",
+    "version": "0.41.0",
     "main": "./dist/dop.nodejs.js",
     "browser": "./dist/dop.js",
     "unpkg": "./dist/dop.min.js",

src/api/getRequest.js

@@ -0,0 +1,12 @@
+dop.getRequest = function(args) {
+    args = Array.prototype.slice.call(args, 0)
+    var request = args[args.length - 1]
+    if (
+        request instanceof Promise &&
+        request.hasOwnProperty('resolve') &&
+        request.hasOwnProperty('reject')
+    )
+        return request
+
+    return dop.core.createAsync()
+}

src/api/isRemoteFunction.js

@@ -1,3 +1,3 @@
-dop.isRemoteFunction = function(fun) {
-    return isFunction(fun) && fun._name === dop.cons.REMOTE_FUNCTION
-}
+dop.isRemoteFunction = function(fun) {
+    return isFunction(fun) && fun._name === dop.cons.REMOTE_FUNCTION
+}

src/protocol/onfunction.js

@@ -1,67 +1,67 @@
-// Used by dop.protocol.oncall && dop.protocol.onbroadcast
-dop.protocol.onfunction = function(
-    node,
-    request_id,
-    request,
-    object_id,
-    validator
-) {
-    var path = request[2],
-        params = request[3],
-        object_data = dop.data.object[object_id]
-
-    if (
-        isObject(object_data) &&
-        isObject(object_data.node[node.token]) &&
-        validator(object_data.node[node.token])
-    ) {
-        var function_name = path.pop(),
-            object = dop.util.get(object_data.object, path),
-            f = object[function_name]
-        if (isFunction(f) && !dop.isBroadcastFunction(f)) {
-            function resolve(value) {
-                var response = dop.core.createResponse(request_id, 0)
-                if (value !== undefined) response.push(value)
-                dop.core.storeSendMessages(node, response)
-                return value
-            }
-            function reject(err) {
-                dop.core.storeSendMessages(
-                    node,
-                    dop.core.createResponse(
-                        request_id,
-                        dop.core.error.reject_remote.CUSTOM_REJECTION,
-                        err
-                    )
-                )
-            }
-
-            if (dop.isRemoteFunction(f))
-                f.apply(null, params)
-                    .then(resolve)
-                    .catch(reject)
-            else
-                dop.core.localProcedureCall(
-                    f,
-                    params,
-                    resolve,
-                    reject,
-                    function(req) {
-                        req.node = node
-                        return req
-                    },
-                    dop.getObjectProxy(object)
-                )
-
-            return
-        }
-    }
-
-    dop.core.storeSendMessages(
-        node,
-        dop.core.createResponse(
-            request_id,
-            dop.core.error.reject_remote.FUNCTION_NOT_FOUND
-        )
-    )
-}
+// Used by dop.protocol.oncall && dop.protocol.onbroadcast
+dop.protocol.onfunction = function(
+    node,
+    request_id,
+    request,
+    object_id,
+    validator
+) {
+    var path = request[2],
+        params = request[3],
+        object_data = dop.data.object[object_id]
+
+    if (
+        isObject(object_data) &&
+        isObject(object_data.node[node.token]) &&
+        validator(object_data.node[node.token])
+    ) {
+        var function_name = path.pop(),
+            object = dop.util.get(object_data.object, path),
+            f = object[function_name]
+        if (isFunction(f) && !dop.isBroadcastFunction(f)) {
+            function resolve(value) {
+                var response = dop.core.createResponse(request_id, 0)
+                if (value !== undefined) response.push(value)
+                dop.core.storeSendMessages(node, response)
+                return value
+            }
+            function reject(err) {
+                dop.core.storeSendMessages(
+                    node,
+                    dop.core.createResponse(
+                        request_id,
+                        dop.core.error.reject_remote.CUSTOM_REJECTION,
+                        err
+                    )
+                )
+            }
+
+            if (dop.isRemoteFunction(f))
+                f.apply(null, params)
+                    .then(resolve)
+                    .catch(reject)
+            else
+                dop.core.localProcedureCall(
+                    f,
+                    params,
+                    resolve,
+                    reject,
+                    function(req) {
+                        req.node = node
+                        return req
+                    },
+                    dop.getObjectProxy(object)
+                )
+
+            return
+        }
+    }
+
+    dop.core.storeSendMessages(
+        node,
+        dop.core.createResponse(
+            request_id,
+            dop.core.error.reject_remote.FUNCTION_NOT_FOUND
+        )
+    )
+}

test/getrequest.js

@@ -0,0 +1,93 @@
+var test = require('tape')
+var dopServer = require('./.proxy').create()
+var dopClient = require('./.proxy').create()
+var transportName = process.argv[2] || 'local'
+var transportListen = require('dop-transports').listen[transportName]
+var transportConnect = require('dop-transports').connect[transportName]
+dopServer.env = 'SERVER'
+dopClient.env = 'CLIENT'
+
+// this code would be in node.js
+var server = dopServer.listen({ transport: transportListen })
+// this code would be in browser
+var client = dopClient.connect({
+    transport: transportConnect,
+    listener: server
+})
+
+var tGlobal // used to test outside tests clausures
+
+var localFunctions = dopServer.register({
+    checkRequestObject: function() {
+        const request = dopServer.getRequest(arguments)
+        tGlobal.equal(request instanceof Promise, true)
+        tGlobal.equal(request.hasOwnProperty('resolve'), true)
+        tGlobal.equal(request.hasOwnProperty('reject'), true)
+        // tGlobal.equal(request.node instanceof dopServer.core.node, true)
+    },
+    checkRequestObjectAsArgs: function() {
+        const args = Array.prototype.slice.call(arguments, 0)
+        const request = dopServer.getRequest(args)
+        tGlobal.equal(request instanceof Promise, true)
+        tGlobal.equal(request.hasOwnProperty('resolve'), true)
+        tGlobal.equal(request.hasOwnProperty('reject'), true)
+        // tGlobal.equal(request.node instanceof dopServer.core.node, true)
+    },
+    checkNodePropertyRemote: function() {
+        const request = dopServer.getRequest(arguments)
+        tGlobal.equal(request instanceof Promise, true)
+        tGlobal.equal(request.hasOwnProperty('resolve'), true)
+        tGlobal.equal(request.hasOwnProperty('reject'), true)
+        tGlobal.equal(request.node instanceof dopServer.core.node, true)
+    },
+    checkNodePropertyLocal: function() {
+        const request = dopServer.getRequest(arguments)
+        tGlobal.equal(request instanceof Promise, true)
+        tGlobal.equal(request.hasOwnProperty('resolve'), true)
+        tGlobal.equal(request.hasOwnProperty('reject'), true)
+        tGlobal.equal(request.hasOwnProperty('node'), false)
+    }
+})
+
+// server
+dopServer.onSubscribe(function() {
+    return localFunctions
+})
+
+var remoteFunctions
+test('Subscribing', function(t) {
+    client.subscribe().then(function(obj) {
+        remoteFunctions = obj
+        t.deepEqual(Object.keys(remoteFunctions), Object.keys(localFunctions))
+        t.end()
+    })
+})
+
+test('checkRequestObject', function(t) {
+    tGlobal = t
+    remoteFunctions.checkRequestObject()
+    localFunctions.checkRequestObject()
+    // t.equal()
+    t.end()
+})
+
+test('checkRequestObjectAsArgs', function(t) {
+    tGlobal = t
+    remoteFunctions.checkRequestObject()
+    localFunctions.checkRequestObject()
+    // t.equal()
+    t.end()
+})
+
+test('checkNodePropertyRemote', function(t) {
+    tGlobal = t
+    remoteFunctions.checkNodePropertyRemote()
+    t.end()
+})
+
+test('checkNodePropertyLocal', function(t) {
+    tGlobal = t
+    localFunctions.checkNodePropertyLocal()
+    t.end()
+    server.listener.close()
+})