Browse Source

ref(e2ee) make tests compatible with new karma/jasmine versions

it removed support for functions being simultaneous async and have done parameter in callback
dev1
Jorge Oliveira 2 years ago
parent
commit
26f05c4207
1 changed files with 19 additions and 15 deletions
  1. 19
    15
      modules/e2ee/Context.spec.js

+ 19
- 15
modules/e2ee/Context.spec.js View File

76
             await receiver.setKey(key, 0);
76
             await receiver.setKey(key, 0);
77
         });
77
         });
78
 
78
 
79
-        it('with an audio frame', async done => {
79
+        it('with an audio frame', done => {
80
             sendController = {
80
             sendController = {
81
                 enqueue: encodedFrame => {
81
                 enqueue: encodedFrame => {
82
                     const data = new Uint8Array(encodedFrame.data);
82
                     const data = new Uint8Array(encodedFrame.data);
90
                 }
90
                 }
91
             };
91
             };
92
 
92
 
93
-            await sender.encodeFunction(makeAudioFrame(), sendController);
93
+            sender.encodeFunction(makeAudioFrame(), sendController);
94
         });
94
         });
95
 
95
 
96
-        it('with a video frame', async done => {
96
+        it('with a video frame', done => {
97
             sendController = {
97
             sendController = {
98
                 enqueue: encodedFrame => {
98
                 enqueue: encodedFrame => {
99
                     const data = new Uint8Array(encodedFrame.data);
99
                     const data = new Uint8Array(encodedFrame.data);
107
                 }
107
                 }
108
             };
108
             };
109
 
109
 
110
-            await sender.encodeFunction(makeVideoFrame(), sendController);
110
+            sender.encodeFunction(makeVideoFrame(), sendController);
111
         });
111
         });
112
     });
112
     });
113
 
113
 
122
             };
122
             };
123
         });
123
         });
124
 
124
 
125
-        it('with an audio frame', async done => {
125
+        it('with an audio frame', done => {
126
             receiveController = {
126
             receiveController = {
127
                 enqueue: encodedFrame => {
127
                 enqueue: encodedFrame => {
128
                     const data = new Uint8Array(encodedFrame.data);
128
                     const data = new Uint8Array(encodedFrame.data);
133
                 }
133
                 }
134
             };
134
             };
135
 
135
 
136
-            await sender.encodeFunction(makeAudioFrame(), sendController);
136
+            sender.encodeFunction(makeAudioFrame(), sendController);
137
         });
137
         });
138
 
138
 
139
-        it('with a video frame', async done => {
139
+        it('with a video frame', done => {
140
             receiveController = {
140
             receiveController = {
141
                 enqueue: encodedFrame => {
141
                 enqueue: encodedFrame => {
142
                     const data = new Uint8Array(encodedFrame.data);
142
                     const data = new Uint8Array(encodedFrame.data);
147
                 }
147
                 }
148
             };
148
             };
149
 
149
 
150
-            await sender.encodeFunction(makeVideoFrame(), sendController);
150
+            sender.encodeFunction(makeVideoFrame(), sendController);
151
         });
151
         });
152
 
152
 
153
-        it('the receiver ratchets forward', async done => {
154
-            // Ratchet the key. We reimport from the raw bytes.
155
-            const material = await importKey(key);
156
-
157
-            await sender.setKey(await ratchet(material), 0);
158
-
153
+        it('the receiver ratchets forward', done => {
159
             receiveController = {
154
             receiveController = {
160
                 enqueue: encodedFrame => {
155
                 enqueue: encodedFrame => {
161
                     const data = new Uint8Array(encodedFrame.data);
156
                     const data = new Uint8Array(encodedFrame.data);
166
                 }
161
                 }
167
             };
162
             };
168
 
163
 
169
-            await sender.encodeFunction(makeAudioFrame(), sendController);
164
+            const encodeFunction = async () => {
165
+                // Ratchet the key. We reimport from the raw bytes.
166
+                const material = await importKey(key);
167
+
168
+                await sender.setKey(await ratchet(material), 0);
169
+
170
+                sender.encodeFunction(makeAudioFrame(), sendController);
171
+            };
172
+
173
+            encodeFunction();
170
         });
174
         });
171
     });
175
     });
172
 });
176
 });

Loading…
Cancel
Save