Haketilo

# SPDX-License-Identifier: CC0-1.0

"""

Haketilo unit tests - list of editable entries

"""

# 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

from selenium.webdriver.support.ui import WebDriverWait

from selenium.webdriver.common.keys import Keys

import inspect

from ..extension_crafting import ExtraHTML

from ..script_loader import load_script

from .utils import *

list_code_template = '(await blocking_allowing_lists(%%s))[%d]'

mode_parameters = [

    #add_action        del_action              instantiate_code

    ('set_repo',       'del_repo',             'await repo_list(%s)'),

    ('set_disallowed', 'set_default_allowing', list_code_template % 0),

    ('set_disallowed', 'set_allowed',          list_code_template % 0),

    ('set_allowed',    'set_default_allowing', list_code_template % 1),

    ('set_allowed',    'set_disallowed',       list_code_template % 1)

]

def instantiate_list(to_return):

    instantiate_code = inspect.stack()[1].frame.f_locals['instantiate_code']

    return inspect.stack()[1].frame.f_locals['execute_in_page'](

        f'''

        let dialog_ctx = dialog.make(() => {{}}, () => {{}}), list;

        async function make_list() {{

            list = {instantiate_code % 'dialog_ctx'};

            document.body.append(list.main_div, dialog_ctx.main_div);

            return [{', '.join(to_return)}];

        }}

        returnval(make_list());

        ''')

dialog_html_append = {'html/text_entry_list.html': '#INCLUDE html/dialog.html'}

dialog_html_test_ext_data = {

    'background_script': broker_js,

    'extra_html': ExtraHTML('html/text_entry_list.html', dialog_html_append),

    'navigate_to': 'html/text_entry_list.html'

}

@pytest.mark.ext_data(dialog_html_test_ext_data)

@pytest.mark.usefixtures('webextension')

@pytest.mark.parametrize('mode', mode_parameters)

def test_text_entry_list_ordering(driver, execute_in_page, mode):

    """

    A test case of ordering of repo URLs or URL patterns in the list.

    """

    add_action, del_action, instantiate_code = mode

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

    endings = ['hyd/', 'hydrilla/', 'Hydrilla/', 'HYDRILLA/',

               'test/', 'test^it/', 'Test^it/', 'TEST^IT/']

    indexes_added = set()

    for iteration, to_include in enumerate([

            set([i for i in range(len(endings)) if is_prime(i)]),

            set([i for i in range(len(endings))

                 if not is_prime(i) and i & 1]),

            set([i for i in range(len(endings)) if i % 3 == 0]),

            set([i for i in range(len(endings))

                 if i % 3 and not i & 1 and not is_prime(i)]),

            set(range(len(endings)))

    ]):

        endings_to_include = [endings[i] for i in sorted(to_include)]

        urls = [f'https://example.com/{e}' for e in endings_to_include]

        def add_urls():

            execute_in_page(

                '''{

                async function add_urls(urls, add_action) {

                    for (const url of urls)

                        await haketilodb[add_action](url);

                }

                returnval(add_urls(...arguments));

                }''',

                urls, add_action)

        def wait_for_completed(wait_id):

            """

            We add an extra url to IndexedDB and wait for it to appear in the

            DOM list. Once this happes, we know other operations must have also

            finished.

            """

            url = f'https://example.org/{iteration}/{wait_id}'

            execute_in_page(

                '''

                returnval(haketilodb[arguments[1]](arguments[0]));

                ''',

                url, add_action)

            WebDriverWait(driver, 10).until(lambda _: url in list_div.text)

        def assert_order(indexes_present, empty_entry_expected=False):

            entries_texts = execute_in_page(

                '''

                returnval([...list.list_div.children].map(n => n.textContent));

                ''')

            if empty_entry_expected:

                assert 'example' not in entries_texts[0]

                entries_texts.pop(0)

            for i, et in zip(sorted(indexes_present), entries_texts):

                assert f'https://example.com/{endings[i]}' in et

            for et in entries_texts[len(indexes_present):]:

                assert 'example.org' in et

        add_urls()

        if iteration == 0:

            list_div, new_entry_but = \

                instantiate_list(['list.list_div', 'list.new_but'])

        indexes_added.update(to_include)

        wait_for_completed(0)

        assert_order(indexes_added)

        execute_in_page(

            '''{

            async function remove_urls(urls, del_action) {

                for (const url of urls)

                    await haketilodb[del_action](url);

            }

            returnval(remove_urls(...arguments));

            }''',

            urls, del_action)

        wait_for_completed(1)

        assert_order(indexes_added.difference(to_include))

        # On the last iteration, add a new editable entry before re-additions.

        if len(to_include) == len(endings):

            new_entry_but.click()

            add_urls()

            wait_for_completed(2)

            assert_order(indexes_added, empty_entry_expected=True)

        else:

            add_urls()

