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