Testing the blockchain application

import { testing, codec, cryptography, Transaction, chain, db, VerifyStatus } from 'klayr-sdk';
import { CreateHelloCommand } from '../../../../../src/app/modules/hello/commands/create_hello_command';
import { CreateHelloParams, createHelloSchema } from '../../../../../src/app/modules/hello/schema';
import { ModuleConfig } from '../../../../../src/app/modules/hello/types';
import { HelloModule } from '../../../../../src/app/modules/hello/module';
import { CounterStore, counterKey } from '../../../../../src/app/modules/hello/stores/counter';
import { MessageStore } from '../../../../../src/app/modules/hello/stores/message';

public async verify(context: CommandVerifyContext<Params>): Promise<VerificationResult> {
    const wordList = context.params.message.split(" ");
    const found = this._blacklist.filter(value => wordList.includes(value));
    if (found.length > 0) {
        context.logger.info("==== FOUND: Message contains a blacklisted word ====");
        const error = Error(
            `Illegal word in hello message: ${found.toString()}`
        );
        return {
            status: VerifyStatus.FAIL,
            error,
        };
    }
    context.logger.info("==== NOT FOUND: Message contains no blacklisted words ====");
    return {
        status: VerifyStatus.OK
    };
}

describe('verify', () => {
    it('should have an illegal message', async () => {
        const illegalParam = codec.encode(createHelloSchema, { 'message': "badWord2" })
        const transaction = new Transaction(getSampleTransaction(illegalParam));

        const context = testing
            .createTransactionContext({
                stateStore,
                transaction,
                header: testing.createFakeBlockHeader({}),
            })
            .createCommandVerifyContext<CreateHelloParams>(createHelloSchema);

        const result = await command.verify(context);
        expect(result.status).toBe(VerifyStatus.FAIL);
    });

    it('should have a legal message', async () => {
        const legalParam = codec.encode(createHelloSchema, { 'message': "Hello Klayr v6 " })
        const transaction = new Transaction(getSampleTransaction(legalParam));

        const context = testing
            .createTransactionContext({
                stateStore,
                transaction,
                header: testing.createFakeBlockHeader({}),
            })
            .createCommandVerifyContext<CreateHelloParams>(createHelloSchema);

        const result = await command.verify(context);
        expect(result.status).toBe(VerifyStatus.OK);
    });
});

public async execute(context: CommandExecuteContext<Params>): Promise<void> {
    // 1. Get the account data of the sender of the Hello transaction.
    const { senderAddress } = context.transaction;
    // 2. Get message and counter stores.
    const messageSubstore = this.stores.get(MessageStore);
    const counterSubstore = this.stores.get(CounterStore);

    // 3. Save the Hello message to the message store, using the senderAddress as the key, and the message as value.
    await messageSubstore.set(context, senderAddress, {
        message: context.params.message,
    });

    // 3. Get the Hello counter from the counter store.
    let helloCounter: CounterStoreData;
    try {
        helloCounter = await counterSubstore.get(context, counterKey);
    } catch (error) {
        helloCounter = {
            counter: 0,
        }
    }
    // 5. Increment the Hello counter +1.
    helloCounter.counter += 1;

    // 6. Save the Hello counter to the counter store.
    await counterSubstore.set(context, counterKey, helloCounter);

    // 7. Emit a "New Hello" event
    const newHelloEvent = this.events.get(NewHelloEvent);
    newHelloEvent.add(context, {
        senderAddress: context.transaction.senderAddress,
        message: context.params.message
    }, [context.transaction.senderAddress]);
}

describe('CreateHelloCommand', () => {

	const getSampleTransaction = (params: Buffer) => ({
		module: 'hello',
		command: CreateHelloCommand.name,
		senderPublicKey: Buffer.from("3bb9a44b71c83b95045486683fc198fe52dcf27b55291003590fcebff0a45d9a", 'hex'),
		nonce: BigInt(0),
		fee: BigInt(100000000),
		params,
		signatures: [cryptography.utils.getRandomBytes(64)],
	});

	let command: CreateHelloCommand;
	let stateStore: any;
	let counterStore: CounterStore;
	let messageStore: MessageStore;

	const config = {
		"blacklist": [
			"illegalWord1",
			"badWord2",
			"censoredWord3"
		]
	}

	beforeEach(async () => {
		const hello = new HelloModule();
		command = new CreateHelloCommand(hello.stores, hello.events);
		await command.init(config as ModuleConfig);
		stateStore = new chain.StateStore(new db.InMemoryDatabase());
		counterStore = hello.stores.get(CounterStore);
		messageStore = hello.stores.get(MessageStore);
	});
});

describe('execute', () => {
    it('should execute legal message', async () => {
        const message = { "message": "Hello from SDK!" };
        const params = codec.encode(createHelloSchema, message)
        const transaction = new Transaction(getSampleTransaction(params));

        const context = testing
            .createTransactionContext({
                stateStore,
                transaction,
                header: testing.createFakeBlockHeader({}),
            })
            .createCommandExecuteContext<CreateHelloParams>(createHelloSchema);

        await command.execute(context);
        const helloMessage = await messageStore.get(context, transaction.senderAddress);
        const helloCounter = await counterStore.get(context, counterKey);
        expect(helloCounter.counter).toBe(1);
        expect(helloMessage.message).toBe("Hello from SDK!");
    });

    it('should test counter value', async () => {
        const message = { "message": "Hello from SDK!" };
        const params = codec.encode(createHelloSchema, message)
        const transaction = new Transaction(getSampleTransaction(params));

        const context = testing
            .createTransactionContext({
                stateStore,
                transaction,
                header: testing.createFakeBlockHeader({}),
            })
            .createCommandExecuteContext<CreateHelloParams>(createHelloSchema);
        await counterStore.set(context, counterKey, { "counter": 10 })
        await command.execute(context);
        const helloMessage = await messageStore.get(context, transaction.senderAddress);
        const helloCounter = await counterStore.get(context, counterKey);
        expect(helloCounter.counter).toBe(11);
        expect(helloMessage.message).toBe("Hello from SDK!");
    });
});