@enbox/dwn-sdk-js 0.0.5 → 0.0.7

package/dist/esm/tests/features/protocol-update-action.spec.js

@@ -1,12 +1,3 @@
-var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
-    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
-    return new (P || (P = Promise))(function (resolve, reject) {
-        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
-        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
-        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
-        step((generator = generator.apply(thisArg, _arguments || [])).next());
-    });
-};
 import sinon from 'sinon';
 import { DataStream } from '../../src/utils/data-stream.js';
 import { Dwn } from '../../src/dwn.js';
@@ -31,7 +22,7 @@ export function testProtocolUpdateAction() {
         let dwn;
         // important to follow the `before` and `after` pattern to initialize and clean the stores in tests
         // so that different test suites can reuse the same backend store for testing
-        beforeAll(() => __awaiter(this, void 0, void 0, function* () {
+        beforeAll(async () => {
             didResolver = new UniversalResolver({ didResolvers: [DidKey] });
             const stores = TestStores.get();
             messageStore = stores.messageStore;
@@ -39,20 +30,20 @@ export function testProtocolUpdateAction() {
             resumableTaskStore = stores.resumableTaskStore;
             stateIndex = stores.stateIndex;
             eventStream = TestEventStream.get();
-            dwn = yield Dwn.create({ didResolver, messageStore, dataStore, stateIndex, eventStream, resumableTaskStore });
-        }));
-        beforeEach(() => __awaiter(this, void 0, void 0, function* () {
+            dwn = await Dwn.create({ didResolver, messageStore, dataStore, stateIndex, eventStream, resumableTaskStore });
+        });
+        beforeEach(async () => {
             sinon.restore(); // wipe all previous stubs/spies/mocks/fakes
             // clean up before each test rather than after so that a test does not depend on other tests to do the clean up
-            yield messageStore.clear();
-            yield dataStore.clear();
-            yield resumableTaskStore.clear();
-            yield stateIndex.clear();
-        }));
-        afterAll(() => __awaiter(this, void 0, void 0, function* () {
-            yield dwn.close();
-        }));
-        it('should only allow author of a role-authorized create to update', () => __awaiter(this, void 0, void 0, function* () {
+            await messageStore.clear();
+            await dataStore.clear();
+            await resumableTaskStore.clear();
+            await stateIndex.clear();
+        });
+        afterAll(async () => {
+            await dwn.close();
+        });
+        it('should only allow author of a role-authorized create to update', async () => {
             // Scenario:
             // 1. Alice installs a protocol with a "author of a role-authorized create can update" rule.
             // 2. Alice gives Bob and Carol the "user" role to be able to write `foo` records.
@@ -62,9 +53,9 @@ export function testProtocolUpdateAction() {
             // 5. Carol creates a `foo` by invoking the user role.
             // 6. Verify that Carol can update her `foo`
             // 7. Verify that Bob cannot update Carol's `foo`
-            const alice = yield TestDataGenerator.generateDidKeyPersona();
-            const bob = yield TestDataGenerator.generateDidKeyPersona();
-            const carol = yield TestDataGenerator.generateDidKeyPersona();
+            const alice = await TestDataGenerator.generateDidKeyPersona();
+            const bob = await TestDataGenerator.generateDidKeyPersona();
+            const carol = await TestDataGenerator.generateDidKeyPersona();
             // 1. Alice installs a protocol with a "author of a role-authorized create can update" rule.
             const protocolDefinition = {
                 protocol: 'foo',
@@ -87,32 +78,32 @@ export function testProtocolUpdateAction() {
                     }
                 }
             };
-            const protocolsConfig = yield ProtocolsConfigure.create({
+            const protocolsConfig = await ProtocolsConfigure.create({
                 definition: protocolDefinition,
                 signer: Jws.createSigner(alice)
             });
-            const protocolsConfigureReply = yield dwn.processMessage(alice.did, protocolsConfig.message);
+            const protocolsConfigureReply = await dwn.processMessage(alice.did, protocolsConfig.message);
             expect(protocolsConfigureReply.status.code).toBe(202);
             // 2. Alice gives Bob and Carol the "user" role to be able to write `foo` records.
-            const userBobRecordsWrite = yield TestDataGenerator.generateRecordsWrite({
+            const userBobRecordsWrite = await TestDataGenerator.generateRecordsWrite({
                 author: alice,
                 recipient: bob.did,
                 protocol: protocolDefinition.protocol,
                 protocolPath: 'user'
             });
-            const userBobRecordsWriteReply = yield dwn.processMessage(alice.did, userBobRecordsWrite.message, { dataStream: userBobRecordsWrite.dataStream });
+            const userBobRecordsWriteReply = await dwn.processMessage(alice.did, userBobRecordsWrite.message, { dataStream: userBobRecordsWrite.dataStream });
             expect(userBobRecordsWriteReply.status.code).toBe(202);
-            const userCarolRecordsWrite = yield TestDataGenerator.generateRecordsWrite({
+            const userCarolRecordsWrite = await TestDataGenerator.generateRecordsWrite({
                 author: alice,
                 recipient: carol.did,
                 protocol: protocolDefinition.protocol,
                 protocolPath: 'user'
             });
-            const userCarolRecordsWriteReply = yield dwn.processMessage(alice.did, userCarolRecordsWrite.message, { dataStream: userCarolRecordsWrite.dataStream });
+            const userCarolRecordsWriteReply = await dwn.processMessage(alice.did, userCarolRecordsWrite.message, { dataStream: userCarolRecordsWrite.dataStream });
             expect(userCarolRecordsWriteReply.status.code).toBe(202);
             // 3. Bob creates a `foo` by invoking the user role.
             const bobFooBytes = TestDataGenerator.randomBytes(100);
-            const bobRoleAuthorizedFoo = yield RecordsWrite.create({
+            const bobRoleAuthorizedFoo = await RecordsWrite.create({
                 signer: Jws.createSigner(bob),
                 protocolRole: 'user',
                 protocol: protocolDefinition.protocol,
@@ -121,32 +112,32 @@ export function testProtocolUpdateAction() {
                 dataFormat: 'any-format',
                 data: bobFooBytes
             });
-            const bobRoleAuthorizedCreateReply = yield dwn.processMessage(alice.did, bobRoleAuthorizedFoo.message, { dataStream: DataStream.fromBytes(bobFooBytes) });
+            const bobRoleAuthorizedCreateReply = await dwn.processMessage(alice.did, bobRoleAuthorizedFoo.message, { dataStream: DataStream.fromBytes(bobFooBytes) });
             expect(bobRoleAuthorizedCreateReply.status.code).toBe(202);
             // 4. Verify that Bob can update his `foo`
             const bobFooNewBytes = TestDataGenerator.randomBytes(100);
-            const bobAuthorizedFooUpdate = yield RecordsWrite.createFrom({
+            const bobAuthorizedFooUpdate = await RecordsWrite.createFrom({
                 recordsWriteMessage: bobRoleAuthorizedFoo.message,
                 data: bobFooNewBytes,
                 signer: Jws.createSigner(bob)
             });
-            const bobAuthorizedFooUpdateReply = yield dwn.processMessage(alice.did, bobAuthorizedFooUpdate.message, { dataStream: DataStream.fromBytes(bobFooNewBytes) });
+            const bobAuthorizedFooUpdateReply = await dwn.processMessage(alice.did, bobAuthorizedFooUpdate.message, { dataStream: DataStream.fromBytes(bobFooNewBytes) });
             expect(bobAuthorizedFooUpdateReply.status.code).toBe(202);
             //   4a. Sanity verify that the update took effect by reading the record back
-            const recordsRead = yield RecordsRead.create({
+            const recordsRead = await RecordsRead.create({
                 filter: {
                     recordId: bobRoleAuthorizedFoo.message.recordId
                 },
                 signer: Jws.createSigner(alice)
             });
-            const recordsReadReply = yield dwn.processMessage(alice.did, recordsRead.message);
+            const recordsReadReply = await dwn.processMessage(alice.did, recordsRead.message);
             expect(recordsReadReply.status.code).toBe(200);
             expect(recordsReadReply.entry.data).toBeDefined();
-            const dataFromReply = yield DataStream.toBytes(recordsReadReply.entry.data);
+            const dataFromReply = await DataStream.toBytes(recordsReadReply.entry.data);
             expect(dataFromReply).toEqual(bobFooNewBytes);
             // 5. Carol creates a `foo` by invoking the user role.
             const carolFooBytes = TestDataGenerator.randomBytes(100);
-            const carolRoleAuthorizedFoo = yield RecordsWrite.create({
+            const carolRoleAuthorizedFoo = await RecordsWrite.create({
                 signer: Jws.createSigner(carol),
                 protocolRole: 'user',
                 protocol: protocolDefinition.protocol,
@@ -155,28 +146,28 @@ export function testProtocolUpdateAction() {
                 dataFormat: 'any-format',
                 data: carolFooBytes
             });
-            const carolRoleAuthorizedCreateReply = yield dwn.processMessage(alice.did, carolRoleAuthorizedFoo.message, { dataStream: DataStream.fromBytes(carolFooBytes) });
+            const carolRoleAuthorizedCreateReply = await dwn.processMessage(alice.did, carolRoleAuthorizedFoo.message, { dataStream: DataStream.fromBytes(carolFooBytes) });
             expect(carolRoleAuthorizedCreateReply.status.code).toBe(202);
             // 6. Verify that carol can update her `foo`
             const carolFooNewBytes = TestDataGenerator.randomBytes(100);
-            const carolAuthorizedFooUpdate = yield RecordsWrite.createFrom({
+            const carolAuthorizedFooUpdate = await RecordsWrite.createFrom({
                 recordsWriteMessage: carolRoleAuthorizedFoo.message,
                 data: carolFooNewBytes,
                 signer: Jws.createSigner(carol)
             });
-            const carolAuthorizedFooUpdateReply = yield dwn.processMessage(alice.did, carolAuthorizedFooUpdate.message, { dataStream: DataStream.fromBytes(carolFooNewBytes) });
+            const carolAuthorizedFooUpdateReply = await dwn.processMessage(alice.did, carolAuthorizedFooUpdate.message, { dataStream: DataStream.fromBytes(carolFooNewBytes) });
             expect(carolAuthorizedFooUpdateReply.status.code).toBe(202);
             // 7. Verify that Bob cannot update Carol's `foo`
-            const bobUnauthorizedFooUpdate = yield RecordsWrite.createFrom({
+            const bobUnauthorizedFooUpdate = await RecordsWrite.createFrom({
                 recordsWriteMessage: carolRoleAuthorizedFoo.message,
                 data: bobFooNewBytes,
                 signer: Jws.createSigner(bob)
             });
-            const bobUnauthorizedFooUpdateReply = yield dwn.processMessage(alice.did, bobUnauthorizedFooUpdate.message, { dataStream: DataStream.fromBytes(bobFooNewBytes) });
+            const bobUnauthorizedFooUpdateReply = await dwn.processMessage(alice.did, bobUnauthorizedFooUpdate.message, { dataStream: DataStream.fromBytes(bobFooNewBytes) });
             expect(bobUnauthorizedFooUpdateReply.status.code).toBe(401);
             expect(bobUnauthorizedFooUpdateReply.status.detail).toContain(DwnErrorCode.ProtocolAuthorizationActionNotAllowed);
-        }));
-        it('should only allow author of an author/recipient-authorized create to update', () => __awaiter(this, void 0, void 0, function* () {
+        });
+        it('should only allow author of an author/recipient-authorized create to update', async () => {
             // Scenario:
             // 1. Alice installs a protocol with "author of an author/recipient-authorized create can update" rules.
             // 2. Alice creates a `foo` with Bob being the recipient, so that Bob can create `bar`.
@@ -191,9 +182,9 @@ export function testProtocolUpdateAction() {
             // 10. Verify that Bob can update his `baz`
             //   10a. Sanity verify that the update took effect by reading the record back.
             // 11. Verify that Bob cannot update Carol's `baz`
-            const alice = yield TestDataGenerator.generateDidKeyPersona();
-            const bob = yield TestDataGenerator.generateDidKeyPersona();
-            const carol = yield TestDataGenerator.generateDidKeyPersona();
+            const alice = await TestDataGenerator.generateDidKeyPersona();
+            const bob = await TestDataGenerator.generateDidKeyPersona();
+            const carol = await TestDataGenerator.generateDidKeyPersona();
             // 1. Alice installs a protocol with "author of an author/recipient-authorized create can update" rules.
             const protocolDefinition = {
                 protocol: 'foo-bar-baz',
@@ -226,33 +217,33 @@ export function testProtocolUpdateAction() {
                     }
                 }
             };
-            const protocolsConfig = yield ProtocolsConfigure.create({
+            const protocolsConfig = await ProtocolsConfigure.create({
                 definition: protocolDefinition,
                 signer: Jws.createSigner(alice)
             });
-            const protocolsConfigureReply = yield dwn.processMessage(alice.did, protocolsConfig.message);
+            const protocolsConfigureReply = await dwn.processMessage(alice.did, protocolsConfig.message);
             expect(protocolsConfigureReply.status.code).toBe(202);
             // 2. Alice creates a `foo` with Bob being the recipient, so that Bob can create `bar`.
-            const fooForBob = yield TestDataGenerator.generateRecordsWrite({
+            const fooForBob = await TestDataGenerator.generateRecordsWrite({
                 author: alice,
                 recipient: bob.did,
                 protocol: protocolDefinition.protocol,
                 protocolPath: 'foo'
             });
-            const fooForBobReply = yield dwn.processMessage(alice.did, fooForBob.message, { dataStream: fooForBob.dataStream });
+            const fooForBobReply = await dwn.processMessage(alice.did, fooForBob.message, { dataStream: fooForBob.dataStream });
             expect(fooForBobReply.status.code).toBe(202);
             // 3. Alice creates a `foo` with Carol being the recipient, so that Carol can create `bar`.
-            const fooForCarol = yield TestDataGenerator.generateRecordsWrite({
+            const fooForCarol = await TestDataGenerator.generateRecordsWrite({
                 author: alice,
                 recipient: carol.did,
                 protocol: protocolDefinition.protocol,
                 protocolPath: 'foo'
             });
-            const fooForCarolReply = yield dwn.processMessage(alice.did, fooForCarol.message, { dataStream: fooForCarol.dataStream });
+            const fooForCarolReply = await dwn.processMessage(alice.did, fooForCarol.message, { dataStream: fooForCarol.dataStream });
             expect(fooForCarolReply.status.code).toBe(202);
             // 4. Bob creates a recipient-authorized `bar`.
             const bobBarBytes = TestDataGenerator.randomBytes(100);
-            const bobRecipientAuthorizedBar = yield RecordsWrite.create({
+            const bobRecipientAuthorizedBar = await RecordsWrite.create({
                 signer: Jws.createSigner(bob),
                 protocol: protocolDefinition.protocol,
                 protocolPath: 'foo/bar',
@@ -261,11 +252,11 @@ export function testProtocolUpdateAction() {
                 dataFormat: 'any-format',
                 data: bobBarBytes
             });
-            const bobRecipientAuthorizedBarReply = yield dwn.processMessage(alice.did, bobRecipientAuthorizedBar.message, { dataStream: DataStream.fromBytes(bobBarBytes) });
+            const bobRecipientAuthorizedBarReply = await dwn.processMessage(alice.did, bobRecipientAuthorizedBar.message, { dataStream: DataStream.fromBytes(bobBarBytes) });
             expect(bobRecipientAuthorizedBarReply.status.code).toBe(202);
             // 5. Carol creates a recipient-authorized `bar`.
             const carolBarBytes = TestDataGenerator.randomBytes(100);
-            const carolRecipientAuthorizedBar = yield RecordsWrite.create({
+            const carolRecipientAuthorizedBar = await RecordsWrite.create({
                 signer: Jws.createSigner(carol),
                 protocol: protocolDefinition.protocol,
                 protocolPath: 'foo/bar',
@@ -274,41 +265,41 @@ export function testProtocolUpdateAction() {
                 dataFormat: 'any-format',
                 data: carolBarBytes
             });
-            const carolRecipientAuthorizedBarReply = yield dwn.processMessage(alice.did, carolRecipientAuthorizedBar.message, { dataStream: DataStream.fromBytes(carolBarBytes) });
+            const carolRecipientAuthorizedBarReply = await dwn.processMessage(alice.did, carolRecipientAuthorizedBar.message, { dataStream: DataStream.fromBytes(carolBarBytes) });
             expect(carolRecipientAuthorizedBarReply.status.code).toBe(202);
             // 6. Verify that Bob can update his `bar`.
             const bobBarNewBytes = TestDataGenerator.randomBytes(100);
-            const bobAuthorizedBarUpdate = yield RecordsWrite.createFrom({
+            const bobAuthorizedBarUpdate = await RecordsWrite.createFrom({
                 recordsWriteMessage: bobRecipientAuthorizedBar.message,
                 data: bobBarNewBytes,
                 signer: Jws.createSigner(bob)
             });
-            const bobAuthorizedBarUpdateReply = yield dwn.processMessage(alice.did, bobAuthorizedBarUpdate.message, { dataStream: DataStream.fromBytes(bobBarNewBytes) });
+            const bobAuthorizedBarUpdateReply = await dwn.processMessage(alice.did, bobAuthorizedBarUpdate.message, { dataStream: DataStream.fromBytes(bobBarNewBytes) });
             expect(bobAuthorizedBarUpdateReply.status.code).toBe(202);
             //   6a. Sanity verify that the update took effect by reading the record back.
-            const bobBarRead = yield RecordsRead.create({
+            const bobBarRead = await RecordsRead.create({
                 filter: {
                     recordId: bobRecipientAuthorizedBar.message.recordId
                 },
                 signer: Jws.createSigner(alice)
             });
-            const bobBarReadReply = yield dwn.processMessage(alice.did, bobBarRead.message);
+            const bobBarReadReply = await dwn.processMessage(alice.did, bobBarRead.message);
             expect(bobBarReadReply.status.code).toBe(200);
             expect(bobBarReadReply.entry.data).toBeDefined();
-            const dataFromBobBarRead = yield DataStream.toBytes(bobBarReadReply.entry.data);
+            const dataFromBobBarRead = await DataStream.toBytes(bobBarReadReply.entry.data);
             expect(dataFromBobBarRead).toEqual(bobBarNewBytes);
             // 7. Verify that Bob cannot update Carol's `bar`.
-            const bobUnauthorizedBarUpdate = yield RecordsWrite.createFrom({
+            const bobUnauthorizedBarUpdate = await RecordsWrite.createFrom({
                 recordsWriteMessage: carolRecipientAuthorizedBar.message,
                 data: bobBarNewBytes,
                 signer: Jws.createSigner(bob)
             });
-            const bobUnauthorizedBarUpdateReply = yield dwn.processMessage(alice.did, bobUnauthorizedBarUpdate.message, { dataStream: DataStream.fromBytes(bobBarNewBytes) });
+            const bobUnauthorizedBarUpdateReply = await dwn.processMessage(alice.did, bobUnauthorizedBarUpdate.message, { dataStream: DataStream.fromBytes(bobBarNewBytes) });
             expect(bobUnauthorizedBarUpdateReply.status.code).toBe(401);
             expect(bobUnauthorizedBarUpdateReply.status.detail).toContain(DwnErrorCode.ProtocolAuthorizationActionNotAllowed);
             // 8. Bob creates a author-authorized `baz` after his `bar`.
             const bobBazBytes = TestDataGenerator.randomBytes(100);
-            const bobAuthorAuthorizedBaz = yield RecordsWrite.create({
+            const bobAuthorAuthorizedBaz = await RecordsWrite.create({
                 signer: Jws.createSigner(bob),
                 protocol: protocolDefinition.protocol,
                 protocolPath: 'foo/bar/baz',
@@ -317,11 +308,11 @@ export function testProtocolUpdateAction() {
                 dataFormat: 'any-format',
                 data: bobBazBytes
             });
-            const bobAuthorAuthorizedBazReply = yield dwn.processMessage(alice.did, bobAuthorAuthorizedBaz.message, { dataStream: DataStream.fromBytes(bobBazBytes) });
+            const bobAuthorAuthorizedBazReply = await dwn.processMessage(alice.did, bobAuthorAuthorizedBaz.message, { dataStream: DataStream.fromBytes(bobBazBytes) });
             expect(bobAuthorAuthorizedBazReply.status.code).toBe(202);
             // 9. Carol creates a author-authorized `baz` after her `bar`.
             const carolBazBytes = TestDataGenerator.randomBytes(100);
-            const carolAuthorAuthorizedBaz = yield RecordsWrite.create({
+            const carolAuthorAuthorizedBaz = await RecordsWrite.create({
                 signer: Jws.createSigner(carol),
                 protocol: protocolDefinition.protocol,
                 protocolPath: 'foo/bar/baz',
@@ -330,40 +321,40 @@ export function testProtocolUpdateAction() {
                 dataFormat: 'any-format',
                 data: carolBazBytes
             });
-            const carolAuthorAuthorizedBazReply = yield dwn.processMessage(alice.did, carolAuthorAuthorizedBaz.message, { dataStream: DataStream.fromBytes(carolBazBytes) });
+            const carolAuthorAuthorizedBazReply = await dwn.processMessage(alice.did, carolAuthorAuthorizedBaz.message, { dataStream: DataStream.fromBytes(carolBazBytes) });
             expect(carolAuthorAuthorizedBazReply.status.code).toBe(202);
             // 10. Verify that Bob can update his `baz`
             const bobBazNewBytes = TestDataGenerator.randomBytes(100);
-            const bobAuthorizedBazUpdate = yield RecordsWrite.createFrom({
+            const bobAuthorizedBazUpdate = await RecordsWrite.createFrom({
                 recordsWriteMessage: bobAuthorAuthorizedBaz.message,
                 data: bobBazNewBytes,
                 signer: Jws.createSigner(bob)
             });
-            const bobAuthorizedBazUpdateReply = yield dwn.processMessage(alice.did, bobAuthorizedBazUpdate.message, { dataStream: DataStream.fromBytes(bobBazNewBytes) });
+            const bobAuthorizedBazUpdateReply = await dwn.processMessage(alice.did, bobAuthorizedBazUpdate.message, { dataStream: DataStream.fromBytes(bobBazNewBytes) });
             expect(bobAuthorizedBazUpdateReply.status.code).toBe(202);
             //   10a. Sanity verify that the update took effect by reading the record back.
-            const bobBazRead = yield RecordsRead.create({
+            const bobBazRead = await RecordsRead.create({
                 filter: {
                     recordId: bobAuthorAuthorizedBaz.message.recordId
                 },
                 signer: Jws.createSigner(alice)
             });
-            const bobBazReadReply = yield dwn.processMessage(alice.did, bobBazRead.message);
+            const bobBazReadReply = await dwn.processMessage(alice.did, bobBazRead.message);
             expect(bobBazReadReply.status.code).toBe(200);
             expect(bobBazReadReply.entry.data).toBeDefined();
-            const dataFromBobBazRead = yield DataStream.toBytes(bobBazReadReply.entry.data);
+            const dataFromBobBazRead = await DataStream.toBytes(bobBazReadReply.entry.data);
             expect(dataFromBobBazRead).toEqual(bobBazNewBytes);
             // 11. Verify that Bob cannot update Carol's `baz`
-            const bobUnauthorizedBazUpdate = yield RecordsWrite.createFrom({
+            const bobUnauthorizedBazUpdate = await RecordsWrite.createFrom({
                 recordsWriteMessage: carolRecipientAuthorizedBar.message,
                 data: bobBazNewBytes,
                 signer: Jws.createSigner(bob)
             });
-            const bobUnauthorizedBazUpdateReply = yield dwn.processMessage(alice.did, bobUnauthorizedBazUpdate.message, { dataStream: DataStream.fromBytes(bobBazNewBytes) });
+            const bobUnauthorizedBazUpdateReply = await dwn.processMessage(alice.did, bobUnauthorizedBazUpdate.message, { dataStream: DataStream.fromBytes(bobBazNewBytes) });
             expect(bobUnauthorizedBazUpdateReply.status.code).toBe(401);
             expect(bobUnauthorizedBazUpdateReply.status.detail).toContain(DwnErrorCode.ProtocolAuthorizationActionNotAllowed);
-        }));
-        it('should only allow author of an anyone-authorized create to update', () => __awaiter(this, void 0, void 0, function* () {
+        });
+        it('should only allow author of an anyone-authorized create to update', async () => {
             // Scenario:
             // 1. Alice installs a protocol with "author of an anyone-authorized create can update" rules.
             // 2. Bob creates an anyone-authorized `foo`.
@@ -371,9 +362,9 @@ export function testProtocolUpdateAction() {
             // 4. Verify that Bob can update his `foo`.
             //   4a. Sanity verify that the update took effect by reading the record back.
             // 5. Verify that Bob cannot update Carol's `foo`.
-            const alice = yield TestDataGenerator.generateDidKeyPersona();
-            const bob = yield TestDataGenerator.generateDidKeyPersona();
-            const carol = yield TestDataGenerator.generateDidKeyPersona();
+            const alice = await TestDataGenerator.generateDidKeyPersona();
+            const bob = await TestDataGenerator.generateDidKeyPersona();
+            const carol = await TestDataGenerator.generateDidKeyPersona();
             // 1. Alice installs a protocol with "author of an anyone-authorized create can update" rule.
             const protocolDefinition = {
                 protocol: 'foo',
@@ -392,15 +383,15 @@ export function testProtocolUpdateAction() {
                     }
                 }
             };
-            const protocolsConfig = yield ProtocolsConfigure.create({
+            const protocolsConfig = await ProtocolsConfigure.create({
                 definition: protocolDefinition,
                 signer: Jws.createSigner(alice)
             });
-            const protocolsConfigureReply = yield dwn.processMessage(alice.did, protocolsConfig.message);
+            const protocolsConfigureReply = await dwn.processMessage(alice.did, protocolsConfig.message);
             expect(protocolsConfigureReply.status.code).toBe(202);
             // 2. Bob creates an anyone-authorized `foo`.
             const bobFooBytes = TestDataGenerator.randomBytes(100);
-            const bobAnyoneAuthorizedFoo = yield RecordsWrite.create({
+            const bobAnyoneAuthorizedFoo = await RecordsWrite.create({
                 signer: Jws.createSigner(bob),
                 protocol: protocolDefinition.protocol,
                 protocolPath: 'foo',
@@ -408,11 +399,11 @@ export function testProtocolUpdateAction() {
                 dataFormat: 'any-format',
                 data: bobFooBytes
             });
-            const bobAnyoneAuthorizedFooReply = yield dwn.processMessage(alice.did, bobAnyoneAuthorizedFoo.message, { dataStream: DataStream.fromBytes(bobFooBytes) });
+            const bobAnyoneAuthorizedFooReply = await dwn.processMessage(alice.did, bobAnyoneAuthorizedFoo.message, { dataStream: DataStream.fromBytes(bobFooBytes) });
             expect(bobAnyoneAuthorizedFooReply.status.code).toBe(202);
             // 3. Carol creates a anyone-authorized `foo`.
             const carolFooBytes = TestDataGenerator.randomBytes(100);
-            const carolAnyoneAuthorizedFoo = yield RecordsWrite.create({
+            const carolAnyoneAuthorizedFoo = await RecordsWrite.create({
                 signer: Jws.createSigner(carol),
                 protocol: protocolDefinition.protocol,
                 protocolPath: 'foo',
@@ -420,46 +411,46 @@ export function testProtocolUpdateAction() {
                 dataFormat: 'any-format',
                 data: carolFooBytes
             });
-            const carolAnyoneAuthorizedFooReply = yield dwn.processMessage(alice.did, carolAnyoneAuthorizedFoo.message, { dataStream: DataStream.fromBytes(carolFooBytes) });
+            const carolAnyoneAuthorizedFooReply = await dwn.processMessage(alice.did, carolAnyoneAuthorizedFoo.message, { dataStream: DataStream.fromBytes(carolFooBytes) });
             expect(carolAnyoneAuthorizedFooReply.status.code).toBe(202);
             // 4. Verify that Bob can update his `foo`.
             const bobFooNewBytes = TestDataGenerator.randomBytes(100);
-            const bobAuthorizedFooUpdate = yield RecordsWrite.createFrom({
+            const bobAuthorizedFooUpdate = await RecordsWrite.createFrom({
                 recordsWriteMessage: bobAnyoneAuthorizedFoo.message,
                 data: bobFooNewBytes,
                 signer: Jws.createSigner(bob)
             });
-            const bobAuthorizedFooUpdateReply = yield dwn.processMessage(alice.did, bobAuthorizedFooUpdate.message, { dataStream: DataStream.fromBytes(bobFooNewBytes) });
+            const bobAuthorizedFooUpdateReply = await dwn.processMessage(alice.did, bobAuthorizedFooUpdate.message, { dataStream: DataStream.fromBytes(bobFooNewBytes) });
             expect(bobAuthorizedFooUpdateReply.status.code).toBe(202);
             //   4a. Sanity verify that the update took effect by reading the record back.
-            const bobBarRead = yield RecordsRead.create({
+            const bobBarRead = await RecordsRead.create({
                 filter: {
                     recordId: bobAnyoneAuthorizedFoo.message.recordId
                 },
                 signer: Jws.createSigner(alice)
             });
-            const bobFooReadReply = yield dwn.processMessage(alice.did, bobBarRead.message);
+            const bobFooReadReply = await dwn.processMessage(alice.did, bobBarRead.message);
             expect(bobFooReadReply.status.code).toBe(200);
             expect(bobFooReadReply.entry.data).toBeDefined();
-            const dataFromBobFooRead = yield DataStream.toBytes(bobFooReadReply.entry.data);
+            const dataFromBobFooRead = await DataStream.toBytes(bobFooReadReply.entry.data);
             expect(dataFromBobFooRead).toEqual(bobFooNewBytes);
             // 5. Verify that Bob cannot update Carol's `foo`.
-            const bobUnauthorizedBarUpdate = yield RecordsWrite.createFrom({
+            const bobUnauthorizedBarUpdate = await RecordsWrite.createFrom({
                 recordsWriteMessage: carolAnyoneAuthorizedFoo.message,
                 data: bobFooNewBytes,
                 signer: Jws.createSigner(bob)
             });
-            const bobUnauthorizedFooUpdateReply = yield dwn.processMessage(alice.did, bobUnauthorizedBarUpdate.message, { dataStream: DataStream.fromBytes(bobFooNewBytes) });
+            const bobUnauthorizedFooUpdateReply = await dwn.processMessage(alice.did, bobUnauthorizedBarUpdate.message, { dataStream: DataStream.fromBytes(bobFooNewBytes) });
             expect(bobUnauthorizedFooUpdateReply.status.code).toBe(401);
             expect(bobUnauthorizedFooUpdateReply.status.detail).toContain(DwnErrorCode.ProtocolAuthorizationActionNotAllowed);
-        }));
-        it('should fail an update to an non-existent record', () => __awaiter(this, void 0, void 0, function* () {
+        });
+        it('should fail an update to an non-existent record', async () => {
             // Scenario:
             // 1. Alice installs a protocol with "author of an anyone-authorized create can update" rules.
             // 2. Bob constructs an anyone-authorized `foo` but never sent it to the DWN.
             // 3. Verify that Bob cannot update a `foo` that does not exist in the DWN.
-            const alice = yield TestDataGenerator.generateDidKeyPersona();
-            const bob = yield TestDataGenerator.generateDidKeyPersona();
+            const alice = await TestDataGenerator.generateDidKeyPersona();
+            const bob = await TestDataGenerator.generateDidKeyPersona();
             // 1. Alice installs a protocol with "author of an anyone-authorized create can update" rule.
             const protocolDefinition = {
                 protocol: 'foo',
@@ -478,15 +469,15 @@ export function testProtocolUpdateAction() {
                     }
                 }
             };
-            const protocolsConfig = yield ProtocolsConfigure.create({
+            const protocolsConfig = await ProtocolsConfigure.create({
                 definition: protocolDefinition,
                 signer: Jws.createSigner(alice)
             });
-            const protocolsConfigureReply = yield dwn.processMessage(alice.did, protocolsConfig.message);
+            const protocolsConfigureReply = await dwn.processMessage(alice.did, protocolsConfig.message);
             expect(protocolsConfigureReply.status.code).toBe(202);
             // 2. Bob constructs an anyone-authorized `foo` but never sent it to the DWN.
             const bobFooBytes = TestDataGenerator.randomBytes(100);
-            const bobAnyoneAuthorizedFoo = yield RecordsWrite.create({
+            const bobAnyoneAuthorizedFoo = await RecordsWrite.create({
                 signer: Jws.createSigner(bob),
                 protocol: protocolDefinition.protocol,
                 protocolPath: 'foo',
@@ -496,16 +487,16 @@ export function testProtocolUpdateAction() {
             });
             // 3. Verify that Bob cannot update a `foo` that does not exist in the DWN.
             const bobFooNewBytes = TestDataGenerator.randomBytes(100);
-            const bobAuthorizedFooUpdate = yield RecordsWrite.createFrom({
+            const bobAuthorizedFooUpdate = await RecordsWrite.createFrom({
                 recordsWriteMessage: bobAnyoneAuthorizedFoo.message,
                 data: bobFooNewBytes,
                 signer: Jws.createSigner(bob)
             });
-            const bobAuthorizedFooUpdateReply = yield dwn.processMessage(alice.did, bobAuthorizedFooUpdate.message, { dataStream: DataStream.fromBytes(bobFooNewBytes) });
+            const bobAuthorizedFooUpdateReply = await dwn.processMessage(alice.did, bobAuthorizedFooUpdate.message, { dataStream: DataStream.fromBytes(bobFooNewBytes) });
             expect(bobAuthorizedFooUpdateReply.status.code).toBe(401);
             expect(bobAuthorizedFooUpdateReply.status.detail).toContain(DwnErrorCode.ProtocolAuthorizationActionNotAllowed);
-        }));
-        it('should not allow creation of a protocol definition with action rule containing `update` without `create`', () => __awaiter(this, void 0, void 0, function* () {
+        });
+        it('should not allow creation of a protocol definition with action rule containing `update` without `create`', async () => {
             const protocolDefinition = {
                 protocol: 'foo',
                 published: true,
@@ -523,14 +514,14 @@ export function testProtocolUpdateAction() {
                     }
                 }
             };
-            const alice = yield TestDataGenerator.generateDidKeyPersona();
+            const alice = await TestDataGenerator.generateDidKeyPersona();
             const protocolsConfigureCreatePromise = ProtocolsConfigure.create({
                 definition: protocolDefinition,
                 signer: Jws.createSigner(alice)
             });
-            yield expect(protocolsConfigureCreatePromise).rejects.toThrow(DwnErrorCode.ProtocolsConfigureInvalidActionUpdateWithoutCreate);
-        }));
-        it('should reject ProtocolsConfigure with action rule containing `update` action without `create` during processing', () => __awaiter(this, void 0, void 0, function* () {
+            await expect(protocolsConfigureCreatePromise).rejects.toThrow(DwnErrorCode.ProtocolsConfigureInvalidActionUpdateWithoutCreate);
+        });
+        it('should reject ProtocolsConfigure with action rule containing `update` action without `create` during processing', async () => {
             const protocolDefinition = {
                 protocol: 'http://foo',
                 published: true,
@@ -555,16 +546,16 @@ export function testProtocolUpdateAction() {
                 messageTimestamp: Time.getCurrentTimestamp(),
                 definition: protocolDefinition
             };
-            const alice = yield TestDataGenerator.generateDidKeyPersona();
-            const authorization = yield Message.createAuthorization({
+            const alice = await TestDataGenerator.generateDidKeyPersona();
+            const authorization = await Message.createAuthorization({
                 descriptor,
                 signer: Jws.createSigner(alice)
             });
             const protocolsConfigureMessage = { descriptor, authorization };
-            const protocolsConfigureReply = yield dwn.processMessage(alice.did, protocolsConfigureMessage);
+            const protocolsConfigureReply = await dwn.processMessage(alice.did, protocolsConfigureMessage);
             expect(protocolsConfigureReply.status.code).toBe(400);
             expect(protocolsConfigureReply.status.detail).toContain(DwnErrorCode.ProtocolsConfigureInvalidActionUpdateWithoutCreate);
-        }));
+        });
     });
 }
 //# sourceMappingURL=protocol-update-action.spec.js.map