fdroidserver/tests/metadata.TestCase

#!/usr/bin/env python3

import copy
import io
import logging
import optparse
import os
import random
import ruamel.yaml
import shutil
import sys
import unittest
import tempfile
import textwrap
from collections import OrderedDict
from pathlib import Path
from unittest import mock

from testcommon import TmpCwd, mkdtemp

localmodule = Path(__file__).resolve().parent.parent
print('localmodule: ' + str(localmodule))
if localmodule not in sys.path:
    sys.path.insert(0, str(localmodule))

import fdroidserver
from fdroidserver import metadata
from fdroidserver.exception import MetaDataException
from fdroidserver.common import DEFAULT_LOCALE


def _get_mock_mf(s):
    mf = io.StringIO(s)
    mf.name = 'mock_filename.yaml'
    return mf


class MetadataTest(unittest.TestCase):
    '''fdroidserver/metadata.py'''

    def setUp(self):
        logging.basicConfig(level=logging.DEBUG)
        self.basedir = localmodule / 'tests'
        os.chdir(self.basedir)
        self._td = mkdtemp()
        self.testdir = self._td.name
        fdroidserver.metadata.warnings_action = 'error'

    def tearDown(self):
        # auto-generated dirs by functions, not tests, so they are not always cleaned up
        self._td.cleanup()
        try:
            os.rmdir("srclibs")
        except OSError:
            pass
        try:
            os.rmdir("tmp")
        except OSError:
            pass

    def test_fieldtypes_key_exist(self):
        for k in fdroidserver.metadata.fieldtypes.keys():
            self.assertTrue(k in fdroidserver.metadata.yaml_app_fields)

    def test_build_flagtypes_key_exist(self):
        for k in fdroidserver.metadata.flagtypes.keys():
            self.assertTrue(k in fdroidserver.metadata.build_flags)

    def test_FieldValidator_BitcoinAddress(self):
        validator = None
        for vali in fdroidserver.metadata.valuetypes:
            if vali.name == 'Bitcoin address':
                validator = vali
                break
        self.assertIsNotNone(validator, "could not find 'Bitcoin address' validator")

        # some valid addresses (P2PKH, P2SH, Bech32)
        self.assertIsNone(
            validator.check('1BrrrrErsrWetrTrnrrrrm4GFg7xJaNVN2', 'fake.app.id')
        )
        self.assertIsNone(
            validator.check('3JrrrrWrEZr3rNrrvrecrnyirrnqRhWNLy', 'fake.app.id')
        )
        self.assertIsNone(
            validator.check('bc1qar0srrr7xrkvr5lr43lrdnwrre5rgtrzrf5rrq', 'fake.app.id')
        )

        # some invalid addresses
        self.assertRaises(
            fdroidserver.exception.MetaDataException,
            validator.check,
            '21BvMrSYsrWrtrrlL5A10mlGFr7rrarrN2',
            'fake.app.id',
        )
        self.assertRaises(
            fdroidserver.exception.MetaDataException,
            validator.check,
            '5Hrgr3ur5rGLrfKrrrrrrHSrqJrroGrrzrQrrrrrrLNrsrDrrrA',
            'fake.app.id',
        )
        self.assertRaises(
            fdroidserver.exception.MetaDataException,
            validator.check,
            '92rr46rUrgTrrromrVrirW6r1rrrdrerrdbJrrrhrCsYrrrrrrc',
            'fake.app.id',
        )
        self.assertRaises(
            fdroidserver.exception.MetaDataException,
            validator.check,
            'K1BvMrSYsrWrtrrrn5Au4m4GFr7rrarrN2',
            'fake.app.id',
        )
        self.assertRaises(
            fdroidserver.exception.MetaDataException,
            validator.check,
            'L1BvMrSYsrWrtrrrn5Au4m4GFr7rrarrN2',
            'fake.app.id',
        )
        self.assertRaises(
            fdroidserver.exception.MetaDataException,
            validator.check,
            'tb1qw5r8drrejxrrg4y5rrrrrraryrrrrwrkxrjrsx',
            'fake.app.id',
        )

    def test_FieldValidator_LitecoinAddress(self):
        validator = None
        for vali in fdroidserver.metadata.valuetypes:
            if vali.name == 'Litecoin address':
                validator = vali
                break
        self.assertIsNotNone(validator, "could not find 'Litecoin address' validator")

        # some valid addresses (L, M, 3, segwit)
        self.assertIsNone(
            validator.check('LgeGrrrrJAxyXprrPrrBrrX5Qrrrrrrrrd', 'fake.app.id')
        )
        self.assertIsNone(
            validator.check('MrrrrrrrJAxyXpanPtrrRAX5QHxvUJo8id', 'fake.app.id')
        )
        self.assertIsNone(validator.check('3rereVr9rAryrranrrrrrAXrrHx', 'fake.app.id'))
        self.assertIsNone(
            validator.check(
                'ltc1q7euacwhn6ef99vcfa57mute92q572aqsc4c2j5', 'fake.app.id'
            )
        )

        # some invalid addresses (various special use/testnet addresses, invalid chars)
        self.assertRaises(
            fdroidserver.exception.MetaDataException,
            validator.check,
            '21BvMrSYsrWrtrrrn5Au4l4GFr7rrarrN2',
            'fake.app.id',
        )
        self.assertRaises(
            fdroidserver.exception.MetaDataException,
            validator.check,
            '5Hrgr3ur5rGLrfKrrrrrr1SrqJrroGrrzrQrrrrrrLNrsrDrrrA',
            'fake.app.id',
        )
        self.assertRaises(
            fdroidserver.exception.MetaDataException,
            validator.check,
            '92rr46rUrgTrrromrVrirW6r1rrrdrerrdbJrrrhrCsYrrrrrrc',
            'fake.app.id',
        )
        self.assertRaises(
            fdroidserver.exception.MetaDataException,
            validator.check,
            'K1BvMrSYsrWrtrrrn5Au4m4GFr7rrarrN2',
            'fake.app.id',
        )
        self.assertRaises(
            fdroidserver.exception.MetaDataException,
            validator.check,
            'L0000rSYsrWrtrrrn5Au4m4GFr7rrarrN2',
            'fake.app.id',
        )
        self.assertRaises(
            fdroidserver.exception.MetaDataException,
            validator.check,
            'tb1qw5r8drrejxrrg4y5rrrrrraryrrrrwrkxrjrsx',
            'fake.app.id',
        )

    def test_valid_funding_yml_regex(self):
        """Check the regex can find all the cases"""
        with (self.basedir / 'funding-usernames.yaml').open() as fp:
            yaml = ruamel.yaml.YAML(typ='safe')
            data = yaml.load(fp)

        for k, entries in data.items():
            for entry in entries:
                m = fdroidserver.metadata.VALID_USERNAME_REGEX.match(entry)
                if k == 'custom':
                    pass
                elif k == 'bad':
                    self.assertIsNone(
                        m, 'this is an invalid %s username: {%s}' % (k, entry)
                    )
                else:
                    self.assertIsNotNone(
                        m, 'this is a valid %s username: {%s}' % (k, entry)
                    )

    @mock.patch('git.Repo')
    @mock.patch('logging.error')
    def test_read_metadata(self, logging_error, git_repo):
        """Read specified metadata files included in tests/, compare to stored output"""

        self.maxDiff = None

        config = dict()
        fdroidserver.common.fill_config_defaults(config)
        fdroidserver.common.config = config
        fdroidserver.metadata.warnings_action = None

        yaml = ruamel.yaml.YAML(typ='safe')
        apps = fdroidserver.metadata.read_metadata()
        for appid in (
            'app.with.special.build.params',
            'org.smssecure.smssecure',
            'org.adaway',
            'org.videolan.vlc',
            'com.politedroid',
        ):
            savepath = Path('metadata/dump') / (appid + '.yaml')
            frommeta = dict(apps[appid])
            self.assertTrue(appid in apps)
            with savepath.open('r') as f:
                from_yaml = yaml.load(f)
            self.assertEqual(frommeta, from_yaml)
            # comment above assert and uncomment below to update test
            # files when new metadata fields are added
            # with savepath.open('w') as fp:
            #     yaml.default_flow_style = False
            #     yaml.register_class(metadata.Build)
            #     yaml.dump(frommeta, fp)

        # errors are printed when .yml overrides localized
        logging_error.assert_called()
        self.assertEqual(3, len(logging_error.call_args_list))

    @mock.patch('git.Repo')
    def test_metadata_overrides_dot_fdroid_yml(self, git_Repo):
        """Fields in metadata files should override anything in .fdroid.yml."""
        app = metadata.parse_metadata('metadata/info.guardianproject.urzip.yml')
        self.assertEqual(app['Summary'], '一个实用工具，获取已安装在您的设备上的应用的有关信息')

    def test_dot_fdroid_yml_works_without_git(self):
        """Parsing should work if .fdroid.yml is present and it is not a git repo."""
        os.chdir(self.testdir)
        yml = Path('metadata/test.yml')
        yml.parent.mkdir()
        with yml.open('w') as fp:
            fp.write('Repo: https://example.com/not/git/or/anything')
        fdroid_yml = Path('build/test/.fdroid.yml')
        fdroid_yml.parent.mkdir(parents=True)
        with fdroid_yml.open('w') as fp:
            fp.write('OpenCollective: test')
        metadata.parse_metadata(yml)  # should not throw an exception

    @mock.patch('git.Repo')
    @mock.patch('logging.error')
    def test_rewrite_yaml_fakeotaupdate(self, logging_error, git_Repo):
        with tempfile.TemporaryDirectory() as testdir:
            testdir = Path(testdir)
            fdroidserver.common.config = {'accepted_formats': ['yml']}
            fdroidserver.metadata.warnings_action = None

            # rewrite metadata
            allapps = fdroidserver.metadata.read_metadata()
            for appid, app in allapps.items():
                if appid == 'fake.ota.update':
                    fdroidserver.metadata.write_metadata(
                        testdir / (appid + '.yml'), app
                    )

            # assert rewrite result
            self.maxDiff = None
            file_name = 'fake.ota.update.yml'
            self.assertEqual(
                (testdir / file_name).read_text(encoding='utf-8'),
                (Path('metadata-rewrite-yml') / file_name).read_text(encoding='utf-8'),
            )

        # errors are printed when .yml overrides localized
        logging_error.assert_called()
        self.assertEqual(3, len(logging_error.call_args_list))

    @mock.patch('git.Repo')
    def test_rewrite_yaml_fdroidclient(self, git_Repo):
        with tempfile.TemporaryDirectory() as testdir:
            testdir = Path(testdir)
            fdroidserver.common.config = {'accepted_formats': ['yml']}

            # rewrite metadata
            allapps = fdroidserver.metadata.read_metadata()
            for appid, app in allapps.items():
                if appid == 'org.fdroid.fdroid':
                    fdroidserver.metadata.write_metadata(
                        testdir / (appid + '.yml'), app
                    )

            # assert rewrite result
            self.maxDiff = None
            file_name = 'org.fdroid.fdroid.yml'
            self.assertEqual(
                (testdir / file_name).read_text(encoding='utf-8'),
                (Path('metadata-rewrite-yml') / file_name).read_text(encoding='utf-8'),
            )

    @mock.patch('git.Repo')
    def test_rewrite_yaml_special_build_params(self, git_Repo):
        """Test rewriting a plain YAML metadata file without localized files."""
        os.chdir(self.testdir)
        os.mkdir('metadata')
        appid = 'app.with.special.build.params'
        file_name = Path('metadata/%s.yml' % appid)
        shutil.copy(self.basedir / file_name, file_name)

        # rewrite metadata
        allapps = fdroidserver.metadata.read_metadata({appid: -1})
        for appid, app in allapps.items():
            metadata.write_metadata(file_name, app)

        # assert rewrite result
        self.maxDiff = None
        self.assertEqual(
            file_name.read_text(),
            (self.basedir / 'metadata-rewrite-yml' / file_name.name).read_text(),
        )

    def test_normalize_type_string(self):
        """TYPE_STRING currently has some quirky behavior."""
        self.assertEqual('123456', metadata._normalize_type_string(123456))
        self.assertEqual('1.0', metadata._normalize_type_string(1.0))
        self.assertEqual('0', metadata._normalize_type_string(0))
        self.assertEqual('0.0', metadata._normalize_type_string(0.0))
        self.assertEqual('0.1', metadata._normalize_type_string(0.1))
        self.assertEqual('[]', metadata._normalize_type_string(list()))
        self.assertEqual('{}', metadata._normalize_type_string(dict()))
        self.assertEqual('false', metadata._normalize_type_string(False))
        self.assertEqual('true', metadata._normalize_type_string(True))

    def test_normalize_type_string_sha256(self):
        """SHA-256 values are TYPE_STRING, which YAML can parse as decimal ints."""
        yaml = ruamel.yaml.YAML(typ='safe')
        for v in range(1, 1000):
            s = '%064d' % (v * (10**51))
            self.assertEqual(s, metadata._normalize_type_string(yaml.load(s)))

    def test_normalize_type_stringmap_none(self):
        self.assertEqual(dict(), metadata._normalize_type_stringmap('key', None))

    def test_normalize_type_stringmap_empty_list(self):
        self.assertEqual(dict(), metadata._normalize_type_stringmap('AntiFeatures', []))

    def test_normalize_type_stringmap_simple_list_format(self):
        self.assertEqual(
            {'Ads': {}, 'Tracking': {}},
            metadata._normalize_type_stringmap('AntiFeatures', ['Ads', 'Tracking']),
        )

    def test_normalize_type_int(self):
        """TYPE_INT should be an int whenever possible."""
        self.assertEqual(0, metadata._normalize_type_int('key', 0))
        self.assertEqual(1, metadata._normalize_type_int('key', 1))
        self.assertEqual(-5, metadata._normalize_type_int('key', -5))
        self.assertEqual(0, metadata._normalize_type_int('key', '0'))
        self.assertEqual(1, metadata._normalize_type_int('key', '1'))
        self.assertEqual(-5, metadata._normalize_type_int('key', '-5'))
        self.assertEqual(
            12345678901234567890,
            metadata._normalize_type_int('key', 12345678901234567890),
        )

    def test_normalize_type_int_fails(self):
        with self.assertRaises(MetaDataException):
            metadata._normalize_type_int('key', '1a')
        with self.assertRaises(MetaDataException):
            metadata._normalize_type_int('key', 1.1)
        with self.assertRaises(MetaDataException):
            metadata._normalize_type_int('key', True)

    def test_normalize_type_list(self):
        """TYPE_LIST is always a list of strings, no matter what YAML thinks."""
        k = 'placeholder'
        yaml = ruamel.yaml.YAML(typ='safe')
        self.assertEqual(['1.0'], metadata._normalize_type_list(k, 1.0))
        self.assertEqual(['1234567890'], metadata._normalize_type_list(k, 1234567890))
        self.assertEqual(['false'], metadata._normalize_type_list(k, False))
        self.assertEqual(['true'], metadata._normalize_type_list(k, True))
        self.assertEqual(['foo'], metadata._normalize_type_list(k, 'foo'))
        self.assertEqual([], metadata._normalize_type_list(k, list()))
        self.assertEqual([], metadata._normalize_type_list(k, tuple()))
        self.assertEqual([], metadata._normalize_type_list(k, set()))
        self.assertEqual(['0', '1', '2'], metadata._normalize_type_list(k, {0, 1, 2}))
        self.assertEqual(
            ['a', 'b', 'c', '0', '0.0'],
            metadata._normalize_type_list(k, yaml.load('[a, b, c, 0, 0.0]')),
        )
        self.assertEqual(
            ['1', '1.0', 's', 'true', '{}'],
            metadata._normalize_type_list(k, yaml.load('[1, 1.0, s, true, {}]')),
        )
        self.assertEqual(
            ['1', '1.0', 's', 'true', '{}'],
            metadata._normalize_type_list(k, (1, 1.0, 's', True, dict())),
        )

    def test_normalize_type_list_fails(self):
        with self.assertRaises(MetaDataException):
            metadata._normalize_type_list('placeholder', dict())

    def test_post_parse_yaml_metadata(self):
        yamldata = dict()
        metadata.post_parse_yaml_metadata(yamldata)

        yamldata[
            'AllowedAPKSigningKeys'
        ] = 'c03dac71394d6c26766f1b04d3e31cfcac5d03b55d8aa40cc9b9fa6b74354c66'
        metadata.post_parse_yaml_metadata(yamldata)

    def test_post_parse_yaml_metadata_ArchivePolicy_int(self):
        for i in range(20):
            yamldata = {'ArchivePolicy': i}
            metadata.post_parse_yaml_metadata(yamldata)
            self.assertEqual(i, yamldata['ArchivePolicy'])

    def test_post_parse_yaml_metadata_ArchivePolicy_string(self):
        for i in range(20):
            yamldata = {'ArchivePolicy': '%d' % i}
            metadata.post_parse_yaml_metadata(yamldata)
            self.assertEqual(i, yamldata['ArchivePolicy'])

    def test_post_parse_yaml_metadata_ArchivePolicy_versions(self):
        """Test that the old format still works."""
        for i in range(20):
            yamldata = {'ArchivePolicy': '%d versions' % i}
            metadata.post_parse_yaml_metadata(yamldata)
            self.assertEqual(i, yamldata['ArchivePolicy'])

    def test_post_parse_yaml_metadata_fails(self):
        yamldata = {'AllowedAPKSigningKeys': {'bad': 'dict-placement'}}
        with self.assertRaises(MetaDataException):
            metadata.post_parse_yaml_metadata(yamldata)

    def test_post_parse_yaml_metadata_0padding_sha256(self):
        """SHA-256 values are strings, but YAML 1.2 will read some as decimal ints."""
        v = '0027293472934293872934729834729834729834729834792837487293847926'
        yaml = ruamel.yaml.YAML(typ='safe')
        yamldata = yaml.load('AllowedAPKSigningKeys: ' + v)
        metadata.post_parse_yaml_metadata(yamldata)
        self.assertEqual(yamldata['AllowedAPKSigningKeys'], [v])

    def test_post_parse_yaml_metadata_builds(self):
        yamldata = OrderedDict()
        builds = []
        yamldata['Builds'] = builds
        build = OrderedDict()
        builds.append(build)

        build['versionCode'] = 1.1
        self.assertRaises(
            fdroidserver.exception.MetaDataException,
            fdroidserver.metadata.post_parse_yaml_metadata,
            yamldata,
        )

        build['versionCode'] = '1a'
        self.assertRaises(
            fdroidserver.exception.MetaDataException,
            fdroidserver.metadata.post_parse_yaml_metadata,
            yamldata,
        )

        build['versionCode'] = 1
        build['versionName'] = 1
        fdroidserver.metadata.post_parse_yaml_metadata(yamldata)
        self.assertNotEqual(1, yamldata['Builds'][0]['versionName'])
        self.assertEqual('1', yamldata['Builds'][0]['versionName'])
        self.assertEqual(1, yamldata['Builds'][0]['versionCode'])

        build['versionName'] = 1.0
        fdroidserver.metadata.post_parse_yaml_metadata(yamldata)
        self.assertNotEqual(1.0, yamldata['Builds'][0]['versionName'])
        self.assertEqual('1.0', yamldata['Builds'][0]['versionName'])

        build['commit'] = 1.0
        fdroidserver.metadata.post_parse_yaml_metadata(yamldata)
        self.assertNotEqual(1.0, yamldata['Builds'][0]['commit'])
        self.assertEqual('1.0', yamldata['Builds'][0]['commit'])

        teststr = '98234fab134b'
        build['commit'] = teststr
        fdroidserver.metadata.post_parse_yaml_metadata(yamldata)
        self.assertEqual(teststr, yamldata['Builds'][0]['commit'])

        testcommitid = 1234567890
        build['commit'] = testcommitid
        fdroidserver.metadata.post_parse_yaml_metadata(yamldata)
        self.assertNotEqual(testcommitid, yamldata['Builds'][0]['commit'])
        self.assertEqual('1234567890', yamldata['Builds'][0]['commit'])

    def test_read_metadata_sort_by_time(self):
        with tempfile.TemporaryDirectory() as testdir, TmpCwd(testdir):
            testdir = Path(testdir)
            metadatadir = testdir / 'metadata'
            metadatadir.mkdir()

            randomlist = []
            randomapps = list((self.basedir / 'metadata').glob('*.yml'))
            random.shuffle(randomapps)
            i = 1
            for f in randomapps:
                shutil.copy(f, metadatadir)
                new = metadatadir / f.name
                stat = new.stat()
                os.utime(new, (stat.st_ctime, stat.st_mtime + i))
                # prepend new item so newest is always first
                randomlist = [f.stem] + randomlist
                i += 1
            allapps = fdroidserver.metadata.read_metadata(sort_by_time=True)
            allappids = []
            for appid, app in allapps.items():
                allappids.append(appid)
            self.assertEqual(randomlist, allappids)

    def test_parse_yaml_metadata_0size_file(self):
        self.assertEqual(dict(), metadata.parse_yaml_metadata(_get_mock_mf('')))

    def test_parse_yaml_metadata_empty_dict_file(self):
        self.assertEqual(dict(), metadata.parse_yaml_metadata(_get_mock_mf('{}')))

    def test_parse_yaml_metadata_empty_string_file(self):
        self.assertEqual(dict(), metadata.parse_yaml_metadata(_get_mock_mf('""')))

    def test_parse_yaml_metadata_fail_on_root_list(self):
        with self.assertRaises(MetaDataException):
            metadata.parse_yaml_metadata(_get_mock_mf('-'))
        with self.assertRaises(MetaDataException):
            metadata.parse_yaml_metadata(_get_mock_mf('[]'))
        with self.assertRaises(MetaDataException):
            metadata.parse_yaml_metadata(_get_mock_mf('- AutoName: fake'))

    def test_parse_yaml_metadata_type_list_str(self):
        v = 'e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855'
        mf = _get_mock_mf('AllowedAPKSigningKeys: "%s"' % v)
        self.assertEqual(
            v,
            metadata.parse_yaml_metadata(mf)['AllowedAPKSigningKeys'][0],
        )

    def test_parse_yaml_metadata_type_list_build_str(self):
        mf = _get_mock_mf('Builds: [{versionCode: 1, rm: s}]')
        self.assertEqual(
            metadata.parse_yaml_metadata(mf),
            {'Builds': [{'rm': ['s'], 'versionCode': 1}]},
        )

    def test_parse_yaml_metadata_app_type_list_fails(self):
        mf = _get_mock_mf('AllowedAPKSigningKeys: {t: f}')
        with self.assertRaises(MetaDataException):
            metadata.parse_yaml_metadata(mf)

    def test_parse_yaml_metadata_build_type_list_fails(self):
        mf = _get_mock_mf('Builds: [{versionCode: 1, rm: {bad: dict-placement}}]')
        with self.assertRaises(MetaDataException):
            metadata.parse_yaml_metadata(mf)

    def test_parse_yaml_metadata_unknown_app_field(self):
        mf = io.StringIO(
            textwrap.dedent(
                """\
                AutoName: F-Droid
                RepoType: git
                Builds: []
                bad: value"""
            )
        )
        mf.name = 'mock_filename.yaml'
        with self.assertRaises(MetaDataException):
            fdroidserver.metadata.parse_yaml_metadata(mf)

    def test_parse_yaml_metadata_unknown_build_flag(self):
        mf = io.StringIO(
            textwrap.dedent(
                """\
                AutoName: F-Droid
                RepoType: git
                Builds:
                - bad: value"""
            )
        )
        mf.name = 'mock_filename.yaml'
        with self.assertRaises(MetaDataException):
            fdroidserver.metadata.parse_yaml_metadata(mf)

    @mock.patch('logging.warning')
    @mock.patch('logging.error')
    def test_parse_yaml_metadata_continue_on_warning(self, _error, _warning):
        """When errors are disabled, parsing should provide something that can work.

        When errors are disabled, then it should try to give data that
        lets something happen.  A zero-length file is valid for
        operation, it just declares a Application ID as "known" and
        nothing else.  This example gives a list as the base in the
        .yml file, which is unparsable, so it gives a warning message
        and carries on with a blank dict.

        """
        fdroidserver.metadata.warnings_action = None
        mf = _get_mock_mf('[AntiFeatures: Tracking]')
        self.assertEqual(fdroidserver.metadata.parse_yaml_metadata(mf), dict())
        _warning.assert_called_once()
        _error.assert_called_once()

    def test_parse_localized_antifeatures(self):
        """Unit test based on reading files included in the test repo."""
        app = dict()
        app['id'] = 'app.with.special.build.params'
        metadata.parse_localized_antifeatures(app)
        self.maxDiff = None
        self.assertEqual(
            app,
            {
                'AntiFeatures': {
                    'Ads': {'en-US': 'please no'},
                    'NoSourceSince': {'en-US': 'no activity\n'},
                },
                'Builds': [
                    {
                        'versionCode': 50,
                        'antifeatures': {
                            'Ads': {
                                'en-US': 'includes ad lib\n',
                                'zh-CN': '包括广告图书馆\n',
                            },
                            'Tracking': {'en-US': 'standard suspects\n'},
                        },
                    },
                    {
                        'versionCode': 49,
                        'antifeatures': {
                            'Tracking': {'zh-CN': 'Text from zh-CN/49_Tracking.txt'},
                        },
                    },
                ],
                'id': app['id'],
            },
        )

    def test_parse_localized_antifeatures_passthrough(self):
        """Test app values are cleanly passed through if no localized files."""
        before = {
            'id': 'placeholder',
            'AntiFeatures': {'NonFreeDep': {}},
            'Builds': [{'versionCode': 999, 'antifeatures': {'zero': {}, 'one': {}}}],
        }
        after = copy.deepcopy(before)
        with tempfile.TemporaryDirectory() as testdir:
            os.chdir(testdir)
            os.mkdir('metadata')
            os.mkdir(os.path.join('metadata', after['id']))
            metadata.parse_localized_antifeatures(after)
        self.assertEqual(before, after)

    def test_parse_metadata_antifeatures_NoSourceSince(self):
        """Test that NoSourceSince gets added as an Anti-Feature."""
        os.chdir(self.testdir)
        yml = Path('metadata/test.yml')
        yml.parent.mkdir()
        with yml.open('w') as fp:
            fp.write('AntiFeatures: Ads\nNoSourceSince: gone\n')
        app = metadata.parse_metadata(yml)
        self.assertEqual(
            app['AntiFeatures'], {'Ads': {}, 'NoSourceSince': {DEFAULT_LOCALE: 'gone'}}
        )

    @mock.patch('logging.error')
    def test_yml_overrides_localized_antifeatures(self, logging_error):
        """Definitions in .yml files should override the localized versions."""
        app = metadata.parse_metadata('metadata/app.with.special.build.params.yml')

        self.assertEqual(app['AntiFeatures'], {'UpstreamNonFree': {}})

        self.assertEqual(49, app['Builds'][-3]['versionCode'])
        self.assertEqual(
            app['Builds'][-3]['antifeatures'],
            {'Tracking': {DEFAULT_LOCALE: 'Uses the Facebook SDK.'}},
        )

        self.assertEqual(50, app['Builds'][-2]['versionCode'])
        self.assertEqual(
            app['Builds'][-2]['antifeatures'],
            {
                'Ads': {
                    'en-US': 'includes ad lib\n',
                    'zh-CN': '包括广告图书馆\n',
                },
                'Tracking': {'en-US': 'standard suspects\n'},
            },
        )
        # errors are printed when .yml overrides localized
        logging_error.assert_called()
        self.assertEqual(3, len(logging_error.call_args_list))

    def test_parse_yaml_srclib_corrupt_file(self):
        with tempfile.TemporaryDirectory() as testdir:
            testdir = Path(testdir)
            srclibfile = testdir / 'srclib/mock.yml'
            srclibfile.parent.mkdir()
            with srclibfile.open('w') as fp:
                fp.write(
                    textwrap.dedent(
                        """
                        - RepoType: git
                        - Repo: https://github.com/realm/realm-js.git
                        """
                    )
                )
            with self.assertRaises(MetaDataException):
                fdroidserver.metadata.parse_yaml_srclib(srclibfile)

    def test_write_yaml_with_placeholder_values(self):
        mf = io.StringIO()

        app = fdroidserver.metadata.App()
        app.Categories = ['None']
        app.SourceCode = "https://gitlab.com/fdroid/fdroidclient.git"
        app.IssueTracker = "https://gitlab.com/fdroid/fdroidclient/issues"
        app.RepoType = 'git'
        app.Repo = 'https://gitlab.com/fdroid/fdroidclient.git'
        app.AutoUpdateMode = 'None'
        app.UpdateCheckMode = 'Tags'
        build = fdroidserver.metadata.Build()
        build.versionName = 'Unknown'  # taken from fdroidserver/import.py
        build.versionCode = 0  # taken from fdroidserver/import.py
        build.disable = 'Generated by import.py ...'
        build.commit = 'Unknown'
        build.gradle = ['yes']
        app['Builds'] = [build]

        fdroidserver.metadata.write_yaml(mf, app)

        mf.seek(0)
        self.assertEqual(
            mf.read(),
            textwrap.dedent(
                """\
                Categories:
                  - None
                License: Unknown
                SourceCode: https://gitlab.com/fdroid/fdroidclient.git
                IssueTracker: https://gitlab.com/fdroid/fdroidclient/issues

                RepoType: git
                Repo: https://gitlab.com/fdroid/fdroidclient.git

                Builds:
                  - versionName: Unknown
                    versionCode: 0
                    disable: Generated by import.py ...
                    commit: Unknown
                    gradle:
                      - yes

                AutoUpdateMode: None
                UpdateCheckMode: Tags
                """
            ),
        )

    def test_parse_yaml_metadata_prebuild_list(self):
        mf = io.StringIO(
            textwrap.dedent(
                """\
                AutoName: F-Droid
                RepoType: git
                Builds:
                  - versionCode: 1
                    versionName: v0.1.0
                    sudo:
                      - apt-get update
                      - apt-get install -y whatever
                      - sed -i -e 's/<that attr="bad"/<that attr="good"/' ~/.whatever/config.xml
                    init:
                      - bash generate_some_file.sh
                      - sed -i -e 'g/what/ever/' /some/file
                    prebuild:
                      - npm something
                      - echo 'important setting' >> /a/file
                    build:
                      - ./gradlew someSpecialTask
                      - sed -i 'd/that wrong config/' gradle.properties
                      - ./gradlew compile
                """
            )
        )
        mf.name = 'mock_filename.yaml'
        mf.seek(0)
        result = fdroidserver.metadata.parse_yaml_metadata(mf)
        self.maxDiff = None
        self.assertDictEqual(
            result,
            {
                'AutoName': 'F-Droid',
                'RepoType': 'git',
                'Builds': [
                    {
                        'versionCode': 1,
                        'versionName': 'v0.1.0',
                        'sudo': [
                            "apt-get update",
                            "apt-get install -y whatever",
                            "sed -i -e 's/<that attr=\"bad\"/<that attr=\"good\"/' ~/.whatever/config.xml",
                        ],
                        'init': [
                            "bash generate_some_file.sh",
                            "sed -i -e 'g/what/ever/' /some/file",
                        ],
                        'prebuild': [
                            "npm something",
                            "echo 'important setting' >> /a/file",
                        ],
                        'build': [
                            "./gradlew someSpecialTask",
                            "sed -i 'd/that wrong config/' gradle.properties",
                            "./gradlew compile",
                        ],
                    }
                ],
            },
        )

    def test_parse_yaml_metadata_prebuild_strings(self):
        mf = io.StringIO(
            textwrap.dedent(
                """\
                AutoName: F-Droid
                RepoType: git
                Builds:
                  - versionCode: 1
                    versionName: v0.1.0
                    sudo: |-
                      apt-get update && apt-get install -y whatever && sed -i -e 's/<that attr="bad"/<that attr="good"/' ~/.whatever/config.xml
                    init: bash generate_some_file.sh && sed -i -e 'g/what/ever/' /some/file
                    prebuild: npm something && echo 'important setting' >> /a/file
                    build: |-
                      ./gradlew someSpecialTask && sed -i 'd/that wrong config/' gradle.properties && ./gradlew compile
                """
            )
        )
        mf.name = 'mock_filename.yaml'
        mf.seek(0)
        result = fdroidserver.metadata.parse_yaml_metadata(mf)
        self.maxDiff = None
        self.assertDictEqual(
            result,
            {
                'AutoName': 'F-Droid',
                'RepoType': 'git',
                'Builds': [
                    {
                        'versionCode': 1,
                        'versionName': 'v0.1.0',
                        'sudo': [
                            "apt-get update && "
                            "apt-get install -y whatever && "
                            "sed -i -e 's/<that attr=\"bad\"/<that attr=\"good\"/' ~/.whatever/config.xml"
                        ],
                        'init': [
                            "bash generate_some_file.sh && "
                            "sed -i -e 'g/what/ever/' /some/file"
                        ],
                        'prebuild': [
                            "npm something && echo 'important setting' >> /a/file"
                        ],
                        'build': [
                            "./gradlew someSpecialTask && "
                            "sed -i 'd/that wrong config/' gradle.properties && "
                            "./gradlew compile"
                        ],
                    }
                ],
            },
        )

    def test_parse_yaml_metadata_prebuild_string(self):
        mf = io.StringIO(
            textwrap.dedent(
                """\
                AutoName: F-Droid
                RepoType: git
                Builds:
                  - versionCode: 1
                    versionName: v0.1.0
                    prebuild: |-
                      a && b && sed -i 's,a,b,'
                """
            )
        )
        mf.name = 'mock_filename.yaml'
        mf.seek(0)
        result = fdroidserver.metadata.parse_yaml_metadata(mf)
        self.assertDictEqual(
            result,
            {
                'AutoName': 'F-Droid',
                'RepoType': 'git',
                'Builds': [
                    {
                        'versionCode': 1,
                        'versionName': 'v0.1.0',
                        'prebuild': ["a && b && " "sed -i 's,a,b,'"],
                    }
                ],
            },
        )

    def test_parse_yaml_provides_should_be_ignored(self):
        mf = io.StringIO(
            textwrap.dedent(
                """\
                Provides: this.is.deprecated
                AutoName: F-Droid
                RepoType: git
                Builds:
                  - versionCode: 1
                    versionName: v0.1.0
                    prebuild: |-
                      a && b && sed -i 's,a,b,'
                """
            )
        )
        mf.name = 'mock_filename.yaml'
        mf.seek(0)
        result = fdroidserver.metadata.parse_yaml_metadata(mf)
        self.assertNotIn('Provides', result)
        self.assertNotIn('provides', result)

    def test_parse_yaml_app_antifeatures_dict(self):
        nonfreenet = 'free it!'
        tracking = 'so many'
        mf = io.StringIO(
            textwrap.dedent(
                f"""
                AntiFeatures:
                  Tracking: {tracking}
                  NonFreeNet: {nonfreenet}
                """
            )
        )
        self.assertEqual(
            metadata.parse_yaml_metadata(mf),
            {
                'AntiFeatures': {
                    'NonFreeNet': {DEFAULT_LOCALE: nonfreenet},
                    'Tracking': {DEFAULT_LOCALE: tracking},
                }
            },
        )

    def test_parse_yaml_metadata_build_antifeatures_old_style(self):
        mf = _get_mock_mf(
            textwrap.dedent(
                """
                AntiFeatures:
                  - Ads
                Builds:
                  - versionCode: 123
                    antifeatures:
                      - KnownVuln
                      - UpstreamNonFree
                      - NonFreeAssets
                """
            )
        )
        self.assertEqual(
            metadata.parse_yaml_metadata(mf),
            {
                'AntiFeatures': {'Ads': {}},
                'Builds': [
                    {
                        'antifeatures': {
                            'KnownVuln': {},
                            'NonFreeAssets': {},
                            'UpstreamNonFree': {},
                        },
                        'versionCode': 123,
                    }
                ],
            },
        )

    def test_parse_yaml_metadata_antifeatures_sort(self):
        """All data should end up sorted, to minimize diffs in the index files."""
        self.assertEqual(
            metadata.parse_yaml_metadata(
                _get_mock_mf(
                    textwrap.dedent(
                        """
                Builds:
                  - versionCode: 123
                    antifeatures:
                      KnownVuln:
                        es: 2nd
                        az: zero
                        en-US: first
                      UpstreamNonFree:
                      NonFreeAssets:
                AntiFeatures:
                  NonFreeDep:
                  Ads:
                    sw: 2nd
                    zh-CN: 3rd
                    de: 1st
                """
                    )
                )
            ),
            {
                'AntiFeatures': {
                    'Ads': {'de': '1st', 'sw': '2nd', 'zh-CN': '3rd'},
                    'NonFreeDep': {},
                },
                'Builds': [
                    {
                        'antifeatures': {
                            'KnownVuln': {'az': 'zero', 'en-US': 'first', 'es': '2nd'},
                            'NonFreeAssets': {},
                            'UpstreamNonFree': {},
                        },
                        'versionCode': 123,
                    }
                ],
            },
        )

    def test_parse_yaml_app_antifeatures_str(self):
        self.assertEqual(
            metadata.parse_yaml_metadata(io.StringIO('AntiFeatures: Tracking')),
            {'AntiFeatures': {'Tracking': {}}},
        )

    def test_parse_yaml_app_antifeatures_bool(self):
        self.assertEqual(
            metadata.parse_yaml_metadata(io.StringIO('AntiFeatures: true')),
            {'AntiFeatures': {'true': {}}},
        )

    def test_parse_yaml_app_antifeatures_float_nan(self):
        self.assertEqual(
            metadata.parse_yaml_metadata(io.StringIO('AntiFeatures: .nan')),
            {'AntiFeatures': {'.nan': {}}},
        )

    def test_parse_yaml_app_antifeatures_float_inf(self):
        self.assertEqual(
            metadata.parse_yaml_metadata(io.StringIO('AntiFeatures: .inf')),
            {'AntiFeatures': {'.inf': {}}},
        )

    def test_parse_yaml_app_antifeatures_float_negative_inf(self):
        self.assertEqual(
            metadata.parse_yaml_metadata(io.StringIO('AntiFeatures: -.inf')),
            {'AntiFeatures': {'-.inf': {}}},
        )

    def test_parse_yaml_app_antifeatures_int(self):
        self.assertEqual(
            metadata.parse_yaml_metadata(io.StringIO('AntiFeatures: 1')),
            {'AntiFeatures': {'1': {}}},
        )

    def test_parse_yaml_app_antifeatures_float(self):
        self.assertEqual(
            metadata.parse_yaml_metadata(io.StringIO('AntiFeatures: 1.0')),
            {'AntiFeatures': {'1.0': {}}},
        )

    def test_parse_yaml_app_antifeatures_list_float(self):
        self.assertEqual(
            metadata.parse_yaml_metadata(io.StringIO('AntiFeatures:\n  - 1.0\n')),
            {'AntiFeatures': {'1.0': {}}},
        )

    def test_parse_yaml_app_antifeatures_dict_float(self):
        mf = io.StringIO('AntiFeatures:\n  0.0: too early\n')
        self.assertEqual(
            metadata.parse_yaml_metadata(mf),
            {'AntiFeatures': {'0.0': {'en-US': 'too early'}}},
        )

    def test_parse_yaml_app_antifeatures_dict_float_fail_value(self):
        mf = io.StringIO('AntiFeatures:\n  NoSourceSince: 1.0\n')
        self.assertEqual(
            metadata.parse_yaml_metadata(mf),
            {'AntiFeatures': {'NoSourceSince': {'en-US': '1.0'}}},
        )

    def test_parse_yaml_metadata_type_stringmap_old_list(self):
        mf = _get_mock_mf(
            textwrap.dedent(
                """
                    AntiFeatures:
                      - Ads
                      - Tracking
                """
            )
        )
        self.assertEqual(
            {'AntiFeatures': {'Ads': {}, 'Tracking': {}}},
            metadata.parse_yaml_metadata(mf),
        )

    def test_parse_yaml_app_antifeatures_dict_no_value(self):
        mf = io.StringIO(
            textwrap.dedent(
                """\
                AntiFeatures:
                  Tracking:
                  NonFreeNet:
                """
            )
        )
        self.assertEqual(
            metadata.parse_yaml_metadata(mf),
            {'AntiFeatures': {'NonFreeNet': {}, 'Tracking': {}}},
        )

    def test_parse_yaml_metadata_type_stringmap_transitional(self):
        """Support a transitional format, where users just append a text"""
        ads = 'Has ad lib in it.'
        tracking = 'opt-out reports with ACRA'
        mf = _get_mock_mf(
            textwrap.dedent(
                f"""
                    AntiFeatures:
                      - Ads: {ads}
                      - Tracking: {tracking}
                """
            )
        )
        self.assertEqual(
            metadata.parse_yaml_metadata(mf),
            {
                'AntiFeatures': {
                    'Ads': {DEFAULT_LOCALE: ads},
                    'Tracking': {DEFAULT_LOCALE: tracking},
                }
            },
        )

    def test_parse_yaml_app_antifeatures_dict_mixed_values(self):
        ads = 'true'
        tracking = 'many'
        nonfreenet = '1'
        mf = io.StringIO(
            textwrap.dedent(
                f"""
                AntiFeatures:
                  Ads: {ads}
                  Tracking: {tracking}
                  NonFreeNet: {nonfreenet}
                """
            )
        )
        self.assertEqual(
            metadata.parse_yaml_metadata(mf),
            {
                'AntiFeatures': {
                    'Ads': {DEFAULT_LOCALE: ads},
                    'NonFreeNet': {DEFAULT_LOCALE: nonfreenet},
                    'Tracking': {DEFAULT_LOCALE: tracking},
                }
            },
        )

    def test_parse_yaml_app_antifeatures_stringmap_full(self):
        ads = 'watching'
        tracking = 'many'
        nonfreenet = 'pipes'
        nonfreenet_zh = '非免费网络'
        self.maxDiff = None
        mf = io.StringIO(
            textwrap.dedent(
                f"""
                AntiFeatures:
                  Ads:
                    {DEFAULT_LOCALE}: {ads}
                  Tracking:
                    {DEFAULT_LOCALE}: {tracking}
                  NonFreeNet:
                    {DEFAULT_LOCALE}: {nonfreenet}
                    zh-CN: {nonfreenet_zh}
                """
            )
        )
        self.assertEqual(
            metadata.parse_yaml_metadata(mf),
            {
                'AntiFeatures': {
                    'Ads': {DEFAULT_LOCALE: ads},
                    'NonFreeNet': {DEFAULT_LOCALE: nonfreenet, 'zh-CN': nonfreenet_zh},
                    'Tracking': {DEFAULT_LOCALE: tracking},
                }
            },
        )

    def test_parse_yaml_build_type_int_fail(self):
        mf = io.StringIO('Builds: [{versionCode: 1a}]')
        with self.assertRaises(MetaDataException):
            fdroidserver.metadata.parse_yaml_metadata(mf)

    def test_parse_yaml_int_strict_typing_fails(self):
        """Things that cannot be preserved when parsing as YAML."""
        mf = io.StringIO('Builds: [{versionCode: 1, rm: 0xf}]')
        self.assertEqual(
            {'Builds': [{'rm': ['15'], 'versionCode': 1}]},  # 15 != 0xf
            fdroidserver.metadata.parse_yaml_metadata(mf),
        )
        mf = io.StringIO('Builds: [{versionCode: 1, rm: 0x010}]')
        self.assertEqual(
            {'Builds': [{'rm': ['16'], 'versionCode': 1}]},  # 16 != 0x010
            fdroidserver.metadata.parse_yaml_metadata(mf),
        )
        mf = io.StringIO('Builds: [{versionCode: 1, rm: 0o015}]')
        self.assertEqual(
            {'Builds': [{'rm': ['13'], 'versionCode': 1}]},  # 13 != 0o015
            fdroidserver.metadata.parse_yaml_metadata(mf),
        )
        mf = io.StringIO('Builds: [{versionCode: 1, rm: 10_000}]')
        self.assertEqual(
            {'Builds': [{'rm': ['10000'], 'versionCode': 1}]},  # 10000 != 10_000
            fdroidserver.metadata.parse_yaml_metadata(mf),
        )

    def test_write_yaml_1_line_scripts_as_string(self):
        mf = io.StringIO()
        app = fdroidserver.metadata.App()
        app.Categories = ['None']
        app['Builds'] = []
        build = fdroidserver.metadata.Build()
        build.versionCode = 102030
        build.versionName = 'v1.2.3'
        build.sudo = ["chmod +rwx /opt"]
        build.init = ["sed -i -e 'g/what/ever/' /some/file"]
        build.prebuild = ["sed -i 'd/that wrong config/' gradle.properties"]
        build.build = ["./gradlew compile"]
        app['Builds'].append(build)
        fdroidserver.metadata.write_yaml(mf, app)
        mf.seek(0)
        self.assertEqual(
            mf.read(),
            textwrap.dedent(
                """\
                Categories:
                  - None
                License: Unknown

                Builds:
                  - versionName: v1.2.3
                    versionCode: 102030
                    sudo: chmod +rwx /opt
                    init: sed -i -e 'g/what/ever/' /some/file
                    prebuild: sed -i 'd/that wrong config/' gradle.properties
                    build: ./gradlew compile

                AutoUpdateMode: None
                UpdateCheckMode: None
                """
            ),
        )

    def test_write_yaml_1_line_scripts_as_list(self):
        mf = io.StringIO()
        app = fdroidserver.metadata.App()
        app.Categories = ['None']
        app['Builds'] = []
        build = fdroidserver.metadata.Build()
        build.versionCode = 102030
        build.versionName = 'v1.2.3'
        build.sudo = ["chmod +rwx /opt"]
        build.init = ["sed -i -e 'g/what/ever/' /some/file"]
        build.prebuild = ["sed -i 'd/that wrong config/' gradle.properties"]
        build.build = ["./gradlew compile"]
        app['Builds'].append(build)
        fdroidserver.metadata.write_yaml(mf, app)
        mf.seek(0)
        self.assertEqual(
            mf.read(),
            textwrap.dedent(
                """\
                Categories:
                  - None
                License: Unknown

                Builds:
                  - versionName: v1.2.3
                    versionCode: 102030
                    sudo: chmod +rwx /opt
                    init: sed -i -e 'g/what/ever/' /some/file
                    prebuild: sed -i 'd/that wrong config/' gradle.properties
                    build: ./gradlew compile

                AutoUpdateMode: None
                UpdateCheckMode: None
                """
            ),
        )

    def test_write_yaml_multiline_scripts_from_list(self):
        mf = io.StringIO()
        app = fdroidserver.metadata.App()
        app.Categories = ['None']
        app['Builds'] = []
        build = fdroidserver.metadata.Build()
        build.versionCode = 102030
        build.versionName = 'v1.2.3'
        build.sudo = [
            "apt-get update",
            "apt-get install -y whatever",
            "sed -i -e 's/<that attr=\"bad\"/<that attr=\"good\"/' ~/.whatever/config.xml",
        ]
        build.init = [
            "bash generate_some_file.sh",
            "sed -i -e 'g/what/ever/' /some/file",
        ]
        build.prebuild = ["npm something", "echo 'important setting' >> /a/file"]
        build.build = [
            "./gradlew someSpecialTask",
            "sed -i 'd/that wrong config/' gradle.properties",
            "./gradlew compile",
        ]
        app['Builds'].append(build)
        fdroidserver.metadata.write_yaml(mf, app)
        mf.seek(0)
        self.assertEqual(
            mf.read(),
            textwrap.dedent(
                """\
            Categories:
              - None
            License: Unknown

            Builds:
              - versionName: v1.2.3
                versionCode: 102030
                sudo:
                  - apt-get update
                  - apt-get install -y whatever
                  - sed -i -e 's/<that attr="bad"/<that attr="good"/' ~/.whatever/config.xml
                init:
                  - bash generate_some_file.sh
                  - sed -i -e 'g/what/ever/' /some/file
                prebuild:
                  - npm something
                  - echo 'important setting' >> /a/file
                build:
                  - ./gradlew someSpecialTask
                  - sed -i 'd/that wrong config/' gradle.properties
                  - ./gradlew compile

            AutoUpdateMode: None
            UpdateCheckMode: None
            """
            ),
        )

    def test_write_yaml_multiline_scripts_from_string(self):
        mf = io.StringIO()
        app = fdroidserver.metadata.App()
        app.Categories = ['None']
        app['Builds'] = []
        build = fdroidserver.metadata.Build()
        build.versionCode = 102030
        build.versionName = 'v1.2.3'
        build.sudo = [
            "apt-get update",
            "apt-get install -y whatever",
            "sed -i -e 's/<that attr=\"bad\"/<that attr=\"good\"/' ~/.whatever/config.xml",
        ]
        build.init = [
            "bash generate_some_file.sh",
            "sed -i -e 'g/what/ever/' /some/file",
        ]
        build.prebuild = ["npm something", "echo 'important setting' >> /a/file"]
        build.build = [
            "./gradlew someSpecialTask",
            "sed -i 'd/that wrong config/' gradle.properties",
            "./gradlew compile",
        ]
        app['Builds'].append(build)
        fdroidserver.metadata.write_yaml(mf, app)
        mf.seek(0)
        self.assertEqual(
            mf.read(),
            textwrap.dedent(
                """\
            Categories:
              - None
            License: Unknown

            Builds:
              - versionName: v1.2.3
                versionCode: 102030
                sudo:
                  - apt-get update
                  - apt-get install -y whatever
                  - sed -i -e 's/<that attr="bad"/<that attr="good"/' ~/.whatever/config.xml
                init:
                  - bash generate_some_file.sh
                  - sed -i -e 'g/what/ever/' /some/file
                prebuild:
                  - npm something
                  - echo 'important setting' >> /a/file
                build:
                  - ./gradlew someSpecialTask
                  - sed -i 'd/that wrong config/' gradle.properties
                  - ./gradlew compile

            AutoUpdateMode: None
            UpdateCheckMode: None
            """
            ),
        )

    def test_write_yaml_build_antifeatures(self):
        mf = io.StringIO()
        app = metadata.App(
            {
                'License': 'Apache-2.0',
                'Builds': [
                    metadata.Build(
                        {
                            'versionCode': 102030,
                            'versionName': 'v1.2.3',
                            'gradle': ['yes'],
                            'antifeatures': {
                                'a': {},
                                'b': {'de': 'Probe', 'en-US': 'test'},
                            },
                        }
                    ),
                ],
                'id': 'placeholder',
            }
        )
        metadata.write_yaml(mf, app)
        mf.seek(0)
        self.assertEqual(
            mf.read(),
            textwrap.dedent(
                """\
                License: Apache-2.0

                Builds:
                  - versionName: v1.2.3
                    versionCode: 102030
                    gradle:
                      - yes
                    antifeatures:
                        a: {}
                        b:
                            de: Probe
                            en-US: test
                """
            ),
        )

    def test_write_yaml_build_antifeatures_old_style(self):
        mf = io.StringIO()
        app = metadata.App(
            {
                'License': 'Apache-2.0',
                'Builds': [
                    metadata.Build(
                        {
                            'versionCode': 102030,
                            'versionName': 'v1.2.3',
                            'gradle': ['yes'],
                            'antifeatures': {'b': {}, 'a': {}},
                        }
                    ),
                ],
                'id': 'placeholder',
            }
        )
        metadata.write_yaml(mf, app)
        mf.seek(0)
        self.assertEqual(
            mf.read(),
            textwrap.dedent(
                """\
                License: Apache-2.0

                Builds:
                  - versionName: v1.2.3
                    versionCode: 102030
                    gradle:
                      - yes
                    antifeatures:
                      - a
                      - b
                """
            ),
        )

    def test_write_yaml_make_sure_provides_does_not_get_written(self):
        mf = io.StringIO()
        app = fdroidserver.metadata.App()
        app.Categories = ['None']
        app.Provides = 'this.is.deprecated'
        app['Builds'] = []
        build = fdroidserver.metadata.Build()
        build.versionCode = 102030
        build.versionName = 'v1.2.3'
        build.gradle = ['yes']
        app['Builds'].append(build)
        fdroidserver.metadata.write_yaml(mf, app)
        mf.seek(0)
        self.assertEqual(
            mf.read(),
            textwrap.dedent(
                """\
                Categories:
                  - None
                License: Unknown

                Builds:
                  - versionName: v1.2.3
                    versionCode: 102030
                    gradle:
                      - yes

                AutoUpdateMode: None
                UpdateCheckMode: None
                """
            ),
        )

    def test_parse_yaml_srclib_unknown_key(self):
        with tempfile.TemporaryDirectory() as tmpdir, TmpCwd(tmpdir):
            with Path('test.yml').open('w', encoding='utf-8') as f:
                f.write(
                    textwrap.dedent(
                        '''\
                        RepoType: git
                        Repo: https://example.com/test.git
                        Evil: I should not be here.
                        '''
                    )
                )
            with self.assertRaisesRegex(
                MetaDataException,
                "Invalid srclib metadata: " "unknown key 'Evil' in " "'test.yml'",
            ):
                fdroidserver.metadata.parse_yaml_srclib(Path('test.yml'))

    def test_parse_yaml_srclib_does_not_exists(self):
        with self.assertRaisesRegex(
            MetaDataException,
            "Invalid scrlib metadata: "
            r"'non(/|\\)existent-test-srclib.yml' "
            "does not exist",
        ):
            fdroidserver.metadata.parse_yaml_srclib(
                Path('non/existent-test-srclib.yml')
            )

    def test_parse_yaml_srclib_simple(self):
        with tempfile.TemporaryDirectory() as tmpdir, TmpCwd(tmpdir):
            with Path('simple.yml').open('w', encoding='utf-8') as f:
                f.write(
                    textwrap.dedent(
                        '''\
                    # this should be simple
                    RepoType: git
                    Repo: https://git.host/repo.git
                    '''
                    )
                )
            srclib = fdroidserver.metadata.parse_yaml_srclib(Path('simple.yml'))
            self.assertDictEqual(
                {
                    'Repo': 'https://git.host/repo.git',
                    'RepoType': 'git',
                    'Subdir': None,
                    'Prepare': None,
                },
                srclib,
            )

    def test_parse_yaml_srclib_simple_with_blanks(self):
        with tempfile.TemporaryDirectory() as tmpdir, TmpCwd(tmpdir):
            with Path('simple.yml').open('w', encoding='utf-8') as f:
                f.write(
                    textwrap.dedent(
                        '''\
                    # this should be simple

                    RepoType: git

                    Repo: https://git.host/repo.git

                    Subdir:

                    Prepare:
                    '''
                    )
                )
            srclib = fdroidserver.metadata.parse_yaml_srclib(Path('simple.yml'))
            self.assertDictEqual(
                {
                    'Repo': 'https://git.host/repo.git',
                    'RepoType': 'git',
                    'Subdir': [''],
                    'Prepare': [],
                },
                srclib,
            )

    def test_parse_yaml_srclib_Changelog_cketti(self):
        with tempfile.TemporaryDirectory() as tmpdir, TmpCwd(tmpdir):
            with Path('Changelog-cketti.yml').open('w', encoding='utf-8') as f:
                f.write(
                    textwrap.dedent(
                        '''\
                    RepoType: git
                    Repo: https://github.com/cketti/ckChangeLog

                    Subdir: library,ckChangeLog/src/main
                    Prepare: "[ -f project.properties ] || echo 'source.dir=java' > ant.properties && echo -e 'android.library=true\\\\ntarget=android-19' > project.properties"
                    '''
                    )
                )
            srclib = fdroidserver.metadata.parse_yaml_srclib(
                Path('Changelog-cketti.yml')
            )
            self.assertDictEqual(
                srclib,
                {
                    'Repo': 'https://github.com/cketti/ckChangeLog',
                    'RepoType': 'git',
                    'Subdir': ['library', 'ckChangeLog/src/main'],
                    'Prepare': [
                        "[ -f project.properties ] || echo 'source.dir=java' > "
                        "ant.properties && echo -e "
                        "'android.library=true\\ntarget=android-19' > project.properties"
                    ],
                },
            )

    def test_read_srclibs_yml_subdir_list(self):
        fdroidserver.metadata.srclibs = None
        with tempfile.TemporaryDirectory() as tmpdir, TmpCwd(tmpdir):
            Path('srclibs').mkdir()
            with Path('srclibs/with-list.yml').open('w', encoding='utf-8') as f:
                f.write(
                    textwrap.dedent(
                        '''\
                    # this should be simple
                    RepoType: git
                    Repo: https://git.host/repo.git

                    Subdir:
                     - This is your last chance.
                     - After this, there is no turning back.
                     - You take the blue pill—the story ends,
                     - you wake up in your bed
                     - and believe whatever you want to believe.
                     - You take the red pill—you stay in Wonderland
                     - and I show you how deep the rabbit-hole goes.
                    Prepare:
                        There is a difference between knowing the path
                        and walking the path.
                    '''
                    )
                )
            fdroidserver.metadata.read_srclibs()
        self.maxDiff = None
        self.assertDictEqual(
            fdroidserver.metadata.srclibs,
            {
                'with-list': {
                    'RepoType': 'git',
                    'Repo': 'https://git.host/repo.git',
                    'Subdir': [
                        'This is your last chance.',
                        'After this, there is no turning back.',
                        'You take the blue pill—the story ends,',
                        'you wake up in your bed',
                        'and believe whatever you want to believe.',
                        'You take the red pill—you stay in Wonderland',
                        'and I show you how deep the rabbit-hole goes.',
                    ],
                    'Prepare': [
                        'There is a difference between knowing the path '
                        'and walking the path.'
                    ],
                }
            },
        )

    def test_read_srclibs_yml_prepare_list(self):
        fdroidserver.metadata.srclibs = None
        with tempfile.TemporaryDirectory() as tmpdir, TmpCwd(tmpdir):
            Path('srclibs').mkdir()
            with Path('srclibs/with-list.yml').open('w', encoding='utf-8') as f:
                f.write(
                    textwrap.dedent(
                        '''\
                    # this should be simple
                    RepoType: git
                    Repo: https://git.host/repo.git

                    Subdir:
                    Prepare:
                     - Many
                     - invalid
                     - commands
                     - here.
                    '''
                    )
                )
            fdroidserver.metadata.read_srclibs()
        self.maxDiff = None
        self.assertDictEqual(
            fdroidserver.metadata.srclibs,
            {
                'with-list': {
                    'RepoType': 'git',
                    'Repo': 'https://git.host/repo.git',
                    'Subdir': [''],
                    'Prepare': [
                        'Many',
                        'invalid',
                        'commands',
                        'here.',
                    ],
                }
            },
        )

    def test_read_srclibs(self):
        fdroidserver.metadata.srclibs = None
        with tempfile.TemporaryDirectory() as tmpdir, TmpCwd(tmpdir):
            Path('srclibs').mkdir()
            with Path('srclibs/simple.yml').open('w', encoding='utf-8') as f:
                f.write(
                    textwrap.dedent(
                        '''\
                    RepoType: git
                    Repo: https://git.host/repo.git
                    '''
                    )
                )
            with Path('srclibs/simple-wb.yml').open('w', encoding='utf-8') as f:
                f.write(
                    textwrap.dedent(
                        '''\
                    # this should be simple
                    RepoType: git
                    Repo: https://git.host/repo.git

                    Subdir:
                    Prepare:
                    '''
                    )
                )
            fdroidserver.metadata.read_srclibs()
        self.assertDictEqual(
            fdroidserver.metadata.srclibs,
            {
                'simple-wb': {
                    'RepoType': 'git',
                    'Repo': 'https://git.host/repo.git',
                    'Subdir': [''],
                    'Prepare': [],
                },
                'simple': {
                    'RepoType': 'git',
                    'Repo': 'https://git.host/repo.git',
                    'Subdir': None,
                    'Prepare': None,
                },
            },
        )

    def test_build_ndk_path(self):
        """"""
        with tempfile.TemporaryDirectory(prefix='android-sdk-') as sdk_path:
            config = {'ndk_paths': {}, 'sdk_path': sdk_path}
            fdroidserver.common.config = config

            build = fdroidserver.metadata.Build()
            build.ndk = 'r10e'
            self.assertEqual('', build.ndk_path())

            correct = '/fake/path/ndk/r21b'
            config['ndk_paths'] = {'r21b': correct}
            self.assertEqual('', build.ndk_path())
            config['ndk_paths'] = {'r10e': correct}
            self.assertEqual(correct, build.ndk_path())

            r10e = '/fake/path/ndk/r10e'
            r22b = '/fake/path/ndk/r22e'
            config['ndk_paths'] = {'r10e': r10e, 'r22b': r22b}
            self.assertEqual(r10e, build.ndk_path())

            build.ndk = ['r10e', 'r22b']
            self.assertEqual(r10e, build.ndk_path())

            build.ndk = ['r22b', 'r10e']
            self.assertEqual(r22b, build.ndk_path())

    def test_build_ndk_path_only_accepts_str(self):
        """Paths in the config must be strings, never pathlib.Path instances"""
        config = {'ndk_paths': {'r24': Path('r24')}}
        fdroidserver.common.config = config
        build = fdroidserver.metadata.Build()
        build.ndk = 'r24'
        with self.assertRaises(TypeError):
            build.ndk_path()

    def test_del_duplicated_NoSourceSince(self):
        app = {
            'AntiFeatures': {'Ads': {}, 'NoSourceSince': {DEFAULT_LOCALE: '1.0'}},
            'NoSourceSince': '1.0',
        }
        metadata._del_duplicated_NoSourceSince(app)
        self.assertEqual(app, {'AntiFeatures': {'Ads': {}}, 'NoSourceSince': '1.0'})

    def test_check_manually_extended_NoSourceSince(self):
        app = {
            'AntiFeatures': {'NoSourceSince': {DEFAULT_LOCALE: '1.0', 'de': '1,0'}},
            'NoSourceSince': '1.0',
        }
        metadata._del_duplicated_NoSourceSince(app)
        self.assertEqual(
            app,
            {
                'AntiFeatures': {'NoSourceSince': {DEFAULT_LOCALE: '1.0', 'de': '1,0'}},
                'NoSourceSince': '1.0',
            },
        )

    def test_make_sure_nosourcesince_does_not_get_written(self):
        appid = 'com.politedroid'
        app = metadata.read_metadata({appid: -1})[appid]
        builds = app['Builds']
        app['Builds'] = [copy.deepcopy(builds[0])]
        mf = io.StringIO()
        metadata.write_yaml(mf, app)
        mf.seek(0)
        self.maxDiff = None
        self.assertEqual(
            mf.read(),
            textwrap.dedent(
                """\
                AntiFeatures:
                  - NonFreeNet
                Categories:
                  - Time
                License: GPL-3.0-only
                SourceCode: https://github.com/miguelvps/PoliteDroid
                IssueTracker: https://github.com/miguelvps/PoliteDroid/issues

                AutoName: Polite Droid
                Summary: Calendar tool
                Description: Activates silent mode during calendar events.

                RepoType: git
                Repo: https://github.com/miguelvps/PoliteDroid.git

                Builds:
                  - versionName: '1.2'
                    versionCode: 3
                    commit: 6a548e4b19
                    target: android-10
                    antifeatures:
                      - KnownVuln
                      - NonFreeAssets
                      - UpstreamNonFree

                ArchivePolicy: 4
                AutoUpdateMode: Version v%v
                UpdateCheckMode: Tags
                CurrentVersion: '1.5'
                CurrentVersionCode: 6

                NoSourceSince: '1.5'
                """
            ),
        )

    def test_app_to_yaml_smokecheck(self):
        self.assertTrue(
            isinstance(metadata._app_to_yaml(dict()), ruamel.yaml.comments.CommentedMap)
        )

    def test_app_to_yaml_build_list_empty(self):
        app = metadata.App({'Builds': [metadata.Build({'rm': []})]})
        self.assertEqual(dict(), metadata._app_to_yaml(app)['Builds'][0])

    def test_app_to_yaml_build_list_one(self):
        app = metadata.App({'Builds': [metadata.Build({'rm': ['one']})]})
        self.assertEqual({'rm': ['one']}, metadata._app_to_yaml(app)['Builds'][0])

    def test_app_to_yaml_build_list_two(self):
        app = metadata.App({'Builds': [metadata.Build({'rm': ['1', '2']})]})
        self.assertEqual({'rm': ['1', '2']}, metadata._app_to_yaml(app)['Builds'][0])

    def test_app_to_yaml_build_list(self):
        app = metadata.App({'Builds': [metadata.Build({'rm': ['b2', 'NO1']})]})
        self.assertEqual({'rm': ['b2', 'NO1']}, metadata._app_to_yaml(app)['Builds'][0])

    def test_app_to_yaml_AllowedAPKSigningKeys_two(self):
        cm = metadata._app_to_yaml(metadata.App({'AllowedAPKSigningKeys': ['b', 'A']}))
        self.assertEqual(['b', 'a'], cm['AllowedAPKSigningKeys'])

    def test_app_to_yaml_AllowedAPKSigningKeys_one(self):
        cm = metadata._app_to_yaml(metadata.App({'AllowedAPKSigningKeys': ['One']}))
        self.assertEqual('one', cm['AllowedAPKSigningKeys'])

    def test_app_to_yaml_int_hex(self):
        cm = metadata._app_to_yaml(metadata.App({'CurrentVersionCode': 0xFF}))
        self.assertEqual(255, cm['CurrentVersionCode'])

    def test_app_to_yaml_int_underscore(self):
        cm = metadata._app_to_yaml(metadata.App({'CurrentVersionCode': 1_2_3}))
        self.assertEqual(123, cm['CurrentVersionCode'])

    def test_app_to_yaml_int_0(self):
        """Document that 0 values fail to make it through."""
        # TODO it should be possible to use `CurrentVersionCode: 0`
        cm = metadata._app_to_yaml(metadata.App({'CurrentVersionCode': 0}))
        self.assertFalse('CurrentVersionCode' in cm)

    def test_format_multiline(self):
        self.assertEqual(metadata._format_multiline('description'), 'description')

    def test_format_multiline_empty(self):
        self.assertEqual(metadata._format_multiline(''), '')

    def test_format_multiline_newline_char(self):
        self.assertEqual(metadata._format_multiline('one\\ntwo'), 'one\\ntwo')

    def test_format_multiline_newlines(self):
        self.assertEqual(
            metadata._format_multiline(
                textwrap.dedent(
                    """
                    one
                    two
                    three
                    """
                )
            ),
            '\none\ntwo\nthree\n',
        )

    def test_format_list_empty(self):
        self.assertEqual(metadata._format_list(['', None]), list())

    def test_format_list_one_empty(self):
        self.assertEqual(metadata._format_list(['foo', None]), ['foo'])

    def test_format_list_two(self):
        self.assertEqual(metadata._format_list(['2', '1']), ['2', '1'])

    def test_format_list_newline(self):
        self.assertEqual(metadata._format_list(['one\ntwo']), ['one\ntwo'])

    def test_format_list_newline_char(self):
        self.assertEqual(metadata._format_list(['one\\ntwo']), ['one\\ntwo'])

    def test_format_script_empty(self):
        self.assertEqual(metadata._format_script(['', None]), list())

    def test_format_script_newline(self):
        self.assertEqual(metadata._format_script(['one\ntwo']), 'one\ntwo')

    def test_format_script_newline_char(self):
        self.assertEqual(metadata._format_script(['one\\ntwo']), 'one\\ntwo')

    def test_format_stringmap_empty(self):
        self.assertEqual(
            metadata._format_stringmap('🔥', 'test', dict()),
            list(),
        )

    def test_format_stringmap_one_list(self):
        self.assertEqual(
            metadata._format_stringmap('🔥', 'test', {'Tracking': {}, 'Ads': {}}),
            ['Ads', 'Tracking'],
        )

    def test_format_stringmap_one_list_empty_desc(self):
        self.assertEqual(
            metadata._format_stringmap('🔥', 'test', {'NonFree': {}, 'Ads': {'en': ''}}),
            ['Ads', 'NonFree'],
        )

    def test_format_stringmap_three_list(self):
        self.assertEqual(
            metadata._format_stringmap('🔥', 'test', {'B': {}, 'A': {}, 'C': {}}),
            ['A', 'B', 'C'],
        )

    def test_format_stringmap_two_dict(self):
        self.assertEqual(
            metadata._format_stringmap('🔥', 'test', {'1': {'uz': 'a'}, '2': {}}),
            {'1': {'uz': 'a'}, '2': {}},
        )

    def test_format_stringmap_three_locales(self):
        self.assertEqual(
            metadata._format_stringmap(
                '🔥', 'test', {'AF': {'uz': 'a', 'ko': 'b', 'zh': 'c'}}
            ),
            {'AF': {'ko': 'b', 'uz': 'a', 'zh': 'c'}},
        )

    def test_format_stringmap_move_build_antifeatures_to_filesystem(self):
        os.chdir(self.testdir)
        appid = 'a'
        yml = Path('metadata/a.yml')
        yml.parent.mkdir()
        self.assertEqual(
            metadata._format_stringmap(
                appid, 'antifeatures', {'AF': {'uz': 'a', 'ko': 'b', 'zh': 'c'}}
            ),
            {'AF': {'ko': 'b', 'uz': 'a', 'zh': 'c'}},
        )

    def test_format_stringmap_app_antifeatures_conflict(self):
        """Raise an error if a YAML Anti-Feature conflicts with a localized file."""
        os.chdir(self.testdir)
        appid = 'a'
        field = 'AntiFeatures'
        locale = 'ko'
        yml = Path('metadata/a.yml')
        antifeatures_ko = yml.parent / appid / locale / field.lower()
        antifeatures_ko.mkdir(parents=True)
        afname = 'Anti-🔥'
        (antifeatures_ko / (afname + '.txt')).write_text('SOMETHING ELSE')
        with self.assertRaises(MetaDataException):
            metadata._format_stringmap(
                appid, field, {afname: {'uz': 'a', locale: 'b', 'zh': 'c'}}
            )

    def test_format_stringmap_app_antifeatures_conflict_same_contents(self):
        """Raise an error if a YAML Anti-Feature conflicts with a localized file."""
        os.chdir(self.testdir)
        appid = 'a'
        field = 'AntiFeatures'
        locale = 'ko'
        yml = Path('metadata/a.yml')
        antifeatures_ko = yml.parent / appid / locale / field.lower()
        antifeatures_ko.mkdir(parents=True)
        afname = 'Anti-🔥'
        (antifeatures_ko / (afname + '.txt')).write_text('b')
        metadata._format_stringmap(
            appid, field, {afname: {'uz': 'a', locale: 'b', 'zh': 'c'}}
        )

    def test_format_stringmap_build_antifeatures_conflict(self):
        """Raise an error if a YAML Anti-Feature conflicts with a localized file."""
        os.chdir(self.testdir)
        appid = 'a'
        field = 'antifeatures'
        locale = 'ko'
        versionCode = 123
        yml = Path('metadata/a.yml')
        antifeatures_ko = yml.parent / appid / locale / field.lower()
        antifeatures_ko.mkdir(parents=True)
        afname = 'Anti-🔥'
        with (antifeatures_ko / ('%d_%s.txt' % (versionCode, afname))).open('w') as fp:
            fp.write('SOMETHING ELSE')
        with self.assertRaises(MetaDataException):
            metadata._format_stringmap(
                appid, field, {afname: {'uz': 'a', locale: 'b', 'zh': 'c'}}, versionCode
            )

    def test_app_to_yaml_one_category(self):
        """Categories does not get simplified to string when outputting YAML."""
        self.assertEqual(
            metadata._app_to_yaml({'Categories': ['one']}),
            {'Categories': ['one']},
        )

    def test_app_to_yaml_categories(self):
        """Sort case-insensitive before outputting YAML."""
        self.assertEqual(
            metadata._app_to_yaml({'Categories': ['c', 'a', 'B']}),
            {'Categories': ['a', 'B', 'c']},
        )

    def test_builds_to_yaml_gradle_yes(self):
        app = {'Builds': [{'versionCode': 0, 'gradle': ['yes']}]}
        self.assertEqual(
            metadata._builds_to_yaml(app), [{'versionCode': 0, 'gradle': ['yes']}]
        )

    def test_builds_to_yaml_gradle_off(self):
        app = {'Builds': [{'versionCode': 0, 'gradle': ['off']}]}
        self.assertEqual(
            metadata._builds_to_yaml(app), [{'versionCode': 0, 'gradle': ['off']}]
        )

    def test_builds_to_yaml_gradle_true(self):
        app = {'Builds': [{'versionCode': 0, 'gradle': ['true']}]}
        self.assertEqual(
            metadata._builds_to_yaml(app), [{'versionCode': 0, 'gradle': ['true']}]
        )

    def test_builds_to_yaml_gradle_false(self):
        app = {'Builds': [{'versionCode': 0, 'gradle': ['false']}]}
        self.assertEqual(
            metadata._builds_to_yaml(app), [{'versionCode': 0, 'gradle': ['false']}]
        )

    def test_builds_to_yaml_stripped(self):
        self.assertEqual(
            metadata._builds_to_yaml(
                {
                    'Builds': [
                        metadata.Build({'versionCode': 0, 'rm': [None], 'init': ['']})
                    ]
                }
            ),
            [{'versionCode': 0}],
        )

    def test_builds_to_yaml(self):
        """Include one of each flag type with a valid value."""
        app = {
            'Builds': [
                metadata.Build(
                    {
                        'versionCode': 0,
                        'gradle': ['free'],
                        'rm': ['0', '2'],
                        'submodules': True,
                        'timeout': 0,
                        'init': ['false', 'two'],
                    }
                )
            ]
        }
        # check that metadata.Build() inited flag values
        self.assertEqual(app['Builds'][0]['scanignore'], list())
        # then unchanged values should be removed by _builds_to_yaml
        self.assertEqual(
            metadata._builds_to_yaml(app),
            [
                {
                    'versionCode': 0,
                    'gradle': ['free'],
                    'rm': ['0', '2'],
                    'submodules': True,
                    'timeout': 0,
                    'init': ['false', 'two'],
                }
            ],
        )


