e2ee: clean up tests

and make them a bit more concise. No functional changes

modules/e2ee/Context.spec.js

@@ -27,9 +27,32 @@ function hexdump(buffer) {
 const audioBytes = [ 0xde, 0xad, 0xbe, 0xef ];
 const videoBytes = [ 0xde, 0xad, 0xbe, 0xef, 0xde, 0xad, 0xbe, 0xef, 0xde, 0xad, 0xbe, 0xef ];
 
+/**
+ * generates a dummy audio frame
+ */
+function makeAudioFrame() {
+    return {
+        data: new Uint8Array(audioBytes).buffer,
+        type: undefined // type is undefined for audio frames.
+    };
+}
+
+/**
+ * generates a dummy video frame
+ */
+function makeVideoFrame() {
+    return {
+        data: new Uint8Array(videoBytes).buffer,
+        type: 'key'
+    };
+}
+
+
 describe('E2EE Context', () => {
     let sender;
+    let sendController;
     let receiver;
+    let receiveController;
     const key = new Uint8Array([
         1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
         0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
@@ -41,8 +64,13 @@ describe('E2EE Context', () => {
     });
 
     describe('encode function', () => {
+        beforeEach(async () => {
+            await sender.setKey(key, 0);
+            await receiver.setKey(key, 0);
+        });
+
         it('with an audio frame', async done => {
-            const sendController = {
+            sendController = {
                 enqueue: encodedFrame => {
                     const data = new Uint8Array(encodedFrame.data);
 
@@ -50,22 +78,16 @@ describe('E2EE Context', () => {
                     //   4 bytes truncated signature, counter (1 byte) and 1 byte trailer.
                     expect(data.byteLength).toEqual(audioBytes.length + 6);
 
-                    // TODO: provide test vector and matcher.
+                    // TODO: provide test vector.
                     done();
                 }
             };
-            const frame = {
-                data: new Uint8Array(audioBytes).buffer,
-                type: undefined // type is undefined for audio frames.
-            };
 
-            await sender.setKey(key, 0);
-            await receiver.setKey(key, 0);
-            await sender.encodeFunction(frame, sendController);
+            await sender.encodeFunction(makeAudioFrame(), sendController);
         });
 
         it('with a video frame', async done => {
-            const sendController = {
+            sendController = {
                 enqueue: encodedFrame => {
                     const data = new Uint8Array(encodedFrame.data);
 
@@ -74,26 +96,28 @@ describe('E2EE Context', () => {
 
                     expect(data.byteLength).toEqual(videoBytes.length + 12);
 
-                    // TODO: provide test vector and matcher.
+                    // TODO: provide test vector.
                     done();
                 }
             };
-            const frame = {
-                data: new Uint8Array(videoBytes).buffer,
-                type: 'key'
-            };
 
-            await sender.setKey(key, 0);
-            await receiver.setKey(key, 0);
-            await sender.encodeFunction(frame, sendController);
+            await sender.encodeFunction(makeVideoFrame(), sendController);
         });
     });
 
     describe('end-to-end test', () => {
-        it('with an audio frame', async done => {
+        beforeEach(async () => {
             await sender.setKey(key, 0);
             await receiver.setKey(key, 0);
-            const receiveController = {
+            sendController = {
+                enqueue: async encodedFrame => {
+                    await receiver.decodeFunction(encodedFrame, receiveController);
+                }
+            };
+        });
+
+        it('with an audio frame', async done => {
+            receiveController = {
                 enqueue: encodedFrame => {
                     const data = new Uint8Array(encodedFrame.data);
 
@@ -102,23 +126,12 @@ describe('E2EE Context', () => {
                     done();
                 }
             };
-            const sendController = {
-                enqueue: encodedFrame => {
-                    receiver.decodeFunction(encodedFrame, receiveController);
-                }
-            };
-            const frame = {
-                data: new Uint8Array(audioBytes).buffer,
-                type: undefined // type is undefined for audio frames.
-            };
 
-            await sender.encodeFunction(frame, sendController);
+            await sender.encodeFunction(makeAudioFrame(), sendController);
         });
 
         it('with a video frame', async done => {
-            await sender.setKey(key, 0);
-            await receiver.setKey(key, 0);
-            const receiveController = {
+            receiveController = {
                 enqueue: encodedFrame => {
                     const data = new Uint8Array(encodedFrame.data);
 
@@ -127,29 +140,17 @@ describe('E2EE Context', () => {
                     done();
                 }
             };
-            const sendController = {
-                enqueue: encodedFrame => {
-                    receiver.decodeFunction(encodedFrame, receiveController);
-                }
-            };
-            const frame = {
-                data: new Uint8Array(videoBytes).buffer,
-                type: 'key'
-            };
 
-            await sender.encodeFunction(frame, sendController);
+            await sender.encodeFunction(makeVideoFrame(), sendController);
         });
 
         it('the receiver ratchets forward', async done => {
-            await sender.setKey(key, 0);
-            await receiver.setKey(key, 0);
-
             // Ratchet the key. We reimport from the raw bytes.
             const material = await importKey(key);
 
             await sender.setKey(await ratchet(material), 0);
 
-            const receiveController = {
+            receiveController = {
                 enqueue: encodedFrame => {
                     const data = new Uint8Array(encodedFrame.data);
 
@@ -158,17 +159,8 @@ describe('E2EE Context', () => {
                     done();
                 }
             };
-            const sendController = {
-                enqueue: encodedFrame => {
-                    receiver.decodeFunction(encodedFrame, receiveController);
-                }
-            };
-            const frame = {
-                data: new Uint8Array(audioBytes).buffer,
-                type: undefined
-            };
 
-            await sender.encodeFunction(frame, sendController);
+            await sender.encodeFunction(makeAudioFrame(), sendController);
         });
     });
 });