support light client mock

.github/workflows/ci_light.yml

@@ -0,0 +1,43 @@
+name: ci-light
+
+on:
+  push:
+    branches:
+      - main
+  pull_request:
+
+
+jobs:
+  npm-install-1:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v3
+      - uses: actions/setup-node@v3
+        with:
+          node-version: '16'
+      - name: Get yarn cache directory path
+        id: yarn-cache-dir-path
+        run: echo "::set-output name=dir::$(yarn cache dir)"
+      - name: Node Cache
+        uses: actions/cache@v2
+        id: npm-and-yarn-cache # use this to check for `cache-hit` (`steps.yarn-cache.outputs.cache-hit != 'true'`)
+        with:
+          path: |
+            ${{ steps.yarn-cache-dir-path.outputs.dir }}
+            ~/.npm
+          key: ${{ runner.os }}-node_modules-${{ hashFiles('/home/runner/work/**/package-lock.json', '/home/runner/work/**/yarn.lock') }}
+          restore-keys: |
+            ${{ runner.os }}-node_modules-
+      - name: Run tests
+        id: runtest
+        run: |
+          sh prepare.sh
+          npm install --save-dev mocha @types/mocha chai @types/chai
+          npm run build:lumos
+          npm run test-mock-light
+      - name: Publish reports
+        if: failure()
+        uses: actions/upload-artifact@v2
+        with:
+          name: jfoa-build-reports-${{ runner.os }}
+          path: test-report.html

package.json

@@ -50,6 +50,7 @@
   "scripts": {
     "build:lumos": "cd lumos && pnpm install && pnpm run build",
     "test": "mocha --config test/runners/mocha/.mocharc.jsonc --reporter mochawesome",
-    "test-mock": "jest --verbose ./test/mock"
+    "test-mock": "jest --verbose ./test/mock",
+    "test-mock-light": "jest --verbose ./test/mockLight"
   }
 }

prepare.sh

@@ -1,6 +1,6 @@
 git clone https://github.com/ckb-js/lumos.git
 cd lumos
-git checkout ckb2023
+git checkout develop
 cd ../
 git clone https://github.com/gpBlockchain/ckb-rpc-mock-data.git
 cd ckb-rpc-mock-data
@@ -9,4 +9,10 @@ pip install -r requirements.txt
 pip install Werkzeug==2.2.2
 python3 api/index.py > index.log 2>&1 &
 sleep 5
+cat index.log
+cd ../
+git clone https://github.com/gpBlockchain/ckb-light-client-rpc-mock-data.git
+cd ckb-light-client-rpc-mock-data
+python3 api/index.py > index.log 2>&1 &
+sleep 5
 cat index.log

test/mock/test_util.ts

@@ -1,10 +1,17 @@
 import {RPC} from "@ckb-lumos/rpc";
 import {get} from "../util/util";
+import {LightClientRPC} from "@ckb-lumos/light-client";
 
 export async function mock_rpc(){
     let data = get_method_and_params(expect.getState().currentTestName)
     return get_mock_test_data(data.method,data.params)
 }
