github.com/kaleido-io/firefly@v0.0.0-20210622132723-8b4b6aacb971/kat/src/test/ethereum/assets/unauthored/private/structured.ts (about)

     1  // Copyright © 2021 Kaleido, Inc.
     2  //
     3  // Licensed under the Apache License, Version 2.0 (the "License");
     4  // you may not use this file except in compliance with the License.
     5  // You may obtain a copy of the License at
     6  //
     7  //     http://www.apache.org/licenses/LICENSE-2.0
     8  //
     9  // Unless required by applicable law or agreed to in writing, software
    10  // distributed under the License is distributed on an "AS IS" BASIS,
    11  // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
    12  // See the License for the specific language governing permissions and
    13  // limitations under the License.
    14  
    15  import { app, mockEventStreamWebSocket } from '../../../../common';
    16  import { testContent } from '../../../../samples';
    17  import nock from 'nock';
    18  import request from 'supertest';
    19  import assert from 'assert';
    20  import { IEventAssetDefinitionCreated, IDBAssetDefinition, IEventAssetInstanceCreated, IDBAssetInstance } from '../../../../../lib/interfaces';
    21  import * as utils from '../../../../../lib/utils';
    22  
    23  export const testUnauthoredPrivateStructured = () => {
    24  
    25  describe('Assets: unauthored - private - structured', async () => {
    26  
    27    const assetDefinitionID = '02d7cbbf-aa9e-4724-a645-86edf4572ff3';
    28    const timestamp = utils.getTimestamp();
    29  
    30    describe('Asset definition', async () => {
    31  
    32      it('Checks that the event stream notification for confirming the asset definition creation is handled', async () => {
    33  
    34        nock('https://ipfs.kaleido.io')
    35          .get('/ipfs/QmUsjZyav8UhEvK41EGCgntbfGJT3fQx5KRzFw8uCFhqTe')
    36          .reply(200, {
    37            assetDefinitionID: assetDefinitionID,
    38            name: 'unauthored - private - structured',
    39            isContentPrivate: true,
    40            isContentUnique: true,
    41            contentSchema: testContent.schema.object,
    42          });
    43  
    44        const eventPromise = new Promise<void>((resolve) => {
    45          mockEventStreamWebSocket.once('send', message => {
    46            assert.strictEqual(message, '{"type":"ack","topic":"dev"}');
    47            resolve();
    48          })
    49        });
    50        const data: IEventAssetDefinitionCreated = {
    51          author: '0x0000000000000000000000000000000000000002',
    52          assetDefinitionHash: '0x611c9f2515ec393c0fd9cacaf51caff2a4462b6d0571b2b5600dc7ea961b8c49',
    53          timestamp: timestamp.toString()
    54        };
    55        mockEventStreamWebSocket.emit('message', JSON.stringify([{
    56          signature: utils.contractEventSignatures.ASSET_DEFINITION_CREATED,
    57          data,
    58          blockNumber: '123',
    59          transactionHash: '0x0000000000000000000000000000000000000000000000000000000000000000'
    60        }]));
    61        await eventPromise;
    62      });
    63  
    64      it('Checks that the asset definition is confirmed', async () => {
    65        const getAssetDefinitionsResponse = await request(app)
    66          .get('/api/v1/assets/definitions')
    67          .expect(200);
    68        const assetDefinition = getAssetDefinitionsResponse.body.find((assetDefinition: IDBAssetDefinition) => assetDefinition.name === 'unauthored - private - structured');
    69        assert.strictEqual(assetDefinition.assetDefinitionID, assetDefinitionID);
    70        assert.strictEqual(assetDefinition.author, '0x0000000000000000000000000000000000000002');
    71        assert.deepStrictEqual(assetDefinition.contentSchema, testContent.schema.object);
    72        assert.strictEqual(assetDefinition.isContentPrivate, true);
    73        assert.strictEqual(assetDefinition.name, 'unauthored - private - structured');
    74        assert.strictEqual(assetDefinition.timestamp, timestamp);
    75        assert.strictEqual(assetDefinition.submitted, undefined);
    76        assert.strictEqual(assetDefinition.receipt, undefined);
    77        assert.strictEqual(assetDefinition.blockNumber, 123);
    78        assert.strictEqual(assetDefinition.transactionHash, '0x0000000000000000000000000000000000000000000000000000000000000000');
    79  
    80        const getAssetDefinitionResponse = await request(app)
    81        .get(`/api/v1/assets/definitions/${assetDefinitionID}`)
    82        .expect(200);
    83        assert.deepStrictEqual(assetDefinition, getAssetDefinitionResponse.body);
    84      });
    85  
    86    });
    87  
    88    describe('Asset instances', async () => {
    89  
    90      const assetInstanceID = '9d53cce2-0879-4aaa-9b82-cb30eb6331be';
    91  
    92      it('Checks that the event stream notification for confirming the asset instance creation is handled', async () => {
    93  
    94        const eventPromise = new Promise<void>((resolve) => {
    95          mockEventStreamWebSocket.once('send', message => {
    96            assert.strictEqual(message, '{"type":"ack","topic":"dev"}');
    97            resolve();
    98          })
    99        });
   100        const data: IEventAssetInstanceCreated = {
   101          assetDefinitionID: utils.uuidToHex(assetDefinitionID),
   102          author: '0x0000000000000000000000000000000000000002',
   103          assetInstanceID: utils.uuidToHex(assetInstanceID),
   104          contentHash: testContent.sample.docExchangeSha256,
   105          timestamp: timestamp.toString(),
   106          isContentPrivate: true
   107        };
   108        mockEventStreamWebSocket.emit('message', JSON.stringify([{
   109          signature: utils.contractEventSignatures.DESCRIBED_ASSET_INSTANCE_CREATED,
   110          data,
   111          blockNumber: '123',
   112          transactionHash: '0x0000000000000000000000000000000000000000000000000000000000000000'
   113        }]));
   114        await eventPromise;
   115      });
   116  
   117      it('Checks that the asset instance is confirmed', async () => {
   118        const getAssetInstancesResponse = await request(app)
   119          .get(`/api/v1/assets/${assetDefinitionID}`)
   120          .expect(200);
   121        const assetInstance = getAssetInstancesResponse.body.find((assetInstance: IDBAssetInstance) => assetInstance.assetInstanceID === assetInstanceID);
   122        assert.strictEqual(assetInstance.author, '0x0000000000000000000000000000000000000002');
   123        assert.strictEqual(assetInstance.assetDefinitionID, assetDefinitionID);
   124        assert.strictEqual(assetInstance.contentHash, testContent.sample.docExchangeSha256);
   125        assert.deepStrictEqual(assetInstance.content, undefined);
   126        assert.strictEqual(assetInstance.receipt, undefined);
   127        assert.strictEqual(assetInstance.submitted, undefined);
   128        assert.strictEqual(assetInstance.timestamp, timestamp);
   129        assert.strictEqual(assetInstance.blockNumber, 123);
   130        assert.strictEqual(assetInstance.transactionHash, '0x0000000000000000000000000000000000000000000000000000000000000000');
   131  
   132        const getAssetInstanceResponse = await request(app)
   133          .get(`/api/v1/assets/${assetDefinitionID}/${assetInstanceID}`)
   134          .expect(200);
   135        assert.deepStrictEqual(assetInstance, getAssetInstanceResponse.body);
   136      });
   137  
   138    });
   139  
   140  });
   141  };