def active(id):

    return inspect.stack()[1].frame.f_locals['execute_in_page']\

        (f'returnval(list.active_entry.{id});')

def existing(id, entry_nr=0):

    return inspect.stack()[1].frame.f_locals['execute_in_page'](

        '''

        returnval(list.entries_by_text.get(list.shown_texts[arguments[0]])\

                  [arguments[1]]);

        ''',

        entry_nr, id)

@pytest.mark.ext_data(dialog_html_test_ext_data)

@pytest.mark.usefixtures('webextension')

@pytest.mark.parametrize('mode', [mp for mp in mode_parameters

                                  if mp[1] != 'set_default_allowing'])

def test_text_entry_list_editing(driver, execute_in_page, mode):

    """

    A test case of editing entries in repo URLs list.

    """

    add_action, _, instantiate_code = mode

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

    execute_in_page(

        '''

        let original_loader = dialog.loader, last_loader_msg;

        dialog.loader = (ctx, ...msg) => {

            last_loader_msg = msg;

            return original_loader(ctx, ...msg);

        }

        ''')

    last_loader_msg = lambda: execute_in_page('returnval(last_loader_msg);')

    list_div, new_entry_but = \

        instantiate_list(['list.list_div', 'list.new_but'])

    if 'allow' in add_action:

        assert last_loader_msg() == ['Loading script blocking settings...']

    else:

        assert last_loader_msg() == ['Loading repositories...']

    assert execute_in_page('returnval(dialog_ctx.shown);') == False

    # Test adding new item. Submit via button click.

    new_entry_but.click()

    assert not active('noneditable_view').is_displayed()

    assert not active('save_but').is_displayed()

    assert active('add_but').is_displayed()

    assert active('cancel_but').is_displayed()

    active('input').send_keys('https://example.com///')

    active('add_but').click()

    WebDriverWait(driver, 10).until(lambda _: 'example.com' in list_div.text)

    assert execute_in_page('returnval(list.list_div.children.length);') == 1

    if 'disallow' in add_action:

        assert last_loader_msg() == \

            ["Blocking scripts on 'https://example.com/'..."]

    elif 'allow' in add_action:

        assert last_loader_msg() == \

            ["Allowing scripts on 'https://example.com/'..."]

    else:

        assert last_loader_msg() == \

            ["Adding repository 'https://example.com/'..."]

    assert not existing('editable_view').is_displayed()

    assert existing('text').is_displayed()

    assert existing('remove_but').is_displayed()

    # Test editing item. Submit via 'Enter' hit. Also test url pattern

    # normalization.

    existing('text').click()

    assert not active('noneditable_view').is_displayed()

    assert not active('add_but').is_displayed()

    assert active('save_but').is_displayed()

    assert active('cancel_but').is_displayed()

    assert active('input.value') == 'https://example.com/'

    active('input').send_keys(Keys.BACKSPACE * 30 + 'https://example.org//a//b'

                              + Keys.ENTER)

    WebDriverWait(driver, 10).until(lambda _: 'example.org' in list_div.text)

    assert execute_in_page('returnval(list.list_div.children.length);') == 1

    if 'disallow' in add_action:

        assert last_loader_msg() == ['Rewriting script blocking rule...']

    elif 'allow' in add_action:

        assert last_loader_msg() == ['Rewriting script allowing rule...']

    else:

        assert last_loader_msg() == ['Replacing repository...']

    # Test entry removal.

    existing('remove_but').click()

    WebDriverWait(driver, 10).until(lambda _: 'xample.org' not in list_div.text)

    assert execute_in_page('returnval(list.list_div.children.length);') == 0

    if 'allow' in add_action:

        assert last_loader_msg() == \

            ["Setting default scripts blocking policy on 'https://example.org/a/b'..."]

    else:

        assert last_loader_msg() == ["Removing repository 'https://example.org//a//b/'..."]

    # The rest of this test remains the same regardless of mode. No point

    # testing the same thing multiple times.

    if 'repo' not in add_action:

        return

    # Test that clicking hidden buttons of item not being edited does nothing.

    new_entry_but.click()

    active('input').send_keys('https://example.foo' + Keys.ENTER)

    WebDriverWait(driver, 10).until(lambda _: 'xample.foo/' in list_div.text)

    existing('add_but.click()')

    existing('save_but.click()')

    existing('cancel_but.click()')

    assert execute_in_page('returnval(dialog_ctx.shown);') == False

    assert execute_in_page('returnval(list.list_div.children.length);') == 1

    assert not existing('editable_view').is_displayed()

    # Test that clicking hidden buttons of item being edited does nothing.

    existing('text').click()

    active('remove_but.click()')

    active('add_but.click()')

    assert execute_in_page('returnval(dialog_ctx.shown);') == False

    assert execute_in_page('returnval(list.list_div.children.length);') == 1

    assert not active('noneditable_view').is_displayed()

    # Test that creating a new entry makes the other one noneditable again.

    new_entry_but.click()

    assert existing('text').is_displayed()

    # Test that clicking hidden buttons of new item entry does nothing.

    active('remove_but.click()')

    active('save_but.click()')

    assert execute_in_page('returnval(dialog_ctx.shown);') == False

    assert execute_in_page('returnval(list.list_div.children.length);') == 2

    assert not active('noneditable_view').is_displayed()

    # Test that starting edit of another entry removes the new entry.

    existing('text').click()

    assert existing('editable_view').is_displayed()

    assert execute_in_page('returnval(list.list_div.children.length);') == 1

    # Test that starting edit of another entry cancels edit of the first entry.

    new_entry_but.click()

    active('input').send_keys('https://example.net' + Keys.ENTER)

    WebDriverWait(driver, 10).until(lambda _: 'example.net/' in list_div.text)

    assert execute_in_page('returnval(list.list_div.children.length);') == 2

    existing('text', 0).click()

    assert existing('editable_view', 0).is_displayed()

    assert not existing('editable_view', 1).is_displayed()

    existing('text', 1).click()

    assert not existing('editable_view', 0).is_displayed()

    assert existing('editable_view', 1).is_displayed()

