Hydrilla

            if permissions.get('cors_bypass'):

                processed_permissions['cors_bypass'] = True

            if processed_permissions:

                new_item_obj['permissions'] = processed_permissions

import pytest

import json

import shutil

from tempfile import TemporaryDirectory

from pathlib import Path, PurePosixPath

        yield sample_source

variant_makers = []

def sample_source_change_index_json(monkeypatch, sample_source):

    """

    Return a non-standard path for index.json. Ensure parent directories exist.

    path.parent.mkdir()

    return path

def sample_source_add_comments(monkeypatch, sample_source):

    """Add index.json comments that should be preserved."""

    for dictionary in index_obj, *index_obj['definitions'], *expected:

        monkeypatch.setitem(dictionary, 'comment', 'index.json comment')

def sample_source_remove_spdx(monkeypatch, sample_source):

    """Remove spdx report generation."""

    monkeypatch.delitem(index_obj, 'reuse_generate_spdx_report')

    # raise an error if called.

    (sample_source / 'mock_reuse_missing').touch()

def sample_source_remove_additional_files(monkeypatch, sample_source):

    """Use default value ([]) for 'additionall_files' property."""

    monkeypatch.delitem(index_obj, 'additional_files')

    for name in 'README.txt', 'README.txt.license', '.reuse/dep5':

        monkeypatch.delitem(src_files, name)

def sample_source_remove_script(monkeypatch, sample_source):

    """Use default value ([]) for 'scripts' property in one of the resources."""

    monkeypatch.delitem(index_obj['definitions'][2], 'scripts')

    for files in dist_files, src_files:

        monkeypatch.delitem(files, 'message.js')

def sample_source_remove_payloads(monkeypatch, sample_source):

    """Use default value ({}) for 'payloads' property in mapping."""

    monkeypatch.delitem(index_obj['definitions'][0], 'payloads')

    monkeypatch.setitem(expected_mapping, 'payloads', {})

def sample_source_remove_uuids(monkeypatch, sample_source):

    """Don't use UUIDs (they are optional)."""

    for definition in index_obj['definitions']:

        if 'uuid' in description:

            monkeypatch.delitem(description, 'uuid')

def sample_source_add_extra_props(monkeypatch, sample_source):

    """Add some unrecognized properties that should be stripped."""

    to_process = [index_obj]

                              if k != 'payloads')

            monkeypatch.setitem(processed, 'spurious_property', 'some_value')

def sample_source_make_version_2(monkeypatch, sample_source,

                                 expected_documents_to_modify=[]):

    for obj in index_obj, *expected_documents_to_modify:

        monkeypatch.setitem(obj, '$schema', obj['$schema'].replace('1', '2'))

    """

    at 1.

    """

    for definition in index_obj['definitions']:

    sample_source_make_version_2(monkeypatch, sample_source, expected_items)

    for obj in expected_items:

    """

    """

    sample_source_make_version_2(monkeypatch, sample_source)

def sample_source_req_mappings_ignored(monkeypatch, sample_source,

                                       value=[{'identifier': 'mapping-dep'}]):

    """

    for definition in index_obj['definitions']:

        monkeypatch.setitem(definition, 'required_mappings', value);

def sample_source_req_mappings(monkeypatch, sample_source):

    """Specify dependencies on mappings."""

    sample_source_req_mappings_ignored(monkeypatch, sample_source)

        monkeypatch.setitem(obj, 'required_mappings',

                            [{'identifier': 'mapping-dep'}])

def sample_source_req_mappings_defaults(monkeypatch, sample_source):

    """Specify dependencies of a mapping, but use the default value ("[]")."""

    sample_source_req_mappings_ignored(monkeypatch, sample_source, value=[])

    sample_source_make_version_2(monkeypatch, sample_source)

def sample_source_combined_def(monkeypatch, sample_source):

    """Define mapping and resource together."""

    sample_source_make_version_2(monkeypatch, sample_source)

    monkeypatch.setitem(expected_source_description['definitions'][0],

                        'version', new_mapping_ver)

def sample_source_minmax_haketilo_ver_ignored(monkeypatch, sample_source,

                                              min_ver=[1, 2], max_ver=[1, 2]):

    """

    monkeypatch.setitem(mapping_def, 'min_haketilo_version', min_ver)

    monkeypatch.setitem(mapping_def, 'max_haketilo_version', max_ver)

