github.com/kaleido-io/firefly@v0.0.0-20210622132723-8b4b6aacb971/kat/src/test/ethereum/assets/unauthored/public/described-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 { testDescription, 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 testUnauthoredPublicDescribedStructured = () => {
    24  
    25  describe('Assets: unauthored - public - described - structured', async () => {
    26  
    27    const assetDefinitionID = 'cb289f68-5eaf-46d2-9be1-3dcfdde76885';
    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        const eventPromise = new Promise<void>((resolve) => {
    35          mockEventStreamWebSocket.once('send', message => {
    36            assert.strictEqual(message, '{"type":"ack","topic":"dev"}');
    37            resolve();
    38          })
    39        });
    40        nock('https://ipfs.kaleido.io')
    41          .get('/ipfs/Qma49mzceUqCmZrBsFAzC26XnwT1gVzhTBkby2JZsYiaUF')
    42          .reply(200, {
    43            assetDefinitionID: assetDefinitionID,
    44            name: 'unauthored - public - described - structured',
    45            isContentPrivate: false,
    46            isContentUnique: true,
    47            descriptionSchema: testDescription.schema.object,
    48            contentSchema: testContent.schema.object
    49          });
    50  
    51        const data: IEventAssetDefinitionCreated = {
    52          author: '0x0000000000000000000000000000000000000002',
    53          assetDefinitionHash: '0xae123c4d3b9e77716be55ea8ad616b74ac67c455951698f4e40f22e1ed7981e8',
    54          timestamp: timestamp.toString()
    55        };
    56        mockEventStreamWebSocket.emit('message', JSON.stringify([{
    57          signature: utils.contractEventSignatures.ASSET_DEFINITION_CREATED,
    58          data,
    59          blockNumber: '123',
    60          transactionHash: '0x0000000000000000000000000000000000000000000000000000000000000000'
    61        }]));
    62        await eventPromise;
    63      });
    64  
    65      it('Checks that the asset definition is confirmed', async () => {
    66        const getAssetDefinitionsResponse = await request(app)
    67          .get('/api/v1/assets/definitions')
    68          .expect(200);
    69        const assetDefinition = getAssetDefinitionsResponse.body.find((assetDefinition: IDBAssetDefinition) => assetDefinition.name === 'unauthored - public - described - structured');
    70        assert.strictEqual(assetDefinition.assetDefinitionID, assetDefinitionID);
    71        assert.strictEqual(assetDefinition.author, '0x0000000000000000000000000000000000000002');
    72        assert.strictEqual(assetDefinition.isContentPrivate, false);
    73        assert.deepStrictEqual(assetDefinition.descriptionSchema, testDescription.schema.object);
    74        assert.deepStrictEqual(assetDefinition.contentSchema, testContent.schema.object);
    75        assert.strictEqual(assetDefinition.name, 'unauthored - public - described - structured');
    76        assert.strictEqual(assetDefinition.timestamp, timestamp);
    77        assert.strictEqual(assetDefinition.submitted, undefined);
    78        assert.strictEqual(assetDefinition.receipt, undefined);
    79        assert.strictEqual(assetDefinition.blockNumber, 123);
    80        assert.strictEqual(assetDefinition.transactionHash, '0x0000000000000000000000000000000000000000000000000000000000000000');
    81  
    82        const getAssetDefinitionResponse = await request(app)
    83        .get(`/api/v1/assets/definitions/${assetDefinitionID}`)
    84        .expect(200);
    85        assert.deepStrictEqual(assetDefinition, getAssetDefinitionResponse.body);
    86      });
    87  
    88    });
    89  
    90    describe('Asset instances', async () => {
    91  
    92      const assetInstanceID = '9e8acd3b-4067-443f-ad6e-739976bc63ee';
    93  
    94      it('Checks that the event stream notification for confirming the asset instance creation is handled', async () => {
    95  
    96        nock('https://ipfs.kaleido.io')
    97        .get(`/ipfs/${testDescription.sample.ipfsMultiHash}`)
    98        .reply(200, testDescription.sample.object)
    99        .get(`/ipfs/${testContent.sample.ipfsMultiHash}`)
   100        .reply(200, testContent.sample.object)
   101  
   102        const eventPromise = new Promise<void>((resolve) => {
   103          mockEventStreamWebSocket.once('send', message => {
   104            assert.strictEqual(message, '{"type":"ack","topic":"dev"}');
   105            resolve();
   106          })
   107        });
   108        const data: IEventAssetInstanceCreated = {
   109          assetDefinitionID: utils.uuidToHex(assetDefinitionID),
   110          author: '0x0000000000000000000000000000000000000002',
   111          assetInstanceID: utils.uuidToHex(assetInstanceID),
   112          descriptionHash: testDescription.sample.ipfsSha256,
   113          contentHash: testContent.sample.ipfsSha256,
   114          timestamp: timestamp.toString(),
   115          isContentPrivate: false
   116        };
   117        mockEventStreamWebSocket.emit('message', JSON.stringify([{
   118          signature: utils.contractEventSignatures.DESCRIBED_ASSET_INSTANCE_CREATED,
   119          data,
   120          blockNumber: '123',
   121          transactionHash: '0x0000000000000000000000000000000000000000000000000000000000000000'
   122        }]));
   123        await eventPromise;
   124      });
   125  
   126      it('Checks that the asset instance is confirmed', async () => {
   127        const getAssetInstancesResponse = await request(app)
   128          .get(`/api/v1/assets/${assetDefinitionID}`)
   129          .expect(200);
   130        const assetInstance = getAssetInstancesResponse.body.find((assetInstance: IDBAssetInstance) => assetInstance.assetInstanceID === assetInstanceID);
   131        assert.strictEqual(assetInstance.author, '0x0000000000000000000000000000000000000002');
   132        assert.strictEqual(assetInstance.assetDefinitionID, assetDefinitionID);
   133        assert.strictEqual(assetInstance.descriptionHash, testDescription.sample.ipfsSha256);
   134        assert.deepStrictEqual(assetInstance.description, testDescription.sample.object);
   135        assert.strictEqual(assetInstance.contentHash, testContent.sample.ipfsSha256);
   136        assert.deepStrictEqual(assetInstance.content, testContent.sample.object);
   137        assert.strictEqual(assetInstance.submitted, undefined);
   138        assert.strictEqual(assetInstance.receipt, undefined);
   139        assert.strictEqual(assetInstance.timestamp, timestamp);
   140        assert.strictEqual(assetInstance.blockNumber, 123);
   141        assert.strictEqual(assetInstance.transactionHash, '0x0000000000000000000000000000000000000000000000000000000000000000');
   142  
   143        const getAssetInstanceResponse = await request(app)
   144          .get(`/api/v1/assets/${assetDefinitionID}/${assetInstanceID}`)
   145          .expect(200);
   146        assert.deepStrictEqual(assetInstance, getAssetInstanceResponse.body);
   147      });
   148  
   149    });
   150  
   151  });
   152  };