Haketilo

/*

 * Returns true if the argument is a nonempty array of numbers without trailing

 * zeros.

 */

function is_valid_version(version) {

    return Array.isArray(version) && version.length > 0 &&

	version.every(n => typeof n === "number") &&

	version[version.length - 1] !== 0;

}

#EXPORT is_valid_version

function Showable(on_show_cb, on_hide_cb) {

    this.shown = false;

    /*

     * Wrap the requested callback into one that only executes it if showable is

     * not shown.

     */

    this.when_hidden = cb => {

	const wrapped_cb = (...args) => {

	    if (!this.shown)

		return cb(...args);

	}

	return wrapped_cb;

    }

    this.show = () => {

	if (this.shown)

	    return false;

	this.shown = true;

	try {

	    on_show_cb();

	} catch(e) {

	    console.error(e);

	}

	return true;

    }

    this.hide = () => {

	if (!this.shown)

	    return false;

	this.shown = false;

	try {

	    on_hide_cb();

	} catch(e) {

	    console.error(e);

	}

	return true;

    }

}

#EXPORT Showable

div.top_line {

div.bottom_line {

#FROM html/DOM_helpers.js IMPORT clone_template, Showable

    dialog_context.queue = [];

    Showable.call(dialog_context, on_dialog_show, on_dialog_hide);

	dialog_context.hide();

    if (dialog_context.show())

      margin: 1em;

#FROM html/DOM_helpers.js IMPORT clone_template, Showable

#FROM common/entities.js  IMPORT item_id_string, version_string, get_files, \

                                 is_valid_version

    preview_cb = install_view.dialog_ctx.when_hidden(preview_cb);

    Showable.call(this, on_view_show, on_view_hide);

    let back_cb = () => show_container("install_preview");

    back_cb = this.dialog_ctx.when_hidden(back_cb);

	if (!is_valid_version(response.json.api_schema_version)) {

	    var bad_api_ver = "";

	} else if (response.json.api_schema_version > [1]) {

	    var bad_api_ver =

		` (${version_string(response.json.api_schema_version)})`;

	} else {

	    var bad_api_ver = false;

	}

	if (bad_api_ver !== false) {

	    const msg = `${captype} ${item_id_string(id, ver)} was served using unsupported Hydrilla API version${bad_api_ver}. You might need to update Haketilo.`;

    const show_super = this.show;

	if (!show_super())

	    this.hide();

	this.hide();

    const hide_super = this.hide;

    this.hide = () => {

	if (!hide_super())

    const hide_cb = this.dialog_ctx.when_hidden(this.hide);

    const install_cb = this.dialog_ctx.when_hidden(perform_install);

#EXPORT InstallView

#IF !REPO_QUERY_LOADED

#DEFINE REPO_QUERY_LOADED

<!--

    SPDX-License-Identifier: GPL-3.0-or-later OR CC-BY-SA-4.0

    Show available repositories and allow querying them for resources.

    This file is part of Haketilo.

    Copyright (C) 2022 Wojtek Kosior <koszko@koszko.org>

    File is dual-licensed. You can choose either GPLv3+, CC BY-SA or both.

    This program is free software: you can redistribute it and/or modify

    it under the terms of the GNU General Public License as published by

    the Free Software Foundation, either version 3 of the License, or

    (at your option) any later version.

    This program is distributed in the hope that it will be useful,

    but WITHOUT ANY WARRANTY; without even the implied warranty of

    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

    GNU General Public License for more details.

    You should have received a copy of the GNU General Public License

    along with this program.  If not, see <https://www.gnu.org/licenses/>.

    I, Wojtek Kosior, thereby promise not to sue for violation of this file's

    licenses. Although I request that you do not make use of this code in a

    proprietary program, I am not going to enforce this in court.

  -->

<!--

    This is not a standalone page. This file is meant to be imported into other

    HTML code.

  -->

#INCLUDE html/install.html

#LOADCSS html/reset.css

#LOADCSS html/base.css

#LOADCSS html/grid.css

<style>

  .repo_query_top_text {

      text-align: center;

      margin: 0.4em;

  }

  .repo_queried_url {

      text-decoration: underline;

  }

  .repo_query_repo_li {

      margin: 0;

      background-color:#dadada;

  }

  .repo_query_repo_li > .repo_query_entry {

      padding: 0.2em;

  }

  .repo_query_repo_li > .repo_query_results_list {

      background-color: #f0f0f0;

  }

  .repo_query_result_li {

      margin: 0;

      padding: 0.2em;

  }

  .repo_query_result_li:nth-child(2n) {

      background-color:#dadada;

  }

  .repo_query_entry {

      display: flex;

      align-items: center;

  }

  .repo_query_entry_info {

      display: grid;

      grid-template-columns: auto;

      flex: 1 1 auto;

      min-width: 0;

  }

  .repo_query_entry_info > * {

      white-space: nowrap;

      overflow: hidden;

      text-overflow: ellipsis;

  }

  .repo_query_entry button {

      white-space: nowrap;

  }

  .repo_query_mapping_id {

      font-size: 80%;

      font-style: italic;

  }

  .repo_query_bottom_buttons {

      margin: 1em;

      text-align: center;

  }

</style>

<template>

  <div id="repo_query" data-template="main_div"

       class="grid_1 repo_query_main_div">

    <div data-template="repos_list_container">

      <div class="repo_query_top_text">

	Browsing custom resources for

	<span data-template="url_span" class="repo_queried_url"></span>.

      </div>

      <ul data-template="repos_list"></ul>

      <div class="repo_query_bottom_buttons">

	<button data-template="cancel_but">Cancel</button>

      </div>

    </div>

    <div data-template="install_view_container" class="hide">

      <!-- Install view will be dynamically inserted here. -->

    </div>

  </div>

  <li id="repo_query_single_repo" data-template="main_li"

      class="repo_query_repo_li">

    <div class="top_line"></div>

    <div class="repo_query_entry">

      <div class="repo_query_entry_info">

	<label data-template="repo_url_label"></label>

      </div>

      <span class="repo_query_buttons">

	<button data-template="show_results_but">

	  Show results

	</button>

	<button data-template="hide_results_but" class="hide">

	  Hide results

	</button>

      </span>

    </div>

    <div data-template="list_container" class="hide repo_query_results_list">

      <span data-template="info_span">Querying repository...</span>

      <ul data-template="results_list" class="hide"></ul>

    </div>

  </li>

  <li id="repo_query_single_result" data-template="main_li"

      class="repo_query_entry repo_query_result_li">

    <div class="repo_query_entry_info">

      <span data-template="mapping_name"></span>

      <span data-template="mapping_id" class="repo_query_mapping_id"></span>

    </div>

    <span><button data-template="install_but">Install preview</button></span>

  </li>

</template>

#ENDIF

/**

 * This file is part of Haketilo.

 *

 * Function: Show available repositories and allow querying them for resources.

 *

 * Copyright (C) 2022 Wojtek Kosior

 *

 * This program is free software: you can redistribute it and/or modify

 * it under the terms of the GNU General Public License as published by

 * the Free Software Foundation, either version 3 of the License, or

 * (at your option) any later version.

 *

 * This program is distributed in the hope that it will be useful,

 * but WITHOUT ANY WARRANTY; without even the implied warranty of

 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

 * GNU General Public License for more details.

 *

 * As additional permission under GNU GPL version 3 section 7, you

 * may distribute forms of that code without the copy of the GNU

 * GPL normally required by section 4, provided you include this

 * license notice and, in case of non-source distribution, a URL

 * through which recipients can access the Corresponding Source.

 * If you modify file(s) with this exception, you may extend this

 * exception to your version of the file(s), but you are not

 * obligated to do so. If you do not wish to do so, delete this

 * exception statement from your version.

 *

 * As a special exception to the GPL, any HTML file which merely

 * makes function calls to this code, and for that purpose

 * includes it by reference shall be deemed a separate work for

 * copyright law purposes. If you modify this code, you may extend

 * this exception to your version of the code, but you are not

 * obligated to do so. If you do not wish to do so, delete this

 * exception statement from your version.

 *

 * You should have received a copy of the GNU General Public License

 * along with this program.  If not, see <https://www.gnu.org/licenses/>.

 *

 * I, Wojtek Kosior, thereby promise not to sue for violation of this file's

 * license. Although I request that you do not make use of this code in a

 * proprietary program, I am not going to enforce this in court.

 */

#IMPORT common/indexeddb.js AS haketilodb

#FROM common/browser.js   IMPORT browser

#FROM html/DOM_helpers.js IMPORT clone_template, Showable

#FROM common/entities.js  IMPORT item_id_string, version_string, \

                                 is_valid_version

#FROM html/install.js     IMPORT InstallView

const coll = new Intl.Collator();

function ResultEntry(repo_entry, mapping_ref) {

    Object.assign(this, clone_template("repo_query_single_result"));

    Object.assign(this, {repo_entry, mapping_ref});

    this.mapping_name.innerText = mapping_ref.long_name;

    this.mapping_id.innerText = item_id_string(mapping_ref);

    const iv = repo_entry.query_view.install_view;

    function start_install() {

	iv.show(repo_entry.repo_url, "mapping",

		mapping_ref.identifier, mapping_ref.version);

    }

    const cb = repo_entry.query_view.install_view.when_hidden(start_install);

    this.install_but.addEventListener("click", cb);

}

function RepoEntry(query_view, repo_url) {

    Object.assign(this, clone_template("repo_query_single_repo"));

    Object.assign(this, {query_view, repo_url});

    this.results_shown_before = false;

    this.repo_url_label.innerText = repo_url;

    const query_results = async () => {

	const msg = [

	    "repo_query",

	    `${repo_url}query?url=${encodeURIComponent(query_view.url)}`

	];

	const response = await browser.tabs.sendMessage(query_view.tab_id, msg);

	if ("error" in response)

	    throw "Failure to communicate with repository :(";

	if (!response.ok)

	    throw `Repository sent HTTP code ${response.status} :(`;

	if ("error_json" in response)

	    throw "Repository's response is not valid JSON :(";

	if (!is_valid_version(response.json.api_schema_version)) {

	    var bad_api_ver = "";

	} else if (response.json.api_schema_version > [1]) {

	    var bad_api_ver =

		` (${version_string(response.json.api_schema_version)})`;

	} else {

	    var bad_api_ver = false;

	}

	if (bad_api_ver !== false)

	    throw `Results were served using unsupported Hydrilla API version${bad_api_ver}. You might need to update Haketilo.`;

	/* TODO: here we should perform JSON schema validation! */

	return response.json.mappings;

    }

    const populate_results = async () => {

	this.results_shown_before = true;

	try {

	    var results = await query_results();

	} catch(e) {

	    this.info_span.innerText = e;

	    return;

	}

	this.info_span.remove();

	this.results_list.classList.remove("hide");

	this.result_entries = results.map(ref => new ResultEntry(this, ref));

	const to_append = this.result_entries.length > 0 ?

	      this.result_entries.map(re => re.main_li) :

	      ["No results :("];

	this.results_list.append(...to_append);

    }

    let show_results = () => {

	if (!query_view.shown)

	    return;

	if (!this.results_shown_before)

	    populate_results();

	this.list_container.classList.remove("hide");

	this.hide_results_but.classList.remove("hide");

	this.show_results_but.classList.add("hide");

    }

    show_results = query_view.install_view.when_hidden(show_results);

    let hide_results = () => {

	if (!query_view.shown)

	    return;

	this.list_container.classList.add("hide");

	this.hide_results_but.classList.add("hide");

	this.show_results_but.classList.remove("hide");

    }

    hide_results = query_view.install_view.when_hidden(hide_results);

    this.show_results_but.addEventListener("click", show_results);

    this.hide_results_but.addEventListener("click", hide_results);

}

const container_ids = ["repos_list_container", "install_view_container"];

function RepoQueryView(tab_id, on_view_show, on_view_hide) {

    Showable.call(this, on_view_show, on_view_hide);

    Object.assign(this, clone_template("repo_query"));

    this.tab_id = tab_id;

    const show_container = name => {

	for (const cid of container_ids) {

	    if (cid !== name)

		this[cid].classList.add("hide");

	}

	this[name].classList.remove("hide");

    }

    this.install_view = new InstallView(

	tab_id,

	() => show_container("install_view_container"),

	() => show_container("repos_list_container")

    );

    this.install_view_container.prepend(this.install_view.main_div);

    const show_super = this.show;

    this.show = async url => {

	if (!show_super())

	    return;

	this.url = url;

	this.url_span.innerText = url;

	[...this.repos_list.children].forEach(c => c.remove());

	const repo_urls = await haketilodb.get_repos();

	repo_urls.sort((a, b) => coll.compare(a, b));

	this.repo_entries = repo_urls.map(ru => new RepoEntry(this, ru));

	if (repo_urls.length === 0) {

	    const info_li = document.createElement("li");

	    info_li.innerText = "You have no repositories configured :(";

	    this.repos_list.append(info_li);

	    return;

	}

	this.repos_list.append(...this.repo_entries.map(re => re.main_li));

    }

    this.cancel_but.addEventListener("click",

				     this.install_view.when_hidden(this.hide));

}

#EXPORT RepoQueryView

    <ul id="tab_heads">

    <div id="top_menu_line" class="top_line"></div>

	node.addEventListener("click", list.dialog_ctx.when_hidden(cb));

				list.dialog_ctx.when_hidden(enter_cb));

    this.new_but.addEventListener("click", dialog_ctx.when_hidden(add_new));

import traceback

        except Exception:

            status_code = 500

            headers     = {'Content-Type': 'text/plain'}

            resp_body   = b'Internal Error:\n' + traceback.format_exc().encode()

    mock_cacher(execute_in_page)

        const install_view = new InstallView(0,

        ''')

    'background_script': broker_js,

    WebDriverWait(driver, 10).until(installed)

    fetched = lambda d: 'Fetching ' not in containers['dialog_container'].text

    WebDriverWait(driver, 10).until(fetched)

    assert_container_displayed('dialog_container')

    assert execute_in_page('returnval(shw(6));') == [['show'], True]

# SPDX-License-Identifier: CC0-1.0

"""

Haketilo unit tests - .............

"""

# This file is part of Haketilo

#

# Copyright (C) 2022 Wojtek Kosior <koszko@koszko.org>

#

# This program is free software: you can redistribute it and/or modify

# it under the terms of the CC0 1.0 Universal License as published by

# the Creative Commons Corporation.

#

# This program is distributed in the hope that it will be useful,

# but WITHOUT ANY WARRANTY; without even the implied warranty of

# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

# CC0 1.0 Universal License for more details.

import pytest

import json

from selenium.webdriver.support.ui import WebDriverWait

from ..extension_crafting import ExtraHTML

from ..script_loader import load_script

from ..extension_crafting import ExtraHTML

from ..script_loader import load_script

from .utils import *

repo_urls = [f'https://hydril.la/{s}' for s in ('', '1/', '2/', '3/', '4/')]

queried_url = 'https://example_a.com/something'

def setup_view(execute_in_page, repo_urls):

    mock_cacher(execute_in_page)

    execute_in_page(load_script('html/repo_query.js'))

    execute_in_page(

        '''

        const repo_proms = arguments[0].map(url => haketilodb.set_repo(url));

        const cb_calls = [];

        const view = new RepoQueryView(0,

                                       () => cb_calls.push("show"),

                                       () => cb_calls.push("hide"));

        document.body.append(view.main_div);

        const shw = slice => [cb_calls.slice(slice || 0), view.shown];

        returnval(Promise.all(repo_proms));

        ''',

        repo_urls)

repo_query_ext_data = {

    'background_script': broker_js,

    'extra_html': ExtraHTML('html/repo_query.html', {}),

    'navigate_to': 'html/repo_query.html'

}

@pytest.mark.ext_data(repo_query_ext_data)

@pytest.mark.usefixtures('webextension')

def test_repo_query_normal_usage(driver, execute_in_page):

    """

    Test of using the repo query view to browse results from repository and to

    start installation.

    """

    setup_view(execute_in_page, repo_urls)

    assert execute_in_page('returnval(shw());') == [[], False]

    execute_in_page('view.show(arguments[0]);', queried_url)

    assert execute_in_page('returnval(shw());') == [['show'], True]

    def get_repo_entries(driver):

        return execute_in_page(

            f'returnval((view.repo_entries || []).map({nodes_props_code}));'

        )

    repo_entries = WebDriverWait(driver, 10).until(get_repo_entries)

    assert len(repo_urls) == len(repo_entries)

    for url, entry in reversed(list(zip(repo_urls, repo_entries))):

        assert url in entry['main_li'].text

    but_ids = ('show_results_but', 'hide_results_but')

    for but_idx in (0, 1, 0):

        assert bool(but_idx) == entry['list_container'].is_displayed()

        assert not entry[but_ids[1 - but_idx]].is_displayed()

        entry[but_ids[but_idx]].click()

    def get_mapping_entries(driver):

        return execute_in_page(

            f'''{{

            const result_entries = (view.repo_entries[0].result_entries || []);

            returnval(result_entries.map({nodes_props_code}));

            }}''')

    mapping_entries = WebDriverWait(driver, 10).until(get_mapping_entries)

    assert len(mapping_entries) == 3

    expected_names = ['MAPPING_ABCD', 'MAPPING_ABCD-DEFG-GHIJ', 'MAPPING_A']

    for name, entry in zip(expected_names, mapping_entries):

        assert entry['mapping_name'].text == name

        assert entry['mapping_id'].text == f'{name.lower()}-2022.5.11'

    containers = execute_in_page(

        '''{

        const reductor = (acc, k) => Object.assign(acc, {[k]: view[k]});

        returnval(container_ids.reduce(reductor, {}));

        }''')

    for id, container in containers.items():

        assert (id == 'repos_list_container') == container.is_displayed()

    entry['install_but'].click()

    for id, container in containers.items():

        assert (id == 'install_view_container') == container.is_displayed()

    execute_in_page('returnval(view.install_view.cancel_but);').click()

    for id, container in containers.items():

        assert (id == 'repos_list_container') == container.is_displayed()

    assert execute_in_page('returnval(shw());') == [['show'], True]

    execute_in_page('returnval(view.cancel_but);').click()

    assert execute_in_page('returnval(shw());') == [['show', 'hide'], False]

@pytest.mark.ext_data(repo_query_ext_data)

@pytest.mark.usefixtures('webextension')

@pytest.mark.parametrize('message', [

    'browsing_for',

    'no_repos',

    'failure_to_communicate',

    'HTTP_code',

    'invalid_JSON',

    'newer_API_version',

    'invalid_API_version',

    'querying_repo',

    'no_results'

])

def test_repo_query_messages(driver, execute_in_page, message):

    """

    Test of loading and error messages shown in parts of the repo query view.

    """

    def has_msg(message, elem=None):

        def has_msg_and_is_visible(dummy_driver):

            if elem:

                return elem.is_displayed() and message in elem.text

            else:

                return message in driver.page_source

        return has_msg_and_is_visible

    def show_and_wait_for_repo_entry():

        execute_in_page('view.show(arguments[0]);', queried_url)

        done = lambda d: execute_in_page('returnval(!!view.repo_entries);')

        WebDriverWait(driver, 10).until(done)

        execute_in_page(

            '''

            if (view.repo_entries.length > 0)

                view.repo_entries[0].show_results_but.click();

            ''')

    if message == 'browsing_for':

        setup_view(execute_in_page, [])

        show_and_wait_for_repo_entry()

        elem = execute_in_page('returnval(view.url_span.parentNode);')

        assert has_msg(f'Browsing custom resources for {queried_url}.', elem)(0)

    elif message == 'no_repos':

        setup_view(execute_in_page, [])

        show_and_wait_for_repo_entry()

        elem = execute_in_page('returnval(view.repos_list);')

        done = has_msg('You have no repositories configured :(', elem)

        WebDriverWait(driver, 10).until(done)

    elif message == 'failure_to_communicate':

        setup_view(execute_in_page, repo_urls)

        execute_in_page(

            'browser.tabs.sendMessage = () => Promise.resolve({error: "sth"});'

        )

        show_and_wait_for_repo_entry()

        elem = execute_in_page('returnval(view.repo_entries[0].info_span);')

        done = has_msg('Failure to communicate with repository :(', elem)

        WebDriverWait(driver, 10).until(done)

    elif message == 'HTTP_code':

        setup_view(execute_in_page, repo_urls)

        execute_in_page(

            '''

            const response = {ok: false, status: 405};

            browser.tabs.sendMessage = () => Promise.resolve(response);

            ''')

        show_and_wait_for_repo_entry()

        elem = execute_in_page('returnval(view.repo_entries[0].info_span);')

        done = has_msg('Repository sent HTTP code 405 :(', elem)

        WebDriverWait(driver, 10).until(done)

    elif message == 'invalid_JSON':

        setup_view(execute_in_page, repo_urls)

        execute_in_page(

            '''

            const response = {ok: true, status: 200, error_json: "sth"};

            browser.tabs.sendMessage = () => Promise.resolve(response);

            ''')

        show_and_wait_for_repo_entry()

        elem = execute_in_page('returnval(view.repo_entries[0].info_span);')

        done = has_msg("Repository's response is not valid JSON :(", elem)

        WebDriverWait(driver, 10).until(done)

    elif message == 'newer_API_version':

        setup_view(execute_in_page, repo_urls)

        execute_in_page(

            '''

            const response = {

                ok: true,

                status: 200,

                json: {api_schema_version: [1234]}

            };

            browser.tabs.sendMessage = () => Promise.resolve(response);

            ''')

        show_and_wait_for_repo_entry()

        elem = execute_in_page('returnval(view.repo_entries[0].info_span);')

        msg = 'Results were served using unsupported Hydrilla API version (1234). You might need to update Haketilo.'

        WebDriverWait(driver, 10).until(has_msg(msg, elem))

    elif message == 'invalid_API_version':

        setup_view(execute_in_page, repo_urls)

        execute_in_page(

            '''

            const response = {

                ok: true,

                status: 200,

                json: {api_schema_version: null}

            };

            browser.tabs.sendMessage = () => Promise.resolve(response);

            ''')

        show_and_wait_for_repo_entry()

        elem = execute_in_page('returnval(view.repo_entries[0].info_span);')

        msg = 'Results were served using unsupported Hydrilla API version. You might need to update Haketilo.'

        WebDriverWait(driver, 10).until(has_msg(msg, elem))

    elif message == 'querying_repo':

        setup_view(execute_in_page, repo_urls)

        execute_in_page(

            'browser.tabs.sendMessage = () => new Promise(() => {});'

        )

        show_and_wait_for_repo_entry()

        elem = execute_in_page('returnval(view.repo_entries[0].info_span);')

        assert has_msg('Querying repository...', elem)(0)

    elif message == 'no_results':

        setup_view(execute_in_page, repo_urls)

        execute_in_page(

            '''

            const response = {

                ok: true,

                status: 200,

                json: {

                    api_schema_version: [1],

                    api_schema_revision: 1,

                    mappings: []

                }

            };

            browser.tabs.sendMessage = () => Promise.resolve(response);

            ''')

        show_and_wait_for_repo_entry()

        elem = execute_in_page('returnval(view.repo_entries[0].results_list);')

        WebDriverWait(driver, 10).until(has_msg('No results :(', elem))

    else:

        raise Exception('made a typo in test function params?')

"""

tab_id_responder is meant to be appended to background script of a test

extension.

"""

tab_id_responder = '''

function tell_tab_id(msg, sender, respond_cb) {

    if (msg[0] === "learn_tab_id")

        respond_cb(sender.tab.id);

}

browser.runtime.onMessage.addListener(tell_tab_id);

'''

"""

tab_id_asker is meant to be appended to content script of a test extension.

"""

tab_id_asker = '''

browser.runtime.sendMessage(["learn_tab_id"])

    .then(tid => window.wrappedJSObject.haketilo_tab = tid);

'''

def run_content_script_in_new_window(driver, url):

    """

    Expect an extension to be loaded which had tab_id_responder and tab_id_asker

    appended to its background and content scripts, respectively.

    Open the provided url in a new tab, find its tab id and return it, with

    current window changed back to the initial one.

    """

    initial_handle = driver.current_window_handle

    handles = driver.window_handles

    driver.execute_script('window.open(arguments[0], "_blank");', url)

    WebDriverWait(driver, 10).until(lambda d: d.window_handles is not handles)

    new_handle = [h for h in driver.window_handles if h not in handles][0]

    driver.switch_to.window(new_handle)

    get_tab_id = lambda d: d.execute_script('return window.haketilo_tab;')

    tab_id = WebDriverWait(driver, 10).until(get_tab_id)

    driver.switch_to.window(initial_handle)

    return tab_id

def mock_cacher(execute_in_page):

    Some parts of code depend on content/repo_query_cacher.js and

    background/CORS_bypass_server.js running in their appropriate contexts. This

    function modifies the relevant browser.runtime.sendMessage function to

    perform fetch(), bypassing the cacher.

    execute_in_page(

        '''{

        const old_sendMessage = browser.tabs.sendMessage, old_fetch = fetch;

        async function new_sendMessage(tab_id, msg) {

            if (msg[0] !== "repo_query")

                return old_sendMessage(tab_id, msg);

            /* Use snapshotted fetch(), allow other test code to override it. */

            const response = await old_fetch(msg[1]);

            if (!response)

                return {error: "Something happened :o"};

            const result = {ok: response.ok, status: response.status};

            try {

                result.json = await response.json();

            } catch(e) {

                result.error_json = "" + e;

            }

            return result;

        }

        browser.tabs.sendMessage = new_sendMessage;

        }''')

"""

Convenience snippet of code to retrieve a copy of given object with only those

properties present which are DOM nodes. This makes it possible to easily access

DOM nodes stored in a javascript object that also happens to contain some

other properties that make it impossible to return from a Selenium script.

"""

nodes_props_code = '''\

(obj => {

    const result = {};

    for (const [key, value] of Object.entries(obj)) {

        if (value instanceof Node)

            result[key] = value;

    }

    return result;

})'''

make_handler = lambda txt: lambda c, g, p: (200, {}, txt)

sample_hashes = [sha256(c.encode()).digest().hex() for c in sample_contents]

file_url = lambda hashed: f'https://hydril.la/file/sha256-{hashed}'

sample_files_catalog = dict([(file_url(h), make_handler(c))

sample_queries = {}

    resource_versions = [resource['version'], resource['version'].copy()]

    resource_versions[1][-1] += 1

    mapping_versions = [mapping['version'], mapping['version'].copy()]

    mapping_versions[1][-1] += 1

    sufs = [srt["id_suffix"], *[l for l in srt["id_suffix"] if l.isalpha()]]

    patterns = [f'https://example_{suf}.com/*' for suf in set(sufs)]

    payloads = {}

    for pat in patterns:

        payloads[pat] = {'identifier': resource['identifier']}

        queryable_url = pat.replace('*', 'something')

        if queryable_url not in sample_queries:

            sample_queries[queryable_url] = []

        sample_queries[queryable_url].append({

            'identifier': mapping['identifier'],

            'long_name':  mapping['long_name'],

            'version':    mapping_versions[1]

        })

    mapping['payloads'] = payloads

    for item, versions, catalog in [

        (resource, resource_versions, sample_resources_catalog),

        (mapping,  mapping_versions,  sample_mappings_catalog)

        for ver in versions:

            item['version'] = ver

def serve_query(command, get_params, post_params):

    response = {

        'api_schema_version':  [1],

        'api_schema_revision': 1,

        'mappings':            sample_queries[get_params['url'][0]]

    }

    return (200, {}, json.dumps(response))

sample_queries_catalog = dict([(f'https://hydril.la/{suf}query', serve_query)

                               for suf in ('', '1/', '2/', '3/', '4/')])

    **sample_mappings_catalog,

    **sample_queries_catalog