feat(bindgen): generate dispatch package test scaffold

Author: thewtex

packages/core/typescript/itk-wasm/src/bindgen/python/dispatch-package.js

@@ -1,17 +1,19 @@
 import path from 'path'
 
-import mkdirP from "../mkdir-p.js"
+import mkdirP from '../mkdir-p.js'
 
-import snakeCase from "../snake-case.js"
+import snakeCase from '../snake-case.js'
 
-import dispatchPackageReadme from "./dispatch-package-readme.js"
-import dispatchFunctionModule from "./dispatch-function-module.js"
+import dispatchPackageReadme from './dispatch-package-readme.js'
+import dispatchFunctionModule from './dispatch-function-module.js'
 import packagePyProjectToml from './package-py-project-toml.js'
-import packageDocs from "./package-docs.js"
-import packageDunderInit from "./package-dunder-init.js"
-import packageVersion from "./package-version.js"
+import packageDocs from './package-docs.js'
+import packageDunderInit from './package-dunder-init.js'
+import dispatchTestModule from './dispatch-test-module.js'
+import dispatchPipelineTest from './dispatch-pipeline-test.js'
+import packageVersion from './package-version.js'
 
-import wasmBinaryInterfaceJson from "../wasm-binary-interface-json.js"
+import wasmBinaryInterfaceJson from '../wasm-binary-interface-json.js'
 
 function dispatchPackage(outputDir, buildDir, wasmBinaries, options) {
   const packageName = options.packageName
@@ -27,13 +29,33 @@ function dispatchPackage(outputDir, buildDir, wasmBinaries, options) {
   packageVersion(packageDir, pypackage, options)
   const async = true
   const sync = true
-  packageDunderInit(outputDir, buildDir, wasmBinaries, packageName, options.packageDescription, packageDir, pypackage, async, sync)
+  packageDunderInit(
+    outputDir,
+    buildDir,
+    wasmBinaries,
+    packageName,
+    options.packageDescription,
+    packageDir,
+    pypackage,
+    async,
+    sync
+  )
   packageDocs(packageName, packageDir, pypackage, options)
+  dispatchTestModule(packageDir, pypackage)
 
   wasmBinaries.forEach((wasmBinaryName) => {
-    const { interfaceJson } = wasmBinaryInterfaceJson(outputDir, buildDir, wasmBinaryName)
+    const { interfaceJson } = wasmBinaryInterfaceJson(
+      outputDir,
+      buildDir,
+      wasmBinaryName
+    )
     const functionName = snakeCase(interfaceJson.name)
-    dispatchFunctionModule(interfaceJson, pypackage, path.join(packageDir, pypackage, `${functionName}.py`))
+    dispatchFunctionModule(
+      interfaceJson,
+      pypackage,
+      path.join(packageDir, pypackage, `${functionName}.py`)
+    )
+    dispatchPipelineTest(packageDir, pypackage, functionName)
   })
 }
 

packages/core/typescript/itk-wasm/src/bindgen/python/dispatch-pipeline-test.js

@@ -0,0 +1,34 @@
+import fs from 'fs-extra'
+import path from 'path'
+
+function dispatchPipelineTest(packageDir, pypackage, functionName) {
+  const testDir = path.join(packageDir, 'tests')
+  const testModulePath = path.join(testDir, `test_${functionName}.py`)
+
+  let moduleContent = `import pytest
+import sys
+
+if sys.version_info < (3,10):
+    pytest.skip("Skipping pyodide tests on older Python", allow_module_level=True)
+
+from pytest_pyodide import run_in_pyodide
+
+from .fixtures import emscripten_package_wheel, package_wheel, input_data
+
+@run_in_pyodide(packages=['micropip'])
+async def test_${functionName}(selenium, package_wheel, emscripten_package_wheel):
+    import micropip
+    await micropip.install(emscripten_package_wheel)
+    await micropip.install(package_wheel)
+
+    from ${pypackage} import ${functionName}
+
+    # Write your test code here
+`
+
+  if (!fs.existsSync(testModulePath)) {
+    fs.writeFileSync(testModulePath, moduleContent)
+  }
+}
+
+export default dispatchPipelineTest

packages/core/typescript/itk-wasm/src/bindgen/python/dispatch-test-module.js

@@ -0,0 +1,51 @@
+import fs from 'fs-extra'
+import path from 'path'
+
+import mkdirP from '../mkdir-p.js'
+
+function dispatchTestModule(packageDir, pypackage) {
+  const testDir = path.join(packageDir, 'tests')
+  mkdirP(testDir)
+
+  const initPath = path.join(testDir, '__init__.py')
+  if (!fs.existsSync(initPath)) {
+    fs.writeFileSync(initPath, '')
+  }
+
+  const fixturesContent = `import pytest
+import sys
+import glob
+
+if sys.version_info < (3,10):
+    pytest.skip("Skipping pyodide tests on older Python", allow_module_level=True)
+
+from pytest_pyodide import run_in_pyodide
+
+from ${pypackage} import __version__ as test_package_version
+
+@pytest.fixture
+def package_wheel():
+    return f"${pypackage}-{test_package_version}-py3-none-any.whl"
+
+@pytest.fixture
+def emscripten_package_wheel():
+    return f"${pypackage}-emscripten-{test_package_version}-py3-none-any.whl"
+
+@pytest.fixture
+def input_data():
+    from pathlib import Path
+    input_base_path = Path(__file__).parent.parent / 'test' / 'data'
+    test_files = list(input_base_path.glob('*'))
+    data = {}
+    for test_file in test_files:
+        with open(test_file, 'rb') as f:
+            data[test_file.name] = f.read()
+    return data
+`
+  const fixturesPath = path.join(testDir, 'fixtures.py')
+  if (!fs.existsSync(fixturesPath)) {
+    fs.writeFileSync(fixturesPath, fixturesContent)
+  }
+}
+
+export default dispatchTestModule

packages/core/typescript/itk-wasm/src/bindgen/python/emscripten/emscripten-package.js

@@ -10,24 +10,36 @@ import packageVersion from '../package-version.js'
 import packageDunderInit from '../package-dunder-init.js'
 import emscriptenPyodideModule from './emscripten-pyodide-module.js'
 import emscriptenTestModule from './emscripten-test-module.js'
+import emscriptenPipelineTest from './emscripten-pipeline-test.js'
 import emscriptenFunctionModule from './emscripten-function-module.js'
 import wasmBinaryInterfaceJson from '../../wasm-binary-interface-json.js'
 
 function emscriptenPackage(outputDir, buildDir, wasmBinaries, options) {
-  const defaultJsModulePath = path.join(outputDir, '..', 'typescript', 'dist', 'bundle', 'index-worker-embedded.min.js')
+  const defaultJsModulePath = path.join(
+    outputDir,
+    '..',
+    'typescript',
+    'dist',
+    'bundle',
+    'index-worker-embedded.min.js'
+  )
   const moduleUrl = options.jsModulePath ?? defaultJsModulePath
   if (!fs.existsSync(moduleUrl)) {
-    console.warn(`Could not find ${moduleUrl}: skipping python emscripten package`)
+    console.warn(
+      `Could not find ${moduleUrl}: skipping python emscripten package`
+    )
     return
   }
-  const jsModuleContent = btoa(fs.readFileSync(moduleUrl, { encoding: 'utf8', flag: 'r' }))
+  const jsModuleContent = btoa(
+    fs.readFileSync(moduleUrl, { encoding: 'utf8', flag: 'r' })
+  )
 
   const packageName = `${options.packageName}-emscripten`
   const packageDir = path.join(outputDir, packageName)
   const packageDescription = `${options.packageDescription} Emscripten implementation.`
   mkdirP(packageDir)
 
- const pypackage = snakeCase(packageName)
+  const pypackage = snakeCase(packageName)
   const bindgenPyPackage = pypackage
   mkdirP(path.join(packageDir, pypackage))
 
@@ -36,16 +48,35 @@ function emscriptenPackage(outputDir, buildDir, wasmBinaries, options) {
   packageVersion(packageDir, pypackage, options)
   const async = true
   const sync = false
-  packageDunderInit(outputDir, buildDir, wasmBinaries, packageName, packageDescription, packageDir, pypackage, async, sync)
+  packageDunderInit(
+    outputDir,
+    buildDir,
+    wasmBinaries,
+    packageName,
+    packageDescription,
+    packageDir,
+    pypackage,
+    async,
+    sync
+  )
   emscriptenPyodideModule(jsModuleContent, packageDir, pypackage)
   emscriptenTestModule(packageDir, pypackage)
 
   const wasmModulesDir = path.join(packageDir, pypackage, 'wasm_modules')
   mkdirP(wasmModulesDir)
   wasmBinaries.forEach((wasmBinaryName) => {
-    const { interfaceJson, parsedPath } = wasmBinaryInterfaceJson(outputDir, buildDir, wasmBinaryName)
+    const { interfaceJson, parsedPath } = wasmBinaryInterfaceJson(
+      outputDir,
+      buildDir,
+      wasmBinaryName
+    )
     const functionName = snakeCase(interfaceJson.name) + '_async'
-    emscriptenFunctionModule(interfaceJson, pypackage, path.join(packageDir, pypackage, `${functionName}.py`))
+    emscriptenFunctionModule(
+      interfaceJson,
+      pypackage,
+      path.join(packageDir, pypackage, `${functionName}.py`)
+    )
+    emscriptenPipelineTest(packageDir, pypackage, functionName)
   })
 }
 

packages/core/typescript/itk-wasm/src/bindgen/python/emscripten/emscripten-pipeline-test.js

@@ -0,0 +1,33 @@
+import fs from 'fs-extra'
+import path from 'path'
+
+function emscriptenPipelineTest(packageDir, pypackage, functionName) {
+  const testDir = path.join(packageDir, 'tests')
+  const testModulePath = path.join(testDir, `test_${functionName}.py`)
+
+  let moduleContent = `import pytest
+import sys
+
+if sys.version_info < (3,10):
+    pytest.skip("Skipping pyodide tests on older Python", allow_module_level=True)
+
+from pytest_pyodide import run_in_pyodide
+
+from .fixtures import package_wheel, input_data
+
+@run_in_pyodide(packages=['micropip'])
+async def test_${functionName}(selenium, package_wheel):
+    import micropip
+    await micropip.install(package_wheel)
+
+    from ${pypackage} import ${functionName}
+
+    # Write your test code here
+`
+
+  if (!fs.existsSync(testModulePath)) {
+    fs.writeFileSync(testModulePath, moduleContent)
+  }
+}
+
+export default emscriptenPipelineTest

packages/core/typescript/itk-wasm/src/bindgen/python/emscripten/emscripten-test-module.js

@@ -7,8 +7,14 @@ function emscriptenTestModule(packageDir, pypackage) {
   const testDir = path.join(packageDir, 'tests')
   mkdirP(testDir)
 
-  let moduleContent = `import pytest
+  const initPath = path.join(testDir, '__init__.py')
+  if (!fs.existsSync(initPath)) {
+    fs.writeFileSync(initPath, '')
+  }
+
+  const fixturesContent = `import pytest
 import sys
+import glob
 
 if sys.version_info < (3,10):
     pytest.skip("Skipping pyodide tests on older Python", allow_module_level=True)
@@ -21,24 +27,20 @@ from ${pypackage} import __version__ as test_package_version
 def package_wheel():
     return f"${pypackage}-{test_package_version}-py3-none-any.whl"
 
-@run_in_pyodide(packages=['micropip'])
-async def test_example(selenium, package_wheel):
-    import micropip
-    await micropip.install(package_wheel)
-
-    # Write your test code here
+@pytest.fixture
+def input_data():
+    from pathlib import Path
+    input_base_path = Path(__file__).parent.parent / 'test' / 'data'
+    test_files = list(input_base_path.glob('*'))
+    data = {}
+    for test_file in test_files:
+        with open(test_file, 'rb') as f:
+            data[test_file.name] = f.read()
+    return data
 `
-
-  const modulePath = path.join(
-    testDir,
-    `test_${pypackage.replace('_emscripten', '')}.py`
-  )
-  if (!fs.existsSync(modulePath)) {
-    fs.writeFileSync(modulePath, moduleContent)
-  }
-  const initPath = path.join(testDir, '__init__.py')
-  if (!fs.existsSync(initPath)) {
-    fs.writeFileSync(initPath, '')
+  const fixturesPath = path.join(testDir, 'fixtures.py')
+  if (!fs.existsSync(fixturesPath)) {
+    fs.writeFileSync(fixturesPath, fixturesContent)
   }
 }