diff --git a/.gitignore b/.gitignore index 9e99726..1061b39 100644 --- a/.gitignore +++ b/.gitignore @@ -3,3 +3,4 @@ __pycache__/ .cache/ compile_commands.json serve.log +test/test-results/ diff --git a/RELEASE.md b/RELEASE.md index 2b01a44..684930f 100644 --- a/RELEASE.md +++ b/RELEASE.md @@ -21,6 +21,6 @@ This covers making a new github release in the `git2cpp` repository, and propaga The Emscripten-forge recipe at https://github.com/emscripten-forge/recipes needs to be updated with the new version number and SHA checksum. An Emscripten-forge bot runs once a day and will identify the new github release and create a PR to update the recipe. Wait for this to happen, and if the tests pass and no further changes are required, the PR can be approved and merged. -After the PR is merged to `main`, the recipe will be rebuilt and uploaded to https://prefix.dev/channels/emscripten-forge-dev/packages/git2cpp, which should only take a few minutes. +After the PR is merged to `main`, the recipe will be rebuilt and uploaded to https://prefix.dev/channels/emscripten-forge-4x/packages/git2cpp, which should only take a few minutes. Any subsequent `cockle` or JupyterLite `terminal` deployments that are rebuilt will download and use the latest `git2cpp` WebAssembly package. diff --git a/test/conftest_wasm.py b/test/conftest_wasm.py index 89d5061..1c4fae0 100644 --- a/test/conftest_wasm.py +++ b/test/conftest_wasm.py @@ -1,15 +1,29 @@ -# Extra fixtures used for wasm testing. +# Extra fixtures used for wasm testing, including some that override the default pytest fixtures. from functools import partial -from pathlib import Path +import os +import pathlib from playwright.sync_api import Page import pytest +import re import subprocess import time + +# Only include particular test files when testing wasm. +# This can be removed when all tests support wasm. +def pytest_ignore_collect(collection_path: pathlib.Path) -> bool: + return collection_path.name not in [ + "test_clone.py", + "test_fixtures.py", + "test_git.py", + "test_init.py", + ] + + @pytest.fixture(scope="session", autouse=True) def run_web_server(): with open('serve.log', 'w') as f: - cwd = Path(__file__).parent.parent / 'wasm/test' + cwd = pathlib.Path(__file__).parent.parent / 'wasm/test' proc = subprocess.Popen( ['npm', 'run', 'serve'], stdout=f, stderr=f, cwd=cwd ) @@ -18,24 +32,76 @@ def run_web_server(): yield proc.terminate() + @pytest.fixture(scope="function", autouse=True) def load_page(page: Page): # Load web page at start of every test. page.goto("http://localhost:8000") page.locator("#loaded").wait_for() + +def os_chdir(dir: str): + subprocess.run(["cd", str(dir)], capture_output=True, check=True, text=True) + + +def os_getcwd(): + return subprocess.run(["pwd"], capture_output=True, check=True, text=True).stdout.strip() + + +class MockPath(pathlib.Path): + def __init__(self, path: str = ""): + super().__init__(path) + + def exists(self) -> bool: + p = subprocess.run(['stat', str(self)]) + return p.returncode == 0 + + def is_dir(self) -> bool: + p = subprocess.run(['stat', '-c', '%F', str(self)], capture_output=True, text=True) + return p.returncode == 0 and p.stdout.strip() == 'directory' + + def is_file(self) -> bool: + p = subprocess.run(['stat', '-c', '%F', str(self)], capture_output=True, text=True) + return p.returncode == 0 and p.stdout.strip() == 'regular file' + + def iterdir(self): + p = subprocess.run(["ls", str(self), '-a', '-1'], capture_output=True, text=True, check=True) + for f in filter(lambda f: f not in ['', '.', '..'], re.split(r"\r?\n", p.stdout)): + yield MockPath(self / f) + + def __truediv__(self, other): + if isinstance(other, str): + return MockPath(f"{self}/{other}") + raise RuntimeError("MockPath.__truediv__ only supports strings") + + def subprocess_run( page: Page, cmd: list[str], *, capture_output: bool = False, - cwd: str | None = None, + check: bool = False, + cwd: str | MockPath | None = None, text: bool | None = None ) -> subprocess.CompletedProcess: + shell_run = "async cmd => await window.cockle.shellRun(cmd)" + + # Set cwd. if cwd is not None: - raise RuntimeError('cwd is not yet supported') + proc = page.evaluate(shell_run, "pwd") + if proc['returncode'] != 0: + raise RuntimeError("Error getting pwd") + old_cwd = proc['stdout'].strip() + if old_cwd == str(cwd): + # cwd is already correct. + cwd = None + else: + proc = page.evaluate(shell_run, f"cd {cwd}") + if proc['returncode'] != 0: + raise RuntimeError(f"Error setting cwd to {cwd}") + + proc = page.evaluate(shell_run, " ".join(cmd)) - proc = page.evaluate("async cmd => window.cockle.shellRun(cmd)", cmd) # TypeScript object is auto converted to Python dict. # Want to return subprocess.CompletedProcess, consider namedtuple if this fails in future. stdout = proc['stdout'] if capture_output else '' @@ -43,6 +109,16 @@ def subprocess_run( if not text: stdout = stdout.encode("utf-8") stderr = stderr.encode("utf-8") + + # Reset cwd. + if cwd is not None: + proc = page.evaluate(shell_run, "cd " + old_cwd) + if proc['returncode'] != 0: + raise RuntimeError(f"Error setting cwd to {old_cwd}") + + if check and proc['returncode'] != 0: + raise subprocess.CalledProcessError(proc['returncode'], cmd, stdout, stderr) + return subprocess.CompletedProcess( args=cmd, returncode=proc['returncode'], @@ -50,6 +126,19 @@ def subprocess_run( stderr=stderr ) + +@pytest.fixture(scope="function") +def tmp_path() -> MockPath: + # Assumes only one tmp_path needed per test. + path = MockPath('/drive/tmp0') + subprocess.run(['mkdir', str(path)], check=True) + assert path.exists() + assert path.is_dir() + return path + + @pytest.fixture(scope="function", autouse=True) def mock_subprocess_run(page: Page, monkeypatch): monkeypatch.setattr(subprocess, "run", partial(subprocess_run, page)) + monkeypatch.setattr(os, "chdir", os_chdir) + monkeypatch.setattr(os, "getcwd", os_getcwd) diff --git a/test/test_clone.py b/test/test_clone.py index 0461d43..57144b4 100644 --- a/test/test_clone.py +++ b/test/test_clone.py @@ -1,7 +1,5 @@ -import os import subprocess - -import pytest +from .conftest import GIT2CPP_TEST_WASM url = "https://github.com/xtensor-stack/xtl.git" @@ -11,8 +9,8 @@ def test_clone(git2cpp_path, tmp_path, run_in_tmp_path): p_clone = subprocess.run(clone_cmd, capture_output=True, cwd=tmp_path, text=True) assert p_clone.returncode == 0 - assert os.path.exists(os.path.join(tmp_path, "xtl")) - assert os.path.exists(os.path.join(tmp_path, "xtl/include")) + assert (tmp_path / "xtl").exists() + assert (tmp_path / "xtl/include").exists() def test_clone_is_bare(git2cpp_path, tmp_path, run_in_tmp_path): @@ -20,9 +18,19 @@ def test_clone_is_bare(git2cpp_path, tmp_path, run_in_tmp_path): p_clone = subprocess.run(clone_cmd, capture_output=True, cwd=tmp_path, text=True) assert p_clone.returncode == 0 + assert (tmp_path / "xtl").is_dir() + status_cmd = [git2cpp_path, "status"] - p_status = subprocess.run(status_cmd, capture_output=True, cwd=tmp_path, text=True) - assert p_status.returncode != 0 + p_status = subprocess.run(status_cmd, capture_output=True, cwd=tmp_path / "xtl", text=True) + if not GIT2CPP_TEST_WASM: + # TODO: fix this in wasm build + assert p_status.returncode != 0 + assert "This operation is not allowed against bare repositories" in p_status.stderr + + branch_cmd = [git2cpp_path, "branch"] + p_branch = subprocess.run(branch_cmd, capture_output=True, cwd=tmp_path / "xtl", text=True) + assert p_branch.returncode == 0 + assert p_branch.stdout.strip() == "* master" def test_clone_shallow(git2cpp_path, tmp_path, run_in_tmp_path): diff --git a/test/test_fixtures.py b/test/test_fixtures.py new file mode 100644 index 0000000..c8c0c04 --- /dev/null +++ b/test/test_fixtures.py @@ -0,0 +1,39 @@ +# Test fixtures to confirm that wasm monkeypatching works correctly. + +import re +import subprocess +from .conftest import GIT2CPP_TEST_WASM + + +def test_run_in_tmp_path(tmp_path, run_in_tmp_path): + p = subprocess.run(['pwd'], capture_output=True, text=True, check=True) + assert p.stdout.strip() == str(tmp_path) + + +def test_tmp_path(tmp_path): + p = subprocess.run(['pwd'], capture_output=True, text=True, check=True, cwd=str(tmp_path)) + assert p.stdout.strip() == str(tmp_path) + + assert tmp_path.exists() + assert tmp_path.is_dir() + assert not tmp_path.is_file() + + assert sorted(tmp_path.iterdir()) == [] + subprocess.run(['mkdir', f"{tmp_path}/def"], capture_output=True, text=True, check=True) + assert sorted(tmp_path.iterdir()) == [tmp_path / 'def'] + subprocess.run(['mkdir', f"{tmp_path}/abc"], capture_output=True, text=True, check=True) + assert sorted(tmp_path.iterdir()) == [tmp_path / 'abc', tmp_path / 'def'] + + p = subprocess.run(['pwd'], capture_output=True, text=True, check=True, cwd=tmp_path.parent) + assert p.stdout.strip() == str(tmp_path.parent) + assert tmp_path in list(tmp_path.parent.iterdir()) + + +def test_env_vars(): + # By default there should be not GIT_* env vars set. + p = subprocess.run(['env'], capture_output=True, text=True, check=True) + git_lines = sorted(filter(lambda f: f.startswith("GIT_"), re.split(r"\r?\n", p.stdout))) + if GIT2CPP_TEST_WASM: + assert git_lines == ["GIT_CORS_PROXY=http://localhost:8881/"] + else: + assert git_lines == [] diff --git a/test/test_git.py b/test/test_git.py index 8bf5e4f..50a954e 100644 --- a/test/test_git.py +++ b/test/test_git.py @@ -1,5 +1,7 @@ import pytest +import re import subprocess +from .conftest import GIT2CPP_TEST_WASM @pytest.mark.parametrize("arg", ['-v', '--version']) @@ -18,3 +20,26 @@ def test_error_on_unknown_option(git2cpp_path): assert p.returncode == 109 assert p.stdout == b'' assert p.stderr.startswith(b"The following argument was not expected: --unknown") + + +@pytest.mark.skipif(not GIT2CPP_TEST_WASM, reason="Only test in WebAssembly") +def test_cockle_config(git2cpp_path): + # Check cockle-config shows git2cpp is available. + cmd = ["cockle-config", "module", "git2cpp"] + p = subprocess.run(cmd, capture_output=True, text=True) + assert p.returncode == 0 + lines = [line for line in re.split(r"\r?\n", p.stdout) if len(line) > 0] + assert len(lines) == 5 + assert lines[1] == "│ module │ package │ cached │" + assert lines[3] == "│ git2cpp │ git2cpp │ │" + + p = subprocess.run([git2cpp_path, "-v"], capture_output=True, text=True) + assert p.returncode == 0 + + # Check git2cpp module has been cached. + p = subprocess.run(cmd, capture_output=True, text=True) + assert p.returncode == 0 + lines = [line for line in re.split(r"\r?\n", p.stdout) if len(line) > 0] + assert len(lines) == 5 + assert lines[1] == "│ module │ package │ cached │" + assert lines[3] == "│ git2cpp │ git2cpp │ yes │" diff --git a/wasm/.gitignore b/wasm/.gitignore index a4c0e06..8f8b10f 100644 --- a/wasm/.gitignore +++ b/wasm/.gitignore @@ -8,6 +8,8 @@ node_modules/ package-lock.json .jupyterlite.doit.db +cockle/ +lite-deploy/package.json recipe/em-forge-recipes/ serve/*/ test/assets/*/ diff --git a/wasm/CMakeLists.txt b/wasm/CMakeLists.txt index f8a6670..a6d0df5 100644 --- a/wasm/CMakeLists.txt +++ b/wasm/CMakeLists.txt @@ -1,6 +1,9 @@ cmake_minimum_required(VERSION 3.28) project(git2cpp-wasm) +option(USE_RECIPE_PATCHES "Use patches from emscripten-forge recipe or not" ON) +option(USE_COCKLE_RELEASE "Use latest cockle release rather than repo main branch" OFF) + add_subdirectory(recipe) add_subdirectory(cockle-deploy) add_subdirectory(lite-deploy) @@ -14,3 +17,17 @@ add_custom_target(rebuild DEPENDS rebuild-recipe rebuild-cockle rebuild-lite reb # Serve both cockle and JupyterLite deployments. add_custom_target(serve COMMAND npx static-handler --cors --coop --coep --corp serve) + +if (USE_COCKLE_RELEASE) + execute_process(COMMAND npm view @jupyterlite/cockle version OUTPUT_VARIABLE COCKLE_BRANCH) + set(COCKLE_BRANCH "v${COCKLE_BRANCH}") +else() + set(COCKLE_BRANCH "main") +endif() + +add_custom_target(cockle + COMMENT "Using cockle from github repository ${COCKLE_BRANCH} branch" + # Don't re-clone if directory already exists - could do better here. + COMMAND test -d cockle || git clone https://github.com/jupyterlite/cockle --depth 1 --branch ${COCKLE_BRANCH} + COMMAND cd cockle && npm install && npm run build +) diff --git a/wasm/README.md b/wasm/README.md index 899c0d2..75b828c 100644 --- a/wasm/README.md +++ b/wasm/README.md @@ -33,6 +33,18 @@ cmake . make ``` +The available `cmake` options are: + +- `USE_RECIPE_PATCHES`: Use patches from emscripten-forge recipe or not, default is `ON` +- `USE_COCKLE_RELEASE`: Use latest cockle release rather than repo main branch, default is `OFF` + +For example, to run `cmake` but without using emscripten-forge recipe patches use: + +```bash +cmake . -DUSE_RECIPE_PATCHES=OFF +make +``` + The built emscripten-forge package will be file named something like `git2cpp-0.0.5-h7223423_1.tar.bz2` in the directory `recipe/em-force-recipes/output/emscripten-wasm32`. @@ -53,28 +65,51 @@ Note that the `source` for the `git2cpp` package is the local filesystem rather version number of the current Emscripten-forge recipe rather than the version of the local `git2cpp` source code which can be checked using `git2cpp -v` at the `cockle`/`terminal` command line. +## Rebuild + +After making changes to the local `git2cpp` source code you can rebuild the WebAssembly package, +both deployments and test code using from the `wasm` directory: + +```bash +make rebuild +``` + ## Test -To test the WebAssembly build use: +To test the WebAssembly build use from the `wasm` directory: ```bash make test ``` This runs (some of) the tests in the top-level `test` directory with various monkey patching so that -`git2cpp` commands are executed in the browser. If there are problems running the tests then ensure -you have the latest `playwright` browser installed: - +`git2cpp` commands are executed in the browser. +The tests that are run are defined in the function `pytest_ignore_collect` in `conftest_wasm.py`. +If there are problems running the tests then ensure you have the latest `playwright` browser installed: ```bash playwright install chromium ``` -## Rebuild +You can run a specific test from the top-level `test` directory (not the `wasm/test` directory) +using: -After making changes to the local `git2cpp` source code you can rebuild the WebAssembly package, -both deployments and test code using: +```bash +GIT2CPP_TEST_WASM=1 pytest -v test_git.py::test_version +``` + +### Manually running the test servers + +If wasm tests are failing it can be helpful to run the test servers and manually run `cockle` +commands to help understand the problem. To do this use: ```bash -make rebuild +cd wasm/test +npm run serve ``` + +This will start both the test server on port 8000 and the CORS server on port 8881. Open a browser +at http://localhost:8000/ and to run a command such as `ls -l` open the dev console and enter the +following at the prompt: `await window.cockle.shellRun('ls -al')`. The generated output will appear +in a new `
` in the web page in a format similar to that returned by Python's +`subprocess.run()`. diff --git a/wasm/cockle-deploy/CMakeLists.txt b/wasm/cockle-deploy/CMakeLists.txt index 3cbc66e..6a11bf9 100644 --- a/wasm/cockle-deploy/CMakeLists.txt +++ b/wasm/cockle-deploy/CMakeLists.txt @@ -6,7 +6,7 @@ include("../common.cmake") set(SERVE_DIR "../serve/cockle") add_custom_target(build-cockle - DEPENDS build-recipe + DEPENDS build-recipe cockle COMMAND npm install COMMAND COCKLE_WASM_EXTRA_CHANNEL=${BUILT_PACKAGE_DIR} npm run build BYPRODUCTS cockle_wasm_env node_modules ${SERVE_DIR} diff --git a/wasm/cockle-deploy/package.json b/wasm/cockle-deploy/package.json index 4830e3d..2700383 100644 --- a/wasm/cockle-deploy/package.json +++ b/wasm/cockle-deploy/package.json @@ -20,7 +20,7 @@ "typescript": "^5.4.5" }, "dependencies": { - "@jupyterlite/cockle": "^1.3.0", + "@jupyterlite/cockle": "file:../cockle", "@xterm/addon-fit": "^0.10.0", "@xterm/xterm": "^5.5.0", "deepmerge-ts": "^7.1.4" diff --git a/wasm/lite-deploy/CMakeLists.txt b/wasm/lite-deploy/CMakeLists.txt index 1ba6b5b..eb43121 100644 --- a/wasm/lite-deploy/CMakeLists.txt +++ b/wasm/lite-deploy/CMakeLists.txt @@ -6,7 +6,12 @@ include("../common.cmake") set(SERVE_DIR "../serve/lite") add_custom_target(build-lite - DEPENDS build-recipe + DEPENDS build-recipe cockle + + # Ensure cockle is installed in this directory so that we used the correct prepare_wasm script. + COMMAND npm install ../cockle + COMMAND npm install + COMMAND jupyter lite --version COMMAND COCKLE_WASM_EXTRA_CHANNEL=${BUILT_PACKAGE_DIR} jupyter lite build --output-dir ${SERVE_DIR} BYPRODUCTS cockle-config.json .cockle_temp/ .jupyterlite.doit.db cockle_wasm_env/ ${SERVE_DIR} diff --git a/wasm/recipe/CMakeLists.txt b/wasm/recipe/CMakeLists.txt index 48560e9..43445b9 100644 --- a/wasm/recipe/CMakeLists.txt +++ b/wasm/recipe/CMakeLists.txt @@ -5,7 +5,8 @@ include("../common.cmake") set(EM_FORGE_RECIPES_REPO "https://github.com/emscripten-forge/recipes") set(GIT2CPP_RECIPE_DIR "recipes/recipes_emscripten/git2cpp") -set(RATTLER_ARGS "--package-format tar-bz2 --target-platform emscripten-wasm32 -c https://repo.prefix.dev/emscripten-forge-dev -c microsoft -c conda-forge") +set(PREFIX_CHANNEL "https://repo.prefix.dev/emscripten-forge-4x") +set(RATTLER_ARGS "--package-format tar-bz2 --target-platform emscripten-wasm32 -c ${PREFIX_CHANNEL} -c microsoft -c conda-forge") # Only want the git2cpp recipe from emscripten-forge/recipes repo, not the whole repo. # Note removing the .git directory otherwise `git clean -fxd` will not remove the directory. @@ -18,9 +19,14 @@ add_custom_command( COMMAND ${CMAKE_COMMAND} -E remove_directory ${EM_FORGE_RECIPES_DIR}/.git ) +set(MODIFY_RECIPE_ARGS "") +if (NOT USE_RECIPE_PATCHES) + set(MODIFY_RECIPE_ARGS "--no-patches") +endif() + add_custom_target(modify-recipe DEPENDS ${EM_FORGE_RECIPES_DIR} - COMMAND python ${CMAKE_CURRENT_SOURCE_DIR}/modify-recipe.py ${GIT2CPP_RECIPE_DIR} + COMMAND python ${CMAKE_CURRENT_SOURCE_DIR}/modify-recipe.py ${GIT2CPP_RECIPE_DIR} ${MODIFY_RECIPE_ARGS} WORKING_DIRECTORY ${EM_FORGE_RECIPES_DIR} ) diff --git a/wasm/recipe/modify-recipe.py b/wasm/recipe/modify-recipe.py index 70a3d83..5cd105d 100644 --- a/wasm/recipe/modify-recipe.py +++ b/wasm/recipe/modify-recipe.py @@ -1,20 +1,18 @@ # Modify the git2cpp emscripten-forge recipe to build from the local repo. # This can be called repeatedly and will produce the same output. +import argparse from pathlib import Path import shutil -import sys import yaml -def quit(msg): - print(msg) - exit(1) +parser = argparse.ArgumentParser() +parser.add_argument('input_directory', type=Path) +parser.add_argument('--no-patches', action='store_true') +args = parser.parse_args() -if len(sys.argv) < 2: - quit(f'Usage: {sys.argv[0]} ') - -input_dir = Path(sys.argv[1]) +input_dir = args.input_directory if not input_dir.is_dir(): quit(f'{input_dir} should exist and be a directory') @@ -44,6 +42,10 @@ def quit(msg): print(' Changing source to point to local git2cpp repo') source['path'] = '../../../../../../' +if args.no_patches: + print(' Deleting patches') + del source['patches'] + # Overwrite recipe file. with open(input_filename, 'w') as f: yaml.dump(recipe, f) diff --git a/wasm/test/CMakeLists.txt b/wasm/test/CMakeLists.txt index 29db8ad..5700d94 100644 --- a/wasm/test/CMakeLists.txt +++ b/wasm/test/CMakeLists.txt @@ -4,7 +4,7 @@ project(git2cpp-wasm-test) include("../common.cmake") add_custom_target(build-test - DEPENDS build-recipe + DEPENDS build-recipe cockle COMMAND npm install COMMAND COCKLE_WASM_EXTRA_CHANNEL=${BUILT_PACKAGE_DIR} npm run build BYPRODUCTS cockle_wasm_env lib node_modules @@ -15,8 +15,8 @@ add_custom_target(rebuild-test ) add_custom_target(test - # A pytest fixture ensures that `npm run serve` runs for the duration of the tests. - COMMAND GIT2CPP_TEST_WASM=1 pytest -v -rP test_git.py + # A pytest fixture ensures that `npm run serve` runs for the duration of the tests. + COMMAND GIT2CPP_TEST_WASM=1 pytest -v -rP WORKING_DIRECTORY ../../test ) diff --git a/wasm/test/assets/index.html b/wasm/test/assets/index.html index 57ba584..d6506ab 100644 --- a/wasm/test/assets/index.html +++ b/wasm/test/assets/index.html @@ -1,8 +1,14 @@ - Testing git2cpp in cockle - + Testing git2cpp in cockle + + diff --git a/wasm/test/cockle-config-in.json b/wasm/test/cockle-config-in.json index bbb59a1..cb777b5 100644 --- a/wasm/test/cockle-config-in.json +++ b/wasm/test/cockle-config-in.json @@ -10,10 +10,6 @@ "vi": "vim" }, "environment": { - "GIT_CORS_PROXY": "https://corsproxy.io/?url=", - "GIT_AUTHOR_NAME": "Jane Doe", - "GIT_AUTHOR_EMAIL": "jane.doe@blabla.com", - "GIT_COMMITTER_NAME": "Jane Doe", - "GIT_COMMITTER_EMAIL": "jane.doe@blabla.com" + "GIT_CORS_PROXY": "http://localhost:8881/" } } diff --git a/wasm/test/package.json b/wasm/test/package.json index e4259f6..908dcce 100644 --- a/wasm/test/package.json +++ b/wasm/test/package.json @@ -10,12 +10,16 @@ "scripts": { "build": "rspack build", "postbuild": "node node_modules/@jupyterlite/cockle/lib/tools/prepare_wasm.js --copy assets", - "serve": "rspack serve" + "serve": "concurrently 'npm run serve:cockle' 'npm run serve:cors'", + "serve:cockle": "rspack serve", + "serve:cors": "HOST=localhost PORT=8881 node node_modules/cors-anywhere/server.js " }, "devDependencies": { - "@jupyterlite/cockle": "^1.3.0", + "@jupyterlite/cockle": "file:../cockle", "@rspack/cli": "^0.7.5", "@rspack/core": "^0.7.5", + "concurrently": "^9.2.1", + "cors-anywhere": "^0.4.4", "ts-loader": "^9.5.1", "ts-node": "^10.9.2", "typescript": "^5.5.4" diff --git a/wasm/test/src/index.ts b/wasm/test/src/index.ts index 37d4ab7..4ccb906 100644 --- a/wasm/test/src/index.ts +++ b/wasm/test/src/index.ts @@ -21,7 +21,7 @@ async function setup() { const cockle = { shell, - shellRun: (cmd: string[]) => shellRun(shell, output, cmd) + shellRun: (cmd: string) => shellRun(shell, output, cmd) }; (window as any).cockle = cockle; @@ -29,34 +29,48 @@ async function setup() { // Add div to indicate setup complete which can be awaited at start of tests. const div = document.createElement("div"); div.id = 'loaded'; - div.innerHTML = 'loaded'; + div.innerHTML = 'Loaded'; document.body.appendChild(div); } async function shellRun( shell: Shell, output: MockTerminalOutput, - cmd: string[] + cmd: string, ): Promise { - // Keep stdout and stderr separate by outputting stdout to temporary file and stderr to terminal, - // then read the temporary file to get stdout to return. + // Keep stdout and stderr separate by outputting stdout to terminal and stderr to temporary file, + // then read the temporary file to get stderr to return. + // There are issues here with use of \n and \r\n at ends of lines. output.clear(); - let cmdLine = cmd.join(' ') + '> .outtmp' + '\r'; + let cmdLine = cmd + ' 2> /drive/.errtmp' + '\r'; await shell.input(cmdLine); - const stderr = stripOutput(output.textAndClear(), cmdLine); + const stdout = stripOutput(output.textAndClear(), cmdLine); const returncode = await shell.exitCode(); - // Read stdout from .outtmp file. - cmdLine = 'cat .outtmp\r'; + // Read stderr from .errtmp file. + cmdLine = 'cat /drive/.errtmp\r'; await shell.input(cmdLine); - const stdout = stripOutput(output.textAndClear(), cmdLine); + const stderr = stripOutput(output.textAndClear(), cmdLine); // Delete temporary file. - cmdLine = 'rm .outtmp\r'; + cmdLine = 'rm /drive/.errtmp\r'; await shell.input(cmdLine); output.clear(); + // Display in browser in new div. + const div = document.createElement("div"); + let content = `> ${cmd}
returncode: ${returncode}` + if (stdout.length > 0) { + content += `
stdout: ${stdout.trim().replace(/\n/g, "
")}`; + } + if (stderr.length > 0) { + content += `
stderr: ${stderr.trim().replace(/\n/g, "
")}`; + } + div.innerHTML = content; + document.body.appendChild(div); + div.scrollIntoView(); + return { returncode, stdout, stderr }; }