+
+export async function mock_light_rpc(){
+    let data = get_method_and_params(expect.getState().currentTestName)
+    return get_mock_light_test_data(data.method,data.params)
+}
+
 async function get_mock_test_data(method: string, params: string) {
 
     let data = await get(`http://127.0.0.1:5000/test/${method}/${params}`)
@@ -15,6 +22,16 @@ async function get_mock_test_data(method: string, params: string) {
 
 }
 
+async function get_mock_light_test_data(method: string, params: string) {
+
+    let data = await get(`http://127.0.0.1:5001/test/${method}/${params}`)
+    let requestData = data['request']
+    let responseData = data['response']
+    let LightRPCClient = new LightClientRPC(`http://127.0.0.1:5001/test/${method}/${params}`);
+    return {LightRPCClient,requestData, responseData}
+
+}
+
 function get_method_and_params(currentTestName: string): { method: string, params: string } {
     let [name, params] = splitFirstSpace(currentTestName)
     return {

test/mockLight/fetch_header.test.ts

@@ -0,0 +1,10 @@
+import {camelCaseToUnderscore, mock_light_rpc} from "../mock/test_util";
+
+describe("fetch_header", function () {
+
+    it("fetched",async ()=>{
+        let {LightRPCClient, requestData, responseData} = await mock_light_rpc()
+        let response = await LightRPCClient.fetchHeader(requestData["params"][0])
+        expect(camelCaseToUnderscore(response)).toEqual(responseData["result"])
+    })
+});

test/mockLight/fetch_transaction.test.ts

@@ -0,0 +1,9 @@
+import {camelCaseToUnderscore, mock_light_rpc} from "../mock/test_util";
+
+describe("fetch_transaction", function () {
+    it("fetched", async () => {
+        let {LightRPCClient, requestData, responseData} = await mock_light_rpc()
+        let response = await LightRPCClient.fetchTransaction(requestData["params"][0])
+        expect(camelCaseToUnderscore(response['transaction'])).toEqual(responseData["result"]['transaction'])
+    })
+});

test/mockLight/get_cells.test.ts

@@ -0,0 +1,34 @@
+import {camelCaseToUnderscore, mock_light_rpc} from "../mock/test_util";
+import {toSearchKey} from "@ckb-lumos/ckb-indexer/lib/resultFormatter";
+
+describe("get_cells", function () {
+
+    it("[search_key,order,limit,after_cursor]", async () => {
+        let {LightRPCClient, requestData, responseData} = await mock_light_rpc()
+
+        let response = await LightRPCClient.getCells(
+            {
+                script: toSearchKey(requestData['params'][0]).script,
+                scriptType: toSearchKey(requestData['params'][0]).scriptType,
+                withData: requestData["params"][0]['with_data']
+            },
+            requestData["params"][1],
+            requestData["params"][2],
+            requestData["params"][3]
+        )
+        expect(camelCaseToUnderscore(response)).toEqual(responseData["result"])
+    })
+    it("[search_key,order,limit,null]", async () => {
+        let {LightRPCClient, requestData, responseData} = await mock_light_rpc()
+        let response = await LightRPCClient.getCells(
+            {
+                script: toSearchKey(requestData['params'][0]).script,
+                scriptType: toSearchKey(requestData['params'][0]).scriptType,
+                withData: requestData["params"][0]['with_data']
+            }, requestData["params"][1],
+            requestData["params"][2]
+        )
+        expect(camelCaseToUnderscore(response)).toEqual(responseData["result"])
+    })
+
+});

test/mockLight/get_cells_capacity.test.ts

@@ -0,0 +1,17 @@
+import {camelCaseToUnderscore, mock_light_rpc, mock_rpc} from "../mock/test_util";
+import {toSearchKey} from "@ckb-lumos/ckb-indexer/lib/resultFormatter";
+
+describe("get_cells_capacity", function () {
+
+    it("[search_key]", async () => {
+        let {LightRPCClient, requestData, responseData} = await mock_light_rpc()
+
+        let response = await LightRPCClient.getCellsCapacity(
+            {
+                script: toSearchKey(requestData['params'][0]).script,
+                scriptType: toSearchKey(requestData['params'][0]).scriptType,
+            }
+        )
+        expect(camelCaseToUnderscore(response)).toEqual(responseData["result"])
+    })
+});

test/mockLight/get_genesis_block.test.ts

@@ -0,0 +1,11 @@
+import {camelCaseToUnderscore, mock_light_rpc} from "../mock/test_util";
+
+describe("get_genesis_block", function () {
+
+    it("[]", async () => {
+        let {LightRPCClient, requestData, responseData} = await mock_light_rpc()
+
+        let response = await LightRPCClient.getGenesisBlock()
+        expect(camelCaseToUnderscore(response)).toEqual(responseData["result"])
+    })
+});

test/mockLight/get_header.test.ts

@@ -0,0 +1,13 @@
+import {camelCaseToUnderscore, mock_light_rpc} from "../mock/test_util";
+
+describe("get_header", function () {
+
+    it("[block_hash]", async () => {
+        let {LightRPCClient, requestData, responseData} = await mock_light_rpc()
+
+        let response = await LightRPCClient.getHeader(
+            requestData["params"][0]
+        )
+        expect(camelCaseToUnderscore(response)).toEqual(responseData["result"])
+    })
+});

test/mockLight/get_peers.test.ts

@@ -0,0 +1,11 @@
+import {camelCaseToUnderscore, mock_light_rpc} from "../mock/test_util";
+
+describe("get_peers", function () {
+
+    it("[]", async () => {
+        let {LightRPCClient, requestData, responseData} = await mock_light_rpc()
+
+        let response = await LightRPCClient.getPeers()
+        expect(camelCaseToUnderscore(response)).toEqual(responseData["result"])
+    })
+});

test/mockLight/get_scripts.test.ts

@@ -0,0 +1,11 @@
+import {camelCaseToUnderscore, mock_light_rpc} from "../mock/test_util";
+
+describe("get_scripts", function () {
+
+    it("[]", async () => {
+        let {LightRPCClient, requestData, responseData} = await mock_light_rpc()
+
+        let response = await LightRPCClient.getScripts()
+        expect(camelCaseToUnderscore(response)).toEqual(responseData["result"])
+    })
+});

test/mockLight/get_tip_header.test.ts

@@ -0,0 +1,10 @@
+import {camelCaseToUnderscore, mock_light_rpc} from "../mock/test_util";
+
+describe("get_tip_header", function () {
+
+    it("[]", async () => {
+        let {LightRPCClient, requestData, responseData} = await mock_light_rpc()
+        let response = await LightRPCClient.getTipHeader()
+        expect(camelCaseToUnderscore(response)).toEqual(responseData["result"])
+    })
+});

test/mockLight/get_transaction.test.ts

@@ -0,0 +1,10 @@
+import {camelCaseToUnderscore, mock_light_rpc} from "../mock/test_util";
+
+describe("get_transaction", function () {
+
+    it("[transaction_hash]", async () => {
+        let {LightRPCClient, requestData, responseData} = await mock_light_rpc()
+        let response = await LightRPCClient.getTransaction(requestData["params"][0])
+        expect(camelCaseToUnderscore(response)).toEqual(responseData["result"])
+    })
+});

test/mockLight/get_transactions.test.ts

@@ -0,0 +1,30 @@
+import {camelCaseToUnderscore, mock_light_rpc} from "../mock/test_util";
+import {toSearchKey} from "@ckb-lumos/ckb-indexer/lib/resultFormatter";
+
+describe("get_transactions", function () {
+
+    it("groupedTxWithCells:js", async () => {
+        let {LightRPCClient, requestData, responseData} = await mock_light_rpc()
+        let response = await LightRPCClient.getTransactions(
+            {
+                script: toSearchKey(requestData['params'][0]).script,
+                scriptType: toSearchKey(requestData['params'][0]).scriptType,
+                groupByTransaction: true,
+            }, requestData['params'][1], requestData['params'][2]
+        )
+        console.log(response.objects)
+        expect(camelCaseToUnderscore(response)).toEqual(responseData["result"])
+    })
+
+    it("ungroupedTxWithCell:js",async ()=>{
+        let {LightRPCClient, requestData, responseData} = await mock_light_rpc()
+        let response = await LightRPCClient.getTransactions(
+            {
+                script: toSearchKey(requestData['params'][0]).script,
+                scriptType: toSearchKey(requestData['params'][0]).scriptType
+            }, requestData['params'][1], requestData['params'][2]
+        )
+        console.log(response.objects)
+        expect(camelCaseToUnderscore(response)).toEqual(responseData["result"])
+    })
+});

test/mockLight/local_node_info.test.ts

@@ -0,0 +1,11 @@
+import {camelCaseToUnderscore, mock_light_rpc} from "../mock/test_util";
+
+describe("local_node_info", function () {
+
+    it("[]", async () => {
+        let {LightRPCClient, requestData, responseData} = await mock_light_rpc()
+
+        let response = await LightRPCClient.localNodeInfo()
+        expect(camelCaseToUnderscore(response)).toEqual(responseData["result"])
+    })
+});

test/mockLight/send_transaction.test.ts

@@ -0,0 +1,12 @@
+import { mock_light_rpc} from "../mock/test_util";
+import {toTransaction} from "@ckb-lumos/rpc/lib/resultFormatter";
+
+describe("send_transaction", function () {
+
+    it("[tx]", async () => {
+        let {LightRPCClient, requestData, responseData} = await mock_light_rpc()
+        let tx = toTransaction(requestData["params"][0])
+        let txHash = await LightRPCClient.sendTransaction(tx)
+        expect(txHash).toEqual(responseData["result"])
+    })
+});

test/mockLight/set_scripts.test.ts

@@ -0,0 +1,48 @@
+import {mock_light_rpc} from "../mock/test_util";
+import {toScript} from "@ckb-lumos/rpc/lib/resultFormatter";
+
+
+
+describe("set_scripts", function () {
+
+    it("[Vec<ScriptStatus>,SetScriptCommand:all]", async () => {
+        let {LightRPCClient, requestData, responseData} = await mock_light_rpc()
+        let setLightScript = requestData["params"][0].map(({script, script_type, block_number}) => ({
+            script: toScript(script),
+            scriptType: script_type,
+            blockNumber: block_number,
+        }));
+        await LightRPCClient.setScripts(setLightScript, requestData["params"][1])
+    })
+    it("[Vec<ScriptStatus>,SetScriptCommand:delete]",async ()=>{
+        let {LightRPCClient, requestData, responseData} = await mock_light_rpc()
+        let setLightScript = requestData["params"][0].map(({script, script_type, block_number}) => ({
+            script: toScript(script),
+            scriptType: script_type,
+            blockNumber: block_number,
+        }));
+        await LightRPCClient.setScripts(setLightScript, requestData["params"][1])
+    })
+
+    it("[Vec<ScriptStatus>,SetScriptCommand:partial]",async ()=>{
+        let {LightRPCClient, requestData, responseData} = await mock_light_rpc()
+        let setLightScript = requestData["params"][0].map(({script, script_type, block_number}) => ({
+            script: toScript(script),
+            scriptType: script_type,
+            blockNumber: block_number,
+        }));
+        await LightRPCClient.setScripts(setLightScript, requestData["params"][1])
+    })
+
+    it("[Vec<ScriptStatus>,null]",async ()=>{
+        let {LightRPCClient, requestData, responseData} = await mock_light_rpc()
+        let setLightScript = requestData["params"][0].map(({script, script_type, block_number}) => ({
+            script: toScript(script),
+            scriptType: script_type,
+            blockNumber: block_number,
+        }));
+        await LightRPCClient.setScripts(setLightScript)
+    })
+
+
+});