@pytest.mark.ext_data(dialog_html_test_ext_data)

@pytest.mark.usefixtures('webextension')

@pytest.mark.parametrize('mode', [mp for mp in mode_parameters

                                  if mp[1] != 'set_default_allowing'])

def test_text_entry_list_errors(driver, execute_in_page, mode):

    """

    A test case of error dialogs shown by repo URL list.

    """

    add_action, _, instantiate_code = mode

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

    to_return = ['list.list_div', 'list.new_but', 'dialog_ctx.main_div']

    list_div, new_entry_but, dialog_div = instantiate_list(to_return)

    # Prepare one entry to use later.

    new_entry_but.click()

    active('input').send_keys('https://example.com' + Keys.ENTER)

    # Check invalid URL errors.

    for clickable in (existing('text'), new_entry_but):

        clickable.click()

        active('input').send_keys(Keys.BACKSPACE * 30 + 'ws://example'

                                  + Keys.ENTER)

        execute_in_page('dialog.close(dialog_ctx);')

        if 'allow' in add_action:

            assert "'ws://example' is not a valid URL pattern. See here for more details." \

                in dialog_div.text

            assert patterns_doc_url == \

                driver.find_element_by_link_text('here').get_attribute('href')

            continue

        else:

            assert 'Repository URLs shoud use https:// schema.' \

                in dialog_div.text

        active('input').send_keys(Keys.BACKSPACE * 30 + 'https://example'

                                  + Keys.ENTER)

        assert 'Provided URL is not valid.' in dialog_div.text

        execute_in_page('dialog.close(dialog_ctx);')

    # Mock errors to force error messages to appear.

    execute_in_page(

        '''

        for (const action of [

            "set_repo", "del_repo", "set_allowed", "set_default_allowing"

        ])

            haketilodb[action] = () => {throw "reckless, limitless scope";};

        ''')

    # Check database error dialogs.

    def check_reported_failure(txt):

        fail = lambda _: txt in dialog_div.text

        WebDriverWait(driver, 10).until(fail)

        execute_in_page('dialog.close(dialog_ctx);')

    existing('text').click()

    active('input').send_keys(Keys.BACKSPACE * 30 + 'https://example.org'

                              + Keys.ENTER)

    if 'disallow' in add_action:

        check_reported_failure('Failed to rewrite blocking rule :(')

    elif 'allow' in add_action:

        check_reported_failure('Failed to rewrite allowing rule :(')

    else:

        check_reported_failure('Failed to replace repository :(')

    active('cancel_but').click()

    existing('remove_but').click()

    if 'allow' in add_action:

        check_reported_failure("Failed to remove rule for 'https://example.com' :(")

    else:

        check_reported_failure("Failed to remove repository 'https://example.com/' :(")

    new_entry_but.click()

    active('input').send_keys('https://example.org' + Keys.ENTER)

    if 'disallow' in add_action:

        check_reported_failure("Failed to write blocking rule for 'https://example.org' :(")

    elif 'allow' in add_action:

        check_reported_failure("Failed to write allowing rule for 'https://example.org' :(")

    else:

        check_reported_failure("Failed to add repository 'https://example.org/' :(")