suidouble 0.0.10 → 0.0.12

package/lib/SuiPaginatedResponse.js

@@ -21,6 +21,24 @@ class SuiPaginatedResponse extends SuiCommonMethods {
         this._data = [];
     }
 
+    /**
+     * Simple itterator to go over all list of items, not caring about pagination/cursors etc. It fetches next page when needed
+     * Optional maxLimit second parameter to stop when reached count
+     * @param {Function taking single argument of item} callbackFunc 
+     * @param {Number} maxLimit 
+     */
+    async forEach(callbackFunc, maxLimit = null) {
+        let curN = 0;
+        do {
+            for (const item of this._data) {
+                if (!maxLimit || curN < maxLimit) {
+                    await callbackFunc(item);
+                } 
+                curN++;
+            }
+        } while( (!maxLimit || curN < maxLimit) && (await this.nextPage()) );
+    }
+
     get hasNextPage() {
         return this._hasNextPage;
     }

package/lib/SuiTestScenario.js

@@ -21,6 +21,10 @@ class SuiTestScenario extends SuiCommonMethods {
         this._publishedPackageId = null;
     }
 
+    get currentAs() {
+        return this._currentAs;
+    }
+
     /**
      * Start local test validator and set up `as` as owner of package deploy transaction.
      * Package will be deployed with method `init`, as we try to mimic Sui Move's test_scenario

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "suidouble",
-  "version": "0.0.10",
+  "version": "0.0.12",
   "description": "Set of provider, package and object classes for javascript representation of Sui Move smart contracts. Use same code for publishing, upgrading, integration testing, interaction with smart contracts and integration in browser web3 dapps",
   "main": "index.js",
   "scripts": {

package/test/sui_master_onlocal.test.js

@@ -211,6 +211,42 @@ test('execute contract methods', async t => {
     t.equal(responseText, 'ขอบคุณครับ, 🇺🇦');
 });
 
+test('testing paginatedResponse', async t => {
+    const chatTopMessage = contract.objectStorage.findMostRecentByTypeName('ChatTopMessage');
+    t.ok(chatTopMessage);
+
+    // fill method create a lot of responses ( check out contract's code )
+    const moveCallResult = await contract.moveCall('suidouble_chat', 'fill', [chatTopMessage.id, 'the message response', 'metadata']);
+    t.ok(moveCallResult.created.length >= 60); // it's 60 in move code, but let's keep chat flexible
+
+    const eventsResponse = await contract.fetchEvents('suidouble_chat');
+    const idsInEventsDict = {};
+    let responsesInEventsCount = 0;
+    do {
+        for (const event of eventsResponse.data) {
+            if (!idsInEventsDict[event.parsedJson.id]) {
+                idsInEventsDict[event.parsedJson.id] = true;
+                responsesInEventsCount++;
+            }
+        }
+    } while(await eventsResponse.nextPage());
+
+    t.ok(responsesInEventsCount >= 60); // it's 60 in move code, but let's keep chat flexible
+
+    // or using SuiPaginatedResponse forEach itterator:
+    const anotherEventsResponse = await contract.fetchEvents('suidouble_chat');
+    let loopsInForEach = 0;
+    const idsInLoopDict = {};
+    await anotherEventsResponse.forEach(async (event)=>{
+        if (!idsInLoopDict[event.parsedJson.id]) {
+            idsInLoopDict[event.parsedJson.id] = true;
+            loopsInForEach++;
+        }
+    });
+
+    t.ok(loopsInForEach >= 60); // it's 60 in move code, but let's keep chat flexible
+});
+
 test('stops local test node', async t => {
     SuiLocalTestValidator.stop();
 });

package/test/sui_test_scenario.test.js

@@ -0,0 +1,57 @@
+'use strict'
+
+const t = require('tap');
+const { test } = t;
+const path = require('path');
+
+const { SuiTestScenario } = require('..');
+
+let testScenario = null;
+
+test('initialization', async t => {
+    testScenario = new SuiTestScenario({
+        path: path.join(__dirname, './test_move_contracts/suidouble_chat/'),
+        debug: false,
+    });
+
+    await testScenario.begin('admin');
+    await testScenario.init();
+
+    t.equal(testScenario.currentAs, 'admin');
+});
+
+test('checking takeShared', async t => {
+	t.plan(4);
+
+    await testScenario.nextTx('admin', async()=>{
+        const chatShop = testScenario.takeShared('ChatShop');
+
+        t.ok(chatShop.address); // there should be some address
+        t.ok(`${chatShop.address}`.indexOf('0x') === 0); // adress is string starting with '0x'
+
+        await testScenario.moveCall('suidouble_chat', 'post', [chatShop.address, 'posting a message', 'metadata']);
+        const chatTopMessage = testScenario.takeShared('ChatTopMessage');
+
+        t.ok(chatTopMessage.address); // there should be some address
+        t.ok(`${chatTopMessage.address}`.indexOf('0x') === 0); // adress is string starting with '0x'
+    });
+});
+
+test('checking takeOwned', async t => {
+	t.plan(3);
+
+    await testScenario.nextTx('somebody', async()=>{
+        const chatTopMessage = testScenario.takeShared('ChatTopMessage');
+        t.ok(chatTopMessage.address); // there should be some address
+
+        await testScenario.moveCall('suidouble_chat', 'reply', [chatTopMessage.address, 'posting a response', 'metadata']);
+        const chatResponse = testScenario.takeFromSender('ChatResponse');
+
+        t.ok(chatResponse.address); // there should be some address
+        t.ok(`${chatResponse.address}`.indexOf('0x') === 0); // adress is string starting with '0x'
+    });
+})
+
+test('finishing the test scenario', async t => {
+    await testScenario.end();
+});

package/test/test_move_contracts/suidouble_chat/sources/suidouble_chat.move

@@ -80,7 +80,7 @@ module suidouble_chat::suidouble_chat {
     //     chat_response.text
     // }
 
-    /// Mint (post) a chatMessage object without referencing another object.
+    /// Mint (post) a ChatTopMessage object without referencing another object.
     public entry fun post(
         chat_shop: &ChatShop,
         text: vector<u8>,
@@ -115,6 +115,7 @@ module suidouble_chat::suidouble_chat {
         transfer::share_object(chat_top_message);
     }
 
+    /// Mint (post) a ChatResponse object 
     public entry fun reply(
         chat_top_message: &mut ChatTopMessage,
         text: vector<u8>,
@@ -147,6 +148,40 @@ module suidouble_chat::suidouble_chat {
         transfer::transfer(chat_response, tx_context::sender(ctx));
     }
 
+    /// Mint a lot of responses (we need this to unit test SuiPaginatedResponse faster)
+    public entry fun fill(
+        chat_top_message: &mut ChatTopMessage,
+        text: vector<u8>,
+        metadata: vector<u8>,
+        ctx: &mut TxContext,
+    ) {
+        assert!(length(&text) <= MAX_TEXT_LENGTH, ETextOverflow);
+
+        let dynamic_field_exists = dynamic_object_field::exists_(&chat_top_message.id, b"as_chat_response");
+        if (dynamic_field_exists) {
+            let top_level_chat_response = dynamic_object_field::remove<vector<u8>, ChatResponse>(&mut chat_top_message.id, b"as_chat_response");
+            transfer::transfer(top_level_chat_response, chat_top_message.author);
+        };
+
+        let i: u64 = 0;
+
+        while (i < 60) {
+            let id = object::new(ctx);
+
+            emit(ChatResponseCreated { id: object::uid_to_inner(&id), top_message_id: object::uid_to_inner(&chat_top_message.id), seq_n: chat_top_message.responses_count });
+
+            let chat_response = ChatResponse {
+                id: id,
+                chat_top_message_id: object::id(chat_top_message),
+                author: tx_context::sender(ctx),
+                text: text,
+                metadata,
+                seq_n: chat_top_message.responses_count,
+            };
+            transfer::transfer(chat_response, tx_context::sender(ctx));
+            i = i + 1;
+        };
+    }
 
 
     #[test]