github.com/kaleido-io/firefly@v0.0.0-20210622132723-8b4b6aacb971/kat/src/test/ethereum/assets/authored/public/described-unstructured.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 nock from 'nock';
    17  import request from 'supertest';
    18  import assert from 'assert';
    19  import { IDBAssetDefinition, IEventAssetDefinitionCreated } from '../../../../../lib/interfaces';
    20  import * as utils from '../../../../../lib/utils';
    21  import { testDescription } from '../../../../samples';
    22  
    23  export const testAuthoredPublicDescribedUnstructured = () => {
    24  
    25  describe('Asset definitions: authored - public - described - unstructured', async () => {
    26  
    27    let assetDefinitionID: string;
    28    const assetDefinitionName = 'authored - public - described - unstructured';
    29  
    30    describe('Create asset definition', () => {
    31  
    32      const timestamp = utils.getTimestamp();
    33  
    34      it('Checks that the asset definition can be added', async () => {
    35  
    36        nock('https://apigateway.kaleido.io')
    37          .post('/createAssetDefinition?kld-from=0x0000000000000000000000000000000000000001&kld-sync=false')
    38          .reply(200, { id: 'my-receipt-id' });
    39  
    40        nock('https://ipfs.kaleido.io')
    41          .post('/api/v0/add')
    42          .reply(200, { Hash: 'QmedsLGSbtuo3GsNjh2F4u2nDpNyjVSTkYGet9KtG1WCY5' });
    43  
    44        const result = await request(app)
    45          .post('/api/v1/assets/definitions')
    46          .send({
    47            name: assetDefinitionName,
    48            author: '0x0000000000000000000000000000000000000001',
    49            isContentPrivate: false,
    50            isContentUnique: true,
    51            descriptionSchema: testDescription.schema.object
    52          })
    53          .expect(200);
    54        assert.deepStrictEqual(result.body.status, 'submitted');
    55        assetDefinitionID = result.body.assetDefinitionID;
    56  
    57        const getAssetDefinitionsResponse = await request(app)
    58          .get('/api/v1/assets/definitions')
    59          .expect(200);
    60        const assetDefinition = getAssetDefinitionsResponse.body.find((assetDefinition: IDBAssetDefinition) => assetDefinition.name === 'authored - public - described - unstructured');
    61        assert.strictEqual(assetDefinition.assetDefinitionID, assetDefinitionID);
    62        assert.strictEqual(assetDefinition.author, '0x0000000000000000000000000000000000000001');
    63        assert.strictEqual(assetDefinition.isContentPrivate, false);
    64        assert.strictEqual(assetDefinition.isContentUnique, true);
    65        assert.deepStrictEqual(assetDefinition.descriptionSchema, testDescription.schema.object);
    66        assert.strictEqual(assetDefinition.name, 'authored - public - described - unstructured');
    67        assert.strictEqual(assetDefinition.receipt, 'my-receipt-id');
    68        assert.strictEqual(typeof assetDefinition.submitted, 'number');
    69      });
    70  
    71      it('Checks that the event stream notification for confirming the asset definition creation is handled', async () => {
    72        const eventPromise = new Promise<void>((resolve) => {
    73          mockEventStreamWebSocket.once('send', message => {
    74            assert.strictEqual(message, '{"type":"ack","topic":"dev"}');
    75            resolve();
    76          })
    77        });
    78  
    79        nock('https://ipfs.kaleido.io')
    80          .get('/ipfs/QmedsLGSbtuo3GsNjh2F4u2nDpNyjVSTkYGet9KtG1WCY5')
    81          .reply(200, {
    82            assetDefinitionID: assetDefinitionID,
    83            name: assetDefinitionName,
    84            isContentPrivate: false,
    85            isContentUnique: true,
    86            descriptionSchema: testDescription.schema.object
    87          });
    88  
    89        const data: IEventAssetDefinitionCreated = {
    90          author: '0x0000000000000000000000000000000000000001',
    91          assetDefinitionHash: '0xf22423517fb1783b6b1e913f3915fa3215396000412d3420204b1394ab31e03e',
    92          timestamp: timestamp.toString()
    93        };
    94        mockEventStreamWebSocket.emit('message', JSON.stringify([{
    95          signature: utils.contractEventSignatures.ASSET_DEFINITION_CREATED,
    96          data,
    97          blockNumber: '123',
    98          transactionHash: '0x0000000000000000000000000000000000000000000000000000000000000000'
    99        }]));
   100        await eventPromise;
   101      });
   102  
   103      it('Checks that the asset definition is confirmed', async () => {
   104        const getAssetDefinitionsResponse = await request(app)
   105          .get('/api/v1/assets/definitions')
   106          .expect(200);
   107        const assetDefinition = getAssetDefinitionsResponse.body.find((assetDefinition: IDBAssetDefinition) => assetDefinition.name === 'authored - public - described - unstructured');
   108        assert.strictEqual(assetDefinition.assetDefinitionID, assetDefinitionID);
   109        assert.strictEqual(assetDefinition.author, '0x0000000000000000000000000000000000000001');
   110        assert.strictEqual(assetDefinition.isContentPrivate, false);
   111        assert.strictEqual(assetDefinition.isContentUnique, true);
   112        assert.deepStrictEqual(assetDefinition.descriptionSchema, testDescription.schema.object);
   113        assert.strictEqual(assetDefinition.name, 'authored - public - described - unstructured');
   114        assert.strictEqual(typeof assetDefinition.submitted, 'number');
   115        assert.strictEqual(assetDefinition.timestamp, timestamp);
   116        assert.strictEqual(assetDefinition.receipt, 'my-receipt-id');
   117        assert.strictEqual(assetDefinition.blockNumber, 123);
   118        assert.strictEqual(assetDefinition.transactionHash, '0x0000000000000000000000000000000000000000000000000000000000000000');
   119  
   120        const getAssetDefinitionResponse = await request(app)
   121          .get(`/api/v1/assets/definitions/${assetDefinitionID}`)
   122          .expect(200);
   123        assert.deepStrictEqual(assetDefinition, getAssetDefinitionResponse.body);
   124      });
   125  
   126    });
   127  
   128  });
   129  };