wasmite 0.2.1

Wasmite: Webassembly is the future but now it has a testing toolchain

What is the Wasmite project

Since WebAssembly is the future of the web. I decide to create Wasmite, a python package for unit-testing your wasm or wat code. Wasmite is based on wasmer and the python standard library package unittest. Documentation for can be found here: documentation for unittest and documentation for wasmer

This project was formerly an extension of my Rust/Python Web framework Wasp, so some section of the code may refer to it's earlier name (Native)

Wasmite looks for tests in python files whose names start with test_*.py and runs every test_* function it discovers. The testing folder has more examples.

Having any problems or questions create a issue, i will be happy to help :)

Installation

This project requires python 3 and doesn't support 3.9

pip install wasmite

Project Goals:

• Import wasm or wat module successfully
• Access functions within module
• Type checking of parameters and the result of functions
• Release to PyPi for public to use
• Allow Wasmite ...
  • Export Python functions
  • Export Global Instances
  • Export Memory Instances
• More complex examples in testing folder
• Receive community on how to improve

Examples:

• c++
• c
• wasm
• wat

from wasmite import WasmiteCase, WasmModule
from wasmite import FunctionTypes, Function, Global, Value, main
from wasmite import I32

def sum(x: int, y: int) -> int:
    """ python function to be imported into WASM  """
    return x + y

class Test(WasmiteCase):
    # create a variable the hold all the functions from a specific wasm file.
    module = WasmModule("test_wasm.wasm")
    # import python function into WASM 
    # type annotations on the function is necessary 
    module.register("math", {
        "sum": Function(module.store, sum),
        "seven": Global(module.store, Value.i32(7), mutable=True)
    })
    # start up the module and return the exports (this is mandatory)
    exports = module.get_exports()

    def test_add(self):
        # test add function
        result = self.exports.add(1,2)
        self.assertEqual(result, 3) 

    def test_sub(self):
        # test the sub function
        result = self.exports.sub(2,2)
        self.assertEqual(result, 0)

    def test_args_add(self):
        # check the types for results and parameter of the function "add"
        # param is I32, I32 and result is I32
        add_function = self.exports.add
        self.assertTypes(add_function, FunctionTypes([I32, I32], [I32])) # result will fail

    def test_import_sum(self):
        # test the imported python function sum.
        sum_function = self.exports.addsum(5,2)
        self.assertEqual(sum_function, 7)

    def test_global_read(self):
        # test reading value of global
        read_seven = self.exports.read_global()
        self.assertEqual(read_seven, 7) 

    def test_global_write(self):
        # test writing value of global
        self.exports.write_global(5)
        read_seven = self.exports.read_global()
        self.assertEqual(read_seven, 5) 

# Hi don't forget to add me         
if __name__ == "__main__":
    main()

-->

Then you can then run this test like so:

# make sure you are in examples/wasm
$ python test_wasm.py

test_add (__main__.Test) ... ok
test_args_add (__main__.Test) ... ok
test_global_read (__main__.Test) ... ok
test_global_write (__main__.Test) ... ok
test_import_sum (__main__.Test) ... ok
test_sub (__main__.Test) ... ok

----------------------------------------------------------------------
Ran 6 tests in 0.001s

OK