Auto saving banks...
@@ -1017,6 +1023,35 @@ File Manager
+ +
+
+
+
+
Tone3000
+
+ 
+
+
+ Tone3000
++ Browse the TONE3000 catalog and download the tones you like. Each tone is + saved to its own folder under NAM Models, where you will find it in + the File Manager. +
++ A tone you just downloaded goes to the top of the model list of every NAM + plugin on the board, so you can load it without hunting for it. +
+ + +
diff --git a/html/js/desktop.js b/html/js/desktop.js
index 631a98bdd..08e7b8abd 100644
--- a/html/js/desktop.js
+++ b/html/js/desktop.js
@@ -37,6 +37,8 @@ function Desktop(elements) {
pedalboardTrigger: $('
'),
fileManagerBox: $('
'),
fileManagerBoxTrigger: $('
'),
+ tone3000Box: $('
'),
+ tone3000BoxTrigger: $('
'),
pedalboardBox: $('
'),
pedalboardBoxTrigger: $('
'),
bankBox: $('
'),
@@ -770,6 +772,8 @@ function Desktop(elements) {
elements.bankBoxTrigger)
this.fileManagerBox = self.makeFileManagerBox(elements.fileManagerBox,
elements.fileManagerBoxTrigger)
+ this.tone3000Box = self.makeTone3000Box(elements.tone3000Box,
+ elements.tone3000BoxTrigger)
this.getPluginsData = function (uris, callback) {
$.ajax({
@@ -1313,6 +1317,7 @@ function Desktop(elements) {
elements.bankBoxTrigger.statusTooltip()
elements.cloudPluginBoxTrigger.statusTooltip()
elements.fileManagerBoxTrigger.statusTooltip()
+ elements.tone3000BoxTrigger.statusTooltip()
this.upgradeWindow = elements.upgradeWindow.upgradeWindow({
icon: elements.upgradeIcon,
@@ -1810,6 +1815,14 @@ Desktop.prototype.makeFileManagerBox = function (el, trigger) {
})
}
+Desktop.prototype.makeTone3000Box = function (el, trigger) {
+ var self = this
+ el.tone3000Box({
+ trigger: trigger,
+ windowManager: this.windowManager,
+ })
+}
+
Desktop.prototype.reset = function (callback, skipConfirmDialog) {
if (this.pedalboardModified && !skipConfirmDialog && !confirm("There are unsaved modifications that will be lost. Are you sure?")) {
return
diff --git a/html/js/modgui.js b/html/js/modgui.js
index 25a8feac4..bb70b92cc 100644
--- a/html/js/modgui.js
+++ b/html/js/modgui.js
@@ -57,6 +57,25 @@ function loadFileTypesList(parameter, dummy, callback) {
})
}
+// Only worth expanding once the list outgrows the box. Re-run this whenever the options
+// change: a list that was short enough at build time may not be after a download.
+function assignFileListExpand(elem) {
+ var list = elem.find('.mod-enumerated-list')
+ var button = elem.find('.file-list-btn-expand').off('click')
+
+ if (list.length == 1 && list[0].childElementCount > 5) {
+ button.show().click(function () {
+ if (elem.hasClass('expanded')) {
+ elem.removeClass('expanded')
+ } else {
+ elem.addClass('expanded')
+ }
+ })
+ } else {
+ button.hide()
+ }
+}
+
function loadDependencies(gui, effect, dummy, callback) { //source, effect, bundle, callback) {
var iconLoaded = true
var settingsLoaded = true
@@ -523,6 +542,96 @@ function GUI(effect, options) {
self.triggerJS({ type: 'change', symbol: symbol, value: value })
}
+ /* A file dropdown is filled once, from the /files/list snapshot taken while the GUI was
+ being built, and nothing ever re-reads it -- so a file added afterwards stays invisible
+ to a plugin already on the board. The backend scan is always live; the staleness is
+ entirely here.
+
+ Re-render the plugin's own templates and swap in just the file-list widgets. Going
+ through the template is what makes this work for any plugin: we never build the option
+ nodes ourselves, so we never assume how the author nested them. Re-rendering the whole
+ icon is not an option -- its port elements carry the jsPlumb endpoints the connection
+ manager holds on to, so replacing them would cut every cable into this plugin. */
+ this.refreshFileTypesLists = function (fileType, hoist) {
+ var parameters = []
+ for (var i in effect.parameters) {
+ var parameter = effect.parameters[i]
+ if (parameter.path && parameter.fileTypes && parameter.fileTypes.indexOf(fileType) >= 0) {
+ parameters.push(parameter)
+ }
+ }
+ if (!parameters.length) {
+ return
+ }
+
+ /* The list arrives sorted by path. Lift the files named in `hoist` to the front, so a
+ tone the user just downloaded is the first thing in the dropdown instead of buried
+ wherever its name happened to sort. Only for as long as this GUI lives -- a reload
+ takes the list straight from /files/list again, in its own order. */
+ var reorder = function (files) {
+ if (!hoist || !hoist.length) {
+ return files
+ }
+ var isNew = function (file) {
+ return hoist.indexOf(file.fullname) >= 0
+ }
+ return files.filter(isNew).concat(files.filter(function (file) { return !isNew(file) }))
+ }
+
+ // The templates read effect.parameters, so refresh those, not the self.parameters copies.
+ var pending = parameters.length
+ parameters.forEach(function (parameter) {
+ loadFileTypesList(parameter, false, function () {
+ parameter.files = reorder(parameter.files)
+ if (--pending === 0) {
+ self.swapFileWidgets()
+ }
+ })
+ })
+ }
+
+ this.swapFileWidgets = function () {
+ var templateData = self.getTemplateData(effect, self.skipNamespace)
+ var panels = [
+ [self.icon, effect.gui.iconTemplate || options.defaultIconTemplate],
+ [self.settings, effect.gui.settingsTemplate || options.defaultSettingsTemplate],
+ ]
+
+ panels.forEach(function (panel) {
+ var live = panel[0]
+ if (!live) {
+ return
+ }
+ var fresh = $('
').html(Mustache.render(panel[1], templateData))
+
+ live.find('[mod-widget=custom-select-path]').each(function () {
+ var old = $(this)
+ var uri = old.attr('mod-parameter-uri')
+ var node = fresh.find('[mod-widget=custom-select-path][mod-parameter-uri="' + uri + '"]')
+ if (node.length !== 1) {
+ return
+ }
+
+ var parameter = self.parameters[uri]
+ parameter.widgets = parameter.widgets.filter(function (widget) {
+ return widget[0] !== old[0]
+ })
+
+ /* assignControlFunctionality reads mod-instance off the element it is given and
+ only looks downwards, so hand it a stand-in for the panel holding one widget.
+ It re-registers the widget and restores the selection from parameter.value. */
+ var holder = $('
')
+ if (self.instance) {
+ holder.attr('mod-instance', self.instance)
+ }
+ self.assignControlFunctionality(holder.append(node), false)
+
+ old.replaceWith(node)
+ assignFileListExpand(node.closest('.mod-file-list'))
+ })
+ })
+ }
+
// lv2 patch messages, mostly used for parameters
this.lv2PatchGet = function (uri) {
// let the host know about this
@@ -804,6 +913,7 @@ function GUI(effect, options) {
this.render = function (instance, callback, skipNamespace) {
self.instance = instance
+ self.skipNamespace = skipNamespace
var render = function () {
self.preRender()
@@ -1020,19 +1130,7 @@ function GUI(effect, options) {
if (instance && self.effect.parameters.length)
{
self.settings.find('.mod-file-list').each(function () {
- var elem = $(this)
- var list = elem.find('.mod-enumerated-list')
- if (list.length == 1 && list[0].childElementCount > 5) {
- elem.find('.file-list-btn-expand').click(function () {
- if (elem.hasClass('expanded')) {
- elem.removeClass('expanded')
- } else {
- elem.addClass('expanded')
- }
- })
- } else {
- elem.find('.file-list-btn-expand').hide()
- }
+ assignFileListExpand($(this))
})
}
diff --git a/html/js/tone3000.js b/html/js/tone3000.js
new file mode 100644
index 000000000..7319d043a
--- /dev/null
+++ b/html/js/tone3000.js
@@ -0,0 +1,284 @@
+// SPDX-FileCopyrightText: 2012-2023 MOD Audio UG
+// SPDX-License-Identifier: AGPL-3.0-or-later
+
+/*
+ * Tone3000 Select flow.
+ *
+ * This runs in a popup, not an iframe, and that is not cosmetic. TONE3000's sign-in
+ * cookie is SameSite=Lax, so it is never sent on a cross-site iframe subrequest: the
+ * OTP verifies, the cookie comes back, the next request drops it, and the user lands
+ * on the login screen again -- silently, with no console error, in every browser.
+ * Only TONE3000 can change that (SameSite=None; Secure; Partitioned, or calling
+ * requestStorageAccess() from their own page). A popup is a top-level browsing
+ * context, so its cookies are first-party and none of this applies.
+ *
+ * This file only opens that popup and mints the PKCE pair it will need. Everything
+ * that happens after the user picks a tone -- the token exchange, the API reads, the
+ * download itself -- belongs to tone3000-callback.html, which TONE3000 redirects the
+ * popup to. That page is served from our origin, so it reads the pair straight out of
+ * the sessionStorage written below.
+ */
+
+var TONE3000_STATE_KEY = 't3k_state'
+var TONE3000_VERIFIER_KEY = 't3k_code_verifier'
+var TONE3000_REDIRECT_PATH = '/tone3000-callback.html'
+var TONE3000_POPUP_NAME = 't3k_select'
+
+var tone3000Popup = null
+
+function tone3000Base64Url (bytes) {
+ var str = String.fromCharCode.apply(null, new Uint8Array(bytes))
+ return btoa(str).replace(/\+/g, '-').replace(/\//g, '_').replace(/=/g, '')
+}
+
+function tone3000RandomBase64Url (nbytes) {
+ return tone3000Base64Url(crypto.getRandomValues(new Uint8Array(nbytes)))
+}
+
+// S256 PKCE challenge. crypto.subtle only exists in a secure context. localhost is
+// one; the real device, on plain http:// over a LAN IP, is not. A pure-JS sha256
+// will be needed before this ships to hardware.
+function tone3000Sha256Base64Url (input) {
+ return crypto.subtle.digest('SHA-256', new TextEncoder().encode(input))
+ .then(tone3000Base64Url)
+}
+
+/* Build the authorize URL, stashing the PKCE verifier and CSRF state in OUR
+ sessionStorage. The popup gets only a snapshot of it, taken at window.open() time,
+ which is before these are written -- but the callback page is same-origin with us
+ and reads them back live through window.opener. */
+function tone3000BuildAuthorizeUrl () {
+ var verifier = tone3000RandomBase64Url(32)
+ var state = tone3000RandomBase64Url(16)
+
+ return tone3000Sha256Base64Url(verifier).then(function (challenge) {
+ sessionStorage.setItem(TONE3000_VERIFIER_KEY, verifier)
+ sessionStorage.setItem(TONE3000_STATE_KEY, state)
+
+ var params = {
+ client_id: TONE3000_CLIENT_ID,
+ redirect_uri: window.location.origin + TONE3000_REDIRECT_PATH,
+ response_type: 'code',
+ code_challenge: challenge,
+ code_challenge_method: 'S256',
+ state: state,
+ prompt: 'select_tone',
+ // The NAM plugin is what consumes these files; don't offer the user
+ // formats this device cannot load.
+ format: 'nam',
+ }
+
+ var qs = []
+ for (var key in params) {
+ qs.push(encodeURIComponent(key) + '=' + encodeURIComponent(params[key]))
+ }
+ return TONE3000_API + '/api/v1/oauth/authorize?' + qs.join('&')
+ })
+}
+
+// Headroom for the popup's own title bar, plus whatever the desktop reserves at the
+// bottom of the screen. Tuned by eye; nothing can measure it before the popup exists.
+var TONE3000_POPUP_CHROME = 165
+
+// What `outerHeight - innerHeight` misses. Chrome under-reports the height of its own
+// toolbars by about this much; the true value cannot be recovered from anything a page
+// can read. Unused where mozInnerScreenY exists, which needs no estimate at all.
+var TONE3000_CHROME_UNDERREPORT = 35
+
+/* Screen y of the top of our viewport.
+ *
+ * Firefox says so exactly. Everyone else gets `screenY` (the window frame) plus a guess
+ * at the chrome above the viewport, and the guess runs short -- see the constant. */
+function tone3000ViewportTop () {
+ if (window.mozInnerScreenY !== undefined) {
+ return window.mozInnerScreenY
+ }
+ return window.screenY + (window.outerHeight - window.innerHeight) + TONE3000_CHROME_UNDERREPORT
+}
+
+/* Cover the panel's content area, starting below our own title bar rather than on top
+ * of it. #tone3000-wrapper *is* that area, so measure it instead of guessing -- move
+ * the bar in CSS and the popup follows. */
+function tone3000PopupBounds () {
+ var wrapper = $('#tone3000-wrapper')[0]
+
+ return {
+ left: Math.round(window.screenX),
+ top: Math.round(tone3000ViewportTop() + wrapper.getBoundingClientRect().top),
+ width: window.innerWidth,
+ height: window.innerHeight - TONE3000_POPUP_CHROME,
+ }
+}
+
+function tone3000PopupFeatures (bounds) {
+ return 'width=' + bounds.width +
+ ',height=' + bounds.height +
+ ',left=' + bounds.left + ',top=' + bounds.top +
+ ',toolbar=no,menubar=no,location=no,status=no,resizable=yes,scrollbars=yes'
+}
+
+// How long to keep nudging the popup into place, and how often. It is shown within a
+// frame or two; the rest is slack.
+var TONE3000_PLACE_TRIES = 6
+var TONE3000_PLACE_INTERVAL = 40
+
+/* The feature string's left/top are a hint, and a browser drops them when the opener is
+ * maximized -- width and height survive, position does not. moveTo is the lever left,
+ * and only here: the popup is still the about:blank we opened, so it is same-origin.
+ * One navigation later it is tone3000.com and moveTo throws.
+ *
+ * A single move does not take: window.open() returns before the browser has shown the
+ * window, and the bounds it was created with are applied at show time, over the top of
+ * anything we set first. So keep moving it for a beat. Where the feature string was
+ * honoured this is all no-ops. */
+function tone3000PlacePopup (popup, bounds) {
+ return new Promise(function (resolve) {
+ var attempts = 0
+ function attempt () {
+ attempts += 1
+ try {
+ popup.moveTo(bounds.left, bounds.top)
+ } catch (e) {
+ // Blocked (Firefox's dom.disable_window_move_resize) or already navigated.
+ resolve()
+ return
+ }
+ if (attempts >= TONE3000_PLACE_TRIES || popup.closed) {
+ resolve()
+ return
+ }
+ window.setTimeout(attempt, TONE3000_PLACE_INTERVAL)
+ }
+ attempt()
+ })
+}
+
+function tone3000OpenSelectPopup () {
+ if (!TONE3000_CLIENT_ID) {
+ alert('TONE3000 is not configured on this device: MOD_TONE3000_CLIENT_ID is not set.')
+ return
+ }
+
+ if (tone3000Popup && !tone3000Popup.closed) {
+ tone3000Popup.focus()
+ return
+ }
+
+ // Open synchronously, while we still hold the user activation from the click.
+ // Deferring window.open until after the PKCE promise resolves gets it blocked
+ // as an unsolicited popup.
+ var bounds = tone3000PopupBounds()
+ tone3000Popup = window.open('', TONE3000_POPUP_NAME, tone3000PopupFeatures(bounds))
+ if (!tone3000Popup) {
+ alert('Popup blocked -- allow popups for this site and try again.')
+ return
+ }
+
+ // Both have to finish before the popup leaves about:blank: the URL is what we
+ // navigate to, and after navigating we can no longer move it.
+ var popup = tone3000Popup
+ Promise.all([
+ tone3000BuildAuthorizeUrl(),
+ tone3000PlacePopup(popup, bounds),
+ ]).then(function (results) {
+ popup.location = results[0]
+ }).catch(function (err) {
+ popup.close()
+ alert('Failed to build the TONE3000 authorize URL: ' + err)
+ })
+}
+
+/* Called from the popup once a download lands -- it is same-origin with us, so it reaches
+ this directly. Every plugin already on the board is holding a file list from before the
+ download, so hand each one a fresh copy, with the files just written at the top of it.
+ `downloaded` holds the paths the upload route reported writing. */
+function tone3000RefreshFileLists (downloaded) {
+ if (typeof desktop === 'undefined' || !desktop || !desktop.pedalboard) {
+ return
+ }
+ var plugins = desktop.pedalboard.data('plugins')
+ for (var instance in plugins) {
+ var plugin = plugins[instance]
+ var gui = (plugin && plugin.data) ? plugin.data('gui') : null
+ if (gui && gui.refreshFileTypesLists) {
+ gui.refreshFileTypesLists('nammodel', downloaded)
+ }
+ }
+}
+
+function tone3000ClosePopup () {
+ if (tone3000Popup && !tone3000Popup.closed) {
+ tone3000Popup.close()
+ }
+ tone3000Popup = null
+
+ sessionStorage.removeItem(TONE3000_STATE_KEY)
+ sessionStorage.removeItem(TONE3000_VERIFIER_KEY)
+}
+
+/* A popup outlives the page that opened it, and the callback page reads the PKCE pair
+ out of this window -- so a reload or a navigation would strand it on screen with no
+ opener left to read. pagehide (not unload) is the event that still fires when the
+ page goes into the bfcache. */
+window.addEventListener('pagehide', tone3000ClosePopup)
+
+/* Browser-side for now: this is a preference about this browser's popup, not device state,
+ and there is no user-settings route to put it behind. localStorage throws outright when
+ storage is disabled, rather than degrading, so every access is guarded. */
+var TONE3000_AUTO_OPEN_KEY = 't3k_auto_open'
+
+function tone3000AutoOpen () {
+ try {
+ return localStorage.getItem(TONE3000_AUTO_OPEN_KEY) === '1'
+ } catch (e) {
+ return false
+ }
+}
+
+function tone3000SetAutoOpen (enabled) {
+ try {
+ localStorage.setItem(TONE3000_AUTO_OPEN_KEY, enabled ? '1' : '0')
+ } catch (e) {
+ // Nothing to do -- the checkbox still works for this session.
+ }
+}
+
+JqueryClass('tone3000Box', {
+ init: function (options) {
+ var self = $(this)
+
+ options = $.extend({
+ isMainWindow: true,
+ windowName: "Tone3000",
+ }, options)
+
+ self.data(options)
+
+ self.find('#tone3000-browse').click(function () {
+ tone3000OpenSelectPopup()
+ return false
+ })
+
+ var autoOpen = self.find('#tone3000-autoopen')
+ autoOpen.prop('checked', tone3000AutoOpen())
+ autoOpen.change(function () {
+ tone3000SetAutoOpen(this.checked)
+ })
+
+ /* windowopen fires inside the click that selected the tab, so we still hold the user
+ activation window.open needs. Opening the popup any later gets it blocked.
+
+ There is deliberately no windowclose handler. It fires whenever the panel hides --
+ including when the window manager hides it to raise another panel -- and closing
+ the popup there meant every trip through another tab threw away the user's place
+ in the catalog. The popup outlives the panel; only leaving the page closes it. */
+ options.open = function () {
+ if (tone3000AutoOpen()) {
+ tone3000OpenSelectPopup()
+ }
+ return false
+ }
+
+ self.window(options)
+ },
+})
diff --git a/html/tone3000-callback.html b/html/tone3000-callback.html
new file mode 100644
index 000000000..511ef431d
--- /dev/null
+++ b/html/tone3000-callback.html
@@ -0,0 +1,424 @@
+
+
+
+
+ Tone3000 download
+
+
+
+
+ (creating parent dirs) for a test.
+
+ Thin wrapper around conftest's user_files fixture helper, exposed
+ here because pytest fixture return values can't be injected as
+ parameters into unittest.TestCase test methods (which is what these
+ AsyncHTTPTestCase-derived tests are). The autouse `user_files`
+ fixture in conftest.py still handles wiping USER_FILES_DIR between
+ tests.
+ """
+ return _UserFilesHelper(_USER_FILES_DIR).seed(relpath, content=content)
+
+ def fetch_json(self, path, **kwargs):
+ """GET/POST/etc. `path` and decode the response body as JSON.
+
+ Asserts the response declares a JSON content type, matching the
+ JsonRequestHandler.write() convention used across mod/webserver.py.
+ """
+ response = self.fetch(path, **kwargs)
+ content_type = response.headers.get("Content-Type", "")
+ assert "application/json" in content_type, (
+ "expected JSON content type for %s, got %r (body: %r)"
+ % (path, content_type, response.body)
+ )
+ return response, json.loads(response.body.decode("utf-8"))
diff --git a/test/conftest.py b/test/conftest.py
new file mode 100644
index 000000000..a480d3325
--- /dev/null
+++ b/test/conftest.py
@@ -0,0 +1,256 @@
+#!/usr/bin/env python3
+# SPDX-FileCopyrightText: 2012-2023 MOD Audio UG
+# SPDX-License-Identifier: AGPL-3.0-or-later
+
+"""
+Layer-1 characterization test harness bootstrap.
+
+This module runs at collection time, BEFORE any test module gets a chance to
+``import mod.webserver`` (and transitively ``mod.settings``, which reads every
+``MOD_*`` env var at import time). So all environment setup below is plain
+module-level code, not a fixture -- fixtures would run too late.
+
+These tests exercise the real ``mod.webserver.application`` (the module-level
+tornado ``web.Application`` built at import time) against a throwaway on-disk
+tree. Nothing here calls ``mod.webserver.run()`` or ``prepare()`` -- those pull
+in real hardware / mod-host / JACK setup that isn't available in this dev
+environment.
+
+NEVER-CALL LIST -- routes no test in this suite may fetch. They run
+subprocesses, write outside the sandboxed temp tree, or block forever:
+
+- ``/system/cleanup`` deletes ``~/.pedalboards`` and ``~/.lv2``
+- ``/system/exechange`` reboot/systemctl/mod-backup subprocesses
+- ``/update/download/``, ``/update/begin`` writes under /data, /tmp
+- ``/controlchain/download/`` firmware download, subprocess mv to /tmp
+- ``/switch_cpu_freq/`` writes /sys/devices/system/cpu
+- ``/recording/*`` needs JACK; ``play/wait`` long-polls forever
+- ``/pedalboard/pack_bundle``, ``/pedalboard/load_web``,
+ ``/pedalboard/factorycopy``, ``/pedalboard/image/generate`` subprocesses
+- ``/effect/install``, ``/sdk/install``, ``/package/uninstall`` touch the
+ plugin dir via subprocess tar / rmtree
+- ``/effect/list``, ``/effect/get*``, ``/effect/bulk``, ``/effect/add``,
+ ``/effect/image``, ``/effect/file``, ``/resources/(.*)?uri=`` dereference
+ the global lilv world, which is NULL until ``modtools.utils.init()`` runs
+ -- calling them without init SEGFAULTS the test process (see the phase-6
+ spec in docs/ before touching these)
+- ``/pedalboard/list``, ``/banks/`` while a real pedalboard bundle exists in
+ the sandbox pedalboards dir -- get_all_pedalboards SEGFAULTS parsing it
+ (NamespaceDefinitions::init / lilv_new_uri, needs the uninitialized global
+ lilv world). Both are safe against an EMPTY pedalboards dir; save/remove a
+ bundle within one test and only list after the dir is empty again
+- ``/effect/remove/`` HANGS (no crash, no timeout server-side --
+ the response is simply never sent) for any instance name not already
+ registered in ``SESSION.host.mapper``, which is every instance name in
+ this sandbox (``POST /effect/add`` is itself banned above, so no instance
+ can ever be registered). Root cause: ``Host.remove_plugin``
+ (``mod/host.py:2604``, ``@gen.coroutine``) calls
+ ``self.mapper.get_id_without_creating(instance)`` *before* its own
+ try/except KeyError guard around ``self.plugins.pop(...)`` a few lines
+ down -- the KeyError from the lookup itself is swallowed into the
+ coroutine's Future instead of propagating, so the handler's
+ ``callback(False)`` is never reached and ``gen.Task`` in ``EffectRemove``
+ never resolves. Confirmed by probing with a 4s client-side
+ ``request_timeout``: HTTP 599 (client timeout), not a fast response. See
+ ``test/test_host_commands.py`` module docstring (phase 4).
+"""
+
+import atexit
+import os
+import shutil
+import sys
+import tempfile
+
+import pytest
+
+# ----------------------------------------------------------------------------
+# 0. Fail fast if the native extension mod.webserver depends on isn't built.
+# ----------------------------------------------------------------------------
+
+REPO_ROOT = os.path.dirname(os.path.dirname(os.path.abspath(__file__)))
+_LIBMOD_UTILS_SO = os.path.join(REPO_ROOT, "utils", "libmod_utils.so")
+
+if not os.path.isfile(_LIBMOD_UTILS_SO):
+ pytest.exit(
+ "libmod_utils.so not found at {0}.\n"
+ "Build it first: `make -C utils` (from the repo root). See "
+ "mod-ui/CLAUDE.md for one-time environment setup.".format(_LIBMOD_UTILS_SO),
+ returncode=1,
+ )
+
+# ----------------------------------------------------------------------------
+# 1. Build a throwaway data/user-files tree and point every MOD_* env var
+# that mod.settings reads at it, BEFORE mod.webserver (and mod.settings)
+# is ever imported by a test module.
+# ----------------------------------------------------------------------------
+
+_TEST_ROOT = tempfile.mkdtemp(prefix="modui-test-")
+
+_DATA_DIR = os.path.join(_TEST_ROOT, "data")
+_USER_FILES_DIR = os.path.join(_TEST_ROOT, "user-files")
+_PEDALBOARDS_DIR = os.path.join(_TEST_ROOT, "pedalboards")
+_PLUGINS_DIR = os.path.join(_TEST_ROOT, "lv2")
+# Empty, dedicated -- deliberately NOT the same dir as _PLUGINS_DIR
+# (MOD_USER_PLUGINS_DIR) above, to avoid conflating "where mod-ui thinks user
+# plugins live" with "what lilv scans for the phase-6 tests" even though
+# both happen to be empty today.
+_LV2_SCAN_DIR = os.path.join(_TEST_ROOT, "lv2-path-empty")
+
+os.makedirs(_DATA_DIR, exist_ok=True)
+os.makedirs(_USER_FILES_DIR, exist_ok=True)
+os.makedirs(_PEDALBOARDS_DIR, exist_ok=True)
+os.makedirs(_PLUGINS_DIR, exist_ok=True)
+os.makedirs(_LV2_SCAN_DIR, exist_ok=True)
+
+# Replicate the bits of mod.check_environment() that handlers rely on but
+# that we never call (check_environment() only runs inside prepare()).
+with open(os.path.join(_DATA_DIR, "banks.json"), "w") as fh:
+ fh.write("[]")
+with open(os.path.join(_DATA_DIR, "favorites.json"), "w") as fh:
+ fh.write("[]")
+
+os.environ["MOD_DEV_ENVIRONMENT"] = "1"
+os.environ["MOD_LOG"] = "0"
+os.environ["MOD_DATA_DIR"] = _DATA_DIR
+os.environ["MOD_USER_FILES_DIR"] = _USER_FILES_DIR
+os.environ["MOD_HTML_DIR"] = os.path.join(REPO_ROOT, "html")
+os.environ["MOD_DEFAULT_PEDALBOARD"] = os.path.join(REPO_ROOT, "default.pedalboard")
+# Without these two, mod.settings defaults LV2_PEDALBOARDS_DIR/LV2_PLUGIN_DIR
+# to ~/.pedalboards and ~/.lv2 -- and pedalboard save/remove handlers would
+# write into the REAL user home instead of the sandbox.
+os.environ["MOD_USER_PEDALBOARDS_DIR"] = _PEDALBOARDS_DIR
+os.environ["MOD_USER_PLUGINS_DIR"] = _PLUGINS_DIR
+
+# Phase 6 (docs/characterization-phase-6.md): lilv (the C++ library backing
+# modtools.utils.init()) reads the LV2_PATH env var itself, via plain getenv,
+# at lilv_world_load_all() time inside init() -- not at Python import time
+# and not cached anywhere in Python. Confirmed by reading utils/utils_lilv.cpp
+# init() (~:3893): it only calls lilv_world_new()/lilv_world_load_all(W), with
+# no explicit LV2_PATH manipulation of its own (unlike e.g. get_all_pedalboards
+# a few hundred lines below, which saves/restores LV2_PATH around its own
+# private world). So setting os.environ["LV2_PATH"] here, well before any
+# phase-6 test module even calls init() at fixture time, is sufficient --
+# CPython's os.environ.__setitem__ calls os.putenv() under the hood, which is
+# what a later getenv() in the C library will see. Point it at an empty,
+# sandboxed dir so the lilv world phase 6 builds is always empty and
+# deterministic, never the machine's real ~/.lv2 or /usr/lib/lv2.
+os.environ["LV2_PATH"] = _LV2_SCAN_DIR
+
+# ----------------------------------------------------------------------------
+# 1b. Sandbox guard: every writable path mod.settings resolves must live
+# under the throwaway test root. mod.settings only reads env vars and
+# stdlib (importing it here is cheap and does NOT load libmod_utils.so),
+# so this catches a broken/renamed MOD_* env var before any test can
+# write outside the sandbox.
+# ----------------------------------------------------------------------------
+
+from mod import settings as _mod_settings # noqa: E402 (needs env set above)
+
+for _name in ("DATA_DIR", "USER_FILES_DIR", "LV2_PEDALBOARDS_DIR", "LV2_PLUGIN_DIR"):
+ _path = os.path.realpath(getattr(_mod_settings, _name))
+ if not _path.startswith(os.path.realpath(_TEST_ROOT) + os.sep):
+ pytest.exit(
+ "SANDBOX GUARD: mod.settings.{0} resolves to {1}, which is outside "
+ "the test root {2}. Refusing to run -- tests could write into real "
+ "user/system directories. Check the MOD_* env vars set in "
+ "test/conftest.py against mod/settings.py.".format(_name, _path, _TEST_ROOT),
+ returncode=1,
+ )
+
+# Make the repo importable the same way server.py does (test/ is not on
+# sys.path by default under some pytest invocations).
+if REPO_ROOT not in sys.path:
+ sys.path.insert(0, REPO_ROOT)
+
+
+def _cleanup_test_root():
+ shutil.rmtree(_TEST_ROOT, ignore_errors=True)
+
+
+atexit.register(_cleanup_test_root)
+
+# ----------------------------------------------------------------------------
+# 2. Fixtures
+# ----------------------------------------------------------------------------
+
+
+class _UserFilesHelper(object):
+ """Exposes USER_FILES_DIR plus a seed() helper to test modules."""
+
+ def __init__(self, root):
+ self.root = root
+
+ def seed(self, relpath, content=b"data"):
+ """Create USER_FILES_DIR/ (and any parent dirs) with content."""
+ fullpath = os.path.join(self.root, relpath)
+ os.makedirs(os.path.dirname(fullpath), exist_ok=True)
+ mode = "wb" if isinstance(content, bytes) else "w"
+ with open(fullpath, mode) as fh:
+ fh.write(content)
+ return fullpath
+
+
+def _reset_user_files_dir():
+ if os.path.isdir(_USER_FILES_DIR):
+ shutil.rmtree(_USER_FILES_DIR)
+ os.makedirs(_USER_FILES_DIR, exist_ok=True)
+
+
+@pytest.fixture(autouse=True)
+def user_files():
+ """Function-scoped, autouse: wipe and recreate USER_FILES_DIR around
+ every test, so tests never see leftovers from one another.
+
+ USER_FILES_DIR itself is fixed for the whole process (mod.settings reads
+ MOD_USER_FILES_DIR once, at import time), so we can't swap directories
+ per-test -- instead we clear its contents.
+
+ autouse=True (rather than requiring tests to depend on it explicitly)
+ because our test classes are unittest.TestCase subclasses
+ (tornado.testing.AsyncHTTPTestCase) -- pytest applies autouse fixtures'
+ setup/teardown around unittest-style tests too, but does NOT support
+ injecting a fixture's return value as a test-method parameter for them.
+ Tests that need to seed files use ModUITestCase.seed() (test/base.py)
+ instead, which points at this same directory.
+ """
+ _reset_user_files_dir()
+ yield _UserFilesHelper(_USER_FILES_DIR)
+ _reset_user_files_dir()
+
+
+def _reset_pedalboards_dir():
+ if os.path.isdir(_PEDALBOARDS_DIR):
+ shutil.rmtree(_PEDALBOARDS_DIR)
+ os.makedirs(_PEDALBOARDS_DIR, exist_ok=True)
+
+
+@pytest.fixture(autouse=True)
+def pedalboards_dir():
+ """Function-scoped, autouse: wipe/recreate LV2_PEDALBOARDS_DIR and reset
+ the process-global SESSION around every test.
+
+ Mirrors ``user_files`` above, for the same reason: LV2_PEDALBOARDS_DIR is
+ fixed for the whole process (mod.settings reads MOD_USER_PEDALBOARDS_DIR
+ once, at import time), so we clear its contents instead of swapping
+ directories. Phase 3 (docs/characterization-phase-3.md) is the first
+ phase whose tests write real pedalboard bundles to disk via
+ ``SESSION.host.save()`` (through ``POST /pedalboard/save``) and mutate
+ process-global state on ``SESSION.host`` (``pedalboard_path``,
+ ``pedalboard_snapshots``, ``current_pedalboard_snapshot_id``, ...) via
+ ``/pedalboard/load_bundle/`` and ``/snapshot/*``. Neither the on-disk
+ bundles nor that in-memory state may leak between tests or modules.
+
+ ``SESSION.reset(callback)`` (mod/session.py) runs its callback
+ synchronously here: under ``MOD_DEV_ENVIRONMENT=1`` the FakeHMI is never
+ "initialized" (see module docstring), so ``Session.reset`` takes its
+ synchronous branch straight to ``Host.reset``, and ``FakeHost`` (see
+ ``mod/development.py``) invokes every ``send_notmodified``/
+ ``send_modified`` callback immediately with ``True`` -- no real
+ mod-host, no IOLoop pump required.
+ """
+ _reset_pedalboards_dir()
+ from mod.webserver import SESSION
+ SESSION.reset(lambda ok: None)
+ yield
+ SESSION.reset(lambda ok: None)
+ _reset_pedalboards_dir()
diff --git a/test/fixtures/phase6-fixture.lv2/manifest.ttl b/test/fixtures/phase6-fixture.lv2/manifest.ttl
new file mode 100644
index 000000000..636a5adb3
--- /dev/null
+++ b/test/fixtures/phase6-fixture.lv2/manifest.ttl
@@ -0,0 +1,7 @@
+@prefix lv2: .
+@prefix rdfs: .
+
+
+ a lv2:Plugin ;
+ lv2:binary ;
+ rdfs:seeAlso .
diff --git a/test/fixtures/phase6-fixture.lv2/phase6-fixture.ttl b/test/fixtures/phase6-fixture.lv2/phase6-fixture.ttl
new file mode 100644
index 000000000..8c8561d25
--- /dev/null
+++ b/test/fixtures/phase6-fixture.lv2/phase6-fixture.ttl
@@ -0,0 +1,25 @@
+@prefix lv2: .
+@prefix doap: .
+@prefix rdfs: .
+@prefix foaf:
+ a lv2:Plugin, lv2:UtilityPlugin ;
+ doap:name "Phase 6 Fixture" ;
+ doap:license ;
+ doap:maintainer [
+ foaf:name "mod-ui characterization tests"
+ ] ;
+ lv2:microVersion 0 ;
+ lv2:minorVersion 1 ;
+ lv2:port [
+ a lv2:InputPort, lv2:AudioPort ;
+ lv2:index 0 ;
+ lv2:symbol "in" ;
+ lv2:name "In"
+ ] , [
+ a lv2:OutputPort, lv2:AudioPort ;
+ lv2:index 1 ;
+ lv2:symbol "out" ;
+ lv2:name "Out"
+ ] .
diff --git a/test/js/README.md b/test/js/README.md
new file mode 100644
index 000000000..d0080f3ec
--- /dev/null
+++ b/test/js/README.md
@@ -0,0 +1,65 @@
+# Frontend tests
+
+Tests for the browser JavaScript in `html/js/`. The Python backend has its own suite in
+`test/` (pytest); this is the JS side.
+
+## Running
+
+```bash
+npm install # once, pulls in jsdom (the only dependency)
+npm test # runs everything under test/js/
+npm run test:watch
+```
+
+Node's built-in test runner (`node --test`, `node:assert`) — no Jest, no Vitest, no build
+step. The only third-party dependency is `jsdom`.
+
+## How it works
+
+`html/js/*.js` is not modular. It defines globals and assumes `jQuery`, `Mustache` and a few
+page variables already exist, so it cannot be `require`d. Instead `harness.js` stands up a
+jsdom window, loads the real vendored libraries, then loads the **real source file under
+test** with `window.eval` and drives its now-global functions. The tests exercise the
+shipped code, not a copy of it.
+
+`harness.js` exports:
+
+- `makeWindow({url, body})` — a jsdom window with jQuery/Mustache loaded and the page globals
+ (`VERSION`, `baseUrl`, `desktop`, `isSDK`) defined. Returns `{window, $, load}` where
+ `load(rel)` evals a source file, `rel` being relative to `html/`.
+- `captureWindowOptions(ctx)` — grabs the options a `JqueryClass` box hands to
+ `self.window(...)`, without pulling in the real overlay machinery.
+- `stubAjax(ctx, routes)` — an `$.ajax` that answers by URL substring.
+
+## What this can and cannot test
+
+jsdom has a DOM but no browser around it. So:
+
+**In scope** — DOM manipulation and logic. Widget rendering and re-rendering, event wiring,
+list ordering, preference storage, the shape of data handed between functions. This is where
+the bugs these tests were written for actually lived.
+
+**Out of scope, stays manual** — anything needing a real browser:
+
+- **Layout.** `getBoundingClientRect` is all zeros in jsdom, so popup *placement* (the
+ `mozInnerScreenY` / chrome-height math in `tone3000.js`) cannot be tested here.
+- **Windowing.** `window.open` is a stub; there is no real popup, no cross-window focus, no
+ cookie behaviour.
+- **CSS.** No cascade, no computed styles.
+- **The network and the Tornado backend.** Backend routes are tested in `test/` (pytest);
+ the `POST /files/upload` guards and the `fullname` round-trip belong there, not here.
+
+Keep this boundary honest — a green suite that quietly doesn't cover placement or the backend
+is worse than no suite, because it reads as coverage.
+
+## Files
+
+- `harness.js` — the rig described above (not itself a test; `*.test.js` are the tests).
+- `modgui.filelist.test.js` — `GUI.refreshFileTypesLists` / `swapFileWidgets`: refreshing a
+ plugin's file dropdown in place, across two templates that nest options differently. Runs
+ against `fixtures/icon-nested.html` and the shipped `html/resources/settings.html`.
+- `fixtures/icon-nested.html` — a plugin-icon template whose file options nest inside a
+ `.mod-enumerated-list`, the way NAM's icon does. Vendored so the suite needs only the
+ `mod-ui` checkout, not the sibling `mod-fs/` dev tree.
+- `tone3000.autoopen.test.js` — the Tone3000 tab's auto-open preference and the popup's
+ lifetime relative to the tab.
diff --git a/test/js/fixtures/icon-nested.html b/test/js/fixtures/icon-nested.html
new file mode 100644
index 000000000..589453cbf
--- /dev/null
+++ b/test/js/fixtures/icon-nested.html
@@ -0,0 +1,55 @@
+
+/ will list fine.
+ self.seed("NAM Models/top.nam")
+ self.seed("NAM Models/MyPack/clean.nam")
+ self.seed("NAM Models/MyPack/Nested/deep.nam")
+
+ response, body = self.fetch_json("/files/list?types=nammodel")
+ self.assertEqual(response.code, 200)
+ basenames = sorted(f["basename"] for f in body["files"])
+ self.assertEqual(basenames, ["clean.nam", "deep.nam", "top.nam"])
+
+ def test_nammodel_results_sorted_by_full_path(self):
+ # Pins DP2's findability baseline: ordering is decided by full path.
+ self.seed("NAM Models/zzz.nam")
+ self.seed("NAM Models/aaa.nam")
+ self.seed("NAM Models/MyPack/mmm.nam")
+
+ response, body = self.fetch_json("/files/list?types=nammodel")
+ self.assertEqual(response.code, 200)
+ fullnames = [f["fullname"] for f in body["files"]]
+ self.assertEqual(fullnames, sorted(fullnames))
+
+ def test_nammodel_walk_is_fresh_every_request(self):
+ # Pins that /files/list is NOT cached server-side: a file dropped in
+ # between two requests is visible on the second request with no
+ # extra signal needed (the staleness the Tone3000 feature must
+ # solve is 100% client-side).
+ self.seed("NAM Models/first.nam")
+
+ _, body1 = self.fetch_json("/files/list?types=nammodel")
+ self.assertEqual([f["basename"] for f in body1["files"]], ["first.nam"])
+
+ self.seed("NAM Models/second.nam")
+
+ _, body2 = self.fetch_json("/files/list?types=nammodel")
+ self.assertEqual(
+ sorted(f["basename"] for f in body2["files"]),
+ ["first.nam", "second.nam"],
+ )
+
+ def test_multiple_types_are_unioned_with_own_filetype_tag(self):
+ self.seed("NAM Models/amp.nam")
+ self.seed("Reverb IRs/hall.wav")
+
+ response, body = self.fetch_json("/files/list?types=nammodel,ir")
+ self.assertEqual(response.code, 200)
+
+ by_basename = {f["basename"]: f for f in body["files"]}
+ self.assertEqual(set(by_basename), {"amp.nam", "hall.wav"})
+ self.assertEqual(by_basename["amp.nam"]["filetype"], "nammodel")
+ self.assertEqual(by_basename["hall.wav"]["filetype"], "ir")
diff --git a/test/test_files_upload.py b/test/test_files_upload.py
new file mode 100644
index 000000000..89669cafd
--- /dev/null
+++ b/test/test_files_upload.py
@@ -0,0 +1,95 @@
+#!/usr/bin/env python3
+# SPDX-FileCopyrightText: 2012-2023 MOD Audio UG
+# SPDX-License-Identifier: AGPL-3.0-or-later
+
+"""Tests for POST /files/upload/ (mod/webserver.py:FilesUpload).
+
+The route is the one server-side piece of the Tone3000 download: a browser
+page fetches the model bytes itself and hands them here to be written under
+USER_FILES_DIR. Everything it refuses, it refuses with a plain 400 *before*
+touching the disk -- these tests pin both the happy path and each refusal.
+"""
+
+import json
+import os
+from urllib.parse import urlencode
+
+from base import ModUITestCase
+from conftest import _USER_FILES_DIR
+
+
+def upload_url(filetype="nammodel", folder="My Tone (12)", name="model.nam"):
+ return "/files/upload/%s?%s" % (filetype, urlencode({"folder": folder, "name": name}))
+
+
+class TestFilesUpload(ModUITestCase):
+ __test__ = True
+
+ def upload(self, body=b"nam-bytes", content_type="application/octet-stream", **kwargs):
+ headers = {"Content-Type": content_type} if content_type is not None else None
+ return self.fetch(upload_url(**kwargs), method="POST", body=body, headers=headers)
+
+ def user_files(self):
+ found = []
+ for root, _, files in os.walk(str(_USER_FILES_DIR)):
+ found.extend(os.path.join(root, f) for f in files)
+ return found
+
+ def test_happy_path_writes_and_reports_the_fullname_files_list_shows(self):
+ response = self.upload(folder="Clean Amp (7)", name="Clean Amp - Standard.nam")
+ self.assertEqual(response.code, 200)
+
+ body = json.loads(response.body.decode("utf-8"))
+ self.assertTrue(body["ok"])
+ self.assertTrue(body["fullname"].endswith("NAM Models/Clean Amp (7)/Clean Amp - Standard.nam"))
+
+ with open(body["fullname"], "rb") as fh:
+ self.assertEqual(fh.read(), b"nam-bytes")
+
+ # The reported fullname is byte-for-byte what /files/list will show,
+ # so a caller can find its own upload in the list.
+ _, listing = self.fetch_json("/files/list?types=nammodel")
+ self.assertEqual([f["fullname"] for f in listing["files"]], [body["fullname"]])
+
+ def test_extension_check_is_case_insensitive_like_files_list(self):
+ response = self.upload(name="AMP.NAM")
+ self.assertEqual(response.code, 200)
+
+ def test_unknown_filetype_is_400(self):
+ self.assertEqual(self.upload(filetype="bogus").code, 400)
+
+ def test_unmapped_filetype_is_400(self):
+ # "nam" is a real mod:fileTypes value the NAM plugin declares, but the
+ # category map deliberately returns no folder for it -- only "nammodel"
+ # (and "aidadspmodel") map to a directory.
+ self.assertEqual(self.upload(filetype="nam").code, 400)
+
+ def test_wrong_content_type_is_400(self):
+ # Anything except application/octet-stream is refused; among other
+ # things this keeps every cross-origin POST behind a CORS preflight
+ # that mod-ui never answers.
+ self.assertEqual(self.upload(content_type="text/plain").code, 400)
+ self.assertEqual(self.upload(content_type="multipart/form-data").code, 400)
+
+ def test_wrong_extension_is_400(self):
+ self.assertEqual(self.upload(name="model.wav").code, 400)
+ self.assertEqual(self.upload(name="model").code, 400)
+
+ def test_traversal_in_name_or_folder_is_400_and_writes_nothing(self):
+ for folder, name in (
+ ("..", "model.nam"), # parent dir as the folder
+ ("a/b", "model.nam"), # separator smuggled into folder
+ ("pack", "../evil.nam"), # separator smuggled into name
+ ):
+ response = self.upload(folder=folder, name=name)
+ self.assertEqual(response.code, 400, "folder=%r name=%r" % (folder, name))
+
+ self.assertEqual(self.user_files(), [], "a refused upload must write nothing")
+
+ def test_empty_or_dot_components_are_400(self):
+ for folder, name in (("", "model.nam"), (".", "model.nam"),
+ ("pack", ""), ("pack", "."), ("pack", "..")):
+ response = self.upload(folder=folder, name=name)
+ self.assertEqual(response.code, 400, "folder=%r name=%r" % (folder, name))
+
+ self.assertEqual(self.user_files(), [])
diff --git a/test/test_host_commands.py b/test/test_host_commands.py
new file mode 100644
index 000000000..27ca1cbab
--- /dev/null
+++ b/test/test_host_commands.py
@@ -0,0 +1,296 @@
+#!/usr/bin/env python3
+# SPDX-FileCopyrightText: 2012-2023 MOD Audio UG
+# SPDX-License-Identifier: AGPL-3.0-or-later
+
+"""Characterization tests for the handlers that route into
+SESSION.host/SESSION.hmi (mod/webserver.py: EffectConnect, EffectDisconnect,
+EffectParameterSet, EffectParameterAddress, DashboardClean, SetBufferSize,
+ResetXruns, JackGetMidiDevices, JackSetMidiDevices, TrueBypass,
+PedalboardTransportSetSyncMode, PedalboardCvAddressingPluginPortAdd).
+
+Honest caveat: these tests pin the behavior of the mod/webserver.py handler
+code under FakeHost/FakeHMI (mod/development.py), NOT the production
+mod-host protocol. They are a regression net for webserver.py edits,
+nothing more.
+
+CRITICAL, spec-overriding finding: GET /effect/remove/ HANGS (does
+not error, does not time out server-side -- the HTTP response is simply
+never sent) when was never registered with SESSION.host.mapper,
+which is true of *every* instance name in this sandbox since we cannot call
+POST /effect/add (banned -- dereferences the uninitialized global lilv
+world, see test/conftest.py NEVER-CALL LIST). Root cause, confirmed by
+direct probing with a 4s client-side request_timeout (got HTTP 599 after
+the timeout, not a fast response): Host.remove_plugin (mod/host.py:2604,
+decorated @gen.coroutine) calls self.mapper.get_id_without_creating(instance)
+*before* its own try/except KeyError guard around self.plugins.pop(...). A
+nonexistent instance means that lookup itself raises KeyError, which the
+@gen.coroutine machinery captures into the returned (never awaited-on)
+Future instead of propagating synchronously -- so the handler's
+`callback(False)` line is never reached, gen.Task in EffectRemove never
+resolves, and the request hangs until the HTTP client's own timeout. This
+class does not call GET /effect/remove/* at all; the route has been added to
+the test/conftest.py NEVER-CALL LIST with this reasoning.
+
+Every test below that mutates SESSION.host state relies on the autouse
+`pedalboards_dir` fixture (test/conftest.py) to call SESSION.reset() before
+and after each test method, EXCEPT sync-mode: SESSION.reset() does not touch
+SESSION.host.profile, so the sync-mode test explicitly restores the default
+("/none") at the end.
+"""
+
+import json
+import urllib.parse
+
+from base import ModUITestCase
+
+
+class TestEffectConnectDisconnect(ModUITestCase):
+ __test__ = True
+
+ def test_connect_between_system_ports_returns_true_and_is_idempotent(self):
+ # "/graph/capture_1" and "/graph/playback_1" are hardware-port
+ # shortcuts handled entirely inside Host._fix_host_connection_port
+ # (mod/host.py) without touching the plugin mapper, so they are safe
+ # "syntactically valid but nonexistent instance" stand-ins per the
+ # spec's guidance. FakeHost.send_modified (mod/development.py)
+ # invokes its callback immediately with True regardless of whether
+ # the ports are real JACK ports -- there is no validation under the
+ # fakes.
+ response, body = self.fetch_json(
+ "/effect/connect/graph/capture_1,/graph/playback_1"
+ )
+ self.assertEqual(response.code, 200)
+ self.assertIs(body, True)
+
+ # Second call: (port_from, port_to) is now already in
+ # self.connections, so Host.connect short-circuits to callback(True)
+ # without going through send_modified again -- still True.
+ response2, body2 = self.fetch_json(
+ "/effect/connect/graph/capture_1,/graph/playback_1"
+ )
+ self.assertEqual(response2.code, 200)
+ self.assertIs(body2, True)
+
+ # Clean up: disconnect so SESSION.host.connections is restored to
+ # empty (belt-and-braces -- the autouse fixture would clear it too).
+ response3, body3 = self.fetch_json(
+ "/effect/disconnect/graph/capture_1,/graph/playback_1"
+ )
+ self.assertEqual(response3.code, 200)
+ self.assertIs(body3, True)
+
+ def test_disconnect_with_no_active_connections_returns_true(self):
+ # Spec guessed this might be `false`. Observed: Host.disconnect's
+ # inner host_callback(ok) *always* calls callback(True) regardless
+ # of ok (mod/host.py:3422-3436, "always return true" per its own
+ # comment) -- even the len(self.connections) == 0 short-circuit
+ # path (host_callback(False)) ends up reporting True to the client.
+ response, body = self.fetch_json(
+ "/effect/disconnect/graph/capture_1,/graph/playback_1"
+ )
+ self.assertEqual(response.code, 200)
+ self.assertIs(body, True)
+
+
+class TestEffectParameterSet(ModUITestCase):
+ __test__ = True
+
+ def test_parameter_set_short_circuits_true_when_hmi_uninitialized(self):
+ # FakeHMI.initialized is always False (mod/development.py), so
+ # EffectParameterSet.post's `if not SESSION.hmi.initialized:
+ # self.write(True); return` guard fires before the request body is
+ # even parsed -- an empty body is fine.
+ response, body = self.fetch_json(
+ "/effect/parameter/set/", method="POST", body=b""
+ )
+ self.assertEqual(response.code, 200)
+ self.assertIs(body, True)
+
+
+class TestEffectParameterAddress(ModUITestCase):
+ __test__ = True
+
+ def test_address_nonexistent_instance_returns_false(self):
+ # Unlike EffectRemove, Host.address (mod/host.py:4795) uses
+ # self.mapper.get_id(instance) -- the *creating* variant, which
+ # never raises -- so a never-seen instance safely resolves to
+ # pluginData is None and callback(False) fires synchronously.
+ body_json = json.dumps(
+ {"uri": "https://example.org/actuator", "minimum": 0, "maximum": 1, "value": 0.5}
+ ).encode("utf-8")
+ response, body = self.fetch_json(
+ "/effect/parameter/address/graph/nonexistent/gain",
+ method="POST",
+ body=body_json,
+ )
+ self.assertEqual(response.code, 200)
+ self.assertIs(body, False)
+
+ def test_address_missing_uri_is_404(self):
+ # EffectParameterAddress.post checks `data.get('uri', None) is
+ # None` before anything else and raises web.HTTPError(404).
+ response = self.fetch(
+ "/effect/parameter/address/graph/nonexistent/gain",
+ method="POST",
+ body=b"{}",
+ )
+ self.assertEqual(response.code, 404)
+
+
+class TestReset(ModUITestCase):
+ __test__ = True
+
+ def test_reset_returns_true(self):
+ # SESSION.reset under FakeHMI (never initialized) takes the
+ # synchronous reset_host(True) branch straight to Host.reset, and
+ # FakeHost invokes every send_notmodified callback immediately with
+ # True.
+ response, body = self.fetch_json("/reset/")
+ self.assertEqual(response.code, 200)
+ self.assertIs(body, True)
+
+
+class TestSetBufferSize(ModUITestCase):
+ __test__ = True
+
+ def test_128_and_256_return_ok_false_size_zero(self):
+ # Matches the spec's own prediction: under MOD_DEV_ENVIRONMENT,
+ # IMAGE_VERSION is None so the /data/jack-buffer-size write is
+ # skipped, and set_jack_buffer_size (utils/utils_jack.cpp) is a
+ # null-guarded no-op that returns 0 without a JACK client -- so
+ # newsize (0) never equals the requested size, and 'ok' is always
+ # False.
+ for size in ("128", "256"):
+ response, body = self.fetch_json(
+ "/set_buffersize/%s" % size, method="POST", body=b""
+ )
+ self.assertEqual(response.code, 200)
+ self.assertEqual(body, {"ok": False, "size": 0})
+
+
+class TestResetXruns(ModUITestCase):
+ __test__ = True
+
+ def test_reset_xruns_returns_true(self):
+ response, body = self.fetch_json("/reset_xruns/", method="POST", body=b"")
+ self.assertEqual(response.code, 200)
+ self.assertIs(body, True)
+
+
+class TestJackMidiDevices(ModUITestCase):
+ __test__ = True
+
+ def test_get_midi_devices_shape_under_fake_host(self):
+ # No JACK client -> Host.get_midi_ports() (backing
+ # web_get_midi_device_list) reports no devices; midiAggregatedMode
+ # defaults to True (mod/host.py:368, Host.__init__).
+ response, body = self.fetch_json("/jack/get_midi_devices")
+ self.assertEqual(response.code, 200)
+ self.assertEqual(
+ body,
+ {
+ "devsInUse": [],
+ "devList": [],
+ "names": {},
+ "midiAggregatedMode": True,
+ },
+ )
+
+ def test_set_midi_devices_matching_current_state_is_a_true_noop(self):
+ # devs=[], midiAggregatedMode=True, midiLoopback=False exactly match
+ # Host.__init__'s defaults (mod/host.py:368-369), so both the
+ # "mode changed" and "loopback changed" branches inside
+ # Host.set_midi_devices are skipped -- a side-effect-free call that
+ # still returns True (the handler always writes True on success).
+ body_json = json.dumps(
+ {"devs": [], "midiAggregatedMode": True, "midiLoopback": False}
+ ).encode("utf-8")
+ response, body = self.fetch_json(
+ "/jack/set_midi_devices", method="POST", body=body_json
+ )
+ self.assertEqual(response.code, 200)
+ self.assertIs(body, True)
+
+ def test_set_midi_devices_missing_key_is_500(self):
+ # Spec guessed "echo/true -- observe". Observed: JackSetMidiDevices
+ # .post does three unguarded dict subscripts (data['devs'],
+ # data['midiAggregatedMode'], data['midiLoopback']) with no
+ # try/except -- a body missing any of them raises an uncaught
+ # KeyError before any yield, which tornado turns into a plain 500,
+ # not a JSON error shape.
+ body_json = json.dumps({"devs": []}).encode("utf-8")
+ response = self.fetch(
+ "/jack/set_midi_devices", method="POST", body=body_json
+ )
+ self.assertEqual(response.code, 500)
+
+
+class TestTrueBypass(ModUITestCase):
+ __test__ = True
+
+ def test_truebypass_returns_false_under_fake_jack(self):
+ # Matches the spec's own guess. set_truebypass_value (utils_jack)
+ # is null-guarded without a JACK client and its C-side setter
+ # reports failure, so the handler always writes False under the
+ # fakes, both channels, both requested states.
+ response, body = self.fetch_json("/truebypass/Left/true")
+ self.assertEqual(response.code, 200)
+ self.assertIs(body, False)
+
+ response2, body2 = self.fetch_json("/truebypass/Right/false")
+ self.assertEqual(response2.code, 200)
+ self.assertIs(body2, False)
+
+
+class TestTransportSetSyncMode(ModUITestCase):
+ __test__ = True
+
+ def test_known_modes_return_true_then_restore_default(self):
+ # SESSION.reset() does NOT touch SESSION.host.profile, so this test
+ # explicitly restores the "/none" (internal/default) mode at the
+ # end to avoid leaking Profile state into later tests.
+ try:
+ for mode in ("/none", "/midi_clock_slave", "/link"):
+ response, body = self.fetch_json(
+ "/pedalboard/transport/set_sync_mode%s" % mode,
+ method="POST",
+ body=b"",
+ )
+ self.assertEqual(response.code, 200)
+ self.assertIs(body, True)
+ finally:
+ self.fetch_json(
+ "/pedalboard/transport/set_sync_mode/none", method="POST", body=b""
+ )
+
+ def test_invalid_mode_returns_false_not_error(self):
+ response, body = self.fetch_json(
+ "/pedalboard/transport/set_sync_mode/bogus", method="POST", body=b""
+ )
+ self.assertEqual(response.code, 200)
+ self.assertIs(body, False)
+
+
+class TestCVAddressingPluginPortAdd(ModUITestCase):
+ __test__ = True
+
+ def test_add_500s_without_an_existing_addressed_plugin_instance(self):
+ # Spec said "observe". Observed: PedalboardCvAddressingPluginPortAdd
+ # calls SESSION.web_cv_addressing_plugin_port_add synchronously
+ # (not yielded), which ends up in
+ # Host.addr_task_get_plugin_cv_port_op_mode (mod/host.py:970),
+ # which does self.mapper.get_id_without_creating(instance) on the
+ # instance embedded in the uri. Since no plugin instance can exist
+ # in this sandbox (POST /effect/add is banned -- see
+ # test/conftest.py NEVER-CALL LIST), this *always* raises KeyError
+ # and always 500s -- there is no well-formed uri that succeeds here
+ # without lilv. Unlike EffectRemove this is NOT a hang: the
+ # exception is raised synchronously (no @gen.coroutine boundary
+ # swallows it), so tornado's normal error path returns a fast 500.
+ body = urllib.parse.urlencode(
+ {"uri": "/cv/graph/nonexistent/cvout", "name": "test"}
+ )
+ response = self.fetch(
+ "/pedalboard/cv_addressing_plugin_port/add", method="POST", body=body
+ )
+ self.assertEqual(response.code, 500)
diff --git a/test/test_index.py b/test/test_index.py
new file mode 100644
index 000000000..17227b9a2
--- /dev/null
+++ b/test/test_index.py
@@ -0,0 +1,42 @@
+#!/usr/bin/env python3
+# SPDX-FileCopyrightText: 2012-2023 MOD Audio UG
+# SPDX-License-Identifier: AGPL-3.0-or-later
+
+"""Characterization tests for GET / (mod/webserver.py:TemplateHandler).
+
+This is the page a future Tone3000-tab edit will touch (the #main-menu
+trigger-icon cluster). We pin the redirect-without-?v= behavior and, if the
+dev-fake environment can render the full page without JACK/hardware, that
+the rendered HTML still contains the anchor points the future edit needs.
+"""
+
+from base import ModUITestCase
+
+
+class TestIndexRedirect(ModUITestCase):
+ __test__ = True
+
+ def test_bare_get_redirects_with_version_query_arg(self):
+ response = self.fetch("/", follow_redirects=False)
+ self.assertEqual(response.code, 302)
+ location = response.headers.get("Location", "")
+ self.assertIn("v=", location)
+
+
+class TestIndexRender(ModUITestCase):
+ __test__ = True
+
+ # TemplateHandler.get (mod/webserver.py) is a gen.coroutine that awaits
+ # SESSION.wait_for_hardware_if_needed -- if that never calls back under
+ # the dev-fake environment, this test would hang. self.fetch(...)
+ # applies AsyncTestCase's own timeout (ASYNC_TEST_TIMEOUT env var,
+ # default 5s) as a guard; conftest/CI can raise it if 5s is too tight.
+
+ def test_get_with_version_renders_index_html(self):
+ response = self.fetch("/?v=1")
+ self.assertEqual(response.code, 200)
+ self.assertIn("text/html", response.headers.get("Content-Type", ""))
+
+ body = response.body.decode("utf-8")
+ self.assertIn('id="main-menu"', body)
+ self.assertIn('id="mod-file-manager"', body)
diff --git a/test/test_pedalboards.py b/test/test_pedalboards.py
new file mode 100644
index 000000000..6252d77e2
--- /dev/null
+++ b/test/test_pedalboards.py
@@ -0,0 +1,289 @@
+#!/usr/bin/env python3
+# SPDX-FileCopyrightText: 2012-2023 MOD Audio UG
+# SPDX-License-Identifier: AGPL-3.0-or-later
+
+"""Characterization tests for the pedalboard lifecycle: list, save, info,
+remove, load_bundle (mod/webserver.py: PedalboardList, PedalboardSave,
+PedalboardInfo, PedalboardRemove, PedalboardLoadBundle).
+
+CRITICAL, spec-overriding finding (see docs/characterization-phase-3.md,
+which claimed /pedalboard/list and /banks/ are "self-contained lilv calls"
+and safe): **GET /pedalboard/list and GET /banks/ SEGFAULT the whole test
+process the moment the sandboxed pedalboards dir contains a real, on-disk
+pedalboard bundle** (one written by POST /pedalboard/save). Root cause,
+confirmed with faulthandler/gdb: modtools.utils.get_all_pedalboards()
+(mod/webserver.py:1316 for PedalboardList, :1685 for BankLoad) invalidates
+its Python-side cache and calls into utils.get_all_pedalboards() (the
+libmod_utils.so C extension), which crashes inside
+``NamespaceDefinitions::init(LilvWorldImpl*)`` -> ``lilv_new_uri()`` while
+building its lilv world over a *real* bundle -- reproduced identically via
+both PedalboardList and BankLoad, deterministically, every time, and
+independent of how many times /pedalboard/list was called before (repeated
+calls against an *empty* dir never crash; a *single* call against a dir
+containing one real saved bundle crashes every time). By contrast,
+GET /pedalboard/info/ (single-bundle parse via get_pedalboard_info(), a
+different C entry point) and GET /pedalboard/remove/ are safe with a real
+bundle present -- confirmed by direct probing with faulthandler enabled.
+
+Consequence for this suite: no test here calls GET /pedalboard/list or
+GET /banks/ while a real bundle exists in the sandboxed pedalboards dir.
+The "list now includes TestBoard" step from the phase-3 spec's core
+round-trip is NOT executed as a live HTTP call; the bundle's presence is
+instead verified directly on disk (os.path), which is what a real GET
+/pedalboard/list would enumerate. The bundle is always removed via
+GET /pedalboard/remove/ before any subsequent GET /pedalboard/list call in
+the same test.
+
+The autouse `pedalboards_dir` fixture (test/conftest.py) wipes
+LV2_PEDALBOARDS_DIR and resets SESSION around every test, so tests are
+order-independent regarding on-disk bundles and SESSION.host state.
+"""
+
+import os
+import urllib.parse
+
+from base import ModUITestCase
+
+
+def _quote(bundlepath):
+ return urllib.parse.quote(bundlepath, safe="")
+
+
+class TestPedalboardListBaseline(ModUITestCase):
+ __test__ = True
+
+ def test_list_on_empty_sandbox_is_empty_list(self):
+ # Safe: the sandboxed pedalboards dir is always empty here (no save
+ # has happened yet in this test).
+ response, body = self.fetch_json("/pedalboard/list")
+ self.assertEqual(response.code, 200)
+ self.assertEqual(body, [])
+
+
+class TestPedalboardSave(ModUITestCase):
+ __test__ = True
+
+ def test_save_missing_title_is_400(self):
+ response = self.fetch("/pedalboard/save", method="POST", body="asNew=1")
+ self.assertEqual(response.code, 400)
+
+ def test_save_missing_asnew_is_400(self):
+ response = self.fetch("/pedalboard/save", method="POST", body="title=X")
+ self.assertEqual(response.code, 400)
+
+ def test_save_creates_bundle_on_disk_with_expected_json_shape(self):
+ import mod.settings as settings
+
+ body = urllib.parse.urlencode({"title": "TestBoard", "asNew": "1"})
+ response, payload = self.fetch_json(
+ "/pedalboard/save", method="POST", body=body
+ )
+ self.assertEqual(response.code, 200)
+ self.assertEqual(
+ payload, {"ok": True, "bundlepath": payload["bundlepath"], "title": "TestBoard"}
+ )
+
+ bundlepath = payload["bundlepath"]
+ self.assertTrue(bundlepath.startswith(settings.LV2_PEDALBOARDS_DIR))
+ self.assertTrue(bundlepath.endswith(".pedalboard"))
+ self.assertTrue(os.path.isdir(bundlepath))
+
+ # A .ttl bundle got written (host.save_state_to_ttl), NOT observed
+ # through /pedalboard/list (see module docstring -- that would
+ # segfault) but directly on disk, which is exactly what a real
+ # /pedalboard/list GET would enumerate.
+ entries = os.listdir(bundlepath)
+ self.assertTrue(any(name.endswith(".ttl") for name in entries))
+ self.assertIn("manifest.ttl", entries)
+
+ # cleanup: remove before this test method returns, so no real
+ # bundle is left for the next test even though the autouse fixture
+ # would also wipe it.
+ remove_response = self.fetch(
+ "/pedalboard/remove/?bundlepath=" + _quote(bundlepath)
+ )
+ self.assertEqual(remove_response.body, b"true")
+
+ def test_save_asnew_0_over_fresh_session_behaves_like_asnew_1(self):
+ # No pedalboard was ever loaded/saved in this session yet, so
+ # host.pedalboard_path is "" -- host.save()'s "save over existing"
+ # branch requires a truthy, on-disk, sandbox-rooted pedalboard_path,
+ # so asNew=0 here takes the same "save new" branch as asNew=1.
+ body = urllib.parse.urlencode({"title": "FreshBoard", "asNew": "0"})
+ response, payload = self.fetch_json(
+ "/pedalboard/save", method="POST", body=body
+ )
+ self.assertEqual(response.code, 200)
+ self.assertTrue(payload["ok"])
+ self.assertTrue(os.path.isdir(payload["bundlepath"]))
+
+ self.fetch("/pedalboard/remove/?bundlepath=" + _quote(payload["bundlepath"]))
+
+ def test_save_asnew_0_after_asnew_1_overwrites_same_bundle(self):
+ body1 = urllib.parse.urlencode({"title": "TestBoard", "asNew": "1"})
+ _, payload1 = self.fetch_json("/pedalboard/save", method="POST", body=body1)
+ bundlepath1 = payload1["bundlepath"]
+
+ body2 = urllib.parse.urlencode({"title": "TestBoard", "asNew": "0"})
+ _, payload2 = self.fetch_json("/pedalboard/save", method="POST", body=body2)
+ bundlepath2 = payload2["bundlepath"]
+
+ self.assertEqual(bundlepath1, bundlepath2)
+
+ import mod.settings as settings
+
+ self.assertEqual(os.listdir(settings.LV2_PEDALBOARDS_DIR), [os.path.basename(bundlepath1)])
+
+ self.fetch("/pedalboard/remove/?bundlepath=" + _quote(bundlepath1))
+
+
+class TestPedalboardInfo(ModUITestCase):
+ __test__ = True
+
+ def test_info_on_bogus_bundlepath_is_500(self):
+ # get_pedalboard_info() raises a bare Exception on failure
+ # (modtools/utils.py); PedalboardInfo.get() does not catch it, so it
+ # surfaces as tornado's generic uncaught-exception 500 HTML page --
+ # NOT a JsonRequestHandler JSON error body.
+ response = self.fetch(
+ "/pedalboard/info/?bundlepath=" + _quote("/nonexistent/thing.pedalboard")
+ )
+ self.assertEqual(response.code, 500)
+ self.assertIn("text/html", response.headers.get("Content-Type", ""))
+
+ def test_info_on_real_bundle_matches_saved_title(self):
+ save_body = urllib.parse.urlencode({"title": "TestBoard", "asNew": "1"})
+ _, save_payload = self.fetch_json(
+ "/pedalboard/save", method="POST", body=save_body
+ )
+ bundlepath = save_payload["bundlepath"]
+
+ response, info = self.fetch_json(
+ "/pedalboard/info/?bundlepath=" + _quote(bundlepath)
+ )
+ self.assertEqual(response.code, 200)
+ self.assertEqual(info["title"], "TestBoard")
+ self.assertIn("plugins", info)
+ self.assertIn("width", info)
+ self.assertIn("height", info)
+
+ self.fetch("/pedalboard/remove/?bundlepath=" + _quote(bundlepath))
+
+
+class TestPedalboardRemove(ModUITestCase):
+ __test__ = True
+
+ def test_remove_bogus_bundlepath_returns_false(self):
+ response = self.fetch(
+ "/pedalboard/remove/?bundlepath=" + _quote("/nonexistent/thing.pedalboard")
+ )
+ self.assertEqual(response.code, 200)
+ self.assertEqual(response.body, b"false")
+
+ def test_remove_nonexistent_path_outside_sandbox_returns_false_and_touches_nothing(self):
+ # PedalboardRemove gates on os.path.exists(bundlepath) before ever
+ # calling shutil.rmtree -- a nonexistent path outside the sandbox is
+ # therefore a safe no-op observation, not a real escape attempt.
+ outside_path = "/tmp/modui-characterization-does-not-exist.pedalboard"
+ self.assertFalse(os.path.exists(outside_path))
+
+ response = self.fetch("/pedalboard/remove/?bundlepath=" + _quote(outside_path))
+ self.assertEqual(response.code, 200)
+ self.assertEqual(response.body, b"false")
+
+
+class TestPedalboardCoreRoundTrip(ModUITestCase):
+ __test__ = True
+
+ def test_save_info_remove_round_trip(self):
+ """The highest-value test (spec's "core round-trip"), adapted for
+ the /pedalboard/list segfault documented in the module docstring:
+ the bundle's presence/absence is asserted via the filesystem and
+ via /pedalboard/info/, never via a live /pedalboard/list call while
+ the bundle exists.
+ """
+ import mod.settings as settings
+
+ # 1. Baseline: safe, dir is empty (autouse fixture guarantees this).
+ response, body = self.fetch_json("/pedalboard/list")
+ self.assertEqual(body, [])
+
+ # 2. Save.
+ save_body = urllib.parse.urlencode({"title": "TestBoard", "asNew": "1"})
+ save_response, save_payload = self.fetch_json(
+ "/pedalboard/save", method="POST", body=save_body
+ )
+ self.assertEqual(save_response.code, 200)
+ self.assertTrue(save_payload["ok"])
+ bundlepath = save_payload["bundlepath"]
+ self.assertEqual(save_payload["title"], "TestBoard")
+
+ # 3. "List now includes TestBoard" -- verified on disk (this is
+ # exactly what get_all_pedalboards() would scan), NOT via a live
+ # GET /pedalboard/list call, which segfaults with a real bundle
+ # present (see module docstring).
+ self.assertTrue(os.path.isdir(bundlepath))
+ self.assertEqual(
+ os.listdir(settings.LV2_PEDALBOARDS_DIR),
+ [os.path.basename(bundlepath)],
+ )
+
+ # 4. Info.
+ info_response, info = self.fetch_json(
+ "/pedalboard/info/?bundlepath=" + _quote(bundlepath)
+ )
+ self.assertEqual(info_response.code, 200)
+ self.assertEqual(info["title"], "TestBoard")
+
+ # 5. Remove.
+ remove_response = self.fetch(
+ "/pedalboard/remove/?bundlepath=" + _quote(bundlepath)
+ )
+ self.assertEqual(remove_response.code, 200)
+ self.assertEqual(remove_response.body, b"true")
+ self.assertFalse(os.path.exists(bundlepath))
+
+ # Now the dir is empty again, so a live /pedalboard/list call is
+ # safe once more (see module docstring: only a NON-empty dir
+ # segfaults) and should be back to baseline.
+ final_response, final_body = self.fetch_json("/pedalboard/list")
+ self.assertEqual(final_response.code, 200)
+ self.assertEqual(final_body, [])
+
+
+class TestPedalboardLoadBundle(ModUITestCase):
+ __test__ = True
+
+ def test_load_bundle_on_bogus_bundlepath_returns_ok_false(self):
+ body = urllib.parse.urlencode(
+ {"bundlepath": "/nonexistent/thing.pedalboard", "isDefault": "0"}
+ )
+ response, payload = self.fetch_json(
+ "/pedalboard/load_bundle/", method="POST", body=body
+ )
+ self.assertEqual(response.code, 200)
+ self.assertEqual(payload, {"ok": False, "name": ""})
+
+ def test_load_bundle_on_real_saved_bundle_returns_ok_true_with_name(self):
+ save_body = urllib.parse.urlencode({"title": "TestBoard", "asNew": "1"})
+ _, save_payload = self.fetch_json(
+ "/pedalboard/save", method="POST", body=save_body
+ )
+ bundlepath = save_payload["bundlepath"]
+
+ load_body = urllib.parse.urlencode(
+ {"bundlepath": bundlepath, "isDefault": "0"}
+ )
+ response, payload = self.fetch_json(
+ "/pedalboard/load_bundle/", method="POST", body=load_body
+ )
+ self.assertEqual(response.code, 200)
+ self.assertEqual(payload, {"ok": True, "name": "TestBoard"})
+
+ # Reset SESSION before cleanup, per phase-3 spec's order-dependence
+ # warning: SESSION.host is a process-global singleton, so a test
+ # that loads a pedalboard must reset afterwards.
+ reset_response = self.fetch("/reset/")
+ self.assertEqual(reset_response.code, 200)
+
+ self.fetch("/pedalboard/remove/?bundlepath=" + _quote(bundlepath))
diff --git a/test/test_snapshots.py b/test/test_snapshots.py
new file mode 100644
index 000000000..566a9e3a3
--- /dev/null
+++ b/test/test_snapshots.py
@@ -0,0 +1,158 @@
+#!/usr/bin/env python3
+# SPDX-FileCopyrightText: 2012-2023 MOD Audio UG
+# SPDX-License-Identifier: AGPL-3.0-or-later
+
+"""Characterization tests for the snapshot endpoints (mod/webserver.py:
+SnapshotList, SnapshotName, SnapshotSave, SnapshotSaveAs).
+
+Snapshots live entirely on SESSION.host (Python lists/dicts) -- unlike the
+pedalboard endpoints in test_pedalboards.py, nothing here calls into lilv,
+so there is no segfault risk (confirmed by direct probing).
+
+SESSION.host is a process-global singleton (mod/session.py), and these
+handlers mutate it (pedalboard_snapshots, current_pedalboard_snapshot_id).
+The autouse `pedalboards_dir` fixture (test/conftest.py) calls
+SESSION.reset() before and after every test, so each test method here
+starts from a known-fresh state: pedalboard_snapshots == [], and
+current_pedalboard_snapshot_id == -1 (mod/host.py Host.__init__ defaults;
+SESSION.reset() restores current_pedalboard_snapshot_id to 0 with a single
+"Default" snapshot via host.snapshot_clear() -- see the "after /reset"
+tests below, which pin that distinction).
+"""
+
+import urllib.parse
+
+from base import ModUITestCase
+
+
+class TestSnapshotFreshSession(ModUITestCase):
+ __test__ = True
+
+ def test_list_after_fixture_reset_has_one_default_entry(self):
+ # NOT {} -- host.snapshot_clear() (invoked by SESSION.reset(), which
+ # the autouse pedalboards_dir fixture runs before every test) seeds
+ # exactly one "Default" snapshot at index 0 (host.py:3052-3053).
+ # See TestSnapshotSaveWithoutAnyReset below for the true "nothing at
+ # all" shape ({}), reached only by clearing the list by hand.
+ response, body = self.fetch_json("/snapshot/list")
+ self.assertEqual(response.code, 200)
+ self.assertEqual(body, {"0": "Default"})
+
+ def test_name_with_default_id_after_reset(self):
+ response, body = self.fetch_json("/snapshot/name?id=0")
+ self.assertEqual(response.code, 200)
+ self.assertEqual(body, {"ok": True, "name": "Default"})
+
+ def test_name_with_out_of_range_id_falls_back_to_default_name(self):
+ # snapshot_name(idx) returns None for an out-of-range idx, and the
+ # handler falls back to DEFAULT_SNAPSHOT_NAME ("Default") -- so this
+ # is NOT a 404/error shape, it's indistinguishable in its "ok": True
+ # shape from a real snapshot named "Default".
+ response, body = self.fetch_json("/snapshot/name?id=99")
+ self.assertEqual(response.code, 200)
+ self.assertEqual(body, {"ok": True, "name": "Default"})
+
+ def test_save_after_reset_succeeds_since_reset_seeds_snapshot_0(self):
+ # SESSION.reset() leaves current_pedalboard_snapshot_id == 0 with a
+ # real snapshot at index 0 (see host.py snapshot_clear()), so
+ # SnapshotSave succeeds here -- contrast with
+ # TestSnapshotSaveWithoutAnyReset below, which pins the *true*
+ # "nothing to save" shape (current_pedalboard_snapshot_id == -1).
+ response = self.fetch("/snapshot/save", method="POST", body="")
+ self.assertEqual(response.code, 200)
+ self.assertEqual(response.body, b"true")
+
+ def test_saveas_creates_new_snapshot_and_appears_in_list(self):
+ response, payload = self.fetch_json("/snapshot/saveas?title=Foo")
+ self.assertEqual(response.code, 200)
+ self.assertEqual(payload["ok"], True)
+ self.assertEqual(payload["title"], "Foo")
+ new_id = payload["id"]
+
+ list_response, list_body = self.fetch_json("/snapshot/list")
+ self.assertEqual(list_response.code, 200)
+ self.assertEqual(list_body[str(new_id)], "Foo")
+ # the pre-existing "Default" snapshot (seeded by SESSION.reset())
+ # is still present alongside the new one.
+ self.assertIn("0", list_body)
+
+
+class TestSnapshotSaveWithoutAnyReset(ModUITestCase):
+ __test__ = True
+
+ def test_save_returns_false_when_current_snapshot_id_is_negative_one(self):
+ # Pins the "truly nothing to save" shape from a session that has
+ # never had snapshot_clear() run at all: Host.__init__ (mod/host.py)
+ # defaults current_pedalboard_snapshot_id to -1, and snapshot_save()
+ # returns False whenever that index is out of range. We reach this
+ # state by resetting the underlying attribute directly (the HTTP
+ # surface has no route that produces it, since even GET /reset
+ # seeds a "Default" snapshot at id 0 -- see module docstring).
+ from mod.webserver import SESSION
+
+ SESSION.host.pedalboard_snapshots = []
+ SESSION.host.current_pedalboard_snapshot_id = -1
+
+ response = self.fetch("/snapshot/save", method="POST", body="")
+ self.assertEqual(response.code, 200)
+ self.assertEqual(response.body, b"false")
+
+ def test_list_is_empty_dict_when_snapshots_list_is_empty(self):
+ from mod.webserver import SESSION
+
+ SESSION.host.pedalboard_snapshots = []
+
+ response, body = self.fetch_json("/snapshot/list")
+ self.assertEqual(response.code, 200)
+ self.assertEqual(body, {})
+
+
+class TestSnapshotRoundTripWithRealPedalboard(ModUITestCase):
+ __test__ = True
+
+ def test_saveas_and_list_after_loading_a_real_pedalboard(self):
+ # Save a real bundle, load it back (this reseeds
+ # pedalboard_snapshots with a single "Default" snapshot via
+ # host.load() -> save_state_snapshots()/snapshots.json handling),
+ # then exercise snapshot/saveas + snapshot/list against it.
+ save_body = urllib.parse.urlencode({"title": "TestBoard", "asNew": "1"})
+ _, save_payload = self.fetch_json(
+ "/pedalboard/save", method="POST", body=save_body
+ )
+ bundlepath = save_payload["bundlepath"]
+
+ load_body = urllib.parse.urlencode(
+ {"bundlepath": bundlepath, "isDefault": "0"}
+ )
+ load_response, load_payload = self.fetch_json(
+ "/pedalboard/load_bundle/", method="POST", body=load_body
+ )
+ self.assertEqual(load_response.code, 200)
+ self.assertTrue(load_payload["ok"])
+
+ list_response, list_body = self.fetch_json("/snapshot/list")
+ self.assertEqual(list_response.code, 200)
+ self.assertEqual(list_body, {"0": "Default"})
+
+ saveas_response, saveas_payload = self.fetch_json(
+ "/snapshot/saveas?title=Verse"
+ )
+ self.assertEqual(saveas_response.code, 200)
+ self.assertEqual(saveas_payload["ok"], True)
+ self.assertEqual(saveas_payload["title"], "Verse")
+
+ list_response2, list_body2 = self.fetch_json("/snapshot/list")
+ self.assertEqual(list_body2, {"0": "Default", "1": "Verse"})
+
+ # Order-dependence warning (phase-3 spec): reset SESSION.host before
+ # removing the bundle, so later tests see a clean session -- not
+ # via a live /pedalboard/list call (segfaults with a real bundle
+ # present, see test_pedalboards.py's module docstring), so we go
+ # straight to /reset/ then remove.
+ reset_response = self.fetch("/reset/")
+ self.assertEqual(reset_response.code, 200)
+
+ self.fetch(
+ "/pedalboard/remove/?bundlepath="
+ + urllib.parse.quote(bundlepath, safe="")
+ )
diff --git a/test/test_system.py b/test/test_system.py
new file mode 100644
index 000000000..7ab0058f2
--- /dev/null
+++ b/test/test_system.py
@@ -0,0 +1,90 @@
+#!/usr/bin/env python3
+# SPDX-FileCopyrightText: 2012-2023 MOD Audio UG
+# SPDX-License-Identifier: AGPL-3.0-or-later
+
+"""Characterization tests for /system/info (SystemInfo), /system/prefs
+(SystemPreferences), /hello/ (Hello) and /ping/ (Ping), mod/webserver.py.
+
+None of these write anything -- they only read read-only system paths
+(/etc/mod-release/system, /data/*) that don't exist on a plain dev machine,
+so no snapshot/restore fixture is needed here.
+"""
+
+from base import ModUITestCase
+
+
+class TestSystemInfo(ModUITestCase):
+ __test__ = True
+
+ def test_info_defaults_when_no_hardware_descriptor(self):
+ response, body = self.fetch_json("/system/info")
+ self.assertEqual(response.code, 200)
+
+ # /etc/mod-hardware-descriptor.json and /etc/mod-release/system
+ # don't exist on this dev machine, so every hwdesc-derived field
+ # falls back to "Unknown" and sysdate falls back to "Unknown".
+ self.assertEqual(body["hwname"], "Unknown")
+ self.assertEqual(body["architecture"], "Unknown")
+ self.assertEqual(body["cpu"], "Unknown")
+ self.assertEqual(body["platform"], "Unknown")
+ self.assertEqual(body["bin_compat"], "Unknown")
+ self.assertEqual(body["model"], "Unknown")
+ self.assertEqual(body["sysdate"], "Unknown")
+
+ self.assertIn("version", body["python"])
+ self.assertIn("machine", body["uname"])
+ self.assertIn("release", body["uname"])
+ self.assertIn("sysname", body["uname"])
+ self.assertIn("version", body["uname"])
+
+
+class TestSystemPreferences(ModUITestCase):
+ __test__ = True
+
+ def test_prefs_defaults_when_no_data_files(self):
+ response, body = self.fetch_json("/system/prefs")
+ self.assertEqual(response.code, 200)
+
+ # SystemPreferences reads hardcoded absolute "/data/..." paths (NOT
+ # mod.settings.DATA_DIR -- these are never sandboxed by conftest.py,
+ # but /data doesn't exist on this dev machine so every pref falls
+ # back to its default).
+ self.assertEqual(body["jack_buffer_size"], 128)
+ self.assertEqual(body["jack_mono_copy"], False)
+ self.assertEqual(body["jack_sync_mode"], False)
+ self.assertEqual(body["separate_spdif_outs"], False)
+ # "service_mod_peakmeter" is an OPTION_FILE_NOT_EXISTS pref, so it's
+ # True exactly when the disable-flag file is absent.
+ self.assertEqual(body["service_mod_peakmeter"], True)
+ self.assertEqual(body["service_mod_sdk"], False)
+ self.assertEqual(body["service_netmanager"], False)
+ self.assertEqual(body["autorestart_hmi"], False)
+ # bluetooth_name has no valdef override (defaults to None), so the
+ # key is present with a JSON null, not omitted.
+ self.assertIn("bluetooth_name", body)
+ self.assertIsNone(body["bluetooth_name"])
+
+
+class TestHello(ModUITestCase):
+ __test__ = True
+
+ def test_hello_shape(self):
+ response, body = self.fetch_json("/hello/")
+ self.assertEqual(response.code, 200)
+ # No websocket ever connects in this test harness.
+ self.assertEqual(body["online"], False)
+ # IMAGE_VERSION is None in this dev sandbox (no /etc/mod-release/system).
+ self.assertIsNone(body["version"])
+
+
+class TestPing(ModUITestCase):
+ __test__ = True
+
+ def test_ping_reports_hmi_offline(self):
+ response, body = self.fetch_json("/ping/")
+ self.assertEqual(response.code, 200)
+ # The fake HMI (mod.development.FakeHMI under MOD_DEV_ENVIRONMENT=1)
+ # is never .initialized, so web_ping() calls back False synchronously
+ # -- no 5s gen.with_timeout wait is actually exercised here.
+ self.assertEqual(body["ihm_online"], False)
+ self.assertEqual(body["ihm_time"], 0)
diff --git a/test/test_templates.py b/test/test_templates.py
new file mode 100644
index 000000000..94d9d97df
--- /dev/null
+++ b/test/test_templates.py
@@ -0,0 +1,110 @@
+#!/usr/bin/env python3
+# SPDX-FileCopyrightText: 2012-2023 MOD Audio UG
+# SPDX-License-Identifier: AGPL-3.0-or-later
+
+"""Characterization tests for the template/static-file loaders and the
+header conventions shared by every handler base class in mod/webserver.py:
+
+- TemplateLoader (/load_template/.html)
+- BulkTemplateLoader (/js/templates.js)
+- TimelessStaticFileHandler (any static file, e.g. /js/desktop.js)
+- header pinning: JsonRequestHandler (no Date, no cache headers) vs
+ CachedJsonRequestHandler (Cache-Control + fixed Expires)
+
+None of these write anything, so no snapshot/restore fixture is needed.
+"""
+
+from base import ModUITestCase
+
+
+class TestTemplateLoader(ModUITestCase):
+ __test__ = True
+
+ def test_loads_known_template_from_html_include(self):
+ response = self.fetch("/load_template/pedalboard.html")
+ self.assertEqual(response.code, 200)
+ self.assertIn("text/plain", response.headers.get("Content-Type", ""))
+ self.assertTrue(len(response.body) > 0)
+
+ def test_unknown_template_is_500(self):
+ # TemplateLoader.get() open()s the file directly with no
+ # os.path.exists guard, so a missing template surfaces as an
+ # uncaught FileNotFoundError -> tornado 500, not a 404.
+ response = self.fetch("/load_template/does_not_exist.html")
+ self.assertEqual(response.code, 500)
+
+
+class TestBulkTemplateLoader(ModUITestCase):
+ __test__ = True
+
+ def test_bundles_html_include_into_templates_object(self):
+ response = self.fetch("/js/templates.js")
+ self.assertEqual(response.code, 200)
+ self.assertIn("text/javascript", response.headers.get("Content-Type", ""))
+
+ body = response.body.decode("utf-8")
+ self.assertIn("TEMPLATES['pedalboard']", body)
+
+ def test_has_cache_control_and_expires_headers(self):
+ # BulkTemplateLoader can't subclass CachedJsonRequestHandler (it's
+ # not JSON), so it sets the same two headers by hand -- pin that
+ # both routes converge on the same cache contract.
+ response = self.fetch("/js/templates.js")
+ self.assertEqual(
+ response.headers.get("Cache-Control"), "public, max-age=31536000"
+ )
+ self.assertEqual(
+ response.headers.get("Expires"), "Mon, 31 Dec 2035 12:00:00 gmt"
+ )
+ self.assertNotIn("Date", response.headers)
+
+
+class TestTimelessStaticFileHandler(ModUITestCase):
+ __test__ = True
+
+ def test_static_file_has_no_date_header(self):
+ response = self.fetch("/js/desktop.js")
+ self.assertEqual(response.code, 200)
+ self.assertNotIn("Date", response.headers)
+ self.assertEqual(
+ response.headers.get("Cache-Control"), "public, max-age=31536000"
+ )
+ self.assertEqual(
+ response.headers.get("Expires"), "Mon, 31 Dec 2035 12:00:00 gmt"
+ )
+
+
+class TestJsonRequestHandlerHeaders(ModUITestCase):
+ __test__ = True
+
+ def test_plain_json_route_has_no_date_and_no_cache_headers(self):
+ response = self.fetch("/files/list?types=bogus")
+ self.assertEqual(response.code, 200)
+ self.assertNotIn("Date", response.headers)
+ self.assertNotIn("Cache-Control", response.headers)
+ self.assertNotIn("Expires", response.headers)
+
+
+class TestCachedJsonRequestHandlerHeaders(ModUITestCase):
+ __test__ = True
+
+ def test_pedalboard_image_check_has_cache_headers(self):
+ # PedalboardImageCheck (CachedJsonRequestHandler) is filesystem-only
+ # (SESSION.screenshot_generator.check_screenshot just stats a
+ # thumbnail.png next to the given bundlepath) -- safe to call
+ # without lilv/JACK, unlike the /effect/* routes on the NEVER-CALL
+ # list. The other CachedJsonRequestHandler route, EffectGet, does
+ # need the global lilv world and is skipped (see NEVER-CALL list).
+ response, body = self.fetch_json(
+ "/pedalboard/image/check?bundlepath=/nonexistent/thing.pedalboard"
+ )
+ self.assertEqual(response.code, 200)
+ self.assertEqual(body["status"], -1)
+
+ self.assertEqual(
+ response.headers.get("Cache-Control"), "public, max-age=31536000"
+ )
+ self.assertEqual(
+ response.headers.get("Expires"), "Mon, 31 Dec 2035 12:00:00 gmt"
+ )
+ self.assertNotIn("Date", response.headers)
diff --git a/test/test_tokens.py b/test/test_tokens.py
new file mode 100644
index 000000000..10ea292c0
--- /dev/null
+++ b/test/test_tokens.py
@@ -0,0 +1,141 @@
+#!/usr/bin/env python3
+# SPDX-FileCopyrightText: 2012-2023 MOD Audio UG
+# SPDX-License-Identifier: AGPL-3.0-or-later
+
+"""Characterization tests for /tokens/save, /tokens/get, /tokens/delete
+(mod/webserver.py:TokensSave/TokensGet/TokensDelete).
+
+These read/write DATA_DIR/tokens.conf directly (not via mod.settings, the
+handlers build the path from the DATA_DIR global inline), so this module
+snapshots/restores that file around every test to stay order-independent.
+"""
+
+import json
+import os
+
+import pytest
+
+from base import ModUITestCase
+
+
+@pytest.fixture(autouse=True)
+def _snapshot_tokens_conf():
+ from mod import settings
+
+ tokens_conf = os.path.join(settings.DATA_DIR, "tokens.conf")
+ existed = os.path.exists(tokens_conf)
+ before = None
+ if existed:
+ with open(tokens_conf, "r") as fh:
+ before = fh.read()
+
+ yield
+
+ if existed:
+ with open(tokens_conf, "w") as fh:
+ fh.write(before)
+ elif os.path.exists(tokens_conf):
+ os.remove(tokens_conf)
+
+
+class TestTokensGetMissing(ModUITestCase):
+ __test__ = True
+
+ def test_get_with_no_file_returns_ok_false(self):
+ response, body = self.fetch_json("/tokens/get")
+ self.assertEqual(response.code, 200)
+ self.assertEqual(body, {"ok": False})
+
+
+class TestTokensDeleteMissing(ModUITestCase):
+ __test__ = True
+
+ def test_delete_with_no_file_is_a_noop_returning_true(self):
+ response = self.fetch("/tokens/delete")
+ self.assertEqual(response.code, 200)
+ self.assertEqual(response.body, b"true")
+
+
+class TestTokensRoundTrip(ModUITestCase):
+ __test__ = True
+
+ def _payload(self):
+ return {
+ "user_id": "u1",
+ "access_token": "at1",
+ "refresh_token": "rt1",
+ "expires_in_days": 30,
+ }
+
+ def test_save_then_get_returns_saved_payload_minus_expires(self):
+ save_response = self.fetch(
+ "/tokens/save", method="POST", body=json.dumps(self._payload())
+ )
+ self.assertEqual(save_response.code, 200)
+ self.assertEqual(save_response.body, b"true")
+
+ from mod import settings
+
+ tokens_conf = os.path.join(settings.DATA_DIR, "tokens.conf")
+ with open(tokens_conf, "r") as fh:
+ on_disk = json.load(fh)
+ # TokensSave pops "expires_in_days" before writing to disk.
+ self.assertEqual(
+ on_disk, {"user_id": "u1", "access_token": "at1", "refresh_token": "rt1"}
+ )
+
+ get_response, body = self.fetch_json("/tokens/get")
+ self.assertEqual(get_response.code, 200)
+ self.assertEqual(
+ body,
+ {
+ "user_id": "u1",
+ "access_token": "at1",
+ "refresh_token": "rt1",
+ "ok": True,
+ },
+ )
+
+ def test_save_missing_expires_in_days_is_500_and_does_not_write(self):
+ # TokensSave unconditionally data.pop("expires_in_days") before
+ # writing -- a payload that omits it raises an uncaught KeyError
+ # (500), and nothing is written to tokens.conf.
+ partial = {"user_id": "u1", "access_token": "at1", "refresh_token": "rt1"}
+ response = self.fetch(
+ "/tokens/save", method="POST", body=json.dumps(partial)
+ )
+ self.assertEqual(response.code, 500)
+
+ get_response, body = self.fetch_json("/tokens/get")
+ self.assertEqual(get_response.code, 200)
+ self.assertEqual(body, {"ok": False})
+
+ def test_get_missing_a_required_key_is_ok_false(self):
+ partial = {"user_id": "u1", "access_token": "at1", "expires_in_days": 30}
+ save_response = self.fetch(
+ "/tokens/save", method="POST", body=json.dumps(partial)
+ )
+ self.assertEqual(save_response.body, b"true")
+
+ response, body = self.fetch_json("/tokens/get")
+ self.assertEqual(response.code, 200)
+ self.assertEqual(body["ok"], False)
+ self.assertEqual(body["user_id"], "u1")
+ self.assertEqual(body["access_token"], "at1")
+ self.assertNotIn("refresh_token", body)
+
+ def test_save_then_delete_then_get_is_ok_false_again(self):
+ self.fetch("/tokens/save", method="POST", body=json.dumps(self._payload()))
+
+ delete_response = self.fetch("/tokens/delete")
+ self.assertEqual(delete_response.code, 200)
+ self.assertEqual(delete_response.body, b"true")
+
+ from mod import settings
+
+ tokens_conf = os.path.join(settings.DATA_DIR, "tokens.conf")
+ self.assertFalse(os.path.exists(tokens_conf))
+
+ get_response, body = self.fetch_json("/tokens/get")
+ self.assertEqual(get_response.code, 200)
+ self.assertEqual(body, {"ok": False})
diff --git a/test/test_websocket.py b/test/test_websocket.py
new file mode 100644
index 000000000..c7214d7f3
--- /dev/null
+++ b/test/test_websocket.py
@@ -0,0 +1,284 @@
+#!/usr/bin/env python3
+# SPDX-FileCopyrightText: 2012-2023 MOD Audio UG
+# SPDX-License-Identifier: AGPL-3.0-or-later
+
+"""Characterization tests for the /websocket connect-time handshake
+(mod/webserver.py:ServerWebSocket, mod/session.py:Session.websocket_opened,
+mod/host.py:Host.report_current_state -- all wired through
+mod/development.py:FakeHost.open_connection_if_needed in this dev harness).
+
+Pins the message-PUSH sequence a client sees right after connecting: this is
+the ``msg_callback`` broadcast path a future Tone3000 "file added" push
+notification would ride.
+
+Exploratory findings (see docs/characterization-phase-5.md, verified against
+this sandbox -- FakeHMI uninitialized, empty pedalboard, no CC devices, no
+hardware ports, /proc/meminfo present so Host.memtimer is armed):
+
+- The connect-time push on the FIRST socket of the process is exactly 7
+ ordered messages, by PREFIX (first whitespace-delimited word):
+ sys_stats, stats, transport, truebypass, loading_start, size, loading_end
+ The spec's sketch guessed a "stop"/ready-ish closing token; the real
+ ready-marker is ``loading_end ``
+ (mod/host.py:Host.report_current_state, last line before the per-plugin
+ addressing/HW sections, which are all empty in this sandbox).
+- Immediately AFTER that 7-message burst, the first socket receives one
+ EXTRA ``sys_stats ...`` message. This is not part of
+ report_current_state's own push -- it is
+ FakeHost.open_connection_if_needed (mod/development.py) calling
+ ``self.memtimer_callback()`` synchronously, once, right after
+ ``report_current_state()`` returns, on the branch where
+ ``self.readsock``/``self.writesock`` were previously None (i.e. only for
+ the connection that actually "establishes" the fake host link). This is a
+ detail the spec's sketch did not anticipate; tests below treat it as an
+ unpinned trailing message (present in practice in this sandbox, but not
+ asserted on) rather than pin an exact total message count, per the phase's
+ "pin prefixes/arg-counts, not volatile detail" and "consume/ignore extra
+ stats messages" guidance.
+- A SECOND, concurrent connection (opened while the first is still open)
+ gets the exact same 7-message report_current_state burst (every new
+ websocket gets its own full state dump -- Session.websocket_opened's
+ first-vs-not-first branch, session.py:236, only decides whether
+ Host.start_session runs first; it does not change what gets pushed to the
+ new socket). The observable difference is narrower than "first socket
+ session branch": it is FakeHost.open_connection_if_needed's *own* branch
+ on ``self.readsock is not None and self.writesock is not None`` -- true
+ for every connection after the first -- which skips
+ statstimer.start()/memtimer_callback() entirely. So only the very first
+ socket of the process gets the extra trailing sys_stats; the second socket
+ does not, even though both get an identical initial 7-message burst.
+- PeriodicCallback (mod/host.py Host.statstimer/memtimer) binds
+ ``IOLoop.current()`` at construction time (tornado 4.3
+ ioloop.py:PeriodicCallback.__init__), and SESSION.host is a process-level
+ singleton constructed at ``mod.webserver`` import time -- before any
+ per-test IOLoop exists. So ``statstimer.start()``/``memtimer.start()``
+ schedule ticks on a *different*, never-pumped IOLoop; in practice no
+ additional "stats ..."/"sys_stats ..." messages arrive during a test's own
+ ~2s collection window. Tests still avoid asserting exact trailing counts,
+ since this is an artifact of import ordering, not a documented guarantee.
+- Closing the client side of the connection is NOT synchronously reflected
+ server-side: right after ``conn.close()`` returns, GET /hello still
+ reports ``online: true`` (SESSION.websockets still has the entry) because
+ ``ServerWebSocket.on_close`` -> ``SESSION.websocket_closed`` only runs
+ once the server's IOLoop actually polls and processes the close frame.
+ This turned out FLAKY to observe deterministically: a bounded number of
+ ``gen.moment`` spins (pure callback-queue turns, no real I/O wait) is
+ sometimes enough and sometimes not. Per the phase spec's own guidance
+ ("count may update asynchronously; drop the assertion rather than
+ sleep-loop if flaky"), the close test below does not assert on the
+ post-close ``online`` value -- it only pins that the server tolerates the
+ close without erroring and keeps answering HTTP requests.
+"""
+
+from tornado import gen, websocket
+from tornado.testing import gen_test
+
+from base import ModUITestCase
+
+# Generous but bounded -- nothing here should ever legitimately take this
+# long; a real hang (behavior regression) fails fast instead of hanging the
+# whole suite.
+_READ_TIMEOUT = 5.0
+
+# Exact pinned prefix sequence of the connect-time report_current_state
+# burst in this sandbox (empty pedalboard, no CC devices, no HW ports).
+_EXPECTED_PREFIXES = [
+ "sys_stats",
+ "stats",
+ "transport",
+ "truebypass",
+ "loading_start",
+ "size",
+ "loading_end",
+]
+
+_READY_MARKER_PREFIX = "loading_end"
+
+
+class WebSocketTestCase(ModUITestCase):
+ """Shared helpers. Not collected directly (__test__ stays False)."""
+
+ __test__ = False
+
+ def ws_url(self):
+ return self.get_url("/websocket").replace("http://", "ws://")
+
+ @gen.coroutine
+ def read_one(self, conn, timeout=_READ_TIMEOUT):
+ """Read a single message with a hard timeout so a behavior change
+ (e.g. the ready marker disappearing) fails fast instead of hanging.
+ """
+ msg = yield gen.with_timeout(self.io_loop.time() + timeout, conn.read_message())
+ raise gen.Return(msg)
+
+ @gen.coroutine
+ def drain_until_ready(self, conn, timeout=_READ_TIMEOUT):
+ """Collect messages up to and including the ready marker
+ (``loading_end ...``). Returns the list of messages, ready marker
+ included. Raises (via with_timeout / assertion) if the marker never
+ arrives or the socket closes first.
+ """
+ messages = []
+ while True:
+ msg = yield self.read_one(conn, timeout=timeout)
+ if msg is None:
+ self.fail(
+ "server closed the websocket before the ready marker "
+ "(%r) arrived; messages so far: %r"
+ % (_READY_MARKER_PREFIX, messages)
+ )
+ messages.append(msg)
+ if msg.split(" ", 1)[0] == _READY_MARKER_PREFIX:
+ break
+ raise gen.Return(messages)
+
+
+class TestWebSocketConnectSequence(WebSocketTestCase):
+ __test__ = True
+
+ @gen_test(timeout=10)
+ def test_connect_pushes_pinned_prefix_sequence(self):
+ conn = yield websocket.websocket_connect(self.ws_url())
+ try:
+ messages = yield self.drain_until_ready(conn)
+ prefixes = [m.split(" ", 1)[0] for m in messages]
+ self.assertEqual(prefixes, _EXPECTED_PREFIXES)
+ finally:
+ conn.close()
+
+ @gen_test(timeout=10)
+ def test_transport_message_shape(self):
+ conn = yield websocket.websocket_connect(self.ws_url())
+ try:
+ messages = yield self.drain_until_ready(conn)
+ transport_msgs = [m for m in messages if m.split(" ", 1)[0] == "transport"]
+ self.assertEqual(len(transport_msgs), 1)
+
+ parts = transport_msgs[0].split(" ")
+ # "transport %i %f %f %s" -- prefix + 4 fields.
+ self.assertEqual(len(parts), 5)
+ rolling, bpb, bpm, sync = parts[1:]
+
+ # arg-count + parseability is the load-bearing assertion; the
+ # concrete defaults below are deterministic Profile() config
+ # (not volatile like cpu%/timestamps), so pinning them is safe
+ # in this fresh-sandbox harness.
+ self.assertEqual(int(rolling), 0)
+ self.assertEqual(float(bpb), 4.0)
+ self.assertEqual(float(bpm), 120.0)
+ self.assertEqual(sync, "none")
+ finally:
+ conn.close()
+
+ @gen_test(timeout=10)
+ def test_truebypass_message_reflects_defaults(self):
+ conn = yield websocket.websocket_connect(self.ws_url())
+ try:
+ messages = yield self.drain_until_ready(conn)
+ tb_msgs = [m for m in messages if m.split(" ", 1)[0] == "truebypass"]
+ self.assertEqual(len(tb_msgs), 1)
+
+ parts = tb_msgs[0].split(" ")
+ # "truebypass %i %i" -- prefix + 2 fields.
+ self.assertEqual(len(parts), 3)
+ left, right = int(parts[1]), int(parts[2])
+ # Observed default (Host.last_true_bypass_left/right initial
+ # state in this dev sandbox): both channels report "true bypass
+ # on".
+ self.assertEqual((left, right), (1, 1))
+ finally:
+ conn.close()
+
+ @gen_test(timeout=10)
+ def test_size_message_present_with_two_numeric_args(self):
+ conn = yield websocket.websocket_connect(self.ws_url())
+ try:
+ messages = yield self.drain_until_ready(conn)
+ size_msgs = [m for m in messages if m.split(" ", 1)[0] == "size"]
+ self.assertEqual(len(size_msgs), 1)
+
+ parts = size_msgs[0].split(" ")
+ # "size %d %d" -- prefix + 2 fields.
+ self.assertEqual(len(parts), 3)
+ width, height = int(parts[1]), int(parts[2])
+ # Empty/default pedalboard in a fresh sandbox -> zero size.
+ self.assertEqual((width, height), (0, 0))
+ finally:
+ conn.close()
+
+ @gen_test(timeout=10)
+ def test_second_concurrent_connection_gets_full_burst_but_no_trailing_extra(self):
+ conn1 = yield websocket.websocket_connect(self.ws_url())
+ try:
+ messages1 = yield self.drain_until_ready(conn1)
+ prefixes1 = [m.split(" ", 1)[0] for m in messages1]
+ self.assertEqual(prefixes1, _EXPECTED_PREFIXES)
+
+ # The first socket also gets one extra trailing sys_stats
+ # (FakeHost.open_connection_if_needed's memtimer_callback()
+ # kick, see module docstring). Consume it so it can't bleed
+ # into the second connection's read below; don't fail if it
+ # doesn't show up (it is an unpinned, environment-dependent
+ # detail).
+ try:
+ extra = yield self.read_one(conn1, timeout=1.0)
+ if extra is not None:
+ self.assertEqual(extra.split(" ", 1)[0], "sys_stats")
+ except gen.TimeoutError:
+ pass
+
+ # Second connection, opened while the first is still open --
+ # exercises Session.websocket_opened's "not the first socket"
+ # branch (session.py:236).
+ conn2 = yield websocket.websocket_connect(self.ws_url())
+ try:
+ messages2 = yield self.drain_until_ready(conn2)
+ prefixes2 = [m.split(" ", 1)[0] for m in messages2]
+ # Same full report_current_state burst as the first socket.
+ self.assertEqual(prefixes2, _EXPECTED_PREFIXES)
+
+ # But NOT the extra trailing sys_stats: FakeHost's
+ # readsock/writesock are already set by the time the second
+ # socket connects, so open_connection_if_needed takes the
+ # early-return branch (report_current_state only, no
+ # statstimer/memtimer kick).
+ with self.assertRaises(gen.TimeoutError):
+ yield self.read_one(conn2, timeout=1.0)
+ finally:
+ conn2.close()
+ finally:
+ conn1.close()
+
+
+class TestWebSocketClose(WebSocketTestCase):
+ __test__ = True
+
+ @gen_test(timeout=10)
+ def test_clean_close_no_server_error_and_hello_reflects_it(self):
+ conn = yield websocket.websocket_connect(self.ws_url())
+ yield self.drain_until_ready(conn)
+
+ response = yield self.http_client.fetch(self.get_url("/hello/"))
+ self.assertEqual(response.code, 200)
+ self.assertIn(b'"online": true', response.body)
+
+ conn.close()
+
+ # DROPPED (per phase-5 spec §6: "count may update asynchronously;
+ # drop the assertion rather than sleep-loop if flaky"): a strict
+ # assertion that /hello's `online` flips to false shortly after
+ # close. websocket_closed (session.py) only runs once the server's
+ # IOLoop actually polls and processes the close frame -- draining a
+ # bounded number of `gen.moment`s (pure callback-queue turns, no
+ # real I/O wait) was NOT enough to observe it in this harness
+ # (confirmed flaky: failed after 10 moments in a run where the
+ # exploratory script's 5-moments-after-two-fetches version happened
+ # to see it flip). A real wait would require an actual sleep/poll,
+ # which the spec explicitly says not to add. So this test only pins
+ # what's reliable: the server tolerates a client-initiated close
+ # without erroring, and a subsequent HTTP request still succeeds
+ # (well-formed JSON, 200) -- it does not assert on the `online`
+ # value after close.
+ response = yield self.http_client.fetch(self.get_url("/hello/"))
+ self.assertEqual(response.code, 200)
+ self.assertIn(b'"online"', response.body)
+
+
+
+
+
diff --git a/mod/settings.py b/mod/settings.py
index 6f9958cbf..2d79368d2 100644
--- a/mod/settings.py
+++ b/mod/settings.py
@@ -83,6 +83,11 @@
CONTROLCHAIN_HTTP_ADDRESS = os.environ.pop('MOD_CONTROLCHAIN_HTTP_ADDRESS',
"https://download.mod.audio/releases/cc-firmware/v3")
+# Tone3000 integration. The client id is the OAuth publishable key (t3k_pub_...),
+# a public value: it identifies the app, it grants no data access on its own.
+TONE3000_CLIENT_ID = os.environ.get('MOD_TONE3000_CLIENT_ID', "")
+TONE3000_API = os.environ.get('MOD_TONE3000_API', "https://www.tone3000.com")
+
MIDI_BEAT_CLOCK_SENDER_URI = "urn:mod:mclk"
MIDI_BEAT_CLOCK_SENDER_INSTANCE_ID = 9993
MIDI_BEAT_CLOCK_SENDER_OUTPUT_PORT = "mclk" # This is the LV2 symbol of the plug-ins OutputPort
diff --git a/mod/webserver.py b/mod/webserver.py
index 808c8532b..f787452ca 100644
--- a/mod/webserver.py
+++ b/mod/webserver.py
@@ -38,7 +38,8 @@
DEFAULT_ICON_TEMPLATE, DEFAULT_SETTINGS_TEMPLATE, DEFAULT_ICON_IMAGE,
DEFAULT_PEDALBOARD, DEFAULT_SNAPSHOT_NAME, DATA_DIR, KEYS_PATH, USER_FILES_DIR,
FAVORITES_JSON_FILE, PREFERENCES_JSON_FILE, USER_ID_JSON_FILE,
- DEV_HOST, UNTITLED_PEDALBOARD_NAME, MODEL_CPU, MODEL_TYPE, PEDALBOARDS_LABS_HTTP_ADDRESS)
+ DEV_HOST, UNTITLED_PEDALBOARD_NAME, MODEL_CPU, MODEL_TYPE, PEDALBOARDS_LABS_HTTP_ADDRESS,
+ TONE3000_CLIENT_ID, TONE3000_API)
from mod import (
TextFileFlusher, WINDOWS,
@@ -1819,6 +1820,8 @@ def index(self):
'preferences': json.dumps(SESSION.prefs.prefs),
'bufferSize': get_jack_buffer_size(),
'sampleRate': get_jack_sample_rate(),
+ 'tone3000_client_id': mod_squeeze(TONE3000_CLIENT_ID),
+ 'tone3000_api': mod_squeeze(TONE3000_API),
}
return context
@@ -2260,6 +2263,38 @@ def get(self):
'files': tuple(retfiles[fn] for fn in fullnames),
})
+class FilesUpload(JsonRequestHandler):
+ def post(self, filetype):
+ datadir, extensions = FilesList._get_dir_and_extensions_for_filetype(filetype)
+ if datadir is None:
+ raise web.HTTPError(400)
+
+ # Anything outside the 3 CORS "simple" content-types forces a preflight we do not answer,
+ # so a cross-origin page cannot reach this handler.
+ if self.request.headers.get("Content-Type") != "application/octet-stream":
+ raise web.HTTPError(400)
+
+ # basename() alone would quietly turn "../../etc" into "etc" and write it anyway.
+ # Refuse anything it would rewrite, so a caller never gets a file somewhere it did
+ # not ask for. Both are single path components by the time we join them.
+ folder = self.get_argument("folder", "")
+ name = self.get_argument("name", "")
+ if folder != os.path.basename(folder) or name != os.path.basename(name):
+ raise web.HTTPError(400)
+ if folder in ("", ".", "..") or name in ("", ".", ".."):
+ raise web.HTTPError(400)
+ if not name.lower().endswith(extensions):
+ raise web.HTTPError(400)
+
+ destdir = os.path.join(USER_FILES_DIR, datadir, folder)
+ os.makedirs(destdir, exist_ok=True)
+ fullname = os.path.join(destdir, name)
+ with open(fullname, 'wb') as fh:
+ fh.write(self.request.body)
+
+ # Same string FilesList builds by walking, so a caller can match on it.
+ self.write({'ok': True, 'fullname': fullname})
+
settings = {'log_function': lambda handler: None} if not LOG else {}
application = web.Application(
@@ -2352,6 +2387,7 @@ def get(self):
# file listing etc
(r"/files/list/?", FilesList),
+ (r"/files/upload/([a-z]+)/?", FilesUpload),
(r"/reset/?", DashboardClean),
diff --git a/package.json b/package.json
new file mode 100644
index 000000000..443cc187c
--- /dev/null
+++ b/package.json
@@ -0,0 +1,12 @@
+{
+ "name": "mod-ui",
+ "private": true,
+ "description": "Frontend tests for mod-ui. The app itself is browser-global JS served from html/; this package exists only to run the test/js/ suite under Node's built-in test runner.",
+ "scripts": {
+ "test": "node --test \"test/js/**/*.test.js\"",
+ "test:watch": "node --test --watch \"test/js/**/*.test.js\""
+ },
+ "devDependencies": {
+ "jsdom": "^29.1.1"
+ }
+}
diff --git a/pytest.ini b/pytest.ini
new file mode 100644
index 000000000..3655b1c20
--- /dev/null
+++ b/pytest.ini
@@ -0,0 +1,36 @@
+[pytest]
+testpaths = test
+python_files = test_*.py
+markers =
+ lilv: tests that initialize the global lilv world (opt-in; run with -m lilv).
+ Deliberately excluded from the default run by addopts below -- see
+ docs/characterization-phase-6.md. These tests call modtools.utils.init(),
+ which is process-global and has no de-init in this suite (cleanup()
+ exists but is intentionally not called -- see test/test_effects_lilv.py).
+ A combined run (`pytest -m "(lilv or not lilv) and not lilv_fixture"`
+ -- see the lilv_fixture marker below for why the "and not lilv_fixture"
+ is required) was verified green with no observed leakage into other
+ tests as of phase 6, but -m lilv should still be treated as its own
+ invocation in CI to keep the blast radius of a lilv/JACK-adjacent
+ regression contained to one job.
+ lilv_fixture: the phase-6 stretch-goal tests (test/test_effects_lilv_fixture.py)
+ that scan a hand-written, binaryless .lv2 bundle. Opt-in; run with
+ -m lilv_fixture, and ONLY that -- as its OWN, separate pytest
+ invocation. DO NOT run together with -m lilv: modtools.utils.init()
+ is only safe to call ONCE per process. Calling it a second time (this
+ module's fixture vs. test_effects_lilv.py's) leaves lilv's
+ process-global NamespaceDefinitions singleton bound to a freed world
+ -- confirmed by direct reproduction to silently return empty
+ ports/category data and then SIGSEGV the interpreter on exit. Keeping
+ this marker's tests in a file of their own, with their own single
+ init() call and their own `pytest -m lilv_fixture` invocation, is not
+ a style preference, it is the only way to keep this suite
+ segfault-free.
+ DANGER, easy to get wrong: a bare `-m "lilv or not lilv"` (the
+ phase-6 spec's combined-run check) ALSO collects lilv_fixture tests,
+ because a lilv_fixture-only test is NOT marked lilv and therefore
+ satisfies "not lilv" -- that recreates the exact double-init crash
+ above. When running that combined check, always add
+ `and not lilv_fixture`:
+ `pytest -m "(lilv or not lilv) and not lilv_fixture"`.
+addopts = -m "not lilv and not lilv_fixture"
diff --git a/test-requirements.txt b/test-requirements.txt
new file mode 100644
index 000000000..6957b218d
--- /dev/null
+++ b/test-requirements.txt
@@ -0,0 +1,4 @@
+pytest
+
+# Python 3.12 removed ssl.match_hostname, which tornado 4.3 falls back to importing from this package
+backports.ssl_match_hostname; python_version >= "3.12"
diff --git a/test/base.py b/test/base.py
new file mode 100644
index 000000000..958dd9a0d
--- /dev/null
+++ b/test/base.py
@@ -0,0 +1,78 @@
+#!/usr/bin/env python3
+# SPDX-FileCopyrightText: 2012-2023 MOD Audio UG
+# SPDX-License-Identifier: AGPL-3.0-or-later
+
+"""Shared base class for layer-1 characterization tests.
+
+Uses tornado 4.3's tornado.testing.AsyncHTTPTestCase (unittest-based, plain
+tornado-4 idioms -- no async/await) against the real module-level
+mod.webserver.application. conftest.py has already set every MOD_* env var
+before this module (or any test module) imports mod.webserver.
+"""
+
+import json
+
+from tornado.testing import AsyncHTTPTestCase
+
+from conftest import _UserFilesHelper, _USER_FILES_DIR
+
+
+class ModUITestCase(AsyncHTTPTestCase):
+ # Every test_*.py imports this class directly (`from base import
+ # ModUITestCase`) so it can subclass it -- which also puts it in each
+ # test module's globals. pytest's unittest integration collects *any*
+ # TestCase subclass it finds at module scope, regardless of name (the
+ # usual python_classes="Test*" filter does not apply to TestCase
+ # subclasses), so without this it would try to collect ModUITestCase
+ # itself as a test in every module that imports it and fail with
+ # "no attribute 'runTest'" (it defines no test_* methods of its own).
+ # Concrete subclasses below must set __test__ = True to opt back in,
+ # since __test__ is looked up via normal attribute inheritance.
+ __test__ = False
+
+ def runTest(self):
+ # Never actually invoked as a real test (real test_* methods are
+ # collected and run individually by pytest). Exists only because
+ # modern pytest (9.x) instantiates every unittest.TestCase subclass
+ # once with methodName="runTest" during collection, to register
+ # fixture factories (_pytest.unittest.UnitTestCase.newinstance()).
+ # tornado 4.3's own AsyncTestCase.__init__ (tornado/testing.py)
+ # unconditionally does getattr(self, methodName) -- unlike stdlib
+ # unittest.TestCase, it does not special-case a missing "runTest" --
+ # so without this method that probe instantiation raises
+ # AttributeError and collection fails for every test class.
+ pass
+
+ def get_app(self):
+ # Imported lazily (not at module top-level) so that conftest.py's
+ # env-var setup is guaranteed to have already run before mod.webserver
+ # -- and mod.settings, which reads MOD_* env vars at import time --
+ # is ever imported.
+ import mod.webserver
+ return mod.webserver.application
+
+ def seed(self, relpath, content=b"data"):
+ """Write USER_FILES_DIR/TONE3000
+Getting your tone…
+Exchanging the authorization code…
+ +
+
+
+
+
+
+
+
+
+ in NAM Models · shown in the File Manager
+
+
+
+
+
+
+
+
+
+
diff --git a/test/js/harness.js b/test/js/harness.js
new file mode 100644
index 000000000..34bef67f1
--- /dev/null
+++ b/test/js/harness.js
@@ -0,0 +1,102 @@
+// SPDX-FileCopyrightText: 2012-2023 MOD Audio UG
+// SPDX-License-Identifier: AGPL-3.0-or-later
+
+/*
+ * Test rig for the browser-global frontend.
+ *
+ * html/js/*.js is not modular -- it defines globals and assumes jQuery, Mustache and a few
+ * page-scoped variables already exist. So it cannot be require()'d. Instead we stand up a
+ * jsdom window, load the real vendored libraries into it, then load the real source file
+ * under test with window.eval, and drive its now-global functions.
+ *
+ * What this reaches, it tests for real. What jsdom lacks, it cannot: there is no layout
+ * (getBoundingClientRect is all zeros), no windowing (window.open is a stub), no network,
+ * no CSS. Popup *placement*, cross-window behaviour and styling are out of scope here and
+ * stay manual -- see README.md.
+ */
+
+const fs = require('fs')
+const path = require('path')
+const { JSDOM } = require('jsdom')
+
+const HTML = path.resolve(__dirname, '../../html')
+
+// Vendored libraries the frontend takes for granted, in load order.
+const LIBS = [
+ 'js/lib/jquery-1.9.1.min.js',
+ 'js/lib/mustache.js',
+ 'js/lib/sprintf-0.6.js',
+]
+
+/*
+ * Build a fresh window with jQuery + Mustache loaded and the globals the frontend expects
+ * to find on the page. Returns { window, $, load } where load(relPath) evals a real source
+ * file (path relative to html/) into the window.
+ *
+ * opts.url -- document origin, e.g. 'http://localhost:8888/' (default about:blank)
+ * opts.body -- initial innerHTML
+ * opts.jqueryUI -- stub draggable/droppable/resizable (icons call these); default true
+ */
+function makeWindow(opts) {
+ opts = opts || {}
+ const dom = new JSDOM('' + (opts.body || '') + '', {
+ runScripts: 'outside-only',
+ url: opts.url || 'about:blank',
+ })
+ const window = dom.window
+ const load = rel => window.eval(fs.readFileSync(path.join(HTML, rel), 'utf8'))
+
+ LIBS.forEach(load)
+ const $ = window.jQuery
+
+ // Page-scoped globals index.html defines before any js/ file runs. modgui.js reads
+ // VERSION/baseUrl at GUI-construction time; several files reference desktop/isSDK.
+ window.eval('var desktop = null; var isSDK = false; var VERSION = 1; var baseUrl = "";')
+
+ // jsdom has no TextEncoder on the window; PKCE code paths want it.
+ if (!window.TextEncoder) {
+ window.TextEncoder = require('util').TextEncoder
+ }
+
+ if (opts.jqueryUI !== false) {
+ ['draggable', 'droppable', 'resizable'].forEach(m => { $.fn[m] = function () { return this } })
+ }
+
+ return { window, $, load }
+}
+
+/*
+ * Capture what a JqueryClass box hands to self.window(options), without pulling in the real
+ * window.js overlay machinery. Call before loading a file that defines a *Box widget; the
+ * returned getter yields the latest options object the box registered.
+ */
+function captureWindowOptions(ctx) {
+ let captured = null
+ ctx.window.JqueryClass = function (name, methods) {
+ ctx.$.fn[name] = function (o) { return methods.init.apply(this, [o]) }
+ }
+ ctx.$.fn.window = function (options) { captured = options; return this }
+ return () => captured
+}
+
+/*
+ * An $.ajax stub that answers by URL substring. routes is { substring: responseOrFn };
+ * a function receives the ajax options and returns the response passed to success.
+ * Unmatched URLs invoke opts.error if present. Returns a thenable-ish object like $.ajax.
+ */
+function stubAjax(ctx, routes) {
+ ctx.$.ajax = opts => {
+ const url = opts.url || ''
+ for (const key in routes) {
+ if (url.indexOf(key) >= 0) {
+ const r = routes[key]
+ opts.success(typeof r === 'function' ? r(opts) : r)
+ return { done: () => {} }
+ }
+ }
+ if (opts.error) opts.error()
+ return { done: () => {} }
+ }
+}
+
+module.exports = { makeWindow, captureWindowOptions, stubAjax, HTML }
diff --git a/test/js/modgui.filelist.test.js b/test/js/modgui.filelist.test.js
new file mode 100644
index 000000000..327453689
--- /dev/null
+++ b/test/js/modgui.filelist.test.js
@@ -0,0 +1,212 @@
+// SPDX-FileCopyrightText: 2012-2023 MOD Audio UG
+// SPDX-License-Identifier: AGPL-3.0-or-later
+
+/*
+ * GUI.refreshFileTypesLists / swapFileWidgets -- refreshing a plugin's file dropdown in
+ * place after a download, without rebuilding the icon (which would cut its jsPlumb cables).
+ *
+ * Driven against the REAL html/js/modgui.js, rendered over two templates that nest the
+ * option nodes differently: html/resources/settings.html (options are direct children of
+ * the widget) and fixtures/icon-nested.html (options nested inside .mod-enumerated-list,
+ * the shape NAM's icon uses). The point of the swap is to work for both without assuming
+ * either.
+ */
+
+const { test, before } = require('node:test')
+const assert = require('node:assert')
+const fs = require('fs')
+const path = require('path')
+const { makeWindow, stubAjax, HTML } = require('./harness')
+
+// The icon template nests the file options inside a .mod-enumerated-list; settings.html
+// makes them direct children of the widget. Testing both is the point: the swap must not
+// assume either shape. The icon fixture is vendored here (see fixtures/icon-nested.html for
+// why); settings.html is the real shipped template, read from the checkout.
+const ICON = path.resolve(__dirname, 'fixtures/icon-nested.html')
+
+const URI = 'http://x#model'
+
+let ctx, $, iconTemplate, settingsTemplate
+
+before(() => {
+ ctx = makeWindow({ url: 'http://localhost:8888/' })
+ $ = ctx.$
+ ctx.load('js/modgui.js')
+ iconTemplate = fs.readFileSync(ICON, 'utf8')
+ settingsTemplate = fs.readFileSync(path.join(HTML, 'resources/settings.html'), 'utf8')
+})
+
+// Fresh file listing the ajax stub serves; each test sets it.
+let listing = []
+
+function mkEffect() {
+ return {
+ uri: 'http://nam', label: 'NAM', name: 'NAM', renderedVersion: 1,
+ ports: { audio: { input: [], output: [] }, midi: { input: [], output: [] },
+ cv: { input: [], output: [] }, control: { input: [], output: [] } },
+ presets: [], parameters: [{
+ uri: URI, label: 'Model', type: 'http://lv2plug.in/ns/ext/atom#Path',
+ fileTypes: ['nam', 'nammodel'], ranges: { default: '' }, value: '',
+ properties: [], units: {}, writable: true, readable: true, comment: '',
+ shortName: 'Model', symbol: 'model',
+ }],
+ gui: { iconTemplate, settingsTemplate, templateData: {}, javascript: null },
+ }
+}
+
+// Build a rendered GUI with an initially empty file list, the way loadDependencies would.
+function build() {
+ // loadDependencies re-fetches the templates over ajax even when effect.gui has them,
+ // so the stub must answer per-URL, not hand everyone the file list.
+ stubAjax(ctx, {
+ '/files/list': () => ({ files: listing.slice() }),
+ 'iconTemplate': iconTemplate,
+ 'settingsTemplate': settingsTemplate,
+ })
+ const effect = mkEffect()
+ const gui = new ctx.window.GUI(effect, {
+ defaultIconTemplate: '', defaultSettingsTemplate: '',
+ change() {}, patchGet() {}, patchSet() {}, presetLoad() {},
+ })
+ gui.dependenciesLoaded = true
+ effect.parameters[0].files = []
+ effect.parameters[0].path = true
+ let icon, settings
+ gui.render('graph/nam_1', (i, s) => { icon = i; settings = s }, false)
+ return { gui, icon, settings }
+}
+
+const options = root => root.find('[mod-role=enumeration-option]')
+const values = root => options(root).map((i, e) => $(e).attr('mod-parameter-value')).get()
+const file = (full, base) => ({ fullname: full, basename: base, filetype: 'nammodel' })
+
+test('starts with no options in either panel', () => {
+ listing = []
+ const { icon, settings } = build()
+ assert.equal(options(icon).length, 0)
+ assert.equal(options(settings).length, 0)
+})
+
+test('a download lands options inside each template\'s own container', () => {
+ listing = []
+ const { gui, icon, settings } = build()
+ listing = [
+ file('/u/NAM Models/T (1)/T - standard.nam', 'T - standard.nam'),
+ file('/u/NAM Models/T (1)/T - lite.nam', 'T - lite.nam'),
+ ]
+ gui.refreshFileTypesLists('nammodel')
+
+ const iconWidget = icon.find('[mod-widget=custom-select-path]')
+ assert.equal(iconWidget.length, 1, 'icon widget still present')
+ assert.equal(options(icon).length, 2, 'icon has both options')
+ // The icon nests options one level down; they must be inside the list, not floating.
+ assert.equal(iconWidget.find('.mod-enumerated-list [mod-role=enumeration-option]').length, 2)
+ assert.equal(iconWidget.children('[mod-role=enumeration-option]').length, 0)
+ assert.equal(iconWidget.find('[mod-role=input-parameter-value]').length, 1, 'kept value node')
+
+ const setWidget = settings.find('[mod-widget=custom-select-path]')
+ assert.equal(options(settings).length, 2, 'settings has both options')
+ // settings.html makes options direct children of the widget.
+ assert.equal(setWidget.children('[mod-role=enumeration-option]').length, 2)
+})
+
+test('parameter.widgets holds exactly the live nodes, no stale entries', () => {
+ listing = []
+ const { gui, icon, settings } = build()
+ listing = [file('/u/NAM Models/T (1)/T - a.nam', 'T - a.nam')]
+ gui.refreshFileTypesLists('nammodel')
+
+ const param = gui.parameters[URI]
+ assert.equal(param.widgets.length, 2, 'one per panel')
+ assert.ok(param.widgets.every(w =>
+ $.contains(icon[0], w[0]) || $.contains(settings[0], w[0])), 'all in the document')
+
+ // A second refresh must not accumulate widgets.
+ gui.refreshFileTypesLists('nammodel')
+ assert.equal(gui.parameters[URI].widgets.length, 2)
+})
+
+test('the current selection survives a refresh, in both panels', () => {
+ listing = [
+ file('/u/NAM Models/T (1)/T - lite.nam', 'T - lite.nam'),
+ file('/u/NAM Models/T (1)/T - standard.nam', 'T - standard.nam'),
+ ]
+ const { gui, icon, settings } = build()
+ gui.refreshFileTypesLists('nammodel')
+ const param = gui.parameters[URI]
+ param.value = '/u/NAM Models/T (1)/T - lite.nam'
+ gui.setWritableParameterValue(URI, 'p', param.value, null, true)
+
+ listing.push(file('/u/NAM Models/T (2)/T - nano.nam', 'T - nano.nam'))
+ gui.refreshFileTypesLists('nammodel')
+
+ assert.equal(options(icon).length, 3)
+ assert.equal(icon.find('.selected').attr('mod-parameter-value'), param.value)
+ assert.equal(settings.find('.selected').attr('mod-parameter-value'), param.value)
+})
+
+test('a value that no longer exists selects nothing, like a fresh build', () => {
+ listing = [file('/u/a.nam', 'a.nam'), file('/u/b.nam', 'b.nam')]
+ const { gui, icon } = build()
+ gui.refreshFileTypesLists('nammodel', ['/u/gone.nam'])
+ // hoisting a missing file is a no-op; selection was never set, so nothing is selected
+ gui.parameters[URI].value = '/u/gone.nam'
+ gui.setWritableParameterValue(URI, 'p', '/u/gone.nam', null, true)
+ assert.equal(icon.find('.selected').length, 0)
+})
+
+test('clicking a freshly-swapped option fires exactly one patch_set', () => {
+ listing = [file('/u/a.nam', 'a.nam'), file('/u/b.nam', 'b.nam')]
+ const { gui, icon } = build()
+ gui.refreshFileTypesLists('nammodel')
+ const sets = []
+ gui.lv2PatchSet = (uri, vt, v) => sets.push(v)
+ icon.find('[mod-parameter-value="/u/b.nam"]').click()
+ assert.deepEqual(sets, ['/u/b.nam'])
+})
+
+test('hoisted files lead the list, in both panels', () => {
+ const LITE = '/u/NAM Models/T (1)/T - lite.nam'
+ const NANO = '/u/NAM Models/T (2)/T - nano.nam'
+ listing = [
+ file(LITE, 'T - lite.nam'),
+ file('/u/NAM Models/T (1)/T - standard.nam', 'T - standard.nam'),
+ file(NANO, 'T - nano.nam'),
+ ]
+ const { gui, icon, settings } = build()
+ gui.refreshFileTypesLists('nammodel', [NANO])
+
+ assert.equal(values(icon)[0], NANO, 'hoisted file first in icon')
+ assert.equal(values(settings)[0], NANO, 'hoisted file first in settings')
+ assert.equal(values(icon).length, 3, 'no options lost')
+ // non-hoisted keep their /files/list (alphabetical) order after the hoisted ones
+ assert.equal(values(icon)[1], LITE)
+ assert.ok(values(icon)[2].endsWith('standard.nam'))
+})
+
+test('two hoisted files both lead, keeping /files/list order among themselves', () => {
+ const LITE = '/u/NAM Models/T (1)/T - lite.nam'
+ const NANO = '/u/NAM Models/T (2)/T - nano.nam'
+ listing = [
+ file(LITE, 'T - lite.nam'),
+ file('/u/NAM Models/T (1)/T - standard.nam', 'T - standard.nam'),
+ file(NANO, 'T - nano.nam'),
+ ]
+ const { gui, icon } = build()
+ gui.refreshFileTypesLists('nammodel', [NANO, LITE])
+ const lead = values(icon).slice(0, 2)
+ // passed [NANO, LITE] but the list order is lite-before-nano, and that is what's kept
+ assert.deepEqual(lead, [LITE, NANO])
+ assert.ok(values(icon)[2].endsWith('standard.nam'))
+})
+
+test('without a hoist argument the list keeps /files/list order', () => {
+ const LITE = '/u/NAM Models/T (1)/T - lite.nam'
+ listing = [
+ file(LITE, 'T - lite.nam'),
+ file('/u/NAM Models/T (2)/T - nano.nam', 'T - nano.nam'),
+ ]
+ const { gui, icon } = build()
+ gui.refreshFileTypesLists('nammodel')
+ assert.equal(values(icon)[0], LITE)
+})
diff --git a/test/js/tone3000.autoopen.test.js b/test/js/tone3000.autoopen.test.js
new file mode 100644
index 000000000..49f1ecb39
--- /dev/null
+++ b/test/js/tone3000.autoopen.test.js
@@ -0,0 +1,159 @@
+// SPDX-FileCopyrightText: 2012-2023 MOD Audio UG
+// SPDX-License-Identifier: AGPL-3.0-or-later
+
+/*
+ * tone3000Box -- the auto-open preference and the popup's lifetime relative to the tab.
+ *
+ * Driven against the REAL html/js/tone3000.js. The popup is a stub (jsdom has no real
+ * window.open), so this covers the wiring and the preference, not placement.
+ *
+ * Two behaviours pinned here, both of which were bugs at some point:
+ * - the "open automatically" checkbox persists in localStorage and gates windowopen;
+ * - selecting the tab while the popup is open FOCUSES it, never re-opens or re-navigates
+ * it -- there is deliberately no windowclose handler, because windowclose fires whenever
+ * the panel hides, including when another tab is raised.
+ */
+
+const { test, beforeEach } = require('node:test')
+const assert = require('node:assert')
+const { makeWindow, captureWindowOptions } = require('./harness')
+
+const KEY = 't3k_auto_open'
+const BODY = '
+ {{#controls}}
+
+
+
+
+
+ {{/controls}}
+ {{name}}
+
+
+
+
+ {{#effect.parameters}}
+ {{#path}}
+
+
+
+ {{/path}}
+ {{/effect.parameters}}
+
+ -- choose a model --
+
+
+ {{#files}}
+
+ {{basename}}
+ {{/files}}
+
+ {{#effect.ports.audio.input}}
+
+
+
+
+ {{/effect.ports.audio.input}}
+
+ {{#effect.ports.audio.output}}
+
+
+
+
+ {{/effect.ports.audio.output}}
+ ' +
+ '' +
+ '' +
+ '' +
+ '
'
+
+let ctx, $, getOptions
+let opened, popups
+
+// A stand-in popup. `location` is what a re-navigation would write; `focused` counts focus().
+function makePopup() {
+ const p = { closed: false, focused: 0, location: '',
+ focus() { this.focused++ }, close() { this.closed = true } }
+ popups.push(p)
+ return p
+}
+
+beforeEach(() => {
+ ctx = makeWindow({ url: 'http://localhost:8888/', body: BODY })
+ $ = ctx.$
+ getOptions = captureWindowOptions(ctx)
+
+ opened = 0
+ popups = []
+ ctx.window.open = () => { opened++; return makePopup() }
+ ctx.window.alert = () => {}
+ ctx.window.TONE3000_CLIENT_ID = 'pk_test'
+ ctx.window.TONE3000_API = 'https://www.tone3000.com'
+ // crypto.subtle.digest never resolves here, so the authorize URL is never built and the
+ // popup is never navigated -- exactly what lets us assert location stays ''. window.crypto
+ // is a read-only accessor in jsdom, so define over it rather than assign.
+ Object.defineProperty(ctx.window, 'crypto', {
+ value: { getRandomValues: a => a, subtle: { digest: () => new Promise(() => {}) } },
+ configurable: true,
+ })
+ ctx.window.btoa = s => Buffer.from(s, 'binary').toString('base64')
+
+ ctx.load('js/tone3000.js')
+})
+
+const checkbox = () => $('#tone3000-autoopen')
+const initBox = () => $('#t3k').tone3000Box({})
+// The popup persists in module state across initBox(); close it so the next
+// "does open() open one?" check starts clean, the way a fresh session would.
+const closePopups = () => { popups.forEach(p => { p.closed = true }); opened = 0 }
+
+test('checkbox is off and nothing auto-opens by default', () => {
+ initBox()
+ assert.equal(checkbox().prop('checked'), false)
+ getOptions().open()
+ assert.equal(opened, 0)
+})
+
+test('ticking the checkbox persists the preference', () => {
+ initBox()
+ checkbox().prop('checked', true).trigger('change')
+ assert.equal(ctx.window.localStorage.getItem(KEY), '1')
+})
+
+test('when the preference is on, selecting the tab opens the popup', () => {
+ ctx.window.localStorage.setItem(KEY, '1')
+ initBox()
+ assert.equal(checkbox().prop('checked'), true, 'checkbox restored from storage')
+ closePopups()
+ getOptions().open()
+ assert.equal(opened, 1)
+})
+
+test('the preference survives a reload (a rebuild of the box)', () => {
+ ctx.window.localStorage.setItem(KEY, '1')
+ initBox()
+ initBox() // reload
+ assert.equal(checkbox().prop('checked'), true)
+ closePopups()
+ getOptions().open()
+ assert.equal(opened, 1)
+})
+
+test('unticking clears the preference and stops auto-open', () => {
+ ctx.window.localStorage.setItem(KEY, '1')
+ initBox()
+ checkbox().prop('checked', false).trigger('change')
+ assert.equal(ctx.window.localStorage.getItem(KEY), '0')
+ initBox()
+ assert.equal(checkbox().prop('checked'), false)
+ closePopups()
+ getOptions().open()
+ assert.equal(opened, 0)
+})
+
+test('open() returns false so it does not swallow the panel-show', () => {
+ initBox()
+ closePopups()
+ assert.equal(getOptions().open(), false)
+})
+
+test('re-selecting the tab focuses the open popup, never re-opens or re-navigates it', () => {
+ ctx.window.localStorage.setItem(KEY, '1')
+ initBox()
+ closePopups()
+ popups = []
+
+ getOptions().open()
+ assert.equal(opened, 1, 'first selection opens it')
+ const popup = popups[0]
+ assert.equal(popup.location, '', 'not navigated (authorize URL never built here)')
+
+ getOptions().open() // leave to another tab, come back
+ getOptions().open()
+ assert.equal(opened, 1, 'no second popup')
+ assert.equal(popup.focused, 2, 'focused each return')
+ assert.equal(popup.location, '', 'never re-navigated')
+})
+
+test('there is no windowclose handler -- the popup outlives the panel', () => {
+ initBox()
+ assert.equal(getOptions().close, undefined)
+})
+
+test('once the user closes the popup, the tab opens a fresh one', () => {
+ ctx.window.localStorage.setItem(KEY, '1')
+ initBox()
+ closePopups()
+ popups = []
+ getOptions().open()
+ popups[0].closed = true
+ getOptions().open()
+ assert.equal(opened, 2, 'a closed popup is replaced, not focused')
+ assert.equal(popups.length, 2)
+})
+
+test('a localStorage that throws (private mode) does not break the tab', () => {
+ const real = Object.getOwnPropertyDescriptor(ctx.window, 'localStorage')
+ Object.defineProperty(ctx.window, 'localStorage',
+ { get() { throw new Error('denied') }, configurable: true })
+ assert.doesNotThrow(() => { initBox(); getOptions().open() })
+ Object.defineProperty(ctx.window, 'localStorage', real)
+})
diff --git a/test/test_banks.py b/test/test_banks.py
new file mode 100644
index 000000000..2da07013a
--- /dev/null
+++ b/test/test_banks.py
@@ -0,0 +1,101 @@
+#!/usr/bin/env python3
+# SPDX-FileCopyrightText: 2012-2023 MOD Audio UG
+# SPDX-License-Identifier: AGPL-3.0-or-later
+
+"""Characterization tests for /banks/save (BankSave) and /banks/ (BankLoad),
+mod/webserver.py.
+
+conftest.py pre-seeds DATA_DIR/banks.json with "[]" (mimicking
+check_environment(), which real prepare() calls but this sandbox never
+does). Both handlers use mod.settings.USER_BANKS_JSON_FILE, so this module
+snapshots/restores that file around every test.
+"""
+
+import json
+import os
+
+import pytest
+
+from base import ModUITestCase
+
+
+@pytest.fixture(autouse=True)
+def _snapshot_banks_json():
+ from mod import settings
+
+ with open(settings.USER_BANKS_JSON_FILE, "r") as fh:
+ before = fh.read()
+
+ yield
+
+ with open(settings.USER_BANKS_JSON_FILE, "w") as fh:
+ fh.write(before)
+
+
+class TestBankLoadEmpty(ModUITestCase):
+ __test__ = True
+
+ def test_load_with_empty_banks_json_returns_empty_list(self):
+ response, body = self.fetch_json("/banks/")
+ self.assertEqual(response.code, 200)
+ self.assertEqual(body, [])
+
+
+class TestBankSave(ModUITestCase):
+ __test__ = True
+
+ def test_save_writes_banks_json_and_returns_true(self):
+ banks = [{"title": "Bank 1", "pedalboards": []}]
+ response = self.fetch("/banks/save", method="POST", body=json.dumps(banks))
+ self.assertEqual(response.code, 200)
+ self.assertEqual(response.body, b"true")
+
+ from mod import settings
+
+ with open(settings.USER_BANKS_JSON_FILE, "r") as fh:
+ on_disk = json.load(fh)
+ self.assertEqual(on_disk, banks)
+
+
+class TestBankRoundTripNonexistentPedalboard(ModUITestCase):
+ __test__ = True
+
+ def test_save_bank_referencing_missing_pedalboard_is_filtered_on_load(self):
+ # DP1/round-trip case from the spec: does BankLoad filter out a
+ # pedalboard whose bundle path doesn't exist in the sandboxed temp
+ # pedalboards dir (which is always empty here)?
+ banks = [
+ {
+ "title": "Bank 1",
+ "pedalboards": [
+ {"bundle": "/nonexistent/thing.pedalboard", "title": "Ghost"}
+ ],
+ }
+ ]
+ save_response = self.fetch(
+ "/banks/save", method="POST", body=json.dumps(banks)
+ )
+ self.assertEqual(save_response.body, b"true")
+
+ load_response, body = self.fetch_json("/banks/")
+ self.assertEqual(load_response.code, 200)
+
+ # The bank itself survives, but its pedalboards list is filtered
+ # empty: list_banks() (mod/bank.py) drops any pedalboard whose
+ # 'bundle' path doesn't os.path.exists(), independent of whether it
+ # is "broken" -- and the temp pedalboards dir is always empty in
+ # this sandbox, so get_all_pedalboards() never repopulates it
+ # either.
+ self.assertEqual(len(body), 1)
+ self.assertEqual(body[0]["title"], "Bank 1")
+ self.assertEqual(body[0]["pedalboards"], [])
+
+ # Observed side effect: list_banks() auto-rewrites banks.json to
+ # drop the now-filtered pedalboard entry as a side effect of a GET
+ # request (mod/bank.py:58-59, changed=True + shouldSave=True by
+ # default). So a plain GET /banks/ is not read-only on disk.
+ from mod import settings
+
+ with open(settings.USER_BANKS_JSON_FILE, "r") as fh:
+ on_disk = json.load(fh)
+ self.assertEqual(on_disk[0]["pedalboards"], [])
diff --git a/test/test_config.py b/test/test_config.py
new file mode 100644
index 000000000..a898094fe
--- /dev/null
+++ b/test/test_config.py
@@ -0,0 +1,188 @@
+#!/usr/bin/env python3
+# SPDX-FileCopyrightText: 2012-2023 MOD Audio UG
+# SPDX-License-Identifier: AGPL-3.0-or-later
+
+"""Characterization tests for the small config/user-data POST endpoints:
+favorites (mod/webserver.py:FavoritesAdd/FavoritesRemove), /config/set
+(SaveSingleConfigValue), /save_user_id/ (SaveUserId) and /auth/nonce
+(AuthNonce).
+
+These all mutate either an in-process singleton (gState.favorites) or a
+DATA_DIR JSON file (favorites.json, prefs.json, user-id.json). Since
+conftest.py's autouse `user_files` fixture only resets USER_FILES_DIR, this
+module snapshots/restores gState.favorites and the DATA_DIR files itself so
+tests stay order-independent (per characterization-phase-2.md ground rule 5).
+"""
+
+import json
+import os
+
+import pytest
+
+from base import ModUITestCase
+
+
+def _read_or_none(path):
+ if not os.path.exists(path):
+ return None
+ with open(path, "r") as fh:
+ return fh.read()
+
+
+def _restore(path, original):
+ if original is None:
+ if os.path.exists(path):
+ os.remove(path)
+ else:
+ with open(path, "w") as fh:
+ fh.write(original)
+
+
+@pytest.fixture(autouse=True)
+def _snapshot_data_dir_state():
+ import mod.webserver as webserver
+ from mod import settings
+
+ favorites_snapshot = list(webserver.gState.favorites)
+ prefs_before = _read_or_none(settings.PREFERENCES_JSON_FILE)
+ user_id_before = _read_or_none(settings.USER_ID_JSON_FILE)
+ favorites_file_before = _read_or_none(settings.FAVORITES_JSON_FILE)
+
+ yield
+
+ webserver.gState.favorites[:] = favorites_snapshot
+ _restore(settings.PREFERENCES_JSON_FILE, prefs_before)
+ _restore(settings.USER_ID_JSON_FILE, user_id_before)
+ _restore(settings.FAVORITES_JSON_FILE, favorites_file_before)
+
+
+class TestFavoritesAdd(ModUITestCase):
+ __test__ = True
+
+ def test_add_writes_favorites_json_and_returns_true(self):
+ response = self.fetch(
+ "/favorites/add", method="POST", body="uri=http%3A%2F%2Fexample.org%2Ffx"
+ )
+ self.assertEqual(response.code, 200)
+ self.assertEqual(response.body, b"true")
+
+ from mod import settings
+
+ with open(settings.FAVORITES_JSON_FILE, "r") as fh:
+ data = json.load(fh)
+ self.assertEqual(data, ["http://example.org/fx"])
+
+ def test_add_duplicate_returns_false_and_does_not_duplicate(self):
+ body = "uri=http%3A%2F%2Fexample.org%2Ffx"
+ first = self.fetch("/favorites/add", method="POST", body=body)
+ self.assertEqual(first.body, b"true")
+
+ second = self.fetch("/favorites/add", method="POST", body=body)
+ self.assertEqual(second.code, 200)
+ self.assertEqual(second.body, b"false")
+
+ from mod import settings
+
+ with open(settings.FAVORITES_JSON_FILE, "r") as fh:
+ data = json.load(fh)
+ self.assertEqual(data, ["http://example.org/fx"])
+
+ def test_add_missing_uri_argument_is_400(self):
+ response = self.fetch("/favorites/add", method="POST", body="")
+ self.assertEqual(response.code, 400)
+
+
+class TestFavoritesRemove(ModUITestCase):
+ __test__ = True
+
+ def test_add_then_remove_empties_favorites_json(self):
+ body = "uri=http%3A%2F%2Fexample.org%2Ffx"
+ self.fetch("/favorites/add", method="POST", body=body)
+
+ response = self.fetch("/favorites/remove", method="POST", body=body)
+ self.assertEqual(response.code, 200)
+ self.assertEqual(response.body, b"true")
+
+ from mod import settings
+
+ with open(settings.FAVORITES_JSON_FILE, "r") as fh:
+ data = json.load(fh)
+ self.assertEqual(data, [])
+
+ def test_remove_unknown_uri_returns_false(self):
+ response = self.fetch(
+ "/favorites/remove",
+ method="POST",
+ body="uri=http%3A%2F%2Fnever-added.example%2Ffx",
+ )
+ self.assertEqual(response.code, 200)
+ self.assertEqual(response.body, b"false")
+
+
+class TestSaveSingleConfigValue(ModUITestCase):
+ __test__ = True
+
+ def test_set_writes_prefs_json_and_returns_true(self):
+ response = self.fetch(
+ "/config/set", method="POST", body="key=some-key&value=some-value"
+ )
+ self.assertEqual(response.code, 200)
+ self.assertEqual(response.body, b"true")
+
+ from mod import settings
+
+ with open(settings.PREFERENCES_JSON_FILE, "r") as fh:
+ data = json.load(fh)
+ # Values are stored verbatim as whatever get_argument() returned:
+ # tornado decodes form params to str, so both key and value land as
+ # plain strings in prefs.json (no int/bool coercion happens here).
+ self.assertEqual(data["some-key"], "some-value")
+ self.assertIsInstance(data["some-key"], str)
+
+ def test_set_missing_key_argument_is_400(self):
+ response = self.fetch("/config/set", method="POST", body="value=x")
+ self.assertEqual(response.code, 400)
+
+
+class TestSaveUserId(ModUITestCase):
+ __test__ = True
+
+ def test_save_writes_user_id_json_and_returns_true(self):
+ response = self.fetch(
+ "/save_user_id/",
+ method="POST",
+ body="name=Ada&email=ada%40example.org",
+ )
+ self.assertEqual(response.code, 200)
+ self.assertEqual(response.body, b"true")
+
+ from mod import settings
+
+ with open(settings.USER_ID_JSON_FILE, "r") as fh:
+ data = json.load(fh)
+ self.assertEqual(data, {"name": "Ada", "email": "ada@example.org"})
+
+ def test_save_missing_name_argument_is_400(self):
+ response = self.fetch(
+ "/save_user_id/", method="POST", body="email=ada%40example.org"
+ )
+ self.assertEqual(response.code, 400)
+
+
+class TestAuthNonce(ModUITestCase):
+ __test__ = True
+
+ def test_auth_nonce_observed_behavior(self):
+ # Spec: "if the crypto `token` module is None -> {}; otherwise may
+ # error -- OBSERVE and pin actual." In this dev sandbox
+ # mod.communication.token imports fine (no exception at import
+ # time), so `token` is NOT None; but MOD_DEVICE_KEY / MOD_DEVICE_TAG
+ # are unset (conftest.py never sets them), so
+ # mod.communication.device.get_tag() raises "Missing device tag"
+ # once AuthNonce actually calls token.create_token_message(). That
+ # exception is uncaught by the handler, so tornado turns it into a
+ # 500.
+ response = self.fetch(
+ "/auth/nonce", method="POST", body=json.dumps({"nonce": "abc123"})
+ )
+ self.assertEqual(response.code, 500)
diff --git a/test/test_cors.py b/test/test_cors.py
new file mode 100644
index 000000000..9bfc5972d
--- /dev/null
+++ b/test/test_cors.py
@@ -0,0 +1,63 @@
+#!/usr/bin/env python3
+# SPDX-FileCopyrightText: 2012-2023 MOD Audio UG
+# SPDX-License-Identifier: AGPL-3.0-or-later
+
+"""Characterization tests for CORS headers.
+
+Pins the constraint that shapes the Tone3000 download design: ordinary
+JsonRequestHandler routes (e.g. /files/list) send no
+Access-Control-Allow-Origin at all, while RemoteRequestHandler subclasses
+(e.g. Hello, at /hello) echo it back only for the mod.audio/moddevices.com
+allow-list (mod/webserver.py:279-292).
+"""
+
+from base import ModUITestCase
+
+
+class TestFilesListCors(ModUITestCase):
+ __test__ = True
+
+ def test_files_list_has_no_cors_header(self):
+ response = self.fetch("/files/list?types=bogus")
+ self.assertEqual(response.code, 200)
+ self.assertNotIn("Access-Control-Allow-Origin", response.headers)
+
+
+class TestHelloAllowedOriginCors(ModUITestCase):
+ """Base case for the allow-list: subclasses only change ``origin``."""
+
+ __test__ = True
+ origin = "https://mod.audio"
+
+ def test_hello_echoes_allowed_origin(self):
+ response = self.fetch("/hello", headers={"Origin": self.origin})
+ self.assertEqual(response.code, 200)
+ self.assertEqual(
+ response.headers.get("Access-Control-Allow-Origin"),
+ self.origin,
+ )
+
+
+class TestHelloAllowedOriginModdevicesCors(TestHelloAllowedOriginCors):
+ origin = "https://moddevices.com"
+
+
+class TestHelloAllowedOriginPlainHttpCors(TestHelloAllowedOriginCors):
+ origin = "http://mod.audio"
+
+
+class TestHelloAllowedOriginModAudioSubdomainCors(TestHelloAllowedOriginCors):
+ origin = "https://pedalboards.mod.audio"
+
+
+class TestHelloAllowedOriginModdevicesSubdomainCors(TestHelloAllowedOriginCors):
+ origin = "https://cloud.moddevices.com"
+
+
+class TestHelloForeignOriginCors(ModUITestCase):
+ __test__ = True
+
+ def test_hello_omits_header_for_foreign_origin(self):
+ response = self.fetch("/hello", headers={"Origin": "https://evil.example"})
+ self.assertEqual(response.code, 200)
+ self.assertNotIn("Access-Control-Allow-Origin", response.headers)
diff --git a/test/test_effects_lilv.py b/test/test_effects_lilv.py
new file mode 100644
index 000000000..6262d40c0
--- /dev/null
+++ b/test/test_effects_lilv.py
@@ -0,0 +1,174 @@
+#!/usr/bin/env python3
+# SPDX-FileCopyrightText: 2012-2023 MOD Audio UG
+# SPDX-License-Identifier: AGPL-3.0-or-later
+
+"""Characterization tests for the /effect/* plugin-info handlers
+(mod/webserver.py: EffectList, EffectGet, EffectGetNonCached, EffectBulk,
+EffectAdd) that dereference the global lilv world (utils/utils_lilv.cpp
+W/PLUGINS, initialized by modtools.utils.init()).
+
+Phase 6 (docs/characterization-phase-6.md): this whole module is the
+controlled, opt-in exception to the test/conftest.py NEVER-CALL LIST entry
+for these exact routes. Every test here runs against an EMPTY lilv world
+(LV2_PATH pointed at a dedicated empty sandbox dir in test/conftest.py) --
+no real plugin is ever scanned, so every URI used below is, from lilv's
+point of view, unknown/nonexistent.
+
+Opt-in via the `lilv` pytest marker (see pytest.ini): `pytestmark` below
+marks every test in this module, and pytest.ini's `addopts = -m "not lilv"`
+excludes the whole module from the default `pytest` run. Run explicitly with
+`pytest -m lilv`.
+
+modtools.utils.init() is the exact function mod/webserver.py's lv2_init()
+(aliased import at webserver.py:52, called inside prepare() at :2451) calls
+-- confirmed by reading modtools/utils.py's init() (:708), which is a bare
+`utils.init()` ctypes call into utils/utils_lilv.cpp init() (:3893:
+lilv_world_free + lilv_world_new + lilv_world_load_all + namespace setup,
+no JACK calls). This fixture calls the same modtools.utils.init(), skipping
+the rest of webserver.prepare() (HMI/host/JACK setup), matching the spec's
+guidance to call the same underlying function without the surrounding
+production bootstrap.
+
+No de-init: modtools.utils.cleanup() exists but is deliberately not called
+here -- it frees the global lilv world (W = nullptr), and any other test
+process code that runs after it (including non-lilv tests, if ever run in
+the same process) would then be back to square one, NULL-W, for any /effect/*
+call. Leaving the world initialized-but-empty for the rest of the process
+is the safer of two bad options and is exactly why this suite keeps these
+tests opt-in/marker-gated rather than trying to isolate them automatically.
+
+The stretch-goal hand-written-.lv2-bundle tests (docs/characterization-
+phase-6.md) live in a SEPARATE file, test/test_effects_lilv_fixture.py,
+under a SEPARATE marker (`lilv_fixture`), run as its own invocation
+(`pytest -m lilv_fixture`) -- NEVER combined in the same process as this
+module's `lilv_world` fixture. Reason (load-bearing finding, see that
+file's docstring): modtools.utils.init() is safe to call once per process,
+but calling it a SECOND time (e.g. to reload with a bundle present) does
+not correctly reset lilv's NamespaceDefinitions::getStaticInstance()
+singleton (utils/utils_lilv.cpp ~:540), which is a process-global object
+independent of the LilvWorld it was last init()ed with. A second init()
+call left get_plugin_info()'s ports/category silently empty (instead of
+the real data) and reliably crashed the interpreter on process exit
+(SIGSEGV during native static/global teardown) -- confirmed by direct
+reproduction, not a guess. One init() per process is a hard constraint of
+this C extension as used here.
+"""
+
+import json
+
+from base import ModUITestCase
+
+import pytest
+
+pytestmark = pytest.mark.lilv
+
+
+@pytest.fixture(scope="module", autouse=True)
+def lilv_world():
+ from modtools import utils
+ utils.init()
+ yield
+ # Deliberately no cleanup()/de-init -- see module docstring.
+
+
+class TestEffectList(ModUITestCase):
+ __test__ = True
+
+ def test_empty_world_returns_empty_list(self):
+ response = self.fetch("/effect/list")
+ self.assertEqual(response.code, 200)
+ content_type = response.headers.get("Content-Type", "")
+ self.assertIn("application/json", content_type)
+ self.assertEqual(json.loads(response.body.decode("utf-8")), [])
+
+
+class TestEffectGet(ModUITestCase):
+ __test__ = True
+
+ def test_unknown_uri_is_404(self):
+ # get_plugin_info() (modtools/utils.py) raises when the C lookup
+ # returns NULL for an unknown URI; EffectGet's bare `except:` around
+ # it turns that into web.HTTPError(404). CachedJsonRequestHandler
+ # does not override write_error, so this is tornado's default HTML
+ # error page, NOT a JSON body -- unlike every other handler in this
+ # suite, do not decode this response as JSON.
+ response = self.fetch("/effect/get?uri=urn:nonexistent")
+ self.assertEqual(response.code, 404)
+
+
+class TestEffectGetNonCached(ModUITestCase):
+ __test__ = True
+
+ def test_unknown_uri_is_404(self):
+ # Same shape as EffectGet: get_non_cached_plugin_info() raises for
+ # an unknown URI, caught by the handler's bare `except:`, re-raised
+ # as web.HTTPError(404) -> tornado's default HTML error page.
+ response = self.fetch("/effect/get_non_cached?uri=urn:nonexistent")
+ self.assertEqual(response.code, 404)
+
+
+class TestEffectBulk(ModUITestCase):
+ __test__ = True
+
+ def _post_bulk(self, uris):
+ return self.fetch(
+ "/effect/bulk/",
+ method="POST",
+ headers={"Content-Type": "application/json"},
+ body=json.dumps(uris),
+ )
+
+ def test_empty_list_returns_empty_object(self):
+ response = self._post_bulk([])
+ self.assertEqual(response.code, 200)
+ content_type = response.headers.get("Content-Type", "")
+ self.assertIn("application/json", content_type)
+ self.assertEqual(json.loads(response.body.decode("utf-8")), {})
+
+ def test_unknown_uris_are_silently_skipped(self):
+ # EffectBulk.post() calls get_plugin_info(uri) per URI inside a bare
+ # try/except that `continue`s on failure -- an unknown URI simply
+ # never makes it into the result dict, no error surfaced at all.
+ response = self._post_bulk(["urn:nonexistent-1", "urn:nonexistent-2"])
+ self.assertEqual(response.code, 200)
+ self.assertEqual(json.loads(response.body.decode("utf-8")), {})
+
+ def test_missing_content_type_is_501(self):
+ # EffectBulk.prepare() requires "application/json" in Content-Type,
+ # else raises web.HTTPError(501) before post() ever runs.
+ response = self.fetch("/effect/bulk/", method="POST", body=json.dumps([]))
+ self.assertEqual(response.code, 501)
+
+
+class TestEffectAdd(ModUITestCase):
+ __test__ = True
+
+ def test_unknown_uri_ends_in_404_not_false(self):
+ # SPEC DEVIATION (docs/characterization-phase-6.md guessed "false?"):
+ # observed behavior is HTTP 404, not a JSON `false` body. Traced:
+ # 1. EffectAdd.get() does `ok = yield gen.Task(SESSION.web_add, ...)`.
+ # 2. web_add -> Host.add_plugin -> FakeHost.send_modified(msg, host_callback)
+ # (mod/development.py) calls host_callback(True) unconditionally
+ # and synchronously -- no real mod-host round trip.
+ # 3. Inside add_plugin's host_callback, `resp` is `True`; the guard
+ # is `if resp < 0`, and `True < 0` is False in Python, so it does
+ # NOT bail out early despite the URI being unknown.
+ # 4. It then calls get_plugin_info_essentials(uri) (modtools/utils.py),
+ # which is NULL-safe: an unknown URI returns a defaults dict
+ # (`{'error': True, 'controlInputs': [], ...}`) instead of
+ # raising. So add_plugin finishes normally, registers a fake
+ # plugin instance in SESSION.host.plugins, and calls
+ # callback(True) -- i.e. `ok` is True back in EffectAdd.get().
+ # 5. Because ok is truthy, EffectAdd.get() proceeds to
+ # `data = get_plugin_info(uri)` (NOT get_plugin_info_essentials)
+ # -- this one DOES raise for an unknown URI (see TestEffectGet
+ # above), caught by EffectAdd's own bare `except:`, which raises
+ # web.HTTPError(404).
+ # Net effect: an unknown-URI add is NOT rejected up front; it silently
+ # registers bookkeeping state on SESSION.host before failing late,
+ # with a 404 (tornado's default HTML error page) as the only visible
+ # signal to the caller -- no JSON, no `false`.
+ response = self.fetch(
+ "/effect/add/lilv_phase6_unknown?uri=urn:nonexistent&x=0&y=0"
+ )
+ self.assertEqual(response.code, 404)
diff --git a/test/test_effects_lilv_fixture.py b/test/test_effects_lilv_fixture.py
new file mode 100644
index 000000000..5bb357d75
--- /dev/null
+++ b/test/test_effects_lilv_fixture.py
@@ -0,0 +1,147 @@
+#!/usr/bin/env python3
+# SPDX-FileCopyrightText: 2012-2023 MOD Audio UG
+# SPDX-License-Identifier: AGPL-3.0-or-later
+
+"""Phase 6 (docs/characterization-phase-6.md) STRETCH GOAL: a minimal
+hand-written .lv2 bundle (test/fixtures/phase6-fixture.lv2/ -- manifest.ttl
++ phase6-fixture.ttl, deliberately NO binary/.so file), scanned into its own
+lilv world, to pin one real /effect/list entry shape and one real
+/effect/get field set -- as opposed to test_effects_lilv.py, which only
+exercises an empty world / unknown URIs.
+
+Confirmed: lilv does NOT need the plugin binary to exist on disk for
+metadata listing or get_plugin_info(). lilv_world_load_all() only RDF-parses
+manifest.ttl and the rdfs:seeAlso'd turtle file; it never dlopen()s
+lv2:binary at scan time (only real audio instantiation would). manifest.ttl
+here points lv2:binary at "phase6-fixture.so", a file that is never created
+anywhere -- the scan and both endpoints below work anyway. So the spec's
+"if lilv refuses a binaryless bundle, drop the stretch" escape hatch was not
+needed for the *lilv* half of this stretch goal.
+
+THIS FILE MUST BE RUN AS ITS OWN INVOCATION: `pytest -m lilv_fixture`, never
+combined with `-m lilv` (test_effects_lilv.py) in the same process, and
+never via a marker expression that would pull both in (e.g. do NOT run
+`pytest -m "lilv or lilv_fixture"`). This is a hard constraint, not
+caution for its own sake -- it is the actual reason the stretch goal ended
+up in its own file instead of a second test class inside
+test_effects_lilv.py (which is where it lived during development).
+
+What went wrong when it *was* a second class in the same file/process,
+reproduced directly: that class's setUpClass copied the fixture bundle into
+a fresh directory, repointed LV2_PATH, and called modtools.utils.init() a
+SECOND time in the process (the module-scoped `lilv_world` fixture in
+test_effects_lilv.py having already called it once for the empty world).
+modtools/utils.py init() is a bare ctypes call into utils/utils_lilv.cpp
+init() (:3893), which does free the previous LilvWorld and build a new one
+-- but it also re-runs `NamespaceDefinitions::getStaticInstance(W).init(W)`
+(:3898). getStaticInstance() (~:540) is a process-wide C++ singleton
+(function-local `static`), NOT reset or freed between the two init() calls
+(cleanup() -- the only code path that calls
+`NamespaceDefinitions::...cleanup()` -- is, per the phase-6 spec, never
+called in this suite). The result, reproduced directly: the second world's
+plugin was found and get_all_plugins()/get_plugin_info() returned it, but
+its `ports` and `category` fields were silently empty (`[]`) instead of the
+real port/category data -- no exception, no crash at that point, just wrong
+data, because the namespace lookups the C++ code uses to classify ports/
+categories were resolved against the FIRST (already-freed) world's nodes.
+Worse, the process then reliably SIGSEGV'd during native static/global
+destructor teardown at interpreter exit (after pytest had already printed
+its full PASSED/FAILED summary -- so a naive glance at "tests passed" would
+have missed it; `timeout ... ; echo $?` showed "dumped core"). This is
+exactly the DANGER-level failure mode the phase-6 spec's NEVER-CALL-LIST
+reasoning warns about, just triggered by a second init() instead of a
+pre-init call.
+
+The fix applied: this module now calls modtools.utils.init() exactly ONCE,
+as the ONLY init() call in its own process, matching the one-call invariant
+that makes test_effects_lilv.py itself safe.
+"""
+
+import json
+import os
+import shutil
+
+from base import ModUITestCase
+
+import pytest
+
+pytestmark = pytest.mark.lilv_fixture
+
+_FIXTURE_BUNDLE_SRC = os.path.join(
+ os.path.dirname(os.path.abspath(__file__)), "fixtures", "phase6-fixture.lv2"
+)
+_FIXTURE_PLUGIN_URI = "http://example.org/plugins/phase6-fixture"
+
+
+@pytest.fixture(scope="module", autouse=True)
+def lilv_world_with_fixture_bundle():
+ from conftest import _TEST_ROOT
+ from modtools import utils
+
+ scan_dir = os.path.join(_TEST_ROOT, "lv2-path-fixture-bundle")
+ if os.path.isdir(scan_dir):
+ shutil.rmtree(scan_dir)
+ os.makedirs(scan_dir)
+ shutil.copytree(_FIXTURE_BUNDLE_SRC, os.path.join(scan_dir, "phase6-fixture.lv2"))
+
+ # See module docstring: os.environ["LV2_PATH"] is read by lilv itself,
+ # inside init(), at call time (test/conftest.py sets an initial empty-dir
+ # value for test_effects_lilv.py; here we override it before this
+ # module's ONE AND ONLY init() call in this process).
+ os.environ["LV2_PATH"] = scan_dir
+ utils.init()
+ yield
+ # No cleanup()/de-init -- same reasoning as test_effects_lilv.py, and
+ # moot here since this is the last thing this process ever does.
+
+
+class TestEffectListWithFixtureBundle(ModUITestCase):
+ __test__ = True
+
+ def test_effect_list_contains_fixture_plugin_mini_shape(self):
+ response = self.fetch("/effect/list")
+ self.assertEqual(response.code, 200)
+ plugins = json.loads(response.body.decode("utf-8"))
+
+ by_uri = {p["uri"]: p for p in plugins}
+ self.assertIn(_FIXTURE_PLUGIN_URI, by_uri)
+
+ entry = by_uri[_FIXTURE_PLUGIN_URI]
+ # Pin the PluginInfo_Mini field set (get_all_plugins), not the full
+ # PluginInfo shape (that's EffectGet, checked separately below).
+ self.assertEqual(entry["name"], "Phase 6 Fixture")
+ self.assertEqual(entry["label"], "Phase 6 Fixture")
+ self.assertEqual(entry["category"], ["Utility"])
+ self.assertEqual(
+ set(entry.keys()),
+ {
+ "uri", "name", "brand", "label", "comment", "buildEnvironment",
+ "category", "microVersion", "minorVersion", "release",
+ "builder", "licensed", "iotype", "gui",
+ },
+ )
+
+
+class TestEffectGetWithFixtureBundle(ModUITestCase):
+ __test__ = True
+
+ def test_effect_get_returns_full_info_for_fixture_plugin(self):
+ response = self.fetch("/effect/get?uri=" + _FIXTURE_PLUGIN_URI)
+ self.assertEqual(response.code, 200)
+ content_type = response.headers.get("Content-Type", "")
+ self.assertIn("application/json", content_type)
+
+ data = json.loads(response.body.decode("utf-8"))
+ self.assertTrue(data["valid"])
+ self.assertEqual(data["uri"], _FIXTURE_PLUGIN_URI)
+ self.assertEqual(data["name"], "Phase 6 Fixture")
+ # lv2:binary in manifest.ttl points at a .so that was never created
+ # on disk -- confirms the binary is not required for full plugin
+ # info (only real audio instantiation would need it).
+ self.assertEqual(data["binary"], "")
+ self.assertEqual(
+ [p["symbol"] for p in data["ports"]["audio"]["input"]], ["in"]
+ )
+ self.assertEqual(
+ [p["symbol"] for p in data["ports"]["audio"]["output"]], ["out"]
+ )
diff --git a/test/test_files_list.py b/test/test_files_list.py
new file mode 100644
index 000000000..866be6ad5
--- /dev/null
+++ b/test/test_files_list.py
@@ -0,0 +1,109 @@
+#!/usr/bin/env python3
+# SPDX-FileCopyrightText: 2012-2023 MOD Audio UG
+# SPDX-License-Identifier: AGPL-3.0-or-later
+
+"""Characterization tests for GET /files/list (mod/webserver.py:FilesList).
+
+These pin the *current* behavior of the pipeline the Tone3000 download
+feature will rely on: a fresh os.walk per request, recursion into
+subfolders (needed for zip-pack downloads), sort-by-fullname ordering, and
+the exact JSON entry shape.
+"""
+
+from base import ModUITestCase
+
+
+class TestFilesList(ModUITestCase):
+ __test__ = True
+
+ def test_missing_types_param_is_501(self):
+ response = self.fetch("/files/list")
+ self.assertEqual(response.code, 501)
+
+ def test_unknown_type_is_empty_ok(self):
+ response, body = self.fetch_json("/files/list?types=bogus")
+ self.assertEqual(response.code, 200)
+ self.assertEqual(body, {"ok": True, "files": []})
+
+ def test_nammodel_missing_folder_is_empty_ok(self):
+ # No NAM Models folder exists at all under USER_FILES_DIR.
+ response, body = self.fetch_json("/files/list?types=nammodel")
+ self.assertEqual(response.code, 200)
+ self.assertEqual(body, {"ok": True, "files": []})
+
+ def test_nammodel_lists_nam_files_and_excludes_decoys(self):
+ self.seed("NAM Models/amp.nam")
+ self.seed("NAM Models/readme.txt")
+ self.seed("NAM Models/ir.wav")
+
+ response, body = self.fetch_json("/files/list?types=nammodel")
+ self.assertEqual(response.code, 200)
+ self.assertTrue(body["ok"])
+
+ basenames = [f["basename"] for f in body["files"]]
+ self.assertEqual(basenames, ["amp.nam"])
+
+ entry = body["files"][0]
+ self.assertEqual(entry["filetype"], "nammodel")
+ self.assertTrue(entry["fullname"].endswith("NAM Models/amp.nam"))
+ self.assertTrue(entry["fullname"].startswith("/"), "fullname should be absolute")
+
+ def test_nammodel_extension_match_is_case_insensitive(self):
+ self.seed("NAM Models/AMP.NAM")
+
+ response, body = self.fetch_json("/files/list?types=nammodel")
+ self.assertEqual(response.code, 200)
+ basenames = [f["basename"] for f in body["files"]]
+ self.assertEqual(basenames, ["AMP.NAM"])
+
+ def test_nammodel_recurses_into_subfolders(self):
+ # Pins DP1: a zip pack unzipped into NAM Models/