diff --git a/.gitignore b/.gitignore
index 51d845ab..881f70f1 100644
--- a/.gitignore
+++ b/.gitignore
@@ -1,5 +1,7 @@
node_modules
coverage
dist
+tmp
.DS_Store
yarn.lock
+.idea
diff --git a/README.md b/README.md
index 5e8bdc38..710dd670 100644
--- a/README.md
+++ b/README.md
@@ -20,21 +20,22 @@ PySyft acts as the parent node, instructing child nodes \(Syft.js instances runn
If you're using a package manage like NPM:
```text
-npm install --save syft.js @tensorflow/tfjs
+npm install --save syft.js @tensorflow/tfjs webrtc-adapter
```
Or if Yarn is your cup of tea:
```text
-yarn add syft.js @tensorflow/tfjs
+yarn add syft.js @tensorflow/tfjs webrtc-adapter
```
-When using a package manager, TensorFlow.js will be automatically installed.
+When using a package manager, [TensorFlow.js](https://www.tensorflow.org/js) and the [WebRTC adapter](https://github.com/webrtc/adapter) will be automatically installed.
If you're not using a package manager, you can also include Syft.js within a `
+
```
diff --git a/copy-examples.sh b/copy-examples.sh
new file mode 100755
index 00000000..66c03473
--- /dev/null
+++ b/copy-examples.sh
@@ -0,0 +1,11 @@
+#!/usr/bin/env bash
+rm -rf ./tmp
+mkdir tmp
+
+for directory in $(find ./examples -type d -mindepth 1 -maxdepth 1);
+do
+ directory="$directory/dist/"
+ name="$(cut -d'/' -f3 <<<$directory)"
+
+ rsync -avzh "$directory" "./tmp/$name"
+done
\ No newline at end of file
diff --git a/examples/basic-example/index.js b/examples/basic-example/index.js
deleted file mode 100644
index 6a95ebf2..00000000
--- a/examples/basic-example/index.js
+++ /dev/null
@@ -1,50 +0,0 @@
-import syft from 'syft.js';
-
-const fromPySyft = `
-(18,
- (((6,
- (1,
- (6,
- ((6,
- ((5, (b'__add__',)),
- (19,
- (23885703668, 30300883787, 85156589176, None, (13, (2,)), False)),
- (6,
- ((19,
- (23885703668,
- 30300883787,
- 85156589176,
- None,
- (13, (2,)),
- False)),)),
- (0, ()))),
- (6, (53361601662,)))))),
- (6,
- (1,
- (6,
- ((6,
- ((5, (b'torch.abs',)),
- None,
- (6,
- ((19, (50671613206, 53361601662, 85156589176, None, None, True)),)),
- (0, ()))),
- (6, (68554228008,)))))),
- (6, (9, 53361601662))),
- 85156589176,
- (1, (30300883787,)),
- (6, (68554228008,)),
- (5, (b'plan_double_abs',)),
- None,
- None,
- True))
-`;
-
-const mySyft = new syft({ verbose: true });
-
-const detailed = mySyft.detail(fromPySyft);
-const simplified = mySyft.simplify(detailed);
-
-console.log('DETAILED', detailed);
-
-console.log('ORIG', fromPySyft.replace(/\s/g, ''));
-console.log('SIMP', simplified.replace(/\s/g, ''));
diff --git a/examples/basic-example/webpack.config.js b/examples/basic-example/webpack.config.js
deleted file mode 100644
index d0e6e3df..00000000
--- a/examples/basic-example/webpack.config.js
+++ /dev/null
@@ -1,23 +0,0 @@
-const HtmlWebpackPlugin = require('html-webpack-plugin');
-
-module.exports = {
- entry: './index.js',
- output: {
- filename: 'index.js',
- path: __dirname + '/dist'
- },
- module: {
- rules: [
- {
- test: /\.js$/,
- exclude: /node_modules/,
- loaders: ['babel-loader']
- }
- ]
- },
- plugins: [
- new HtmlWebpackPlugin({
- title: 'syft.js Example'
- })
- ]
-};
diff --git a/examples/basic-example/README.md b/examples/with-grid/README.md
similarity index 92%
rename from examples/basic-example/README.md
rename to examples/with-grid/README.md
index 312c43bc..50bcf733 100644
--- a/examples/basic-example/README.md
+++ b/examples/with-grid/README.md
@@ -1,4 +1,4 @@
-# syft.js Example
+# syft.js/grid.js Example
In order to get this running, you simply need to run the following:
diff --git a/examples/with-grid/_helpers.js b/examples/with-grid/_helpers.js
new file mode 100644
index 00000000..f7df0c65
--- /dev/null
+++ b/examples/with-grid/_helpers.js
@@ -0,0 +1,35 @@
+export const getQueryVariable = variable => {
+ const query = window.location.search.substring(1),
+ vars = query.split('&');
+
+ for (let i = 0; i < vars.length; i++) {
+ const pair = vars[i].split('=');
+
+ if (decodeURIComponent(pair[0]) === variable) {
+ return decodeURIComponent(pair[1]);
+ }
+ }
+
+ return null;
+};
+
+export const writeLinksToDOM = links => {
+ document.getElementById('participant-links').innerHTML = `
+
+ `;
+};
+
+export const writeIdentityToDOM = text => {
+ document.getElementById('identity').innerHTML = text;
+};
diff --git a/examples/with-grid/index.html b/examples/with-grid/index.html
new file mode 100644
index 00000000..12bb127a
--- /dev/null
+++ b/examples/with-grid/index.html
@@ -0,0 +1,84 @@
+
+
+
+ syft.js Example
+
+
+ Millionaire's problem
+
+ This is a demo using
+ syft.js from OpenMined
+ to display secure multi-party computation in the browser. Please open
+ your Javascript console to see what's going on (instructions for
+ Chrome
+ and
+ Firefox ) .
+
+ Connect to Grid.js instance
+
+
Disconnect
+
+
+
+
Send message
+
/src/_errors.js",
"/test/dummy"
- ]
+ ],
+ "globals": {
+ "window": {}
+ }
},
"dependencies": {
- "@tensorflow/tfjs": "^1.2.5",
- "immutable-tuple": "^0.4.10"
+ "@tensorflow/tfjs": "^1.2.6",
+ "syft-helpers.js": "https://github.com/OpenMined/syft-helpers.js",
+ "webrtc-adapter": "^7.2.9"
},
"peerDependencies": {
- "@tensorflow/tfjs": "^1.2.5"
+ "@tensorflow/tfjs": "^1.2.5",
+ "webrtc-adapter": "^7.2.9"
},
"devDependencies": {
"@babel/core": "^7.5.5",
"@babel/preset-env": "^7.5.5",
"auto-changelog": "^1.14.1",
"babel-jest": "^24.8.0",
+ "gh-pages": "^2.1.1",
"husky": "^3.0.1",
"jest": "^24.8.0",
- "mock-socket": "^8.1.0",
+ "mock-socket": "^9.0.0",
"np": "^5.0.3",
"prettier": "^1.18.2",
"pretty-quick": "^1.11.1",
@@ -77,6 +84,7 @@
"rollup-plugin-babel": "^4.3.3",
"rollup-plugin-commonjs": "^10.0.1",
"rollup-plugin-filesize": "^6.1.1",
+ "rollup-plugin-node-builtins": "^2.1.2",
"rollup-plugin-node-resolve": "^5.2.0",
"rollup-plugin-peer-deps-external": "^2.2.0"
}
diff --git a/rollup.config.js b/rollup.config.js
index 07e83382..bf8786e7 100644
--- a/rollup.config.js
+++ b/rollup.config.js
@@ -1,4 +1,5 @@
import babel from 'rollup-plugin-babel';
+import builtins from 'rollup-plugin-node-builtins';
import peerDepsExternal from 'rollup-plugin-peer-deps-external';
import resolve from 'rollup-plugin-node-resolve';
import commonjs from 'rollup-plugin-commonjs';
@@ -34,9 +35,12 @@ export default {
}
],
plugins: [
+ builtins(),
peerDepsExternal(),
babel({ exclude: 'node_modules/**' }),
- resolve(),
+ resolve({
+ preferBuiltins: true
+ }),
commonjs(),
filesize()
]
diff --git a/src/_constants.js b/src/_constants.js
deleted file mode 100644
index 4033be8c..00000000
--- a/src/_constants.js
+++ /dev/null
@@ -1,8 +0,0 @@
-export const SOCKET_STATUS = 'socket-status';
-export const GET_TENSORS = 'get-tensors';
-export const GET_TENSOR = 'get-tensor';
-export const MESSAGE_RECEIVED = 'message-received';
-export const MESSAGE_SENT = 'message-sent';
-export const RUN_OPERATION = 'run-operation';
-export const TENSOR_ADDED = 'add-tensor';
-export const TENSOR_REMOVED = 'remove-tensor';
diff --git a/src/_errors.js b/src/_errors.js
deleted file mode 100644
index ad1cfdde..00000000
--- a/src/_errors.js
+++ /dev/null
@@ -1,4 +0,0 @@
-export const NO_DETAILER = d =>
- `You have passed a detailer type that may exist in PySyft, but is not currently supported in syft.js. Please file a feature request (https://github.com/OpenMined/syft.js/issues) for type ${
- d[0]
- }, with value: ${d[1]}.`;
diff --git a/src/_helpers.js b/src/_helpers.js
deleted file mode 100644
index c756073e..00000000
--- a/src/_helpers.js
+++ /dev/null
@@ -1,9 +0,0 @@
-export const getArgs = func =>
- func
- .toString()
- .replace(/\/\*[\s\S]*?\*\/|([^\\:]|^)\/\/.*$/gm, '') // Remove all comments
- .replace(/\r?\n|\r/, '') // Remove all new lines
- .match(/function\s.*?\(([^)]*)\)/)[1] // Match the function params and get the 1st group
- .split(',') // Split the group by a ","
- .map(arg => arg.replace(/\/\*.*\*\//, '').trim()) // Map the results
- .filter(arg => arg); // Don't allow for null values!
diff --git a/src/custom-types/plan.js b/src/custom-types/plan.js
deleted file mode 100644
index 9a6fb00d..00000000
--- a/src/custom-types/plan.js
+++ /dev/null
@@ -1,12 +0,0 @@
-export default class Plan {
- constructor(operations, id, args, results, name, tags, description, isBuilt) {
- this.operations = operations;
- this.id = id;
- this.args = args;
- this.results = results;
- this.name = name;
- this.tags = tags;
- this.description = description;
- this.isBuilt = isBuilt;
- }
-}
diff --git a/src/custom-types/pointer-tensor.js b/src/custom-types/pointer-tensor.js
deleted file mode 100644
index ecdb2ecc..00000000
--- a/src/custom-types/pointer-tensor.js
+++ /dev/null
@@ -1,20 +0,0 @@
-// Create a class to represent pointer tensors
-// Add all the attributes that are serialized, just as for range and slice
-
-export default class PointerTensor {
- constructor(
- id,
- idAtLocation,
- locationId,
- pointToAttr,
- shape,
- garbageCollectData
- ) {
- this.id = id;
- this.idAtLocation = idAtLocation;
- this.locationId = locationId;
- this.pointToAttr = pointToAttr;
- this.shape = shape;
- this.garbageCollectData = garbageCollectData;
- }
-}
diff --git a/src/custom-types/range.js b/src/custom-types/range.js
deleted file mode 100644
index 83be2fee..00000000
--- a/src/custom-types/range.js
+++ /dev/null
@@ -1,10 +0,0 @@
-export default class Range {
- constructor(start, end, step) {
- this.start = start;
- this.end = end;
- this.step = step;
-
- // TODO: Fill out range further
- // Keep in mind, we don't want to generate the range in memory because that's exactly what makes Python ranges so efficient
- }
-}
diff --git a/src/custom-types/slice.js b/src/custom-types/slice.js
deleted file mode 100644
index 79fd5df5..00000000
--- a/src/custom-types/slice.js
+++ /dev/null
@@ -1,10 +0,0 @@
-export default class Slice {
- constructor(start, end, step = null) {
- this.start = start;
- this.end = end;
- this.step = step;
-
- // TODO: Fill out slice further
- // Keep in mind, we don't want to generate the slice in memory because that's exactly what makes Python ranges so efficient
- }
-}
diff --git a/src/custom-types/torch-size.js b/src/custom-types/torch-size.js
deleted file mode 100644
index 86a9a93a..00000000
--- a/src/custom-types/torch-size.js
+++ /dev/null
@@ -1,5 +0,0 @@
-export default class TorchSize {
- constructor(size) {
- this.size = size;
- }
-}
diff --git a/src/custom-types/torch-tensor.js b/src/custom-types/torch-tensor.js
deleted file mode 100644
index 77e30b84..00000000
--- a/src/custom-types/torch-tensor.js
+++ /dev/null
@@ -1,20 +0,0 @@
-// This needs to map to a TensorFlow tensors
-// Needs to have its own type
-// Add other metadata
-// Need to recursively parse all entries of 'd'
-// Create a new class called TorchTensor
-// Inside of TorchTensor have a ._data (private method) which stores the information in the tensor as a TensorFlow tensor
-// IMPORTANT: This whole class should be written as a way to translate Torch tensors and commands to TensorFlow, otherwise if we receive a TensorFlow tensor, just pass it right through... no need to translate!
-
-// Consider potentially renaming TorchTensor to TensorFlowTensor since we don't have access to Torch in Javascript
-
-export default class TorchTensor {
- constructor(id, bin, chain, gradChain, tags, description) {
- this.id = id;
- this.bin = bin;
- this.chain = chain;
- this.gradChain = gradChain;
- this.tags = tags;
- this.description = description;
- }
-}
diff --git a/src/events.js b/src/events.js
deleted file mode 100644
index b2ff184d..00000000
--- a/src/events.js
+++ /dev/null
@@ -1,21 +0,0 @@
-export default class EventObserver {
- constructor() {
- this.observers = [];
- }
-
- subscribe(type, func) {
- this.observers.push({ type, func });
- }
-
- unsubscribe(eventType) {
- this.observers = this.observers.filter(({ type }) => eventType !== type);
- }
-
- broadcast(eventType, data) {
- this.observers.forEach(observer => {
- if (eventType === observer.type) {
- return observer.func(data);
- }
- });
- }
-}
diff --git a/src/index.js b/src/index.js
index 27e2c05a..f1916f26 100644
--- a/src/index.js
+++ b/src/index.js
@@ -1,274 +1,181 @@
-import EventObserver from './events';
-import Logger from './logger';
-import { simplify, detail } from './serde';
+// import * as tf from '@tensorflow/tfjs';
import {
+ EventObserver,
+ Logger,
+ detail,
SOCKET_STATUS,
- GET_TENSORS,
- GET_TENSOR,
- MESSAGE_RECEIVED,
- MESSAGE_SENT,
- RUN_OPERATION,
- TENSOR_ADDED,
- TENSOR_REMOVED
-} from './_constants';
-
-import * as tf from '@tensorflow/tfjs';
-
-export default class Syft {
+ GET_PLANS,
+ WEBRTC_INTERNAL_MESSAGE,
+ WEBRTC_JOIN_ROOM,
+ WEBRTC_PEER_LEFT,
+ WEBRTC_PEER_CONFIG,
+ WEBRTC_PEER_OPTIONS
+} from 'syft-helpers.js';
+
+import Socket from './sockets';
+import WebRTCClient from './webrtc';
+
+export default class syft {
/* ----- CONSTRUCTOR ----- */
constructor(opts = {}) {
- const { url, verbose } = opts;
+ const { url, verbose, instanceId, scopeId, protocolId, peerConfig } = opts;
- // Where all tensors are stored locally
- this.tensors = [];
+ // My instance ID
+ this.instanceId = instanceId || null;
- // Set events to be listened to
- this.observer = new EventObserver();
-
- // Set logger
- this.logger = new Logger(verbose);
-
- // A saved instance of the socket connection
- this.socket = this.createSocketConnection(url);
- }
-
- /* ----- SERDE ----- */
-
- simplify(data) {
- return simplify(data);
- }
-
- detail(data) {
- return detail(data);
- }
-
- /* ----- HELPERS ----- */
+ // The assigned scope ID
+ this.scopeId = scopeId || null;
- // Gets a list of all stored tensors
- getTensors() {
- const tensors = this.tensors;
+ // The chosen protocol we are working on
+ this.protocolId = protocolId;
- this.sendMessage(GET_TENSORS, tensors);
-
- return tensors;
- }
+ // Our role in the plans
+ this.role = null;
- // Gets a tensor by a given id
- getTensorById(id) {
- const tensor = this.tensors.find(x => x.id === id) || null;
+ // The participants we will be working with (only for scope creators)
+ this.participants = [];
- this.sendMessage(GET_TENSOR, tensor);
+ // The list of plans we will be executing
+ this.plans = [];
- return tensor;
- }
+ // For creating event listeners
+ this.observer = new EventObserver();
- // Gets the index of the tensor (found by id) in the stored tensor list
- getTensorIndex(passedId) {
- let returnedIndex = null;
+ // For creating verbose logging should the user desire
+ this.logger = new Logger('syft.js', verbose);
- // Look through all tensors and find the index if it exists
- this.tensors.forEach(({ id }, index) => {
- if (id === passedId) {
- returnedIndex = index;
- }
- });
+ // Create a socket connection at this.socket
+ this.socket = null;
+ this.createSocketConnection(url);
- return returnedIndex;
+ // The WebRTC client used for P2P communication
+ this.rtc = null;
+ this.createWebRTCClient(peerConfig);
}
/* ----- FUNCTIONALITY ----- */
- // Adds a tensor to the list of stored tensors
- addTensor(id, tensor) {
- this.logger.log(`Adding tensor "${id}", with value:`, tensor);
-
- // Create a tensor in TensorFlow
- let createdTensor = {
- id,
- tensor: tf.tensor(tensor)
- };
-
- // Push it onto the stack
- this.tensors.push(createdTensor);
-
- this.sendMessage(TENSOR_ADDED, createdTensor);
-
- this.observer.broadcast(TENSOR_ADDED, {
- id,
- tensor: createdTensor.tensor,
- tensors: this.tensors
+ // Get the list of plans that a participant needs to participate from grid.js
+ getPlans() {
+ return this.socket.send(GET_PLANS, {
+ scopeId: this.scopeId,
+ protocolId: this.protocolId
});
-
- // Return the list of tensors in a Promise so the user knows it was added
- return Promise.resolve(this.tensors);
- }
-
- // Removes a tensor from the list of stored tensors
- removeTensor(id) {
- this.logger.log(`Removing tensor "${id}"`);
-
- // Find the index of the tensor
- const index = this.getTensorIndex(id);
-
- // Remove it if we found it
- if (index !== null) {
- this.tensors.splice(index, 1);
-
- this.sendMessage(TENSOR_REMOVED, id);
-
- this.observer.broadcast(TENSOR_REMOVED, { id, tensors: this.tensors });
-
- // Return the list of tensors in a Promise so the user knows it was removed
- return Promise.resolve(this.tensors);
- }
-
- return Promise.reject({ error: 'We cannot find a tensor with that id' });
- }
-
- // Runs any TensorFlow operation over two given tensors
- runOperation(func, tensors, result_id = null) {
- this.logger.log(
- `Running operation "${func}" on "${tensors[0]}" and "${tensors[1]}"`
- );
-
- // Find our tensors in the stored tensors list
- const firstTensor = this.getTensorById(tensors[0]);
- const secondTensor = this.getTensorById(tensors[1]);
-
- // Did we find both tensors?
- if (firstTensor && secondTensor) {
- // Does the first tensor have this function?
- if (typeof firstTensor.tensor[func] === 'function') {
- // We're all good - run the command
- const result = firstTensor.tensor[func](secondTensor.tensor);
-
- this.sendMessage(RUN_OPERATION, {
- result,
- result_id,
- tensors: [firstTensor, secondTensor]
- });
-
- this.observer.broadcast(RUN_OPERATION, { func, result, result_id });
-
- return Promise.resolve(result);
- }
-
- return Promise.reject({ error: 'Function not found in TensorFlow' });
- }
-
- return Promise.reject({ error: 'Cannot find tensors' });
}
/* ----- EVENT HANDLERS ----- */
- onMessageReceived(func) {
- this.observer.subscribe(MESSAGE_RECEIVED, func);
+ onSocketStatus(func) {
+ this.observer.subscribe(SOCKET_STATUS, func);
}
- onMessageSent(func) {
- this.observer.subscribe(MESSAGE_SENT, func);
- }
+ /* ----- SOCKET COMMUNICATION ----- */
- onRunOperation(func) {
- this.observer.subscribe(RUN_OPERATION, func);
+ // To create a socket connection internally and externally
+ createSocketConnection(url) {
+ if (!url) return;
+
+ this.socket = new Socket({
+ url,
+ logger: this.logger,
+ instanceId: this.instanceId,
+ onOpen: event => this.onOpen(event),
+ onClose: event => this.onClose(event),
+ onMessage: event => this.onMessage(event)
+ });
}
- onTensorAdded(func) {
- this.observer.subscribe(TENSOR_ADDED, func);
+ // To close the socket connection with the grid
+ disconnectFromGrid() {
+ this.socket.stop();
}
- onTensorRemoved(func) {
- this.observer.subscribe(TENSOR_REMOVED, func);
+ // When the socket connection is opened
+ // This is the internal event listener, the external method to subscribe to is "onSocketStatus => ({ connected: true })"
+ onOpen(event) {
+ this.observer.broadcast(SOCKET_STATUS, {
+ connected: true,
+ event
+ });
}
- /* ----- SOCKET COMMUNICATION ----- */
+ // When the socket connection is closed
+ // This is the internal event listener, the external method to subscribe to is "onSocketStatus => ({ connected: false })"
+ onClose(event) {
+ this.observer.broadcast(SOCKET_STATUS, {
+ connected: false,
+ event
+ });
+ }
- // Creates a socket connection if a URL is available
- createSocketConnection(url) {
- if (url) {
- this.logger.log(`Creating socket connection at "${url}"`);
+ // When a socket message is received, parse the message, store it, and return it
+ onMessage(event) {
+ const { type, data } = event;
- return new WebSocket(url);
- }
+ if (type === GET_PLANS) {
+ if (data.error) {
+ this.logger.log('There was an error getting your plans', data.error);
- return null;
- }
+ return data;
+ }
- // Receives a socket message from the server
- receiveMessage(event) {
- event = JSON.parse(event);
-
- this.logger.log(`Received a message of type "${event.type}"`, event);
-
- if (event.type === TENSOR_ADDED) {
- // We have a new tensor, store it...
- this.addTensor(event.id, event.values);
- } else if (event.type === TENSOR_REMOVED) {
- // We need to remove a tensor...
- this.removeTensor(event.id);
- } else if (event.type === GET_TENSOR) {
- // We need to get a tensor...
- this.getTensorById(event.id);
- } else if (event.type === GET_TENSORS) {
- // We need to get all tensors...
- this.getTensors();
- } else if (event.type === RUN_OPERATION) {
- // We have a request to perform an operation, run it...
- this.runOperation(event.func, event.tensors, event.result_id);
- }
+ // Save those plans after having Serde detail them
+ this.plans = data.plans.map(plan => detail(plan));
- this.observer.broadcast(MESSAGE_RECEIVED, event);
- }
+ // Save our instanceId if we don't already have it (also for the socket connection)
+ this.instanceId = data.user.instanceId;
+ this.socket.instanceId = this.instanceId;
- // Sends a socket message back to the server
- sendMessage(type, data) {
- // If we're capable of sending a message
- if (this.socket && this.socket.readyState === 1) {
- // Construct the message
- const message = { type, data };
+ // Save our scopeId if we don't already have it
+ this.scopeId = data.user.scopeId;
- this.logger.log(`Sending message to "${this.socket.url}"`, message);
+ // Save our role
+ this.role = data.user.role;
- // Send it via JSON
- this.socket.send(JSON.stringify(message));
+ // Save the other participant instanceId's
+ this.participants = data.participants;
- this.observer.broadcast(MESSAGE_SENT, message);
-
- return Promise.resolve(message);
+ return this.plans;
+ } else if (type === WEBRTC_INTERNAL_MESSAGE) {
+ this.rtc.receiveInternalMessage(data);
+ } else if (type === WEBRTC_JOIN_ROOM) {
+ this.rtc.receiveNewPeer(data);
+ } else if (type === WEBRTC_PEER_LEFT) {
+ this.rtc.removePeer(data.instanceId);
}
}
- // Starts syft.js
- start(url) {
- // Tell PySyft that we're booting up
- this.sendMessage(SOCKET_STATUS, { status: 'starting' });
+ /* ----- WEBRTC ----- */
- this.logger.log('Starting up...');
+ // To create a socket connection internally and externally
+ createWebRTCClient(peerConfig, peerOptions) {
+ // If we don't have a socket sever, we can't create the WebRTCClient
+ if (!this.socket) return;
- if (url) {
- this.socket = this.createSocketConnection(url);
- }
+ // The default STUN/TURN servers to use for NAT traversal
+ if (!peerConfig) peerConfig = WEBRTC_PEER_CONFIG;
- // Tell PySyft that we're ready to receive instructions
- this.sendMessage(SOCKET_STATUS, { status: 'ready' });
+ // Some standard options for establishing peer connections
+ if (!peerOptions) peerOptions = WEBRTC_PEER_OPTIONS;
- // Listen for incoming messages and dispatch them appropriately
- this.socket.onmessage = this.receiveMessage;
+ this.rtc = new WebRTCClient({
+ peerConfig,
+ peerOptions,
+ logger: this.logger,
+ socket: this.socket
+ });
}
- // Stops syft.js
- stop() {
- this.logger.log('Shutting down...');
-
- // Tell PySyft that we're stopping
- this.sendMessage(SOCKET_STATUS, { status: 'stopped' });
+ connectToParticipants() {
+ this.rtc.start(this.instanceId, this.scopeId);
+ }
- // Kill the socket connection
- this.socket.close();
+ disconnectFromParticipants() {
+ this.rtc.stop();
+ }
- // Destroy record of the tensors and socket connection
- this.tensors = [];
- this.socket = null;
+ sendToParticipants(data, to) {
+ this.rtc.sendMessage(data, to);
}
}
diff --git a/src/logger.js b/src/logger.js
deleted file mode 100644
index 94c40fe9..00000000
--- a/src/logger.js
+++ /dev/null
@@ -1,20 +0,0 @@
-// A simple logging function
-export default class Logger {
- constructor(verbose) {
- this.verbose = verbose;
- }
-
- log(message, data) {
- // Only log if verbose is turned on
- if (this.verbose) {
- const output = `${Date.now()}: syft.js - ${message}`;
-
- // Have the passed additional data?
- if (data) {
- console.log(output, data);
- } else {
- console.log(output);
- }
- }
- }
-}
diff --git a/src/serde.js b/src/serde.js
deleted file mode 100644
index a191068b..00000000
--- a/src/serde.js
+++ /dev/null
@@ -1,161 +0,0 @@
-/*
- TODO: Arbitrary commas are being inserted by PySyft at various places, usually at the end of strings, tuples, and TorchSize. They don't do anything and should not be there, this is an issue with PySyft
- TODO: Let's look at optimization potentials by using Map() (with the key being the instanceof class) for the SIMPLIFIERS and DETAILERS variables
-*/
-
-// Import our types
-import Range from './custom-types/range';
-import Slice from './custom-types/slice';
-import Tuple from 'immutable-tuple';
-import TorchTensor from './custom-types/torch-tensor';
-import TorchSize from './custom-types/torch-size';
-import Plan from './custom-types/plan';
-import PointerTensor from './custom-types/pointer-tensor';
-
-// Import our helpers
-import { getArgs } from './_helpers';
-
-// Import our errors
-import { NO_DETAILER } from './_errors';
-
-// These are the replace functions we will run to convert Javascript to Python
-export const SIMPLIFY_REPLACERS = [
- [/null/g, 'None'], // Convert all nulls to Nones
- [/false/g, 'False'], // Convert all false to False
- [/true/g, 'True'] // Convert all true to True
-];
-
-// These are the replace functions we will run to convert Python to Javascript
-export const DETAIL_REPLACERS = [
- [/\(/g, '['], // Convert all Python tuples into a Javascript Array
- [/\)/g, ']'],
- [/b'/g, "'"], // Convert all undefined 'b' functions everywhere, remove them
- [/'/g, '"'], // Convert all single quotes to double quotes so JSON can parse correctly
- [/None/g, null], // Convert all Nones to nulls
- [/False/g, false], // Convert all False to false
- [/True/g, true], // Convert all True to true
- [/,]/g, ']'] // Trim all Arrays with an extra comma
-];
-
-// A simple function to run the above replacers
-export const runReplacers = (data, replacers) => {
- for (let i = 0; i < replacers.length; i++) {
- data = data.replace(...replacers[i]);
- }
-
- return data;
-};
-
-// To simplify, we must take a Javascript object and turn it into a serialized Python string that can be interpreted by PySyft
-// This involves the following steps in order:
-// 1. Recursively parse the data
-// 2. Depending on the data type, we may run it through a simplifier function to convert that value into a string
-// 3. Run the replacers, which will convert any Javascript values into Python (null, false, true, etc.)
-export const simplify = data => {
- const SIMPLIFIERS = {
- dict: d =>
- `(0, (${Array.from(d)
- .map(([key, value]) => `(${parse(key)}, ${parse(value)})`)
- .join()}))`,
- list: d => `(1, (${d.map(i => parse(i)).join()}))`,
- range: d => `(2, (${d.start}, ${d.end}, ${d.step}))`,
- set: d => `(3, (${[...d].map(i => parse(i)).join()}))`,
- slice: d => `(4, (${d.start}, ${d.end}, ${d.step}))`,
- str: d => `(5, (b'${d}'))`,
- tuple: d => `(6, (${d.map(i => parse(i)).join()}))`,
- torchTensor: d =>
- `(12, (${getArgs(TorchTensor)
- .map(i => parse(d[i]))
- .join()}))`,
- torchSize: d => `(13, (${d.size}))`,
- plan: d => {
- const args = getArgs(Plan),
- operations = d[args[0]].map(i => parse(i)),
- rest = args.slice(1).map(i => parse(d[i]));
-
- return `(18, ((${operations}), ${rest.join()}))`;
- },
- pointerTensor: d =>
- `(19, (${getArgs(PointerTensor)
- .map(i => parse(d[i]))
- .join()}))` // 18 = pointer-tensor
- };
-
- const parse = d => {
- if (d === null) return 'null';
-
- let simplifierId = null;
-
- if (d instanceof Map) simplifierId = 'dict';
- else if (d instanceof Array) simplifierId = 'list';
- else if (d instanceof Range) simplifierId = 'range';
- else if (d instanceof Set) simplifierId = 'set';
- else if (d instanceof Slice) simplifierId = 'slice';
- else if (typeof d === 'string') simplifierId = 'str';
- else if (d instanceof Tuple) simplifierId = 'tuple';
- else if (d instanceof TorchTensor) simplifierId = 'torchTensor';
- else if (d instanceof TorchSize) simplifierId = 'torchSize';
- else if (d instanceof Plan) simplifierId = 'plan';
- else if (d instanceof PointerTensor) simplifierId = 'pointerTensor';
-
- if (simplifierId !== null) {
- return SIMPLIFIERS[simplifierId](d);
- }
-
- return d;
- };
-
- return runReplacers(parse(data), SIMPLIFY_REPLACERS);
-};
-
-// To detail, we must take a Python string serialized in PySyft and turn it into a Javascript object that we can manipulate and store
-// This involves the following steps in order:
-// 1. Run the replacers, which will convert any Python values into Javascript (() => [], None, True, False, etc.)
-// 2. Parse the string as JSON
-// 3. Recursively parse the data
-// 4. Depending on the data type, we may run it through a detailer function to convert that value into the appropriate JAvascript type
-export const detail = data => {
- const DETAILERS = [
- d => new Map(d.map(i => i.map(j => parse(j)))), // 0 = dict
- d => d.map(i => parse(i)), // 1 = list
- d => new Range(...d), // 2 = range
- d => new Set(d.map(i => parse(i))), // 3 = set
- d => new Slice(...d), // 4 = slice
- d => d[0], // 5 = str
- d => Tuple(...d.map(i => parse(i))), // 6 = tuple
- null, // 7
- null, // 8
- null, // 9
- null, // 10
- null, // 11
- d => new TorchTensor(...d.map(i => parse(i))), // 12 = torch-tensor
- d => new TorchSize(d), // 13 = torch.Size
- null, // 14
- null, // 15
- null, // 16
- null, // 17
- d => new Plan(d[0].map(j => parse(j)), ...d.slice(1).map(i => parse(i))), // 18 = plan
- d => new PointerTensor(...d.map(i => parse(i))) // 19 = pointer-tensor
- ];
-
- const parse = d => {
- if (
- Array.isArray(d) &&
- d.length === 2 &&
- typeof d[0] === 'number' &&
- Array.isArray(d[1])
- ) {
- const detailer = DETAILERS[d[0]];
-
- if (detailer) {
- return detailer(d[1]);
- }
-
- throw new Error(NO_DETAILER(d));
- }
-
- return d;
- };
-
- return parse(JSON.parse(runReplacers(data, DETAIL_REPLACERS)));
-};
diff --git a/src/sockets.js b/src/sockets.js
new file mode 100644
index 00000000..531b3850
--- /dev/null
+++ b/src/sockets.js
@@ -0,0 +1,86 @@
+import { SOCKET_PING } from 'syft-helpers.js';
+
+export default class Sockets {
+ constructor(opts) {
+ const {
+ url,
+ logger,
+ instanceId,
+ onOpen,
+ onClose,
+ onMessage,
+ keepAliveTimeout = 20000
+ } = opts;
+
+ const socket = new WebSocket(url);
+
+ const keepAlive = () => {
+ this.send(SOCKET_PING);
+ this.timerId = setTimeout(keepAlive, keepAliveTimeout);
+ };
+
+ const cancelKeepAlive = () => {
+ clearTimeout(this.timerId);
+ this.timerId = null;
+ };
+
+ socket.onopen = event => {
+ this.logger.log(
+ `Opening socket connection at ${event.currentTarget.url}`,
+ event
+ );
+
+ keepAlive();
+
+ if (onOpen) onOpen(event);
+ };
+
+ socket.onclose = event => {
+ this.logger.log(
+ `Closing socket connection at ${event.currentTarget.url}`,
+ event
+ );
+
+ cancelKeepAlive();
+
+ if (onClose) onClose(event);
+ };
+
+ this.url = url;
+ this.logger = logger;
+ this.instanceId = instanceId;
+ this.socket = socket;
+ this.onMessage = onMessage;
+ this.timerId = null;
+ }
+
+ send(type, data = {}) {
+ return new Promise((resolve, reject) => {
+ data.instanceId = this.instanceId;
+
+ const message = { type, data };
+
+ this.logger.log('Sending message', message);
+
+ this.socket.send(JSON.stringify(message));
+
+ this.socket.onmessage = event => {
+ const data = JSON.parse(event.data);
+
+ this.logger.log('Receiving message', data);
+
+ resolve(this.onMessage(data));
+ };
+
+ this.socket.onerror = event => {
+ this.logger.log('We have a socket error!', event);
+
+ reject(event);
+ };
+ });
+ }
+
+ stop() {
+ this.socket.close();
+ }
+}
diff --git a/src/webrtc.js b/src/webrtc.js
new file mode 100644
index 00000000..0782d667
--- /dev/null
+++ b/src/webrtc.js
@@ -0,0 +1,351 @@
+// NOTE: Adding async/await in this file requires regenerator-runtime/runtime which adds an unnecessary 2kb on the minified bundled - no thanks!
+import 'webrtc-adapter';
+
+import {
+ WEBRTC_JOIN_ROOM,
+ WEBRTC_INTERNAL_MESSAGE,
+ WEBRTC_PEER_LEFT
+} from 'syft-helpers.js';
+
+export default class WebRTCClient {
+ constructor(opts) {
+ const { peerConfig, peerOptions, logger, socket } = opts;
+
+ this.peerConfig = peerConfig;
+ this.peerOptions = peerOptions;
+ this.logger = logger;
+ this.socket = socket;
+
+ this.peers = {};
+
+ this.instanceId = null;
+ this.scopeId = null;
+ }
+
+ // The main start command for WebRTC
+ // This will store your id (instanceId) and room (scopeId) and immediately join that room
+ start(instanceId, scopeId) {
+ this.logger.log(`WebRTC: Joining room ${scopeId}`);
+
+ this.instanceId = instanceId;
+ this.scopeId = scopeId;
+
+ // Immediately send a request to enter the room
+ this.socket.send(WEBRTC_JOIN_ROOM, { instanceId, scopeId });
+ }
+
+ // The main stop command for WebRTC
+ // This goes through all the peers and closes the connection from each one
+ stop() {
+ this.logger.log('WebRTC: Disconnecting from peers');
+
+ this.socket.send(WEBRTC_PEER_LEFT, {
+ instanceId: this.instanceId,
+ scopeId: this.scopeId
+ });
+
+ this._forEachPeer((peer, instanceId) => {
+ if (peer.channel) {
+ this.removePeer(instanceId);
+ }
+ }, true);
+ }
+
+ // Remove a peer when the signaling server has notified us they've left or when stop() is run
+ removePeer(instanceId) {
+ // If this peer doesn't exist, forget about it
+ if (!this.peers[instanceId]) return;
+
+ this.logger.log(`WebRTC: Closing connection to ${instanceId}`);
+
+ try {
+ this.peers[instanceId].channel.close();
+ } catch (e) {
+ this.logger.log('WebRTC: Error removing peer', e);
+ }
+
+ delete this.peers[instanceId];
+ }
+
+ // Given a message, this function allows you to "broadcast" a message to all peers
+ // Alternatively, you may send a targeted message to one specific peer (specified by the "to" param)
+ sendMessage(message, to) {
+ this.logger.log('WebRTC: Sending message', message);
+
+ const send = (channel, msg) => {
+ try {
+ channel.send(msg);
+ } catch (e) {
+ this.logger.log('WebRTC: Error sending message', e);
+ }
+ };
+
+ // If "to" is specified, send to that users
+ if (
+ to &&
+ to !== this.instanceId &&
+ this.peers[to] &&
+ this.peers[to].channel
+ ) {
+ send(this.peers[to].channel, message);
+ }
+
+ // Otherwise, send to each user specified
+ else {
+ this._forEachPeer(peer => {
+ if (peer.channel) {
+ send(peer.channel, message);
+ }
+ });
+ }
+ }
+
+ // Create an RTCPeerConnection on our end for each offer or answer we receive
+ createConnection(instanceId) {
+ this.logger.log('WebRTC: Creating connection');
+
+ // Create a new peer in the list with a blank candidate cache (to be populated by ICE candidates we receive)
+ this.peers[instanceId] = {
+ candidateCache: []
+ };
+
+ // Create and initialize the new connection, then add that connection to the peers list
+ const pc = new RTCPeerConnection(this.peerConfig, this.peerOptions);
+ this.initConnection(pc, instanceId, 'answer');
+ this.peers[instanceId].connection = pc;
+
+ // When this peer connection receives a data channel
+ pc.ondatachannel = e => {
+ this.logger.log('WebRTC: Calling ondatachannel');
+
+ this.peers[instanceId].channel = e.channel;
+ this.peers[instanceId].channel.owner = instanceId;
+
+ // Set up all our event listeners for this channel so we can hook into them
+ this.addDataChannelListeners(this.peers[instanceId].channel);
+ };
+ }
+
+ // Initialize a given RTCPeerConnection ("pc"), for a peer ("instanceId"), with an sdpType of "offer" or "answer"
+ initConnection(pc, instanceId, sdpType) {
+ this.logger.log('WebRTC: Initializing connection');
+
+ // How an RTCPeerConnection handle new ICE candidates or offer/answer messages...
+ pc.onicecandidate = event => {
+ // If we have an ICE candidate to handle
+ if (event.candidate) {
+ this.logger.log('WebRTC: Saving new ICE candidate');
+
+ // Save it to the list for further sending
+ this.peers[instanceId].candidateCache.push(event.candidate);
+ }
+
+ // When the candidate discovery is completed, the handler will be called again, but without the candidate
+ else {
+ this.logger.log(`WebRTC: Sending ${sdpType} and stored ICE candidates`);
+
+ // In this case, we first send the first SDP offer or SDP answer (depending on the sdpType)...
+ this.sendInternalMessage(sdpType, pc.localDescription, instanceId);
+
+ // ... then we send all stored ICE candidates
+ for (let i = 0; i < this.peers[instanceId].candidateCache.length; i++) {
+ this.sendInternalMessage(
+ 'candidate',
+ this.peers[instanceId].candidateCache[i],
+ instanceId
+ );
+ }
+ }
+ };
+ }
+
+ // When we receive a new peer's instanceId from grid.js...
+ receiveNewPeer({ instanceId }) {
+ this.logger.log('WebRTC: Adding new peer');
+
+ // Create a new peer in the list with a blank candidate cache (to be populated by ICE candidates we receive)
+ this.peers[instanceId] = {
+ candidateCache: []
+ };
+
+ // Create and initialize the new connection, then add that connection to the peers list
+ const pc = new RTCPeerConnection(this.peerConfig, this.peerOptions);
+ this.initConnection(pc, instanceId, 'offer');
+ this.peers[instanceId].connection = pc;
+
+ // Create a data channel through which messaging will take place, we'll call it "dataChannel"
+ // Designate who owns that channel and push it onto the peers list
+ const channel = pc.createDataChannel('dataChannel');
+ channel.owner = instanceId;
+ this.peers[instanceId].channel = channel;
+
+ // Set up all our event listeners for this channel so we can hook into them
+ this.addDataChannelListeners(channel);
+
+ // Create an SDP offer for the peer connection
+ pc.createOffer()
+ .then(offer => {
+ this.logger.log('WebRTC: Offer created');
+
+ // Set the offer as the local description
+ pc.setLocalDescription(offer)
+ .then(this.logger.log('WebRTC: Set offer as local description'))
+ .catch(
+ this._handleError(
+ 'WebRTC: Error setting offer as local description'
+ )
+ );
+ })
+ .catch(this._handleError('WebRTC: Error creating offer'));
+ }
+
+ // Send an internal WebRTC message (this will always be an ICE candidate or SDP message)
+ sendInternalMessage(type, message, to) {
+ // Don't send to yourself, silly!
+ if (to !== this.instanceId) {
+ this.logger.log('WebRTC: Sending internal WebRTC message');
+
+ this.socket.send(WEBRTC_INTERNAL_MESSAGE, {
+ instanceId: this.instanceId,
+ scopeId: this.scopeId,
+ to,
+ type,
+ data: message
+ });
+ }
+ }
+
+ // Receive an internal WebRTC message (this will always be an ICE candidate or SDP message)
+ receiveInternalMessage({ type, instanceId, data }) {
+ switch (type) {
+ case 'candidate':
+ this.remoteCandidateReceived(instanceId, data);
+ break;
+ case 'offer':
+ this.remoteOfferReceived(instanceId, data);
+ break;
+ case 'answer':
+ this.remoteAnswerReceived(instanceId, data);
+ break;
+ }
+ }
+
+ // When that internal WebRTC message is an ICE candidate
+ remoteCandidateReceived(instanceId, data) {
+ this.logger.log('WebRTC: Remote candidate received');
+
+ // If the connection doesn't exist, create it first
+ if (this.peers[instanceId] === undefined) {
+ this.createConnection(instanceId);
+ }
+
+ // Get the peer connection of that user and add the ICE candidate to their list
+ const pc = this.peers[instanceId].connection;
+
+ pc.addIceCandidate(new RTCIceCandidate(data))
+ .then(this.logger.log('WebRTC: Adding ICE candidate to peer connection'))
+ .catch(
+ this._handleError(
+ 'WebRTC: Error adding ICE candidate to peer connection'
+ )
+ );
+ }
+
+ // When that internal WebRTC message is an SDP offer
+ remoteOfferReceived(instanceId, data) {
+ this.logger.log('WebRTC: Remote offer received');
+
+ // If the connection doesn't exist, create it first
+ if (this.peers[instanceId] === undefined) {
+ this.createConnection(instanceId);
+ }
+
+ // Get the peer connection of that user
+ const pc = this.peers[instanceId].connection;
+
+ // Set the remote description to be the SDP offer
+ pc.setRemoteDescription(new RTCSessionDescription(data))
+ .then(() => {
+ this.logger.log('WebRTC: Setting offer as remote description');
+
+ // Create an SDP answer in response to their SDP offer
+ pc.createAnswer()
+ .then(answer => {
+ this.logger.log('WebRTC: Answer created');
+
+ // Set this answer as the peer's local description
+ pc.setLocalDescription(answer)
+ .then(this.logger.log('WebRTC: Set answer as local description'))
+ .catch(
+ this._handleError(
+ 'WebRTC: Error setting answer as local description'
+ )
+ );
+ })
+ .catch(this._handleError('WebRTC: Error creating answer'));
+ })
+ .catch(
+ this._handleError('WebRTC: Error setting offer as remote description')
+ );
+ }
+
+ // When that internal WebRTC message is an SDP answer
+ remoteAnswerReceived(instanceId, data) {
+ this.logger.log('WebRTC: Remote answer received');
+
+ // Get the peer connection of that user and set the remote description to be the SDP offer
+ const pc = this.peers[instanceId].connection;
+
+ pc.setRemoteDescription(new RTCSessionDescription(data))
+ .then(this.logger.log('WebRTC: Setting answer as remote description'))
+ .catch(
+ this._handleError('WebRTC: Error setting answer as remote description')
+ );
+ }
+
+ // This is used to attach generic logging handlers for data channels.
+ addDataChannelListeners(channel) {
+ // When the data channel is opened
+ channel.onopen = event => {
+ this.logger.log('WebRTC: Data channel open', event);
+ };
+
+ // When the data channel is closed
+ channel.onclose = event => {
+ this.logger.log('WebRTC: Data channel close', event);
+ };
+
+ // When the data channel receives a new message
+ channel.onmessage = event => {
+ this.logger.log('WebRTC: Data channel message', event);
+ };
+
+ // When the data channel errors
+ channel.onerror = err => {
+ this.logger.log('WebRTC: Data channel error', err);
+ };
+ }
+
+ // Generic error handler to just log a message
+ _handleError(message) {
+ const self = this;
+
+ return error => {
+ self.logger.log(message, error);
+ };
+ }
+
+ // Generic for each helper for looping through peers
+ _forEachPeer(callback, includeMe = false) {
+ const peers = this.peers;
+
+ // If we don't want to be in the peer list, remove ourselves
+ if (!includeMe) {
+ delete peers[this.instanceId];
+ }
+
+ for (let peer in peers) {
+ callback(peers[peer], peer);
+ }
+ }
+}
diff --git a/test/_helpers.test.js b/test/_helpers.test.js
deleted file mode 100644
index f2ab4ed6..00000000
--- a/test/_helpers.test.js
+++ /dev/null
@@ -1,20 +0,0 @@
-import { getArgs } from '../src/_helpers';
-
-class MyClass {
- constructor(first, second, third) {
- this.first = first;
- this.second = second;
- this.third = third;
- }
-}
-
-describe('Helper functions', () => {
- test('can get the correct number of arguments', () => {
- const args = getArgs(MyClass);
-
- expect(args.length).toBe(3);
- expect(args[0]).toBe('first');
- expect(args[1]).toBe('second');
- expect(args[2]).toBe('third');
- });
-});
diff --git a/test/_webrtc-mocks.js b/test/_webrtc-mocks.js
new file mode 100644
index 00000000..817a2550
--- /dev/null
+++ b/test/_webrtc-mocks.js
@@ -0,0 +1,68 @@
+// RTC classes mocks
+export class RTCPeerConnection {
+ constructor(options, optional) {
+ this.options = options;
+ this.optional = optional;
+ this.localDescription = null;
+ this.remoteDescription = null;
+ this.iceCandidates = [];
+ this.sentMessages = [];
+ this.ondatachannelListener = null;
+ this.onicecandidateListener = null;
+ }
+
+ createDataChannel(label, options) {
+ return {};
+ }
+
+ async createOffer(options) {
+ return Promise.resolve({ type: 'offer', sdp: 'testOfferSdp' });
+ }
+
+ async createAnswer(options) {
+ return Promise.resolve({ type: 'answer', sdp: 'testAnswerSdp' });
+ }
+
+ async setLocalDescription(sessionDescription) {
+ this.localDescription = sessionDescription;
+ return Promise.resolve();
+ }
+
+ async setRemoteDescription(sessionDescription) {
+ this.remoteDescription = sessionDescription;
+ return Promise.resolve();
+ }
+
+ async addIceCandidate(iceCandidate) {
+ this.iceCandidates.push(iceCandidate);
+ return Promise.resolve();
+ }
+
+ get onicecandidate() {
+ return this.onicecandidateListener;
+ }
+
+ set onicecandidate(cb) {
+ this.onicecandidateListener = cb;
+ }
+
+ get ondatachannel() {
+ return this.ondatachannelListener;
+ }
+
+ set ondatachannel(cb) {
+ this.ondatachannelListener = cb;
+ }
+}
+
+export class RTCSessionDescription {
+ constructor(sessionDescription) {
+ Object.assign(this, sessionDescription);
+ }
+}
+
+export class RTCIceCandidate {
+ constructor(iceCandidate) {
+ Object.assign(this, iceCandidate);
+ }
+}
diff --git a/test/custom-types/plan.test.js b/test/custom-types/plan.test.js
deleted file mode 100644
index bc30ae07..00000000
--- a/test/custom-types/plan.test.js
+++ /dev/null
@@ -1,24 +0,0 @@
-import {
- detailedPlan,
- operations,
- id,
- args,
- results,
- name,
- tags,
- description,
- isBuilt
-} from '../dummy/plan';
-
-describe('Plan', () => {
- test('can be properly constructed', () => {
- expect(detailedPlan.operations).toStrictEqual(operations);
- expect(detailedPlan.id).toStrictEqual(id);
- expect(detailedPlan.args).toStrictEqual(args);
- expect(detailedPlan.results).toStrictEqual(results);
- expect(detailedPlan.name).toStrictEqual(name);
- expect(detailedPlan.tags).toStrictEqual(tags);
- expect(detailedPlan.description).toStrictEqual(description);
- expect(detailedPlan.isBuilt).toStrictEqual(isBuilt);
- });
-});
diff --git a/test/custom-types/pointer-tensor.test.js b/test/custom-types/pointer-tensor.test.js
deleted file mode 100644
index 3434cd09..00000000
--- a/test/custom-types/pointer-tensor.test.js
+++ /dev/null
@@ -1,22 +0,0 @@
-import {
- id,
- idAtLocation,
- locationId,
- pointToAttr,
- shape,
- garbageCollectData,
- firstPointerTensor
-} from '../dummy/pointer-tensor';
-
-describe('PointerTensor', () => {
- test('can be properly constructed', () => {
- expect(firstPointerTensor.id).toStrictEqual(id);
- expect(firstPointerTensor.idAtLocation).toStrictEqual(idAtLocation);
- expect(firstPointerTensor.locationId).toStrictEqual(locationId);
- expect(firstPointerTensor.pointToAttr).toStrictEqual(pointToAttr);
- expect(firstPointerTensor.shape).toStrictEqual(shape);
- expect(firstPointerTensor.garbageCollectData).toStrictEqual(
- garbageCollectData
- );
- });
-});
diff --git a/test/custom-types/range.test.js b/test/custom-types/range.test.js
deleted file mode 100644
index b79615ea..00000000
--- a/test/custom-types/range.test.js
+++ /dev/null
@@ -1,9 +0,0 @@
-import { range, start, end, step } from '../dummy/range';
-
-describe('Range', () => {
- test('can be properly constructed', () => {
- expect(range.start).toStrictEqual(start);
- expect(range.end).toStrictEqual(end);
- expect(range.step).toStrictEqual(step);
- });
-});
diff --git a/test/custom-types/slice.test.js b/test/custom-types/slice.test.js
deleted file mode 100644
index 980dd208..00000000
--- a/test/custom-types/slice.test.js
+++ /dev/null
@@ -1,15 +0,0 @@
-import { slice, nullStepSlice, start, end, step } from '../dummy/slice';
-
-describe('Slice', () => {
- test('can be properly constructed', () => {
- expect(slice.start).toStrictEqual(start);
- expect(slice.end).toStrictEqual(end);
- expect(slice.step).toStrictEqual(step);
- });
-
- test('can be properly constructed with no step', () => {
- expect(nullStepSlice.start).toStrictEqual(start);
- expect(nullStepSlice.end).toStrictEqual(end);
- expect(nullStepSlice.step).toStrictEqual(null);
- });
-});
diff --git a/test/custom-types/torch-size.test.js b/test/custom-types/torch-size.test.js
deleted file mode 100644
index f8b724dd..00000000
--- a/test/custom-types/torch-size.test.js
+++ /dev/null
@@ -1,7 +0,0 @@
-import { torchSizeShape, torchSize2 } from '../dummy/torch-size';
-
-describe('TorchSize', () => {
- test('can be properly constructed', () => {
- expect(torchSize2.size).toStrictEqual(torchSizeShape);
- });
-});
diff --git a/test/custom-types/torch-tensor.test.js b/test/custom-types/torch-tensor.test.js
deleted file mode 100644
index 07829425..00000000
--- a/test/custom-types/torch-tensor.test.js
+++ /dev/null
@@ -1,20 +0,0 @@
-import {
- torchTensor,
- id,
- bin,
- chain,
- gradChain,
- tags,
- description
-} from '../dummy/torch-tensor';
-
-describe('TorchTensor', () => {
- test('can be properly constructed', () => {
- expect(torchTensor.id).toStrictEqual(id);
- expect(torchTensor.bin).toStrictEqual(bin);
- expect(torchTensor.chain).toStrictEqual(chain);
- expect(torchTensor.gradChain).toStrictEqual(gradChain);
- expect(torchTensor.tags).toStrictEqual(tags);
- expect(torchTensor.description).toStrictEqual(description);
- });
-});
diff --git a/test/dummy/native.js b/test/dummy/native.js
deleted file mode 100644
index cae5d0e0..00000000
--- a/test/dummy/native.js
+++ /dev/null
@@ -1,23 +0,0 @@
-import Tuple from 'immutable-tuple';
-
-// Python Dictionary = Javascript Map()
-export const dict = new Map([[1, 'hello'], ['key2', 999]]);
-export const simplifiedDict = `(0, ((1, (5, (b'hello',))), ((5, (b'key2',)), 999)))`; // Generated from PySyft based on above
-
-// Python List = Javascript Array
-export const list = ['apple', 'cherry', 'banana'];
-export const simplifiedList = `(1, ((5, (b'apple',)), (5, (b'cherry',)), (5, (b'banana',))))`; // Generated from PySyft based on above
-
-// Python Set = Javascript Set()
-export const set = new Set(['apple', 'cherry', 'banana']);
-
-// NOTE: Sets are unordered in Python, so we had to rearrange the order in the simplifiedSet string below
-export const simplifiedSet = `(3, ((5, (b'apple',)), (5, (b'cherry',)), (5, (b'banana',))))`; // Generated from PySyft based on above
-
-// Python String = Javascript String
-export const string = 'hello';
-export const simplifiedString = `(5, (b'hello',))`; // Generated from PySyft based on above
-
-// Python Tuple = Javascript Tuple (via "immutable-tuple" package)
-export const tuple = Tuple('apple', 'cherry', 'banana');
-export const simplifiedTuple = `(6, ((5, (b'apple',)), (5, (b'cherry',)), (5, (b'banana',))))`; // Generated from PySyft based on above
diff --git a/test/dummy/plan.js b/test/dummy/plan.js
deleted file mode 100644
index ea9f5468..00000000
--- a/test/dummy/plan.js
+++ /dev/null
@@ -1,83 +0,0 @@
-import Plan from '../../src/custom-types/plan';
-import Tuple from 'immutable-tuple';
-import { firstPointerTensor, secondPointerTensor } from './pointer-tensor';
-
-export const simplifiedPlan = `
-(18,
- (((6,
- (1,
- (6,
- ((6,
- ((5, (b'__add__',)),
- (19,
- (23885703668, 30300883787, 85156589176, None, (13, (2,)), False)),
- (6,
- ((19,
- (23885703668,
- 30300883787,
- 85156589176,
- None,
- (13, (2,)),
- False)),)),
- (0, ()))),
- (6, (53361601662,)))))),
- (6,
- (1,
- (6,
- ((6,
- ((5, (b'torch.abs',)),
- None,
- (6,
- ((19, (50671613206, 53361601662, 85156589176, None, None, True)),)),
- (0, ()))),
- (6, (68554228008,)))))),
- (6, (9, 53361601662))),
- 85156589176,
- (1, (30300883787,)),
- (6, (68554228008,)),
- (5, (b'plan_double_abs',)),
- None,
- None,
- True))
-`;
-
-export const operations = [
- Tuple(
- 1,
- Tuple(
- Tuple(
- '__add__',
- firstPointerTensor,
- Tuple(firstPointerTensor),
- new Map()
- ),
- Tuple(53361601662)
- )
- ),
- Tuple(
- 1,
- Tuple(
- Tuple('torch.abs', null, Tuple(secondPointerTensor), new Map()),
- Tuple(68554228008)
- )
- ),
- Tuple(9, 53361601662)
-];
-export const id = 85156589176;
-export const args = [30300883787];
-export const results = Tuple(68554228008);
-export const name = 'plan_double_abs';
-export const tags = null;
-export const description = null;
-export const isBuilt = true;
-
-export const detailedPlan = new Plan(
- operations,
- id,
- args,
- results,
- name,
- tags,
- description,
- isBuilt
-);
diff --git a/test/dummy/pointer-tensor.js b/test/dummy/pointer-tensor.js
deleted file mode 100644
index 7849d99b..00000000
--- a/test/dummy/pointer-tensor.js
+++ /dev/null
@@ -1,33 +0,0 @@
-import PointerTensor from '../../src/custom-types/pointer-tensor';
-import { torchSize2, simplifiedTorchSize } from './torch-size';
-import { runReplacers, SIMPLIFY_REPLACERS } from '../../src/serde';
-
-export const id = 23885703668;
-export const idAtLocation = 30300883787;
-export const locationId = 85156589176;
-export const pointToAttr = null;
-export const shape = torchSize2;
-export const garbageCollectData = false;
-
-export const firstPointerTensor = new PointerTensor(
- id,
- idAtLocation,
- locationId,
- pointToAttr,
- shape,
- garbageCollectData
-);
-
-export const secondPointerTensor = new PointerTensor(
- 50671613206,
- 53361601662,
- 85156589176,
- null,
- null,
- true
-);
-
-export const simplifiedPointerTensor = runReplacers(
- `(19, (${id}, ${idAtLocation}, ${locationId}, ${pointToAttr}, ${simplifiedTorchSize}, ${garbageCollectData}))`,
- SIMPLIFY_REPLACERS
-);
diff --git a/test/dummy/range.js b/test/dummy/range.js
deleted file mode 100644
index e9fa980c..00000000
--- a/test/dummy/range.js
+++ /dev/null
@@ -1,9 +0,0 @@
-import Range from '../../src/custom-types/range';
-
-export const start = 0;
-export const end = 10;
-export const step = 1;
-
-export const range = new Range(start, end, step);
-
-export const simplifiedRange = `(2, (${start}, ${end}, ${step}))`;
diff --git a/test/dummy/slice.js b/test/dummy/slice.js
deleted file mode 100644
index edf2379f..00000000
--- a/test/dummy/slice.js
+++ /dev/null
@@ -1,10 +0,0 @@
-import Slice from '../../src/custom-types/slice';
-
-export const start = 0;
-export const end = 10;
-export const step = 1;
-
-export const slice = new Slice(start, end, step);
-export const nullStepSlice = new Slice(start, end);
-
-export const simplifiedSlice = `(4, (${start}, ${end}, ${step}))`;
diff --git a/test/dummy/torch-size.js b/test/dummy/torch-size.js
deleted file mode 100644
index 752886a7..00000000
--- a/test/dummy/torch-size.js
+++ /dev/null
@@ -1,10 +0,0 @@
-import TorchSize from '../../src/custom-types/torch-size';
-import { runReplacers, SIMPLIFY_REPLACERS } from '../../src/serde';
-
-export const torchSizeShape = [2];
-export const torchSize2 = new TorchSize(torchSizeShape);
-
-export const simplifiedTorchSize = runReplacers(
- `(13, (${torchSizeShape}))`,
- SIMPLIFY_REPLACERS
-);
diff --git a/test/dummy/torch-tensor.js b/test/dummy/torch-tensor.js
deleted file mode 100644
index a7dbbe76..00000000
--- a/test/dummy/torch-tensor.js
+++ /dev/null
@@ -1,31 +0,0 @@
-import TorchTensor from '../../src/custom-types/torch-tensor';
-import { runReplacers, SIMPLIFY_REPLACERS } from '../../src/serde';
-
-export const id = 86275536166;
-export const bin = 'something here';
-export const chain = null;
-export const gradChain = null;
-export const tags = null;
-export const description = null;
-
-export const torchTensor = new TorchTensor(
- id,
- bin,
- chain,
- gradChain,
- tags,
- description
-);
-
-export const simplifiedTorchTensor = runReplacers(
- `
-(12,
- (${id},
- (5,(b'${bin}')),
- ${chain},
- ${gradChain},
- ${tags},
- ${description}))
-`,
- SIMPLIFY_REPLACERS
-);
diff --git a/test/index.test.js b/test/index.test.js
index 35413763..42acd40a 100644
--- a/test/index.test.js
+++ b/test/index.test.js
@@ -1,209 +1,213 @@
-import regeneratorRuntime from 'regenerator-runtime';
-import { Server } from 'mock-socket';
-import Syft from '../src/index';
-import { TENSOR_REMOVED } from '../src/_constants';
+describe('Syft', () => {
+ test('can do something', () => {});
+});
-const fakeURL = 'ws://localhost:8080/';
+// import 'regenerator-runtime/runtime';
+// import { Server } from 'mock-socket';
+// import Syft from '../src/index';
+// import { TENSOR_REMOVED } from '../src/_constants';
-let syft = null;
-let mockServer = null;
+// const fakeURL = 'ws://localhost:8080/';
-describe('Syft', () => {
- beforeAll(done => {
- mockServer = new Server(fakeURL);
- syft = new Syft({ verbose: true });
+// let syft = null;
+// let mockServer = null;
- done();
- });
+// describe('Syft', () => {
+// beforeAll(done => {
+// mockServer = new Server(fakeURL);
+// syft = new Syft({ verbose: true });
- beforeEach(() => {
- syft.start(fakeURL);
- });
+// done();
+// });
- afterEach(() => {
- if (syft.socket) {
- syft.stop();
- }
- });
+// beforeEach(() => {
+// syft.start(fakeURL);
+// });
- /* ----- CONSTRUCTOR ----- */
+// afterEach(() => {
+// if (syft.socket) {
+// syft.stop();
+// }
+// });
- test('can constructor an instance', async () => {
- const newSyft = new Syft({
- url: fakeURL,
- verbose: true
- });
+// /* ----- CONSTRUCTOR ----- */
- expect(newSyft.tensors.length).toBe(0);
+// test('can constructor an instance', async () => {
+// const newSyft = new Syft({
+// url: fakeURL,
+// verbose: true
+// });
- expect(typeof newSyft.observer.subscribe).toBe('function');
- expect(typeof newSyft.observer.unsubscribe).toBe('function');
- expect(typeof newSyft.observer.broadcast).toBe('function');
+// expect(newSyft.tensors.length).toBe(0);
- expect(typeof newSyft.logger.log).toBe('function');
- expect(newSyft.logger.verbose).toBe(true);
+// expect(typeof newSyft.observer.subscribe).toBe('function');
+// expect(typeof newSyft.observer.unsubscribe).toBe('function');
+// expect(typeof newSyft.observer.broadcast).toBe('function');
- expect(newSyft.socket.url).toBe(fakeURL);
- });
+// expect(typeof newSyft.logger.log).toBe('function');
+// expect(newSyft.logger.verbose).toBe(true);
- /* ----- HELPERS ----- */
+// expect(newSyft.socket.url).toBe(fakeURL);
+// });
- // genTensors()
- test('can get a list of tensors', async () => {
- expect(syft.getTensors().length).toBe(0);
+// /* ----- HELPERS ----- */
- await syft.addTensor('first-tensor', [[1, 2], [3, 4]]);
- expect(syft.getTensors().length).toBe(1);
- });
+// // genTensors()
+// test('can get a list of tensors', async () => {
+// expect(syft.getTensors().length).toBe(0);
- // getTensorById()
- test('can get a tensor by id', async () => {
- await syft.addTensor('first-tensor', [[1, 2], [3, 4]]);
+// await syft.addTensor('first-tensor', [[1, 2], [3, 4]]);
+// expect(syft.getTensors().length).toBe(1);
+// });
- const tensor = syft.getTensorById('first-tensor');
+// // getTensorById()
+// test('can get a tensor by id', async () => {
+// await syft.addTensor('first-tensor', [[1, 2], [3, 4]]);
- expect(tensor.id).toBe('first-tensor');
- });
+// const tensor = syft.getTensorById('first-tensor');
- // getTensorIndex()
- test('can the index of a tensor', async () => {
- await syft.addTensor('first-tensor', [[1, 2], [3, 4]]);
- await syft.addTensor('second-tensor', [[1, 2], [3, 4]]);
- await syft.addTensor('third-tensor', [[1, 2], [3, 4]]);
+// expect(tensor.id).toBe('first-tensor');
+// });
- const index = syft.getTensorIndex('second-tensor');
+// // getTensorIndex()
+// test('can the index of a tensor', async () => {
+// await syft.addTensor('first-tensor', [[1, 2], [3, 4]]);
+// await syft.addTensor('second-tensor', [[1, 2], [3, 4]]);
+// await syft.addTensor('third-tensor', [[1, 2], [3, 4]]);
- expect(index).toBe(1);
- });
+// const index = syft.getTensorIndex('second-tensor');
- /* ----- FUNCTIONALITY ----- */
+// expect(index).toBe(1);
+// });
- // addTensor()
- test('can add a tensor to the list', async () => {
- await syft.addTensor('first-tensor', [[1, 2], [3, 4]]).then(tensors => {
- expect(tensors.length).toBe(1);
- expect(tensors[0].id).toBe('first-tensor');
- });
- });
+// /* ----- FUNCTIONALITY ----- */
- // removeTensor()
- test('can remove a tensor from the list', async () => {
- await syft.addTensor('first-tensor', [[1, 2], [3, 4]]);
+// // addTensor()
+// test('can add a tensor to the list', async () => {
+// await syft.addTensor('first-tensor', [[1, 2], [3, 4]]).then(tensors => {
+// expect(tensors.length).toBe(1);
+// expect(tensors[0].id).toBe('first-tensor');
+// });
+// });
- await syft.removeTensor('first-tensor').then(tensors => {
- expect(tensors.length).toBe(0);
- });
- });
+// // removeTensor()
+// test('can remove a tensor from the list', async () => {
+// await syft.addTensor('first-tensor', [[1, 2], [3, 4]]);
- // runOperation()
- test('can perform a TensorFlow operation', async () => {
- await syft.addTensor('first-tensor', [[1, 2], [3, 4]]);
- await syft.addTensor('second-tensor', [[5, 6], [7, 8]]);
+// await syft.removeTensor('first-tensor').then(tensors => {
+// expect(tensors.length).toBe(0);
+// });
+// });
- await syft
- .runOperation('add', ['first-tensor', 'second-tensor'])
- .then(result => {
- const resultData = result.dataSync();
+// // runOperation()
+// test('can perform a TensorFlow operation', async () => {
+// await syft.addTensor('first-tensor', [[1, 2], [3, 4]]);
+// await syft.addTensor('second-tensor', [[5, 6], [7, 8]]);
- expect(resultData).toContain(6);
- expect(resultData).toContain(8);
- expect(resultData).toContain(10);
- expect(resultData).toContain(12);
+// await syft
+// .runOperation('add', ['first-tensor', 'second-tensor'])
+// .then(result => {
+// const resultData = result.dataSync();
- expect(resultData).not.toContain(1);
- expect(resultData).not.toContain(2);
- expect(resultData).not.toContain(3);
- expect(resultData).not.toContain(4);
- });
- });
+// expect(resultData).toContain(6);
+// expect(resultData).toContain(8);
+// expect(resultData).toContain(10);
+// expect(resultData).toContain(12);
- /* ----- EVENT HANDLERS ----- */
+// expect(resultData).not.toContain(1);
+// expect(resultData).not.toContain(2);
+// expect(resultData).not.toContain(3);
+// expect(resultData).not.toContain(4);
+// });
+// });
- test('can subscribe and unsubscribe from an event', async () => {
- syft.onTensorRemoved(({ id, tensors }) => ({ id, tensors }));
+// /* ----- EVENT HANDLERS ----- */
- expect(syft.observer.observers.length).toBe(1);
+// test('can subscribe and unsubscribe from an event', async () => {
+// syft.onTensorRemoved(({ id, tensors }) => ({ id, tensors }));
- syft.observer.unsubscribe(TENSOR_REMOVED);
+// expect(syft.observer.observers.length).toBe(1);
- expect(syft.observer.observers.length).toBe(0);
- });
+// syft.observer.unsubscribe(TENSOR_REMOVED);
- // onMessageReceived()
- // TODO
+// expect(syft.observer.observers.length).toBe(0);
+// });
- // onMessageSent()
- // TODO
+// // onMessageReceived()
+// // TODO
- // onRunOperation()
- test('can subscribe to a TensorFlow operation being performed', async () => {
- syft.onRunOperation(({ func, result }) => {
- expect(func).toBe('add');
+// // onMessageSent()
+// // TODO
- const resultData = result.dataSync();
+// // onRunOperation()
+// test('can subscribe to a TensorFlow operation being performed', async () => {
+// syft.onRunOperation(({ func, result }) => {
+// expect(func).toBe('add');
- expect(resultData).toContain(6);
- expect(resultData).toContain(8);
- expect(resultData).toContain(10);
- expect(resultData).toContain(12);
+// const resultData = result.dataSync();
- expect(resultData).not.toContain(1);
- expect(resultData).not.toContain(2);
- expect(resultData).not.toContain(3);
- expect(resultData).not.toContain(4);
- });
+// expect(resultData).toContain(6);
+// expect(resultData).toContain(8);
+// expect(resultData).toContain(10);
+// expect(resultData).toContain(12);
- await syft.addTensor('first-tensor', [[1, 2], [3, 4]]);
- await syft.addTensor('second-tensor', [[5, 6], [7, 8]]);
- await syft.runOperation('add', ['first-tensor', 'second-tensor']);
- });
+// expect(resultData).not.toContain(1);
+// expect(resultData).not.toContain(2);
+// expect(resultData).not.toContain(3);
+// expect(resultData).not.toContain(4);
+// });
- // onTensorAdded()
- test('can subscribe to a tensor being added', async () => {
- syft.onTensorAdded(({ id, tensor, tensors }) => {
- expect(id).toBe('first-tensor');
- expect(tensor.size).toBe(4);
- expect(tensors.length).toBe(1);
- });
-
- await syft.addTensor('first-tensor', [[1, 2], [3, 4]]);
- });
+// await syft.addTensor('first-tensor', [[1, 2], [3, 4]]);
+// await syft.addTensor('second-tensor', [[5, 6], [7, 8]]);
+// await syft.runOperation('add', ['first-tensor', 'second-tensor']);
+// });
- // onTensorRemoved()
- test('can subscribe to a tensor being removed', async () => {
- syft.onTensorRemoved(({ id, tensors }) => {
- expect(id).toBe('first-tensor');
- expect(tensors.length).toBe(0);
- });
+// // onTensorAdded()
+// test('can subscribe to a tensor being added', async () => {
+// syft.onTensorAdded(({ id, tensor, tensors }) => {
+// expect(id).toBe('first-tensor');
+// expect(tensor.size).toBe(4);
+// expect(tensors.length).toBe(1);
+// });
+
+// await syft.addTensor('first-tensor', [[1, 2], [3, 4]]);
+// });
- await syft.addTensor('first-tensor', [[1, 2], [3, 4]]);
- await syft.removeTensor('first-tensor');
- });
-
- /* ----- SOCKET COMMUNICATION ----- */
-
- // createSocketConnection()
- test('can create a socket connection', async () => {
- expect(syft.createSocketConnection()).toBe(null);
- expect(syft.createSocketConnection(fakeURL).url).toBe(fakeURL);
- });
+// // onTensorRemoved()
+// test('can subscribe to a tensor being removed', async () => {
+// syft.onTensorRemoved(({ id, tensors }) => {
+// expect(id).toBe('first-tensor');
+// expect(tensors.length).toBe(0);
+// });
+
+// await syft.addTensor('first-tensor', [[1, 2], [3, 4]]);
+// await syft.removeTensor('first-tensor');
+// });
+
+// /* ----- SOCKET COMMUNICATION ----- */
+
+// // createSocketConnection()
+// test('can create a socket connection', async () => {
+// expect(syft.createSocketConnection()).toBe(null);
+// expect(syft.createSocketConnection(fakeURL).url).toBe(fakeURL);
+// });
+
+// // sendMessage()
+// // TODO
+
+// // start()
+// test('can start', async () => {
+// const newSyft = new Syft();
- // sendMessage()
- // TODO
-
- // start()
- test('can start', async () => {
- const newSyft = new Syft();
+// newSyft.start(fakeURL);
- newSyft.start(fakeURL);
+// expect(newSyft.socket.url).toBe(fakeURL);
+// });
- expect(newSyft.socket.url).toBe(fakeURL);
- });
+// // stop()
+// test('can stop', async () => {
+// syft.stop();
- // stop()
- test('can stop', async () => {
- syft.stop();
-
- expect(syft.socket).toBe(null);
- });
-});
+// expect(syft.socket).toBe(null);
+// });
+// });
diff --git a/test/serde.test.js b/test/serde.test.js
deleted file mode 100644
index e1efd73f..00000000
--- a/test/serde.test.js
+++ /dev/null
@@ -1,195 +0,0 @@
-import { simplify, detail } from '../src/serde';
-import {
- simplifiedDict,
- dict,
- simplifiedList,
- list,
- simplifiedSet,
- set,
- simplifiedString,
- string,
- simplifiedTuple,
- tuple
-} from './dummy/native';
-import { simplifiedRange, range } from './dummy/range';
-import { simplifiedSlice, slice } from './dummy/slice';
-import { simplifiedTorchTensor, torchTensor } from './dummy/torch-tensor';
-import { simplifiedTorchSize, torchSize2 } from './dummy/torch-size';
-import { simplifiedPlan, detailedPlan } from './dummy/plan';
-import {
- simplifiedPointerTensor,
- firstPointerTensor
-} from './dummy/pointer-tensor';
-
-// NOTE: There's a few things we need to get PySyft and syft.js on equal footing.
-// Msgpack in Python appears to add extraneous commas to the end of a lot of different Python objects, we should remove these from tests since they aren't syntactically significant
-// Likewise, let's trim all white space so that we can ensure there are no issues related to indention or spacing
-const EQUALIZERS = [
- [/\s/g, ''], // Remove all extra spaces
- [/,\)/g, ')'] // Remove all extra commas
-];
-
-const runEqualizers = data => {
- for (let i = 0; i < EQUALIZERS.length; i++) {
- data = data.replace(...EQUALIZERS[i]);
- }
-
- return data;
-};
-
-describe('Serde', () => {
- test('can simplify a Dict', () => {
- const equalizedPresetDict = runEqualizers(simplifiedDict);
- const equalizedSimplifiedDict = runEqualizers(simplify(dict));
-
- expect(equalizedPresetDict).toBe(equalizedSimplifiedDict);
- });
-
- test('can detail a Dict', () => {
- const computedDetailedDict = detail(simplifiedDict);
-
- expect(dict).toStrictEqual(computedDetailedDict);
- });
-
- test('can simplify a List', () => {
- const equalizedPresetList = runEqualizers(simplifiedList);
- const equalizedSimplifiedList = runEqualizers(simplify(list));
-
- expect(equalizedPresetList).toBe(equalizedSimplifiedList);
- });
-
- test('can detail a List', () => {
- const computedDetailedList = detail(simplifiedList);
-
- expect(list).toStrictEqual(computedDetailedList);
- });
-
- test('can simplify a Range', () => {
- const equalizedPresetRange = runEqualizers(simplifiedRange);
- const equalizedSimplifiedRange = runEqualizers(simplify(range));
-
- expect(equalizedPresetRange).toBe(equalizedSimplifiedRange);
- });
-
- test('can detail a Range', () => {
- const computedDetailedRange = detail(simplifiedRange);
-
- expect(range).toStrictEqual(computedDetailedRange);
- });
-
- test('can simplify a Set', () => {
- const equalizedPresetSet = runEqualizers(simplifiedSet);
- const equalizedSimplifiedSet = runEqualizers(simplify(set));
-
- expect(equalizedPresetSet).toBe(equalizedSimplifiedSet);
- });
-
- test('can detail a Set', () => {
- const computedDetailedSet = detail(simplifiedSet);
-
- expect(set).toStrictEqual(computedDetailedSet);
- });
-
- test('can simplify a Slice', () => {
- const equalizedPresetSlice = runEqualizers(simplifiedSlice);
- const equalizedSimplifiedSlice = runEqualizers(simplify(slice));
-
- expect(equalizedPresetSlice).toBe(equalizedSimplifiedSlice);
- });
-
- test('can detail a Slice', () => {
- const computedDetailedSlice = detail(simplifiedSlice);
-
- expect(slice).toStrictEqual(computedDetailedSlice);
- });
-
- test('can simplify a String', () => {
- const equalizedPresetString = runEqualizers(simplifiedString);
- const equalizedSimplifiedString = runEqualizers(simplify(string));
-
- expect(equalizedPresetString).toBe(equalizedSimplifiedString);
- });
-
- test('can detail a String', () => {
- const computedDetailedString = detail(simplifiedString);
-
- expect(string).toStrictEqual(computedDetailedString);
- });
-
- test('can simplify a Tuple', () => {
- const equalizedPresetTuple = runEqualizers(simplifiedTuple);
- const equalizedSimplifiedTuple = runEqualizers(simplify(tuple));
-
- expect(equalizedPresetTuple).toBe(equalizedSimplifiedTuple);
- });
-
- test('can detail a Tuple', () => {
- const computedDetailedTuple = detail(simplifiedTuple);
-
- expect(tuple).toStrictEqual(computedDetailedTuple);
- });
-
- test('can simplify a TorchTensor', () => {
- const equalizedPresetTorchTensor = runEqualizers(simplifiedTorchTensor);
- const equalizedSimplifiedTorchTensor = runEqualizers(simplify(torchTensor));
-
- expect(equalizedPresetTorchTensor).toBe(equalizedSimplifiedTorchTensor);
- });
-
- test('can detail a TorchTensor', () => {
- const computedDetailedTorchTensor = detail(simplifiedTorchTensor);
-
- expect(torchTensor).toStrictEqual(computedDetailedTorchTensor);
- });
-
- test('can simplify a TorchSize', () => {
- const equalizedPresetTorchSize = runEqualizers(simplifiedTorchSize);
- const equalizedSimplifiedTorchSize = runEqualizers(simplify(torchSize2));
-
- expect(equalizedPresetTorchSize).toBe(equalizedSimplifiedTorchSize);
- });
-
- test('can detail a TorchSize', () => {
- const computedDetailedTorchSize = detail(simplifiedTorchSize);
-
- expect(torchSize2).toStrictEqual(computedDetailedTorchSize);
- });
-
- test('can simplify a Plan', () => {
- const equalizedPresetPlan = runEqualizers(simplifiedPlan);
- const equalizedSimplifiedPlan = runEqualizers(simplify(detailedPlan));
-
- expect(equalizedPresetPlan).toBe(equalizedSimplifiedPlan);
- });
-
- test('can detail a Plan', () => {
- const computedDetailedPlan = detail(simplifiedPlan);
-
- expect(detailedPlan).toStrictEqual(computedDetailedPlan);
- });
-
- test('can simplify a PointerTensor', () => {
- const equalizedPresetPointerTensor = runEqualizers(simplifiedPointerTensor);
- const equalizedSimplifiedPointerTensor = runEqualizers(
- simplify(firstPointerTensor)
- );
-
- expect(equalizedPresetPointerTensor).toBe(equalizedSimplifiedPointerTensor);
- });
-
- test('can detail a PointerTensor', () => {
- const computedDetailedPointerTensor = detail(simplifiedPointerTensor);
-
- expect(firstPointerTensor).toStrictEqual(computedDetailedPointerTensor);
- });
-
- // NOTE: We don't need to test if a simplifier is not found because it will never happen
-
- test('will throw an error if no detailer is found', () => {
- const unknownSimplifiedItem = "(999, (b'hello'))";
-
- expect(() => {
- detail(unknownSimplifiedItem);
- }).toThrow();
- });
-});
diff --git a/test/sockets.test.js b/test/sockets.test.js
new file mode 100644
index 00000000..12e87774
--- /dev/null
+++ b/test/sockets.test.js
@@ -0,0 +1,194 @@
+import 'regenerator-runtime/runtime';
+
+import { Logger, SOCKET_PING } from 'syft-helpers.js';
+import { WebSocket, Server } from 'mock-socket';
+
+import Socket from '../src/sockets';
+
+global.WebSocket = WebSocket;
+
+const url = 'ws://localhost:8080/';
+
+// Create a promise that is resolved when the event is triggered.
+const makeEventPromise = (emitter, event) => {
+ let resolver;
+
+ const promise = new Promise(resolve => (resolver = resolve));
+ emitter.on(event, data => resolver(data));
+
+ return promise;
+};
+
+describe('Sockets', () => {
+ const logger = new Logger('syft.js', true);
+
+ let mockServer;
+
+ beforeEach(() => {
+ mockServer = new Server(url);
+ mockServer.connected = makeEventPromise(mockServer, 'connection');
+ });
+
+ afterEach(() => {
+ mockServer.close();
+ });
+
+ test('sends keep-alive messages automatically', async () => {
+ const keepAliveTimeout = 300,
+ expectedMessagesCount = 3,
+ messages = [],
+ expectedTypes = [];
+
+ // Creating a socket will open connection and start keep-alive pings.
+ new Socket({ url, logger, keepAliveTimeout });
+
+ const serverSocket = await mockServer.connected;
+
+ serverSocket.on('message', message => messages.push(JSON.parse(message)));
+
+ await new Promise(done =>
+ setTimeout(
+ done,
+ keepAliveTimeout * expectedMessagesCount + keepAliveTimeout / 2
+ )
+ );
+
+ // One keep-alive message is sent right after connection, hence +1.
+ expect(messages).toHaveLength(expectedMessagesCount + 1);
+
+ for (let i = 0; i < expectedMessagesCount + 1; i++) {
+ expectedTypes.push(SOCKET_PING);
+ }
+
+ expect(messages.map(message => message['type'])).toEqual(expectedTypes);
+ });
+
+ test('triggers onOpen event', async () => {
+ const onOpen = jest.fn();
+
+ new Socket({ url, logger, onOpen });
+
+ await mockServer.connected;
+
+ expect(onOpen).toHaveBeenCalledTimes(1);
+ });
+
+ test('triggers onClose event', async () => {
+ const closed = makeEventPromise(mockServer, 'close'),
+ onClose = jest.fn(),
+ mySocket = new Socket({
+ url,
+ logger,
+ onClose
+ });
+
+ await mockServer.connected;
+
+ mySocket.stop();
+
+ await closed;
+
+ expect(onClose).toHaveBeenCalledTimes(1);
+ expect(mySocket.timerId).toBeNull();
+ });
+
+ test('sends data correctly', async () => {
+ const testReqType = 'test',
+ testReqData = { blob: 1 },
+ testResponse = { response: 'test' },
+ testInstanceId = 'test-instance',
+ mySocket = new Socket({
+ instanceId: testInstanceId,
+ url,
+ logger,
+ onMessage: data => data
+ });
+
+ const serverSocket = await mockServer.connected;
+
+ // Skip first keep-alive message.
+ await makeEventPromise(serverSocket, 'message');
+
+ const responsePromise = mySocket.send(testReqType, testReqData);
+ const message = await makeEventPromise(serverSocket, 'message');
+
+ serverSocket.send(JSON.stringify(testResponse));
+
+ const response = await responsePromise;
+
+ expect(JSON.parse(message)).toEqual({
+ type: testReqType,
+ data: testReqData
+ });
+ expect(response).toEqual(testResponse);
+ });
+
+ test('returns error when .send() fails', async () => {
+ const mySocket = new Socket({
+ url,
+ logger,
+ onMessage: data => data
+ });
+
+ const serverSocket = await mockServer.connected;
+
+ // Skip first keep-alive message.
+ await makeEventPromise(serverSocket, 'message');
+
+ const responsePromise = mySocket.send('test', {});
+
+ mockServer.simulate('error');
+
+ expect.assertions(1);
+
+ try {
+ await responsePromise;
+ } catch (e) {
+ expect(e).toBeDefined();
+ }
+ });
+
+ test('disconnects from server after .stop()', async () => {
+ const mySocket = new Socket({
+ url,
+ logger
+ });
+
+ await mockServer.connected;
+
+ expect(mockServer.clients()).toHaveLength(1);
+
+ mySocket.stop();
+
+ await new Promise(done => setTimeout(done, 100));
+
+ expect(mockServer.clients()).toHaveLength(0);
+ });
+
+ test('triggers onMessage event', async () => {
+ const testResponse = { response: 'test' },
+ testInstanceId = 'test-instance',
+ onMessage = jest.fn(message => message),
+ mySocket = new Socket({
+ instanceId: testInstanceId,
+ url,
+ logger,
+ onMessage: onMessage
+ });
+
+ const serverSocket = await mockServer.connected;
+
+ // Skip first keep-alive message.
+ await makeEventPromise(serverSocket, 'message');
+
+ serverSocket.on('message', () => {
+ serverSocket.send(JSON.stringify(testResponse));
+ });
+
+ await mySocket.send('test1', {});
+ await mySocket.send('test2', {});
+
+ expect(onMessage).toHaveBeenCalledTimes(2);
+ expect(onMessage).toHaveBeenLastCalledWith(testResponse);
+ });
+});
diff --git a/test/webrtc.test.js b/test/webrtc.test.js
new file mode 100644
index 00000000..60078f01
--- /dev/null
+++ b/test/webrtc.test.js
@@ -0,0 +1,404 @@
+import 'regenerator-runtime/runtime';
+
+import {
+ WEBRTC_PEER_CONFIG,
+ WEBRTC_PEER_OPTIONS,
+ WEBRTC_JOIN_ROOM,
+ WEBRTC_INTERNAL_MESSAGE,
+ WEBRTC_PEER_LEFT,
+ Logger
+} from 'syft-helpers.js';
+import WebRTCClient from '../src/webrtc';
+
+// WebRTC mocks.
+import {
+ RTCPeerConnection,
+ RTCSessionDescription,
+ RTCIceCandidate
+} from './_webrtc-mocks';
+global.RTCPeerConnection = RTCPeerConnection;
+global.RTCSessionDescription = RTCSessionDescription;
+global.RTCIceCandidate = RTCIceCandidate;
+
+// Socket mock.
+class SocketMock {
+ send(type, data) {}
+}
+
+describe('WebRTC', () => {
+ const logger = new Logger('syft.js', true),
+ logSpy = jest.spyOn(logger, 'log'),
+ socketMock = new SocketMock();
+ let rtc, socketSendMock;
+
+ beforeEach(() => {
+ rtc = new WebRTCClient({
+ peerConfig: WEBRTC_PEER_CONFIG,
+ peerOptions: WEBRTC_PEER_OPTIONS,
+ logger,
+ socket: socketMock
+ });
+ socketSendMock = jest.spyOn(socketMock, 'send');
+ });
+
+ afterEach(() => {
+ jest.clearAllMocks();
+ });
+
+ test('start() sends message to join the scope', () => {
+ rtc.start('joinTestId', 'joinTestScope');
+ expect(socketSendMock).toBeCalledTimes(1);
+ expect(socketSendMock).lastCalledWith(WEBRTC_JOIN_ROOM, {
+ instanceId: 'joinTestId',
+ scopeId: 'joinTestScope'
+ });
+ });
+
+ test('receiveNewPeer() should initiate new rtc data channel', async () => {
+ const instanceId = 'testId',
+ scopeId = 'testScopeId',
+ peerInstanceId = 'peerInstanceId',
+ pcOnIceCandidateMock = jest.spyOn(
+ RTCPeerConnection.prototype,
+ 'onicecandidate',
+ 'set'
+ );
+
+ rtc.start(instanceId, scopeId);
+ rtc.receiveNewPeer({ instanceId: peerInstanceId });
+ await new Promise(done => setImmediate(done));
+
+ expect(rtc.peers).toHaveProperty(peerInstanceId);
+ expect(rtc.peers[peerInstanceId]).toHaveProperty('connection');
+ expect(rtc.peers[peerInstanceId]['connection']).toBeInstanceOf(
+ RTCPeerConnection
+ );
+ expect(rtc.peers[peerInstanceId]).toHaveProperty('channel');
+
+ // Check channel events are set.
+ const channel = rtc.peers[peerInstanceId]['channel'];
+ expect(channel.onopen).toBeInstanceOf(Function);
+ expect(channel.onclose).toBeInstanceOf(Function);
+ expect(channel.onmessage).toBeInstanceOf(Function);
+ expect(channel.onerror).toBeInstanceOf(Function);
+
+ // Check events are logged.
+ logSpy.mockReset();
+ channel.onopen('onopen');
+ channel.onclose('onclose');
+ channel.onmessage('onmessage');
+ channel.onerror('onerror');
+ expect(logSpy).toHaveBeenCalledTimes(4);
+ expect(logSpy.mock.calls[0][1]).toBe('onopen');
+ expect(logSpy.mock.calls[1][1]).toBe('onclose');
+ expect(logSpy.mock.calls[2][1]).toBe('onmessage');
+ expect(logSpy.mock.calls[3][1]).toBe('onerror');
+
+ const pc = rtc.peers[peerInstanceId]['connection'];
+ expect(pc.options).toStrictEqual(WEBRTC_PEER_CONFIG);
+ expect(pc.optional).toStrictEqual(WEBRTC_PEER_OPTIONS);
+
+ expect(pcOnIceCandidateMock).toHaveBeenCalledTimes(1);
+ const onIceCandidate = pc.onicecandidate;
+ expect(onIceCandidate).toBeInstanceOf(Function);
+
+ // Emulate onicecandidate event.
+ onIceCandidate.call(rtc.peers[peerInstanceId].connection, {
+ candidate: 'test-candidate1'
+ });
+ onIceCandidate.call(rtc.peers[peerInstanceId].connection, {
+ candidate: 'test-candidate2'
+ });
+ onIceCandidate.call(rtc.peers[peerInstanceId].connection, {});
+
+ expect(socketSendMock).toHaveBeenCalledTimes(4);
+ expect(socketSendMock).nthCalledWith(2, WEBRTC_INTERNAL_MESSAGE, {
+ instanceId,
+ scopeId,
+ to: peerInstanceId,
+ type: 'offer',
+ data: { type: 'offer', sdp: 'testOfferSdp' }
+ });
+ expect(socketSendMock).nthCalledWith(3, WEBRTC_INTERNAL_MESSAGE, {
+ instanceId,
+ scopeId,
+ to: peerInstanceId,
+ type: 'candidate',
+ data: 'test-candidate1'
+ });
+ expect(socketSendMock).nthCalledWith(4, WEBRTC_INTERNAL_MESSAGE, {
+ instanceId,
+ scopeId,
+ to: peerInstanceId,
+ type: 'candidate',
+ data: 'test-candidate2'
+ });
+ });
+
+ test('should handle "offer" internal message', async () => {
+ const instanceId = 'testId',
+ scopeId = 'testScopeId',
+ peerInstanceId = 'peerInstanceId',
+ pcOnDataChannelMock = jest.spyOn(
+ RTCPeerConnection.prototype,
+ 'ondatachannel',
+ 'set'
+ );
+
+ rtc.start(instanceId, scopeId);
+ rtc.receiveInternalMessage({
+ instanceId: peerInstanceId,
+ scopeId,
+ to: instanceId,
+ type: 'offer',
+ data: { type: 'offer', sdp: 'testOfferSdp' }
+ });
+
+ await new Promise(done => setImmediate(done));
+
+ expect(rtc.peers).toHaveProperty(peerInstanceId);
+ expect(rtc.peers[peerInstanceId]).toHaveProperty('connection');
+ expect(rtc.peers[peerInstanceId]['connection']).toBeInstanceOf(
+ RTCPeerConnection
+ );
+
+ const pc = rtc.peers[peerInstanceId]['connection'];
+ expect(pc.localDescription).toStrictEqual({
+ type: 'answer',
+ sdp: 'testAnswerSdp'
+ });
+ expect(pc.remoteDescription).toStrictEqual(
+ new RTCSessionDescription({ type: 'offer', sdp: 'testOfferSdp' })
+ );
+
+ expect(pcOnDataChannelMock).toHaveBeenCalledTimes(1);
+ const onDataChannel = pc.ondatachannel;
+ expect(onDataChannel).toBeInstanceOf(Function);
+ // Simulate ondatachannel.
+ onDataChannel.call(pc, { channel: { dummy: 1 } });
+
+ expect(rtc.peers[peerInstanceId]).toHaveProperty('channel');
+ });
+
+ test('should handle "answer" internal message', async () => {
+ const instanceId = 'testId',
+ scopeId = 'testScopeId',
+ peerInstanceId = 'peerInstanceId',
+ pc = new RTCPeerConnection();
+
+ rtc.start(instanceId, scopeId);
+ rtc.peers[peerInstanceId] = {
+ connection: pc
+ };
+ rtc.receiveInternalMessage({
+ instanceId: peerInstanceId,
+ scopeId,
+ to: instanceId,
+ type: 'answer',
+ data: { type: 'answer', sdp: 'testAnswerSdp' }
+ });
+
+ await new Promise(done => setImmediate(done));
+
+ expect(pc.remoteDescription).toStrictEqual(
+ new RTCSessionDescription({ type: 'answer', sdp: 'testAnswerSdp' })
+ );
+ });
+
+ test('should handle "candidate" internal message', async () => {
+ const instanceId = 'testId',
+ scopeId = 'testScopeId',
+ peer1InstanceId = 'peer1InstanceId',
+ peer2InstanceId = 'peer2InstanceId',
+ pc = new RTCPeerConnection();
+
+ rtc.start(instanceId, scopeId);
+
+ // Connection already exists.
+ rtc.peers[peer1InstanceId] = {
+ connection: pc
+ };
+ rtc.receiveInternalMessage({
+ instanceId: peer1InstanceId,
+ scopeId,
+ to: instanceId,
+ type: 'candidate',
+ data: { dummy: 1 }
+ });
+
+ await new Promise(done => setImmediate(done));
+
+ expect(pc.iceCandidates).toHaveLength(1);
+ expect(pc.iceCandidates[0]).toStrictEqual(
+ new RTCIceCandidate({ dummy: 1 })
+ );
+
+ // Connection doesn't exists and must be created.
+ rtc.receiveInternalMessage({
+ instanceId: peer2InstanceId,
+ scopeId,
+ to: instanceId,
+ type: 'candidate',
+ data: { dummy: 2 }
+ });
+
+ await new Promise(done => setImmediate(done));
+
+ expect(rtc.peers).toHaveProperty(peer2InstanceId);
+ expect(rtc.peers[peer2InstanceId]).toHaveProperty('connection');
+ expect(rtc.peers[peer2InstanceId]['connection']).toBeInstanceOf(
+ RTCPeerConnection
+ );
+
+ const pc2 = rtc.peers[peer2InstanceId]['connection'];
+ expect(pc2.iceCandidates).toHaveLength(1);
+ expect(pc2.iceCandidates[0]).toStrictEqual(
+ new RTCIceCandidate({ dummy: 2 })
+ );
+ });
+
+ test('sendMessage() should send messages to peers', async () => {
+ const instanceId = 'testId',
+ scopeId = 'testScopeId',
+ peer1InstanceId = 'peer1InstanceId',
+ peer2InstanceId = 'peer2InstanceId',
+ channelSendMock = jest.fn(),
+ channel1 = {
+ send: data => {
+ channelSendMock(1, data);
+ }
+ },
+ channel2 = {
+ send: data => {
+ channelSendMock(2, data);
+ }
+ },
+ channelWithError = {
+ send: () => {
+ throw new Error();
+ }
+ };
+
+ rtc.start(instanceId, scopeId);
+ rtc.peers = {};
+ rtc.peers[peer1InstanceId] = { channel: channel1 };
+ rtc.peers[peer2InstanceId] = { channel: channel2 };
+
+ // Broadcast.
+ rtc.sendMessage({ dummy: 'hello' });
+
+ expect(channelSendMock).toHaveBeenCalledTimes(2);
+ expect(channelSendMock).toHaveBeenNthCalledWith(1, 1, { dummy: 'hello' });
+ expect(channelSendMock).toHaveBeenNthCalledWith(2, 2, { dummy: 'hello' });
+
+ // Single peer.
+ rtc.sendMessage({ dummy: 'hello there' }, peer1InstanceId);
+ expect(channelSendMock).toHaveBeenCalledTimes(3);
+ expect(channelSendMock).toHaveBeenNthCalledWith(3, 1, {
+ dummy: 'hello there'
+ });
+
+ // Error handling.
+ rtc.peers[peer1InstanceId] = { channel: channelWithError };
+ expect(() => {
+ rtc.sendMessage({ dummy: 'hello error' });
+ }).not.toThrow();
+
+ expect(channelSendMock).toHaveBeenCalledTimes(4);
+ expect(channelSendMock).toHaveBeenNthCalledWith(4, 2, {
+ dummy: 'hello error'
+ });
+ });
+
+ test('removePeer() should close channel', async () => {
+ const instanceId = 'testId',
+ scopeId = 'testScopeId',
+ peer1InstanceId = 'peer1InstanceId',
+ peer2InstanceId = 'peer2InstanceId',
+ channelCloseMock = jest.fn(),
+ channel1 = {
+ close: () => {
+ channelCloseMock(1);
+ }
+ },
+ channel2 = {
+ close: () => {
+ channelCloseMock(2);
+ }
+ },
+ channelWithError = {
+ send: () => {
+ throw new Error();
+ }
+ };
+
+ rtc.start(instanceId, scopeId);
+ rtc.peers = {};
+ rtc.peers[peer1InstanceId] = { channel: channel1 };
+ rtc.peers[peer2InstanceId] = { channel: channel2 };
+
+ rtc.removePeer(peer1InstanceId);
+
+ expect(channelCloseMock).toHaveBeenCalledTimes(1);
+ expect(channelCloseMock).toHaveBeenNthCalledWith(1, 1);
+ expect(rtc.peers).not.toHaveProperty(peer1InstanceId);
+ expect(rtc.peers).toHaveProperty(peer2InstanceId);
+
+ // Non-existing peer.
+ rtc.removePeer('invalid');
+ expect(channelCloseMock).toHaveBeenCalledTimes(1);
+ expect(rtc.peers).toHaveProperty(peer2InstanceId);
+
+ // Error handling.
+ rtc.peers[peer1InstanceId] = { channel: channelWithError };
+ expect(() => {
+ rtc.removePeer(peer1InstanceId);
+ }).not.toThrow();
+
+ expect(rtc.peers).not.toHaveProperty(peer1InstanceId);
+ });
+
+ test('stop() should close all channels and send peer left message', async () => {
+ const instanceId = 'testId',
+ scopeId = 'testScopeId',
+ peer1InstanceId = 'peer1InstanceId',
+ peer2InstanceId = 'peer2InstanceId',
+ channelCloseMock = jest.fn(),
+ channel1 = {
+ close: () => {
+ channelCloseMock(1);
+ }
+ },
+ channel2 = {
+ close: () => {
+ channelCloseMock(2);
+ }
+ };
+
+ rtc.start(instanceId, scopeId);
+ rtc.peers = {};
+ rtc.peers[peer1InstanceId] = { channel: channel1 };
+ rtc.peers[peer2InstanceId] = { channel: channel2 };
+
+ rtc.stop();
+
+ expect(channelCloseMock).toHaveBeenCalledTimes(2);
+ expect(rtc.peers).not.toHaveProperty(peer1InstanceId);
+ expect(rtc.peers).not.toHaveProperty(peer2InstanceId);
+
+ expect(socketSendMock).toBeCalledTimes(2);
+ expect(socketSendMock).lastCalledWith(WEBRTC_PEER_LEFT, {
+ instanceId,
+ scopeId
+ });
+ });
+
+ test('error handler logs message', async () => {
+ logSpy.mockReset();
+ const error = new Error('dummy');
+ rtc._handleError('test error message')(error);
+ expect(logSpy).toHaveBeenCalledTimes(1);
+ expect(logSpy.mock.calls[0][0]).toBe('test error message');
+ expect(logSpy.mock.calls[0][1]).toStrictEqual(error);
+ });
+});
+