def sample_source_minmax_haketilo_ver(monkeypatch, sample_source):

    """Specify version constraints on Haketilo."""

    sample_source_minmax_haketilo_ver_ignored(monkeypatch, sample_source)

    monkeypatch.setitem(expected_mapping, 'min_haketilo_version', [1, 2])

    monkeypatch.setitem(expected_mapping, 'max_haketilo_version', [1, 2])

def sample_source_minmax_haketilo_ver_default(monkeypatch, sample_source):

    """Specify version constraints on Haketilo, but use default values."""

    sample_source_minmax_haketilo_ver_ignored(monkeypatch, sample_source,

    'othersystem/other-something.tar.gz'

]

def sample_source_add_piggyback_ignored(monkeypatch, sample_source,

                                        extra_build_args={}):

    """

	'dependencies': False

    })

def sample_source_add_piggyback(monkeypatch, sample_source,

                                extra_build_args={}):

    """Add piggybacked foreign system packages."""

        archive_path.parent.mkdir(parents=True, exist_ok=True)

        archive_path.write_text(f'dummy {archive_path.name}')

def sample_source_add_piggyback_pass_archives(monkeypatch, sample_source):

    """

    Add piggybacked foreign system packages, use pre-downloaded foreign package

    sample_source_add_piggyback(monkeypatch, sample_source,

                                {'piggyback_files': foreign_packages_dir})

def sample_source_add_piggyback_find_archives(monkeypatch, sample_source):

    """

    Add piggybacked foreign system packages, use pre-downloaded foreign package

    sample_source_add_piggyback(monkeypatch, sample_source)

def sample_source_add_piggyback_no_download(monkeypatch, sample_source,

                                            pass_directory_to_build=False):

    """

    try_validate('api_source_description', expected_source_description)

error_makers = []

def sample_source_error_missing_file(monkeypatch, sample_source):

    """

    Modify index.json to expect missing report.spdx file and cause an error.

    monkeypatch.delitem(index_obj, 'reuse_generate_spdx_report')

    return FileReferenceError, '^referenced_file_report.spdx_missing$'

def sample_source_error_index_schema(monkeypatch, sample_source):

    """Modify index.json to be incompliant with the schema."""

    monkeypatch.delitem(index_obj, 'definitions')

    return ValidationError,

def sample_source_error_bad_comment(monkeypatch, sample_source):

    """Modify index.json to have an invalid '/' in it."""

    return json.JSONDecodeError, '^bad_comment: .*', \

        json.dumps(index_obj) + '/something\n'

def sample_source_error_bad_json(monkeypatch, sample_source):

    """Modify index.json to not be valid json even after comment stripping."""

    return json.JSONDecodeError, '', json.dumps(index_obj) + '???\n'

def sample_source_error_missing_reuse(monkeypatch, sample_source):

    """Cause mocked reuse process invocation to fail with FileNotFoundError."""

    (sample_source / 'mock_reuse_missing').touch()

    return build.ReuseError, '^couldnt_execute_reuse_is_it_installed$'

def sample_source_error_missing_license(monkeypatch, sample_source):

    """Remove a file to make package REUSE-incompliant."""

    (sample_source / 'README.txt.license').unlink()

    return build.ReuseError, error_regex

def sample_source_error_file_outside(monkeypatch, sample_source):

    """Make index.json illegally reference a file outside srcdir."""

    new_list = [*index_obj['copyright'], {'file': '../abc'}]

    monkeypatch.setitem(index_obj, 'copyright', new_list)

    return FileReferenceError, '^path_contains_double_dot_\\.\\./abc$'

def sample_source_error_reference_itself(monkeypatch, sample_source):

    """Make index.json illegally reference index.json."""

    new_list = [*index_obj['copyright'], {'file': 'index.json'}]

    monkeypatch.setitem(index_obj, 'copyright', new_list)

    return FileReferenceError, '^loading_reserved_index_json$'

def sample_source_error_report_excluded(monkeypatch, sample_source):

    """

    Make index.json require generation of report.spdx but don't include it among

    monkeypatch.setitem(index_obj, 'copyright', new_list)

    return FileReferenceError, '^report_spdx_not_in_copyright_list$'

def sample_source_error_combined_unsupported(monkeypatch, sample_source):

    """

    Define mapping and resource together but leave source schema version at 1.x