class PostMetadataParseTest(unittest.TestCase):
    """Test the functions that post process the YAML input.

    The following series of "post_metadata_parse" tests map out the
    current state of automatic type conversion in the YAML post
    processing.  They are not necessary a statement of how things
    should be, but more to surface the details of it functions.

    """

    def setUp(self):
        fdroidserver.metadata.warnings_action = 'error'

    def _post_metadata_parse_app_int(self, from_yaml, expected):
        app = {'ArchivePolicy': from_yaml}
        metadata.post_parse_yaml_metadata(app)
        return {'ArchivePolicy': expected}, app

    def _post_metadata_parse_app_list(self, from_yaml, expected):
        app = {'AllowedAPKSigningKeys': from_yaml}
        metadata.post_parse_yaml_metadata(app)
        return {'AllowedAPKSigningKeys': expected}, app

    def _post_metadata_parse_app_string(self, from_yaml, expected):
        app = {'Repo': from_yaml}
        metadata.post_parse_yaml_metadata(app)
        return {'Repo': expected}, app

    def _post_metadata_parse_build_bool(self, from_yaml, expected):
        tested_key = 'submodules'
        app = {'Builds': [{'versionCode': 1, tested_key: from_yaml}]}
        post = copy.deepcopy(app)
        metadata.post_parse_yaml_metadata(post)
        del app['Builds'][0]['versionCode']
        del post['Builds'][0]['versionCode']
        for build in post['Builds']:
            for k in list(build):
                if k != tested_key:
                    del build[k]
        app['Builds'][0][tested_key] = expected
        return app, post

    def _post_metadata_parse_build_int(self, from_yaml, expected):
        tested_key = 'versionCode'
        app = {'Builds': [{'versionCode': from_yaml}]}
        post = copy.deepcopy(app)
        metadata.post_parse_yaml_metadata(post)
        for build in post['Builds']:
            for k in list(build):
                if k != tested_key:
                    del build[k]
        app['Builds'][0][tested_key] = expected
        return app, post

    def _post_metadata_parse_build_list(self, from_yaml, expected):
        tested_key = 'rm'
        app = {'Builds': [{'versionCode': 1, tested_key: from_yaml}]}
        post = copy.deepcopy(app)
        metadata.post_parse_yaml_metadata(post)
        del app['Builds'][0]['versionCode']
        del post['Builds'][0]['versionCode']
        for build in post['Builds']:
            for k in list(build):
                if k != tested_key:
                    del build[k]
        app['Builds'][0][tested_key] = expected
        return app, post

    def _post_metadata_parse_build_script(self, from_yaml, expected):
        tested_key = 'build'
        app = {'Builds': [{'versionCode': 1, tested_key: from_yaml}]}
        post = copy.deepcopy(app)
        metadata.post_parse_yaml_metadata(post)
        del app['Builds'][0]['versionCode']
        del post['Builds'][0]['versionCode']
        for build in post['Builds']:
            for k in list(build):
                if k != tested_key:
                    del build[k]
        app['Builds'][0][tested_key] = expected
        return app, post

    def _post_metadata_parse_build_string(self, from_yaml, expected):
        tested_key = 'commit'
        app = {'Builds': [{'versionCode': 1, tested_key: from_yaml}]}
        post = copy.deepcopy(app)
        metadata.post_parse_yaml_metadata(post)
        del app['Builds'][0]['versionCode']
        del post['Builds'][0]['versionCode']
        for build in post['Builds']:
            for k in list(build):
                if k != tested_key:
                    del build[k]
        app['Builds'][0][tested_key] = expected
        return app, post

    def test_post_metadata_parse_none(self):
        """Run None aka YAML null or blank through the various field and flag types."""
        self.assertEqual(*self._post_metadata_parse_app_int(None, None))
        self.assertEqual(*self._post_metadata_parse_app_list(None, None))
        self.assertEqual(*self._post_metadata_parse_app_string(None, None))
        self.assertEqual(*self._post_metadata_parse_build_bool(None, None))
        self.assertEqual(*self._post_metadata_parse_build_int(None, None))
        self.assertEqual(*self._post_metadata_parse_build_list(None, None))
        self.assertEqual(*self._post_metadata_parse_build_script(None, None))
        self.assertEqual(*self._post_metadata_parse_build_string(None, None))

    def test_post_metadata_parse_int(self):
        """Run the int 123456 through the various field and flag types."""
        self.assertEqual(*self._post_metadata_parse_app_int(123456, 123456))
        self.assertEqual(*self._post_metadata_parse_app_list(123456, ['123456']))
        self.assertEqual(*self._post_metadata_parse_app_string(123456, '123456'))
        self.assertEqual(*self._post_metadata_parse_build_bool(123456, True))
        self.assertEqual(*self._post_metadata_parse_build_int(123456, 123456))
        self.assertEqual(*self._post_metadata_parse_build_list(123456, ['123456']))
        self.assertEqual(*self._post_metadata_parse_build_script(123456, ['123456']))
        self.assertEqual(*self._post_metadata_parse_build_string(123456, '123456'))

    def test_post_metadata_parse_sha256(self):
        """Run a SHA-256 that YAML calls an int through the various types.

        The current f-droid.org signer set has SHA-256 values with a
        maximum of two leading zeros, but this will handle more.

        """
        yaml = ruamel.yaml.YAML(typ='safe', pure=True)
        str_sha256 = '0000000000000498456908409534729834729834729834792837487293847926'
        sha256 = yaml.load('a: ' + str_sha256)['a']
        self.assertEqual(*self._post_metadata_parse_app_int(sha256, int(str_sha256)))
        self.assertEqual(*self._post_metadata_parse_app_list(sha256, [str_sha256]))
        self.assertEqual(*self._post_metadata_parse_app_string(sha256, str_sha256))
        self.assertEqual(*self._post_metadata_parse_build_bool(sha256, True))
        self.assertEqual(*self._post_metadata_parse_build_int(sha256, sha256))
        self.assertEqual(*self._post_metadata_parse_build_list(sha256, [str_sha256]))
        self.assertEqual(*self._post_metadata_parse_build_script(sha256, [str_sha256]))
        self.assertEqual(*self._post_metadata_parse_build_string(sha256, str_sha256))

    def test_post_metadata_parse_int_0(self):
        """Run the int 0 through the various field and flag types."""
        self.assertEqual(*self._post_metadata_parse_app_int(0, 0))
        self.assertEqual(*self._post_metadata_parse_app_list(0, ['0']))
        self.assertEqual(*self._post_metadata_parse_app_string(0, '0'))
        self.assertEqual(*self._post_metadata_parse_build_bool(0, False))
        self.assertEqual(*self._post_metadata_parse_build_int(0, 0))
        self.assertEqual(*self._post_metadata_parse_build_list(0, ['0']))
        self.assertEqual(*self._post_metadata_parse_build_script(0, ['0']))
        self.assertEqual(*self._post_metadata_parse_build_string(0, '0'))

    def test_post_metadata_parse_float_0_0(self):
        """Run the float 0.0 through the various field and flag types."""
        with self.assertRaises(MetaDataException):
            self._post_metadata_parse_app_int(0.0, MetaDataException)
        self.assertEqual(*self._post_metadata_parse_app_list(0.0, ['0.0']))
        self.assertEqual(*self._post_metadata_parse_app_string(0.0, '0.0'))
        self.assertEqual(*self._post_metadata_parse_build_bool(0.0, False))
        with self.assertRaises(MetaDataException):
            self._post_metadata_parse_build_int(0.0, MetaDataException)
        self.assertEqual(*self._post_metadata_parse_build_list(0.0, ['0.0']))
        self.assertEqual(*self._post_metadata_parse_build_script(0.0, ['0.0']))
        self.assertEqual(*self._post_metadata_parse_build_string(0.0, '0.0'))

    def test_post_metadata_parse_float_0_1(self):
        """Run the float 0.1 through the various field and flag types."""
        with self.assertRaises(MetaDataException):
            self._post_metadata_parse_app_int(0.1, MetaDataException)
        self.assertEqual(*self._post_metadata_parse_app_list(0.1, ['0.1']))
        self.assertEqual(*self._post_metadata_parse_app_string(0.1, '0.1'))
        self.assertEqual(*self._post_metadata_parse_build_bool(0.1, True))
        with self.assertRaises(MetaDataException):
            self._post_metadata_parse_build_int(0.1, MetaDataException)
        self.assertEqual(*self._post_metadata_parse_build_list(0.1, ['0.1']))
        self.assertEqual(*self._post_metadata_parse_build_script(0.1, ['0.1']))
        self.assertEqual(*self._post_metadata_parse_build_string(0.1, '0.1'))

    def test_post_metadata_parse_float_1_0(self):
        """Run the float 1.0 through the various field and flag types."""
        with self.assertRaises(MetaDataException):
            self._post_metadata_parse_app_int(1.0, MetaDataException)
        self.assertEqual(*self._post_metadata_parse_app_list(1.0, ['1.0']))
        self.assertEqual(*self._post_metadata_parse_app_string(1.0, '1.0'))
        self.assertEqual(*self._post_metadata_parse_build_bool(1.0, True))
        with self.assertRaises(MetaDataException):
            self._post_metadata_parse_build_int(1.0, MetaDataException)
        self.assertEqual(*self._post_metadata_parse_build_list(1.0, ['1.0']))
        self.assertEqual(*self._post_metadata_parse_build_script(1.0, ['1.0']))
        self.assertEqual(*self._post_metadata_parse_build_string(1.0, '1.0'))

    def test_post_metadata_parse_empty_list(self):
        with self.assertRaises(MetaDataException):
            self._post_metadata_parse_app_int(list(), MetaDataException)
        self.assertEqual(*self._post_metadata_parse_app_list(list(), list()))
        self.assertEqual(*self._post_metadata_parse_app_string(list(), list()))
        self.assertEqual(*self._post_metadata_parse_build_bool(list(), False))
        with self.assertRaises(MetaDataException):
            self._post_metadata_parse_build_int(list(), MetaDataException)
        self.assertEqual(*self._post_metadata_parse_build_list(list(), list()))
        self.assertEqual(*self._post_metadata_parse_build_script(list(), list()))
        self.assertEqual(*self._post_metadata_parse_build_string(list(), list()))

    def test_post_metadata_parse_set_of_1(self):
        with self.assertRaises(MetaDataException):
            self._post_metadata_parse_app_int({1}, MetaDataException)
        self.assertEqual(*self._post_metadata_parse_app_list({1}, ['1']))
        self.assertEqual(*self._post_metadata_parse_app_string({1}, '{1}'))
        self.assertEqual(*self._post_metadata_parse_build_bool({1}, True))
        with self.assertRaises(MetaDataException):
            self._post_metadata_parse_build_int({1}, MetaDataException)
        self.assertEqual(*self._post_metadata_parse_build_list({1}, ['1']))
        self.assertEqual(*self._post_metadata_parse_build_script({1}, ['1']))
        self.assertEqual(*self._post_metadata_parse_build_string({1}, '{1}'))

    def test_post_metadata_parse_empty_dict(self):
        with self.assertRaises(MetaDataException):
            self._post_metadata_parse_app_int(dict(), MetaDataException)
        self.assertEqual(*self._post_metadata_parse_app_list(dict(), dict()))
        self.assertEqual(*self._post_metadata_parse_app_string(dict(), dict()))
        self.assertEqual(*self._post_metadata_parse_build_bool(dict(), False))
        with self.assertRaises(MetaDataException):
            self._post_metadata_parse_build_int(dict(), MetaDataException)
        self.assertEqual(*self._post_metadata_parse_build_list(dict(), dict()))
        self.assertEqual(*self._post_metadata_parse_build_script(dict(), dict()))
        self.assertEqual(*self._post_metadata_parse_build_string(dict(), dict()))

    def test_post_metadata_parse_list_int_string(self):
        with self.assertRaises(MetaDataException):
            self._post_metadata_parse_app_int([1, 'a'], MetaDataException)
        self.assertEqual(*self._post_metadata_parse_app_list([1, 'a'], ['1', 'a']))
        self.assertEqual(*self._post_metadata_parse_app_string([1, 'a'], "[1, 'a']"))
        self.assertEqual(*self._post_metadata_parse_build_bool([1, 'a'], True))
        with self.assertRaises(MetaDataException):
            self._post_metadata_parse_build_int([1, 'a'], MetaDataException)
        self.assertEqual(*self._post_metadata_parse_build_list([1, 'a'], ['1', 'a']))
        self.assertEqual(*self._post_metadata_parse_build_script([1, 'a'], ['1', 'a']))
        self.assertEqual(*self._post_metadata_parse_build_string([1, 'a'], "[1, 'a']"))

    def test_post_metadata_parse_dict_int_string(self):
        with self.assertRaises(MetaDataException):
            self._post_metadata_parse_app_int({'k': 1}, MetaDataException)
        with self.assertRaises(MetaDataException):
            self._post_metadata_parse_app_list({'k': 1}, MetaDataException)
        self.assertEqual(*self._post_metadata_parse_app_string({'k': 1}, "{'k': 1}"))
        self.assertEqual(*self._post_metadata_parse_build_bool({'k': 1}, True))
        with self.assertRaises(MetaDataException):
            self._post_metadata_parse_build_int({'k': 1}, MetaDataException)
        with self.assertRaises(MetaDataException):
            self._post_metadata_parse_build_list({'k': 1}, MetaDataException)
        with self.assertRaises(MetaDataException):
            self._post_metadata_parse_build_script({'k': 1}, MetaDataException)
        self.assertEqual(*self._post_metadata_parse_build_string({'k': 1}, "{'k': 1}"))

    def test_post_metadata_parse_false(self):
        with self.assertRaises(MetaDataException):
            self._post_metadata_parse_app_int(False, MetaDataException)
        self.assertEqual(*self._post_metadata_parse_app_list(False, ['false']))
        self.assertEqual(*self._post_metadata_parse_app_string(False, 'false'))
        self.assertEqual(*self._post_metadata_parse_build_bool(False, False))
        with self.assertRaises(MetaDataException):
            self._post_metadata_parse_build_int(False, MetaDataException)
        self.assertEqual(*self._post_metadata_parse_build_list(False, ['false']))
        self.assertEqual(*self._post_metadata_parse_build_script(False, ['false']))
        self.assertEqual(*self._post_metadata_parse_build_string(False, 'false'))

    def test_post_metadata_parse_true(self):
        with self.assertRaises(MetaDataException):
            self._post_metadata_parse_app_int(True, MetaDataException)
        self.assertEqual(*self._post_metadata_parse_app_list(True, ['true']))
        self.assertEqual(*self._post_metadata_parse_app_string(True, 'true'))
        self.assertEqual(*self._post_metadata_parse_build_bool(True, True))
        with self.assertRaises(MetaDataException):
            self._post_metadata_parse_build_int(True, MetaDataException)
        self.assertEqual(*self._post_metadata_parse_build_list(True, ['true']))
        self.assertEqual(*self._post_metadata_parse_build_script(True, ['true']))
        self.assertEqual(*self._post_metadata_parse_build_string(True, 'true'))


if __name__ == "__main__":
    parser = optparse.OptionParser()
    parser.add_option(
        "-v",
        "--verbose",
        action="store_true",
        default=False,
        help="Spew out even more information than normal",
    )
    (fdroidserver.common.options, args) = parser.parse_args(['--verbose'])

    newSuite = unittest.TestSuite()
    newSuite.addTest(unittest.makeSuite(MetadataTest))
    unittest.main(failfast=False)