kamp/fdroidserver
1
0
Fork 0
mirror of https://gitlab.com/fdroid/fdroidserver.git synced 2024-11-16 20:00:11 +01:00
Code Activity
96ec2da0e7
fdroidserver/tests/update.TestCase
Hans-Christoph Steiner 18f3acc32e split out options from read_config() 
There is no longer any reason for these to be intertwined.

This deliberately avoids touching some files as much as possible because
they are super tangled and due to be replaced.  Those files are:

* fdroidserver/build.py
* fdroidserver/update.py

# Conflicts:
#	tests/testcommon.py

# Conflicts:
#	fdroidserver/btlog.py
#	fdroidserver/import_subcommand.py
2024-05-08 16:26:46 +02:00

2294 lines
100 KiB
Python
Executable File
Raw Blame History

This file contains ambiguous Unicode characters

This file contains Unicode characters that might be confused with other characters. If you think that this is intentional, you can safely ignore this warning. Use the Escape button to reveal them.

#!/usr/bin/env python3
# http://www.drdobbs.com/testing/unit-testing-with-python/240165163
import copy
import git
import glob
import hashlib
import inspect
import json
import logging
import os
import random
import shutil
import string
import subprocess
import sys
import tempfile
import unittest
import yaml
import zipfile
import textwrap
from binascii import hexlify
from datetime import datetime
from pathlib import Path
from unittest import mock
try:
# these were moved in androguard 4.0
from androguard.core.apk import APK
except ImportError:
from androguard.core.bytecodes.apk import APK
try:
from yaml import CSafeLoader as SafeLoader
except ImportError:
from yaml import SafeLoader
try:
from yaml import CFullLoader as FullLoader
except ImportError:
try:
# FullLoader is available from PyYaml 5.1+, as we don't load user
# controlled data here, it's okay to fall back the unsafe older
# Loader
from yaml import FullLoader
except ImportError:
from yaml import Loader as FullLoader
localmodule = os.path.realpath(
os.path.join(os.path.dirname(inspect.getfile(inspect.currentframe())), '..')
)
print('localmodule: ' + localmodule)
if localmodule not in sys.path:
sys.path.insert(0, localmodule)
import fdroidserver.common
import fdroidserver.exception
import fdroidserver.metadata
import fdroidserver.update
from fdroidserver.common import CATEGORIES_CONFIG_NAME
from fdroidserver.looseversion import LooseVersion
from testcommon import TmpCwd, mkdtemp, parse_args_for_test
DONATION_FIELDS = ('Donate', 'Liberapay', 'OpenCollective')
class Options:
allow_disabled_algorithms = False
clean = False
delete_unknown = False
nosign = False
pretty = True
rename_apks = False
verbose = False
class UpdateTest(unittest.TestCase):
'''fdroid update'''
def setUp(self):
logging.basicConfig(level=logging.INFO)
from PIL import PngImagePlugin
logging.getLogger(PngImagePlugin.__name__).setLevel(logging.INFO)
self.basedir = os.path.join(localmodule, 'tests')
os.chdir(self.basedir)
self._td = mkdtemp()
self.testdir = self._td.name
fdroidserver.common.config = None
fdroidserver.common.options = None
def tearDown(self):
os.chdir(self.basedir)
self._td.cleanup()
def test_insert_store_metadata(self):
os.chdir(self.testdir)
config = dict()
fdroidserver.common.fill_config_defaults(config)
fdroidserver.update.config = config
repo_dir = os.path.join(self.basedir, 'repo')
os.mkdir('metadata')
for packageName in (
'obb.mainpatch.current',
'org.videolan.vlc',
):
shutil.copytree(
os.path.join(repo_dir, packageName), os.path.join('repo', packageName)
)
for packageName in (
'info.guardianproject.checkey',
'info.guardianproject.urzip',
'org.smssecure.smssecure',
):
if not os.path.exists('metadata'):
os.mkdir('metadata')
shutil.copytree(
os.path.join(self.basedir, 'metadata', packageName),
os.path.join('metadata', packageName),
)
for packageName in (
'com.nextcloud.client',
'com.nextcloud.client.dev',
'eu.siacs.conversations',
):
shutil.copytree(
os.path.join(self.basedir, 'source-files', packageName),
os.path.join(self.testdir, 'build', packageName),
)
testfilename = 'icon_yAfSvPRJukZzMMfUzvbYqwaD1XmHXNtiPBtuPVHW-6s=.png'
testfile = os.path.join(repo_dir, 'org.videolan.vlc', 'en-US', 'icon.png')
cpdir = os.path.join('metadata', 'org.videolan.vlc', 'en-US')
cpfile = os.path.join(cpdir, testfilename)
os.makedirs(cpdir, exist_ok=True)
shutil.copy(testfile, cpfile)
shutil.copystat(testfile, cpfile)
apps = dict()
for packageName in (
'info.guardianproject.urzip',
'org.videolan.vlc',
'obb.mainpatch.current',
'com.nextcloud.client',
'com.nextcloud.client.dev',
'eu.siacs.conversations',
):
apps[packageName] = fdroidserver.metadata.App()
apps[packageName]['id'] = packageName
apps[packageName]['CurrentVersionCode'] = 0xCAFEBEEF
apps['info.guardianproject.urzip']['CurrentVersionCode'] = 100
buildnextcloudclient = fdroidserver.metadata.Build()
buildnextcloudclient.gradle = ['generic']
apps['com.nextcloud.client']['Builds'] = [buildnextcloudclient]
buildnextclouddevclient = fdroidserver.metadata.Build()
buildnextclouddevclient.gradle = ['versionDev']
apps['com.nextcloud.client.dev']['Builds'] = [buildnextclouddevclient]
build_conversations = fdroidserver.metadata.Build()
build_conversations.gradle = ['free']
apps['eu.siacs.conversations']['Builds'] = [build_conversations]
fdroidserver.update.insert_localized_app_metadata(apps)
fdroidserver.update.ingest_screenshots_from_repo_dir(apps)
appdir = os.path.join('repo', 'info.guardianproject.urzip', 'en-US')
self.assertTrue(
os.path.isfile(
os.path.join(
appdir, 'icon_NJXNzMcyf-v9i5a1ElJi0j9X1LvllibCa48xXYPlOqQ=.png'
)
)
)
self.assertTrue(
os.path.isfile(
os.path.join(
appdir,
'featureGraphic_GFRT5BovZsENGpJq1HqPODGWBRPWQsx25B95Ol5w_wU=.png',
)
)
)
self.assertEqual(6, len(apps))
for packageName, app in apps.items():
self.assertTrue('localized' in app, packageName)
self.assertTrue('en-US' in app['localized'])
self.assertEqual(1, len(app['localized']))
if packageName == 'info.guardianproject.urzip':
self.assertEqual(7, len(app['localized']['en-US']))
self.assertEqual('full description\n', app['localized']['en-US']['description'])
self.assertEqual('title', app['localized']['en-US']['name'])
self.assertEqual('short description', app['localized']['en-US']['summary'])
self.assertEqual('video', app['localized']['en-US']['video'])
self.assertEqual('icon_NJXNzMcyf-v9i5a1ElJi0j9X1LvllibCa48xXYPlOqQ=.png',
app['localized']['en-US']['icon'])
self.assertEqual('featureGraphic_GFRT5BovZsENGpJq1HqPODGWBRPWQsx25B95Ol5w_wU=.png',
app['localized']['en-US']['featureGraphic'])
self.assertEqual('100\n', app['localized']['en-US']['whatsNew'])
elif packageName == 'org.videolan.vlc':
self.assertEqual(testfilename, app['localized']['en-US']['icon'])
self.assertEqual(9, len(app['localized']['en-US']['phoneScreenshots']))
self.assertEqual(15, len(app['localized']['en-US']['sevenInchScreenshots']))
elif packageName == 'obb.mainpatch.current':
self.assertEqual('icon_WI0pkO3LsklrsTAnRr-OQSxkkoMY41lYe2-fAvXLiLg=.png',
app['localized']['en-US']['icon'])
self.assertEqual('featureGraphic_ffhLaojxbGAfu9ROe1MJgK5ux8d0OVc6b65nmvOBaTk=.png',
app['localized']['en-US']['featureGraphic'])
self.assertEqual(1, len(app['localized']['en-US']['phoneScreenshots']))
self.assertEqual(1, len(app['localized']['en-US']['sevenInchScreenshots']))
elif packageName == 'com.nextcloud.client':
self.assertEqual('Nextcloud', app['localized']['en-US']['name'])
self.assertEqual(1073, len(app['localized']['en-US']['description']))
self.assertEqual(78, len(app['localized']['en-US']['summary']))
elif packageName == 'com.nextcloud.client.dev':
self.assertEqual('Nextcloud Dev', app['localized']['en-US']['name'])
self.assertEqual(586, len(app['localized']['en-US']['description']))
self.assertEqual(78, len(app['localized']['en-US']['summary']))
elif packageName == 'eu.siacs.conversations':
self.assertEqual('Conversations', app['localized']['en-US']['name'])
def test_insert_fastlane_default_txt_changelog(self):
"""Test that Fastlane's default.txt is handled properly
https://docs.fastlane.tools/actions/supply/#changelogs-whats-new
"""
os.chdir(self.testdir)
config = dict()
fdroidserver.common.fill_config_defaults(config)
fdroidserver.update.config = config
app = fdroidserver.metadata.App()
app.id = 'com.example.app'
changelogs_dir = 'build/%s/metadata/en-US/changelogs' % app.id
os.makedirs(changelogs_dir)
with open(os.path.join(changelogs_dir, 'default.txt'), 'w') as fp:
fp.write('default')
with open(os.path.join(changelogs_dir, '42.txt'), 'w') as fp:
fp.write('42')
apps = {app.id: app}
build = fdroidserver.metadata.Build()
build.versionCode = 42
app['Builds'] = [build]
fdroidserver.update.insert_localized_app_metadata(apps)
self.assertEqual('default', apps[app.id]['localized']['en-US']['whatsNew'])
app.CurrentVersionCode = 1
fdroidserver.update.insert_localized_app_metadata(apps)
self.assertEqual('default', apps[app.id]['localized']['en-US']['whatsNew'])
app.CurrentVersionCode = 10000
fdroidserver.update.insert_localized_app_metadata(apps)
self.assertEqual('default', apps[app.id]['localized']['en-US']['whatsNew'])
app.CurrentVersionCode = 42
fdroidserver.update.insert_localized_app_metadata(apps)
self.assertEqual('42', apps[app.id]['localized']['en-US']['whatsNew'])
def test_name_title_scraping(self):
"""metadata file --> fdroiddata localized files --> fastlane/triple-t in app source --> APK"""
shutil.copytree(self.basedir, self.testdir, dirs_exist_ok=True)
config = dict()
fdroidserver.common.fill_config_defaults(config)
fdroidserver.common.config = config
fdroidserver.update.config = config
os.chdir(self.testdir)
fdroidserver.common.options = Options
fdroidserver.update.options = fdroidserver.common.options
fdroidserver.update.options.clean = True
fdroidserver.update.options.delete_unknown = True
apps = fdroidserver.metadata.read_metadata()
apps['info.guardianproject.urzip']['CurrentVersionCode'] = 100
knownapks = fdroidserver.common.KnownApks()
apks, cachechanged = fdroidserver.update.process_apks({}, 'repo', knownapks, False)
fdroidserver.update.insert_localized_app_metadata(apps)
fdroidserver.update.ingest_screenshots_from_repo_dir(apps)
fdroidserver.update.apply_info_from_latest_apk(apps, apks)
app = apps['info.guardianproject.urzip']
self.assertIsNone(app.Name)
self.assertTrue('localized' in app)
self.assertEqual('title', app['localized']['en-US']['name'])
self.assertEqual('100\n', app['localized']['en-US']['whatsNew'])
app = apps['org.videolan.vlc']
self.assertIsNone(app.Name)
self.assertTrue('localized' in app)
self.assertFalse('name' in app['localized']['en-US'])
app = apps['info.guardianproject.checkey']
self.assertEqual('Checkey the app!', app.Name)
self.assertTrue('localized' in app)
self.assertEqual('Checkey: info on local apps', app['localized']['en-US']['name'])
self.assertEqual('Checkey: ローカルアプリの情報', app['localized']['ja-JP']['name'])
app = apps['org.adaway']
self.assertIsNone(app.Name)
self.assertFalse('localized' in app)
app = apps['obb.main.twoversions']
self.assertIsNone(app.Name)
self.assertFalse('localized' in app)
def test_insert_missing_app_names_from_apks(self):
"""en-US serves as the final, default, fallback value with index-v1"""
testvalue = 'TESTVALUE!'
apps = {
'none': {},
'name': {'Name': testvalue},
'onlyapk': {'Name': None},
'autoname': {'AutoName': 'autoname', 'Name': None},
'onlylocalized': {'localized': {'en-US': {'name': testvalue}}},
'non_en_us_localized': {'localized': {'de-AT': {'name': 'leiwand'}}},
'apks': {},
}
apks = [
{'packageName': 'none', 'name': '', 'versionCode': 1},
{'packageName': 'name', 'name': 'fromapk', 'versionCode': 1},
{'packageName': 'onlyapk', 'name': testvalue, 'versionCode': 1},
{'packageName': 'autoname', 'name': testvalue, 'versionCode': 1},
{'packageName': 'onlylocalized', 'name': 'fromapk', 'versionCode': 1},
{'packageName': 'non_en_us_localized', 'name': testvalue, 'versionCode': 0xcafe},
{'packageName': 'apks', 'name': 'fromapk1', 'versionCode': 1},
{'packageName': 'apks', 'name': 'fromapk2', 'versionCode': 2},
{'packageName': 'apks', 'name': testvalue, 'versionCode': 3},
]
fdroidserver.common.options = Options
fdroidserver.update.insert_missing_app_names_from_apks(apps, apks)
for appid, app in apps.items():
if appid == 'none':
self.assertIsNone(app.get('Name'))
self.assertIsNone(app.get('localized'))
elif appid == 'onlyapk':
self.assertIsNone(app.get('Name'))
self.assertEqual(testvalue, app['localized']['en-US']['name'])
elif appid == 'autoname':
self.assertIsNone(app.get('Name'))
self.assertEqual(testvalue, app['localized']['en-US']['name'])
elif appid == 'onlylocalized':
self.assertIsNone(app.get('Name'))
self.assertEqual(testvalue, app['localized']['en-US']['name'])
elif appid == 'non_en_us_localized':
self.assertIsNone(app.get('Name'))
self.assertEqual(testvalue, app['localized']['en-US']['name'])
elif appid == 'name':
self.assertEqual(testvalue, app['Name'])
self.assertIsNone(app.get('localized'))
elif appid == 'apks':
self.assertIsNone(app.get('Name'))
self.assertEqual(testvalue, app['localized']['en-US']['name'])
def test_insert_missing_app_names_from_apks_from_repo(self):
os.chdir(self.testdir)
shutil.copytree(self.basedir, self.testdir, dirs_exist_ok=True)
config = dict()
fdroidserver.common.fill_config_defaults(config)
fdroidserver.common.config = config
fdroidserver.update.config = config
fdroidserver.common.options = Options
fdroidserver.update.options = fdroidserver.common.options
fdroidserver.update.options.clean = True
fdroidserver.update.options.delete_unknown = True
apps = fdroidserver.metadata.read_metadata()
knownapks = fdroidserver.common.KnownApks()
apks, cachechanged = fdroidserver.update.process_apks({}, 'repo', knownapks, False)
appid = 'info.guardianproject.checkey'
testapps = {appid: copy.copy(apps[appid])}
self.assertEqual('Checkey the app!', testapps[appid]['Name'])
del testapps[appid]['Name']
fdroidserver.update.insert_missing_app_names_from_apks(testapps, apks)
self.assertIsNone(testapps[appid].get('Name'))
repoapps = fdroidserver.update.prepare_apps(apps, apks, 'repo')
fdroidserver.update.insert_missing_app_names_from_apks(repoapps, apks)
self.assertIsNone(repoapps['com.politedroid']['Name'])
self.assertEqual('Polite Droid',
repoapps['com.politedroid']['localized']['en-US']['name'])
self.assertEqual('Duplicate Permisssions', repoapps['duplicate.permisssions']['Name'])
self.assertEqual('Caffeine Tile', repoapps['info.zwanenburg.caffeinetile']['Name'])
self.assertEqual('No minSdkVersion or targetSdkVersion', repoapps['no.min.target.sdk']['Name'])
self.assertIsNone(repoapps['obb.main.oldversion'].get('Name'))
self.assertEqual('OBB Main Old Version',
repoapps['obb.main.oldversion']['localized']['en-US']['name'])
self.assertIsNone(repoapps['obb.main.twoversions'].get('Name'))
self.assertEqual('OBB Main Two Versions',
repoapps['obb.main.twoversions']['localized']['en-US']['name'])
self.assertIsNone(repoapps['souch.smsbypass'].get('Name'))
self.assertEqual('Battery level',
repoapps['souch.smsbypass']['localized']['en-US']['name'])
self.assertIsNone(repoapps['info.guardianproject.urzip'].get('Name'))
self.assertEqual('title',
repoapps['info.guardianproject.urzip']['localized']['en-US']['name'])
self.assertIsNone(repoapps['obb.mainpatch.current'].get('Name'))
del repoapps['info.guardianproject.urzip']['localized']
fdroidserver.update.insert_missing_app_names_from_apks(repoapps, apks)
self.assertEqual('urzip-πÇÇπÇÇ现代汉语通用字-български-عربي1234',
repoapps['info.guardianproject.urzip']['localized']['en-US']['name'])
def test_insert_triple_t_metadata(self):
importer = os.path.join(self.basedir, 'tmp', 'importer')
packageName = 'org.fdroid.ci.test.app'
if not os.path.isdir(importer):
logging.warning('skipping test_insert_triple_t_metadata, import.TestCase must run first!')
return
packageDir = os.path.join(self.testdir, 'build', packageName)
shutil.copytree(importer, packageDir)
# always use the same commit so these tests work when ci-test-app.git is updated
repo = git.Repo(packageDir)
for remote in repo.remotes:
remote.fetch()
repo.git.reset('--hard', 'b9e5d1a0d8d6fc31d4674b2f0514fef10762ed4f')
repo.git.clean('-fdx')
os.mkdir(os.path.join(self.testdir, 'metadata'))
metadata = dict()
metadata['Description'] = 'This is just a test app'
with open(os.path.join(self.testdir, 'metadata', packageName + '.yml'), 'w') as fp:
yaml.dump(metadata, fp)
config = dict()
fdroidserver.common.fill_config_defaults(config)
fdroidserver.common.config = config
fdroidserver.update.config = config
os.chdir(self.testdir)
apps = fdroidserver.metadata.read_metadata()
fdroidserver.update.copy_triple_t_store_metadata(apps)
# TODO ideally, this would compare the whole dict like in metadata.TestCase's test_read_metadata()
correctlocales = [
'ar', 'ast_ES', 'az', 'ca', 'ca_ES', 'cs-CZ', 'cs_CZ', 'da',
'da-DK', 'de', 'de-DE', 'el', 'en-US', 'es', 'es-ES', 'es_ES', 'et',
'fi', 'fr', 'fr-FR', 'he_IL', 'hi-IN', 'hi_IN', 'hu', 'id', 'it',
'it-IT', 'it_IT', 'iw-IL', 'ja', 'ja-JP', 'kn_IN', 'ko', 'ko-KR',
'ko_KR', 'lt', 'nb', 'nb_NO', 'nl', 'nl-NL', 'no', 'pl', 'pl-PL',
'pl_PL', 'pt', 'pt-BR', 'pt-PT', 'pt_BR', 'ro', 'ro_RO', 'ru-RU',
'ru_RU', 'sv-SE', 'sv_SE', 'te', 'tr', 'tr-TR', 'uk', 'uk_UA', 'vi',
'vi_VN', 'zh-CN', 'zh_CN', 'zh_TW',
]
locales = sorted(list(apps['org.fdroid.ci.test.app']['localized'].keys()))
self.assertEqual(correctlocales, locales)
def test_insert_triple_t_2_metadata(self):
packageName = 'org.piwigo.android'
shutil.copytree(os.path.join(self.basedir, 'triple-t-2'), self.testdir, dirs_exist_ok=True)
os.chdir(self.testdir)
config = dict()
fdroidserver.common.fill_config_defaults(config)
fdroidserver.common.config = config
fdroidserver.update.config = config
apps = fdroidserver.metadata.read_metadata()
self.assertTrue(packageName in apps)
fdroidserver.update.copy_triple_t_store_metadata(apps)
correctlocales = ['de-DE', 'en-US', 'fr-FR', 'kn-IN']
app = apps[packageName]
self.assertEqual('android@piwigo.org', app['authorEmail'])
self.assertEqual('https://www.piwigo.org', app['authorWebSite'])
locales = sorted(list(app['localized'].keys()))
self.assertEqual(correctlocales, locales)
kn_IN = app['localized']['kn-IN']
self.assertTrue('description' in kn_IN)
self.assertTrue('name' in kn_IN)
self.assertTrue('summary' in kn_IN)
en_US = app['localized']['en-US']
self.assertTrue('whatsNew' in en_US)
os.chdir(os.path.join('repo', packageName))
self.assertTrue(os.path.exists(os.path.join('en-US', 'icon.png')))
self.assertTrue(os.path.exists(os.path.join('en-US', 'featureGraphic.png')))
self.assertTrue(os.path.exists(os.path.join('en-US', 'phoneScreenshots', '01_Login.jpg')))
self.assertTrue(os.path.exists(os.path.join('en-US', 'sevenInchScreenshots', '01_Login.png')))
self.assertFalse(os.path.exists(os.path.join('de-DE', 'icon.png')))
self.assertFalse(os.path.exists(os.path.join('de-DE', 'featureGraphic.png')))
self.assertFalse(os.path.exists(os.path.join('de-DE', 'phoneScreenshots', '01_Login.jpg')))
self.assertFalse(os.path.exists(os.path.join('de-DE', 'sevenInchScreenshots', '01_Login.png')))
def test_insert_triple_t_anysoftkeyboard(self):
packages = ('com.anysoftkeyboard.languagepack.dutch', 'com.menny.android.anysoftkeyboard')
names = ('Dutch for AnySoftKeyboard', 'AnySoftKeyboard')
shutil.copytree(os.path.join(self.basedir, 'triple-t-anysoftkeyboard'), self.testdir, dirs_exist_ok=True)
os.chdir(self.testdir)
for packageName, name in zip(packages, names):
config = dict()
fdroidserver.common.fill_config_defaults(config)
fdroidserver.common.config = config
fdroidserver.update.config = config
fdroidserver.update.options = fdroidserver.common.options
apps = fdroidserver.metadata.read_metadata()
self.assertTrue(packageName in apps)
fdroidserver.update.copy_triple_t_store_metadata(apps)
app = apps[packageName]
self.assertEqual(app['localized']['en-US']['name'], name)
def test_insert_triple_t_multiple_metadata(self):
namespace = 'ch.admin.bag.covidcertificate.'
packages = ('verifier', 'wallet')
names = dict(verifier='COVID Certificate Check', wallet='COVID Certificate')
shutil.copytree(os.path.join(self.basedir, 'triple-t-multiple'), self.testdir, dirs_exist_ok=True)
os.chdir(self.testdir)
for p in packages:
packageName = namespace + p
config = dict()
fdroidserver.common.fill_config_defaults(config)
fdroidserver.common.config = config
fdroidserver.update.config = config
fdroidserver.update.options = fdroidserver.common.options
apps = fdroidserver.metadata.read_metadata()
self.assertTrue(packageName in apps)
fdroidserver.update.copy_triple_t_store_metadata(apps)
app = apps[packageName]
self.assertEqual(app['localized']['en-US']['name'], names[p])
def test_insert_triple_t_flutter(self):
packageName = 'fr.emersion.goguma'
shutil.copytree(os.path.join(self.basedir, 'triple-t-flutter'), self.testdir, dirs_exist_ok=True)
os.chdir(self.testdir)
config = dict()
fdroidserver.common.fill_config_defaults(config)
fdroidserver.common.config = config
fdroidserver.update.config = config
fdroidserver.update.options = fdroidserver.common.options
apps = fdroidserver.metadata.read_metadata()
self.assertTrue(packageName in apps)
fdroidserver.update.copy_triple_t_store_metadata(apps)
app = apps[packageName]
self.assertEqual(app['authorWebSite'], 'https://emersion.fr')
self.assertEqual(app['localized']['en-US']['name'], 'Goguma')
self.assertEqual(app['localized']['en-US']['summary'], 'An IRC client for mobile devices')
def testBadGetsig(self):
"""getsig() should still be able to fetch the fingerprint of bad signatures"""
# config needed to use jarsigner and keytool
config = dict()
fdroidserver.common.fill_config_defaults(config)
fdroidserver.update.config = config
apkfile = 'urzip-badsig.apk'
sig = fdroidserver.update.getsig(apkfile)
self.assertEqual(sig, 'e0ecb5fc2d63088e4a07ae410a127722',
"python sig should be: " + str(sig))
apkfile = 'urzip-badcert.apk'
sig = fdroidserver.update.getsig(apkfile)
self.assertEqual(sig, 'e0ecb5fc2d63088e4a07ae410a127722',
"python sig should be: " + str(sig))
def test_getsig(self):
# config needed to use jarsigner and keytool
config = dict()
fdroidserver.common.fill_config_defaults(config)
fdroidserver.update.config = config
sig = fdroidserver.update.getsig('urzip-release-unsigned.apk')
self.assertIsNone(sig)
good_fingerprint = 'b4964fd759edaa54e65bb476d0276880'
apkpath = 'urzip-release.apk' # v1 only
sig = fdroidserver.update.getsig(apkpath)
self.assertEqual(good_fingerprint, sig,
'python sig was: ' + str(sig))
apkpath = 'repo/v1.v2.sig_1020.apk'
sig = fdroidserver.update.getsig(apkpath)
self.assertEqual(good_fingerprint, sig,
'python sig was: ' + str(sig))
# check that v1 and v2 have the same certificate
apkobject = APK(apkpath)
cert_encoded = apkobject.get_certificates_der_v2()[0]
self.assertEqual(good_fingerprint, sig,
hashlib.md5(hexlify(cert_encoded)).hexdigest()) # nosec just used as ID for signing key
filename = 'v2.only.sig_2.apk'
with zipfile.ZipFile(filename) as z:
self.assertTrue('META-INF/MANIFEST.MF' in z.namelist(), 'META-INF/MANIFEST.MF required')
for f in z.namelist():
# ensure there are no v1 signature files
self.assertIsNone(fdroidserver.common.SIGNATURE_BLOCK_FILE_REGEX.match(f))
sig = fdroidserver.update.getsig(filename)
self.assertEqual(good_fingerprint, sig,
"python sig was: " + str(sig))
def testScanApksAndObbs(self):
os.chdir(self.testdir)
shutil.copytree(os.path.join(self.basedir, 'repo'), 'repo')
shutil.copytree(os.path.join(self.basedir, 'metadata'), 'metadata')
config = dict()
fdroidserver.common.fill_config_defaults(config)
config['ndk_paths'] = dict()
fdroidserver.common.config = config
fdroidserver.update.config = config
fdroidserver.common.options = Options
fdroidserver.update.options = fdroidserver.common.options
fdroidserver.update.options.clean = True
fdroidserver.update.options.delete_unknown = True
apps = fdroidserver.metadata.read_metadata()
knownapks = fdroidserver.common.KnownApks()
apks, cachechanged = fdroidserver.update.process_apks({}, 'repo', knownapks, False)
self.assertEqual(len(apks), 17)
apk = apks[1]
self.assertEqual(apk['packageName'], 'com.politedroid')
self.assertEqual(apk['versionCode'], 3)
self.assertEqual(apk['minSdkVersion'], 3)
self.assertIsNone(apk.get('targetSdkVersion'))
self.assertFalse('maxSdkVersion' in apk)
apk = apks[8]
self.assertEqual(apk['packageName'], 'obb.main.oldversion')
self.assertEqual(apk['versionCode'], 1444412523)
self.assertEqual(apk['minSdkVersion'], 4)
self.assertEqual(apk['targetSdkVersion'], 18)
self.assertFalse('maxSdkVersion' in apk)
fdroidserver.update.insert_obbs('repo', apps, apks)
for apk in apks:
if apk['packageName'] == 'obb.mainpatch.current':
self.assertEqual(apk.get('obbMainFile'), 'main.1619.obb.mainpatch.current.obb')
self.assertEqual(apk.get('obbPatchFile'), 'patch.1619.obb.mainpatch.current.obb')
elif apk['packageName'] == 'obb.main.oldversion':
self.assertEqual(apk.get('obbMainFile'), 'main.1434483388.obb.main.oldversion.obb')
self.assertIsNone(apk.get('obbPatchFile'))
elif apk['packageName'] == 'obb.main.twoversions':
self.assertIsNone(apk.get('obbPatchFile'))
if apk['versionCode'] == 1101613:
self.assertEqual(apk.get('obbMainFile'), 'main.1101613.obb.main.twoversions.obb')
elif apk['versionCode'] == 1101615:
self.assertEqual(apk.get('obbMainFile'), 'main.1101615.obb.main.twoversions.obb')
elif apk['versionCode'] == 1101617:
self.assertEqual(apk.get('obbMainFile'), 'main.1101615.obb.main.twoversions.obb')
else:
self.assertTrue(False)
elif apk['packageName'] == 'info.guardianproject.urzip':
self.assertIsNone(apk.get('obbMainFile'))
self.assertIsNone(apk.get('obbPatchFile'))
def test_apkcache_json(self):
"""test the migration from pickle to json"""
os.chdir(self.testdir)
shutil.copytree(os.path.join(self.basedir, 'repo'), 'repo')
config = dict()
fdroidserver.common.fill_config_defaults(config)
config['ndk_paths'] = dict()
fdroidserver.common.config = config
fdroidserver.update.config = config
fdroidserver.common.options = Options
fdroidserver.update.options = fdroidserver.common.options
fdroidserver.update.options.clean = True
fdroidserver.update.options.delete_unknown = True
fdroidserver.metadata.read_metadata()
knownapks = fdroidserver.common.KnownApks()
apkcache = fdroidserver.update.get_cache()
self.assertEqual(2, len(apkcache))
self.assertEqual(fdroidserver.update.METADATA_VERSION, apkcache["METADATA_VERSION"])
self.assertEqual(fdroidserver.update.options.allow_disabled_algorithms,
apkcache['allow_disabled_algorithms'])
apks, cachechanged = fdroidserver.update.process_apks(apkcache, 'repo', knownapks, False)
fdroidserver.update.write_cache(apkcache)
fdroidserver.update.options.clean = False
read_from_json = fdroidserver.update.get_cache()
self.assertEqual(19, len(read_from_json))
for f in glob.glob('repo/*.apk'):
self.assertTrue(os.path.basename(f) in read_from_json)
fdroidserver.update.options.clean = True
reset = fdroidserver.update.get_cache()
self.assertEqual(2, len(reset))
def test_scan_repo_files(self):
config = dict()
fdroidserver.common.fill_config_defaults(config)
fdroidserver.common.config = config
fdroidserver.update.config = config
os.chdir(self.testdir)
os.mkdir('repo')
os.mkdir('stats')
with open(os.path.join('stats', 'known_apks.txt'), 'w') as fp:
fp.write('se.manyver_30.apk se.manyver 2018-10-10\n')
filename = 'Norway_bouvet_europe_2.obf.zip'
shutil.copy(os.path.join(self.basedir, filename), 'repo')
knownapks = fdroidserver.common.KnownApks()
files, fcachechanged = fdroidserver.update.scan_repo_files(dict(), 'repo', knownapks, False)
knownapks.writeifchanged()
self.assertTrue(fcachechanged)
info = files[0]
self.assertEqual(filename, info['apkName'])
self.assertEqual(datetime, type(info['added']))
self.assertEqual(os.path.getsize(os.path.join('repo', filename)), info['size'])
self.assertEqual(
'531190bdbc07e77d5577249949106f32dac7f62d38d66d66c3ae058be53a729d',
info['hash'],
)
def test_read_added_date_from_all_apks(self):
os.chdir(self.testdir)
shutil.copytree(os.path.join(self.basedir, 'repo'), 'repo')
config = dict()
fdroidserver.common.fill_config_defaults(config)
fdroidserver.common.config = config
fdroidserver.update.config = config
fdroidserver.common.options = Options
apps = fdroidserver.metadata.read_metadata()
knownapks = fdroidserver.common.KnownApks()
apks, cachechanged = fdroidserver.update.process_apks({}, 'repo', knownapks)
fdroidserver.update.read_added_date_from_all_apks(apps, apks)
def test_apply_info_from_latest_apk(self):
os.chdir(self.testdir)
shutil.copytree(os.path.join(self.basedir, 'repo'), 'repo')
config = dict()
fdroidserver.common.fill_config_defaults(config)
fdroidserver.common.config = config
fdroidserver.update.config = config
fdroidserver.common.options = Options
fdroidserver.update.options = fdroidserver.common.options
apps = fdroidserver.metadata.read_metadata()
knownapks = fdroidserver.common.KnownApks()
apks, cachechanged = fdroidserver.update.process_apks({}, 'repo', knownapks)
fdroidserver.update.apply_info_from_latest_apk(apps, apks)
def test_scan_apk(self):
config = dict()
fdroidserver.common.fill_config_defaults(config)
fdroidserver.common.config = config
fdroidserver.update.config = config
os.chdir(self.basedir)
if 'apksigner' in config:
apk_info = fdroidserver.update.scan_apk('v2.only.sig_2.apk')
self.assertIsNone(apk_info.get('maxSdkVersion'))
self.assertEqual(apk_info.get('versionName'), 'v2-only')
self.assertEqual(apk_info.get('versionCode'), 2)
else:
print('WARNING: skipping v2-only test since apksigner cannot be found')
apk_info = fdroidserver.update.scan_apk('repo/v1.v2.sig_1020.apk')
self.assertIsNone(apk_info.get('maxSdkVersion'))
self.assertEqual(apk_info.get('versionName'), 'v1+2')
self.assertEqual(apk_info.get('versionCode'), 1020)
apk_info = fdroidserver.update.scan_apk('repo/souch.smsbypass_9.apk')
self.assertIsNone(apk_info.get('maxSdkVersion'))
self.assertEqual(apk_info.get('versionName'), '0.9')
apk_info = fdroidserver.update.scan_apk('repo/duplicate.permisssions_9999999.apk')
self.assertEqual(apk_info.get('versionName'), '')
self.assertEqual(apk_info['icons_src'], {'160': 'res/drawable/ic_launcher.png',
'-1': 'res/drawable/ic_launcher.png'})
apk_info = fdroidserver.update.scan_apk('org.dyndns.fules.ck_20.apk')
self.assertEqual(apk_info['icons_src'], {'240': 'res/drawable-hdpi-v4/icon_launcher.png',
'120': 'res/drawable-ldpi-v4/icon_launcher.png',
'160': 'res/drawable-mdpi-v4/icon_launcher.png',
'-1': 'res/drawable-mdpi-v4/icon_launcher.png'})
self.assertEqual(apk_info['icons'], {})
self.assertEqual(apk_info['features'], [])
self.assertEqual(apk_info['antiFeatures'], dict())
self.assertEqual(apk_info['versionName'], 'v1.6pre2')
self.assertEqual(apk_info['hash'],
'897486e1f857c6c0ee32ccbad0e1b8cd82f6d0e65a44a23f13f852d2b63a18c8')
self.assertEqual(apk_info['packageName'], 'org.dyndns.fules.ck')
self.assertEqual(apk_info['versionCode'], 20)
self.assertEqual(apk_info['size'], 132453)
self.assertEqual(apk_info['nativecode'],
['arm64-v8a', 'armeabi', 'armeabi-v7a', 'mips', 'mips64', 'x86', 'x86_64'])
self.assertEqual(apk_info['minSdkVersion'], 7)
self.assertEqual(apk_info['sig'], '9bf7a6a67f95688daec75eab4b1436ac')
self.assertEqual(apk_info['hashType'], 'sha256')
self.assertEqual(apk_info['targetSdkVersion'], 8)
apk_info = fdroidserver.update.scan_apk('org.bitbucket.tickytacky.mirrormirror_4.apk')
self.assertEqual(apk_info.get('versionName'), '1.0.3')
self.assertEqual(apk_info['icons_src'], {'160': 'res/drawable-mdpi/mirror.png',
'-1': 'res/drawable-mdpi/mirror.png'})
apk_info = fdroidserver.update.scan_apk('repo/info.zwanenburg.caffeinetile_4.apk')
self.assertEqual(apk_info.get('versionName'), '1.3')
self.assertEqual(apk_info['icons_src'], {})
apk_info = fdroidserver.update.scan_apk('repo/com.politedroid_6.apk')
self.assertEqual(apk_info.get('versionName'), '1.5')
self.assertEqual(apk_info['icons_src'], {'120': 'res/drawable-ldpi-v4/icon.png',
'160': 'res/drawable-mdpi-v4/icon.png',
'240': 'res/drawable-hdpi-v4/icon.png',
'320': 'res/drawable-xhdpi-v4/icon.png',
'-1': 'res/drawable-mdpi-v4/icon.png'})
apk_info = fdroidserver.update.scan_apk('SpeedoMeterApp.main_1.apk')
self.assertEqual(apk_info.get('versionName'), '1.0')
self.assertEqual(apk_info['icons_src'], {})
def test_scan_apk_no_min_target(self):
config = dict()
fdroidserver.common.fill_config_defaults(config)
fdroidserver.common.config = config
fdroidserver.update.config = config
apk_info = fdroidserver.update.scan_apk('repo/no.min.target.sdk_987.apk')
self.maxDiff = None
expected = {
'icons': {},
'icons_src': {'-1': 'res/drawable/ic_launcher.png',
'160': 'res/drawable/ic_launcher.png'},
'name': 'No minSdkVersion or targetSdkVersion',
'signer': '32a23624c201b949f085996ba5ed53d40f703aca4989476949cae891022e0ed6',
'hashType': 'sha256',
'packageName': 'no.min.target.sdk',
'features': [],
'antiFeatures': dict(),
'size': 14102,
'sig': 'b4964fd759edaa54e65bb476d0276880',
'versionName': '1.2-fake',
'uses-permission-sdk-23': [],
'hash': 'e2e1dc1d550df2b5bc383860139207258645b5540abeccd305ed8b2cb6459d2c',
'versionCode': 987,
'minSdkVersion': 3,
'uses-permission': [
fdroidserver.update.UsesPermission(name='android.permission.WRITE_EXTERNAL_STORAGE',
maxSdkVersion=None),
fdroidserver.update.UsesPermission(name='android.permission.READ_PHONE_STATE',
maxSdkVersion=None),
fdroidserver.update.UsesPermission(name='android.permission.READ_EXTERNAL_STORAGE',
maxSdkVersion=None),
],
}
if config.get('ipfs_cid'):
expected['ipfsCIDv1'] = 'bafybeidwxseoagnew3gtlasttqovl7ciuwxaud5a5p4a5pzpbrfcfj2gaa'
self.assertDictEqual(apk_info, expected)
def test_scan_apk_no_sig(self):
config = dict()
fdroidserver.common.fill_config_defaults(config)
fdroidserver.common.config = config
fdroidserver.update.config = config
os.chdir(self.basedir)
if os.path.basename(os.getcwd()) != 'tests':
raise Exception('This test must be run in the "tests/" subdir')
with self.assertRaises(fdroidserver.exception.BuildException):
fdroidserver.update.scan_apk('urzip-release-unsigned.apk')
def test_scan_apk_bad_zip(self):
config = dict()
fdroidserver.common.fill_config_defaults(config)
fdroidserver.common.config = config
fdroidserver.update.config = config
os.chdir(self.testdir)
os.mkdir('repo')
apkfile = 'repo/badzip_1.apk'
with open(apkfile, 'w') as fp:
fp.write('this is not a zip file')
with self.assertRaises(fdroidserver.exception.BuildException):
fdroidserver.update.scan_apk(apkfile)
@unittest.skipUnless(
os.path.exists('tests/SystemWebView-repack.apk'), "file too big for sdist"
)
def test_scan_apk_bad_icon_id(self):
"""Some APKs can produce an exception when extracting the icon
This kind of parsing exception should be reported then ignored
so that working APKs can be included in the index. There are
so many weird things that make it into APKs, that does not
automatically disqualify them from inclusion. For example:
ValueError: invalid literal for int() with base 16: '<0x801FF, type 0x07>'
The test APK was made from:
https://gitlab.com/fdroid/fdroidserver/-/merge_requests/1018#note_690565333
It was then stripped down by doing:
* mkdir SystemWebView
* cd SystemWebView/
* unzip ../SystemWebView.apk
* rm -rf META-INF/ lib assets/icudtl.dat assets/stored-locales/
* jar cf ../SystemWebView-repack.apk *
"""
# reset the state, perhaps this should be in setUp()
config = dict()
fdroidserver.common.fill_config_defaults(config)
fdroidserver.common.config = config
fdroidserver.update.config = config
with tempfile.TemporaryDirectory() as tmpdir, TmpCwd(tmpdir):
os.mkdir('repo')
apkfile = 'repo/SystemWebView-repack.apk'
shutil.copy(os.path.join(self.basedir, os.path.basename(apkfile)), apkfile)
fdroidserver.update.scan_apk(apkfile)
def test_scan_apk_bad_namespace_in_manifest(self):
"""Some APKs can produce an exception when parsing the AndroidManifest.xml
This kind of parsing exception should be reported then ignored
so that working APKs can be included in the index. There are
so many weird things that make it into APKs, that does not
automatically disqualify them from inclusion.
This APK has <uses-permission> elements with messed up namespaces:
<uses-permission xmlns:n1="android" n1:name="android.permission.VIBRATE"/>
"""
# reset the state, perhaps this should be in setUp()
config = dict()
fdroidserver.common.fill_config_defaults(config)
fdroidserver.common.config = config
fdroidserver.update.config = config
with tempfile.TemporaryDirectory() as tmpdir, TmpCwd(tmpdir):
os.mkdir('repo')
apkfile = 'repo/org.sajeg.fallingblocks_3.apk'
shutil.copy(os.path.join(self.basedir, os.path.basename(apkfile)), apkfile)
fdroidserver.update.scan_apk(apkfile)
def test_process_apk(self):
def _build_yaml_representer(dumper, data):
'''Creates a YAML representation of a Build instance'''
return dumper.represent_dict(data)
os.chdir(self.testdir)
shutil.copytree(self.basedir, 'tests')
config = dict()
fdroidserver.common.fill_config_defaults(config)
fdroidserver.common.config = config
fdroidserver.update.config = config
os.chdir("tests")
config['ndk_paths'] = dict()
fdroidserver.common.config = config
fdroidserver.update.config = config
fdroidserver.common.options = Options
fdroidserver.update.options = fdroidserver.common.options
fdroidserver.update.options.clean = True
fdroidserver.update.options.delete_unknown = True
for icon_dir in fdroidserver.update.get_all_icon_dirs('repo'):
if not os.path.exists(icon_dir):
os.makedirs(icon_dir)
knownapks = fdroidserver.common.KnownApks()
apkList = ['../urzip.apk', '../org.dyndns.fules.ck_20.apk']
for apkName in apkList:
_, apk, cachechanged = fdroidserver.update.process_apk({}, apkName, 'repo', knownapks,
False)
# Don't care about the date added to the repo and relative apkName
self.assertEqual(datetime, type(apk['added']))
del apk['added']
del apk['apkName']
# ensure that icons have been extracted properly
if apkName == '../urzip.apk':
self.assertEqual(apk['icon'], 'info.guardianproject.urzip.100.png')
if apkName == '../org.dyndns.fules.ck_20.apk':
self.assertEqual(apk['icon'], 'org.dyndns.fules.ck.20.png')
for density in fdroidserver.update.screen_densities:
icon_path = os.path.join(
fdroidserver.update.get_icon_dir('repo', density), apk['icon']
)
self.assertTrue(os.path.isfile(icon_path))
self.assertTrue(os.path.getsize(icon_path) > 1)
savepath = os.path.join('metadata', 'apk', apk['packageName'] + '.yaml')
# Uncomment to save APK metadata
# with open(savepath, 'w') as f:
# yaml.add_representer(fdroidserver.metadata.Build, _build_yaml_representer)
# yaml.dump(apk, f, default_flow_style=False)
# CFullLoader doesn't always work
# https://github.com/yaml/pyyaml/issues/266#issuecomment-559116876
TestLoader = FullLoader
try:
testyaml = '- !!python/object/new:fdroidserver.update.UsesPermission\n - test\n - null'
from_yaml = yaml.load(testyaml, Loader=TestLoader)
except yaml.constructor.ConstructorError:
from yaml import UnsafeLoader as TestLoader
with open(savepath, 'r') as f:
from_yaml = yaml.load(f, Loader=TestLoader)
self.maxDiff = None
if not config.get('ipfs_cid'):
del from_yaml['ipfsCIDv1'] # handle when ipfs_cid is not installed
self.assertEqual(apk, from_yaml)
def test_process_apk_signed_by_disabled_algorithms(self):
config = dict()
fdroidserver.common.fill_config_defaults(config)
fdroidserver.update.config = config
config['ndk_paths'] = dict()
fdroidserver.common.config = config
fdroidserver.update.config = config
fdroidserver.common.options = Options
fdroidserver.update.options = fdroidserver.common.options
fdroidserver.update.options.clean = True
fdroidserver.update.options.verbose = True
fdroidserver.update.options.delete_unknown = True
knownapks = fdroidserver.common.KnownApks()
with tempfile.TemporaryDirectory() as tmptestsdir, TmpCwd(tmptestsdir):
os.mkdir('repo')
os.mkdir('archive')
# setup the repo, create icons dirs, etc.
fdroidserver.update.process_apks({}, 'repo', knownapks)
fdroidserver.update.process_apks({}, 'archive', knownapks)
disabledsigs = ['org.bitbucket.tickytacky.mirrormirror_2.apk']
for apkName in disabledsigs:
shutil.copy(os.path.join(self.basedir, apkName),
os.path.join(tmptestsdir, 'repo'))
skip, apk, cachechanged = fdroidserver.update.process_apk({}, apkName, 'repo',
knownapks,
allow_disabled_algorithms=True,
archive_bad_sig=False)
self.assertFalse(skip)
self.assertIsNotNone(apk)
self.assertTrue(cachechanged)
self.assertFalse(os.path.exists(os.path.join('archive', apkName)))
self.assertTrue(os.path.exists(os.path.join('repo', apkName)))
if os.path.exists('/usr/bin/apksigner') or 'apksigner' in config:
print('SKIPPING: apksigner installed and it allows MD5 signatures')
return
javac = config['jarsigner'].replace('jarsigner', 'javac')
v = subprocess.check_output([javac, '-version'], stderr=subprocess.STDOUT)[6:-1].decode('utf-8')
if LooseVersion(v) < LooseVersion('1.8.0_132'):
print('SKIPPING: running tests with old Java (' + v + ')')
return
# this test only works on systems with fully updated Java/jarsigner
# that has MD5 listed in jdk.jar.disabledAlgorithms in java.security
# https://blogs.oracle.com/java-platform-group/oracle-jre-will-no-longer-trust-md5-signed-code-by-default
skip, apk, cachechanged = fdroidserver.update.process_apk({}, apkName, 'repo',
knownapks,
allow_disabled_algorithms=False,
archive_bad_sig=True)
self.assertTrue(skip)
self.assertIsNone(apk)
self.assertFalse(cachechanged)
self.assertTrue(os.path.exists(os.path.join('archive', apkName)))
self.assertFalse(os.path.exists(os.path.join('repo', apkName)))
skip, apk, cachechanged = fdroidserver.update.process_apk({}, apkName, 'archive',
knownapks,
allow_disabled_algorithms=False,
archive_bad_sig=False)
self.assertFalse(skip)
self.assertIsNotNone(apk)
self.assertTrue(cachechanged)
self.assertTrue(os.path.exists(os.path.join('archive', apkName)))
self.assertFalse(os.path.exists(os.path.join('repo', apkName)))
# ensure that icons have been moved to the archive as well
for density in fdroidserver.update.screen_densities:
icon_path = os.path.join(fdroidserver.update.get_icon_dir('archive', density),
apk['icon'])
self.assertTrue(os.path.isfile(icon_path))
self.assertTrue(os.path.getsize(icon_path) > 1)
badsigs = ['urzip-badcert.apk', 'urzip-badsig.apk', 'urzip-release-unsigned.apk', ]
for apkName in badsigs:
shutil.copy(os.path.join(self.basedir, apkName),
os.path.join(self.testdir, 'repo'))
skip, apk, cachechanged = fdroidserver.update.process_apk({}, apkName, 'repo',
knownapks,
allow_disabled_algorithms=False,
archive_bad_sig=False)
self.assertTrue(skip)
self.assertIsNone(apk)
self.assertFalse(cachechanged)
def test_process_invalid_apk(self):
os.chdir(self.basedir)
if os.path.basename(os.getcwd()) != 'tests':
raise Exception('This test must be run in the "tests/" subdir')
config = dict()
fdroidserver.common.fill_config_defaults(config)
fdroidserver.common.config = config
fdroidserver.update.config = config
fdroidserver.common.options = Options
fdroidserver.update.options = fdroidserver.common.options
fdroidserver.update.options.delete_unknown = False
knownapks = fdroidserver.common.KnownApks()
apk = 'fake.ota.update_1234.zip' # this is not an APK, scanning should fail
(skip, apk, cachechanged) = fdroidserver.update.process_apk({}, apk, 'repo', knownapks,
False)
self.assertTrue(skip)
self.assertIsNone(apk)
self.assertFalse(cachechanged)
def test_get_apks_without_allowed_signatures(self):
"""Test when no AllowedAPKSigningKeys is specified"""
os.chdir(self.testdir)
shutil.copytree(os.path.join(self.basedir, 'repo'), 'repo')
config = dict()
fdroidserver.common.fill_config_defaults(config)
fdroidserver.common.config = config
fdroidserver.common.options = Options
fdroidserver.update.options = fdroidserver.common.options
app = fdroidserver.metadata.App()
knownapks = fdroidserver.common.KnownApks()
apks, cachechanged = fdroidserver.update.process_apks({}, 'repo', knownapks)
apkfile = 'v1.v2.sig_1020.apk'
(skip, apk, cachechanged) = fdroidserver.update.process_apk(
{}, apkfile, 'repo', knownapks, False
)
r = fdroidserver.update.get_apks_without_allowed_signatures(app, apk)
self.assertIsNone(r)
def test_get_apks_without_allowed_signatures_allowed(self):
"""Test when the APK matches the specified AllowedAPKSigningKeys"""
os.chdir(self.testdir)
shutil.copytree(os.path.join(self.basedir, 'repo'), 'repo')
config = dict()
fdroidserver.common.fill_config_defaults(config)
fdroidserver.common.config = config
fdroidserver.common.options = Options
fdroidserver.update.options = fdroidserver.common.options
app = fdroidserver.metadata.App(
{
'AllowedAPKSigningKeys': '32a23624c201b949f085996ba5ed53d40f703aca4989476949cae891022e0ed6'
}
)
knownapks = fdroidserver.common.KnownApks()
apks, cachechanged = fdroidserver.update.process_apks({}, 'repo', knownapks)
apkfile = 'v1.v2.sig_1020.apk'
(skip, apk, cachechanged) = fdroidserver.update.process_apk(
{}, apkfile, 'repo', knownapks, False
)
r = fdroidserver.update.get_apks_without_allowed_signatures(app, apk)
self.assertIsNone(r)
def test_get_apks_without_allowed_signatures_blocked(self):
"""Test when the APK does not match any specified AllowedAPKSigningKeys"""
os.chdir(self.testdir)
shutil.copytree(os.path.join(self.basedir, 'repo'), 'repo')
config = dict()
fdroidserver.common.fill_config_defaults(config)
fdroidserver.common.config = config
fdroidserver.common.options = Options
fdroidserver.update.options = fdroidserver.common.options
app = fdroidserver.metadata.App(
{
'AllowedAPKSigningKeys': 'fa4edeadfa4edeadfa4edeadfa4edeadfa4edeadfa4edeadfa4edeadfa4edead'
}
)
knownapks = fdroidserver.common.KnownApks()
apks, cachechanged = fdroidserver.update.process_apks({}, 'repo', knownapks)
apkfile = 'v1.v2.sig_1020.apk'
(skip, apk, cachechanged) = fdroidserver.update.process_apk(
{}, apkfile, 'repo', knownapks, False
)
r = fdroidserver.update.get_apks_without_allowed_signatures(app, apk)
self.assertEqual(apkfile, r)
def test_update_with_AllowedAPKSigningKeys(self):
"""Test that APKs without allowed signatures get deleted."""
os.chdir(self.testdir)
os.mkdir('repo')
testapk = os.path.join('repo', 'com.politedroid_6.apk')
shutil.copy(os.path.join(self.basedir, testapk), testapk)
os.mkdir('metadata')
metadatafile = os.path.join('metadata', 'com.politedroid.yml')
# Copy and manipulate metadata file
shutil.copy(os.path.join(self.basedir, metadatafile), metadatafile)
with open(metadatafile, 'a') as fp:
fp.write(
'\n\nAllowedAPKSigningKeys: 32a23624c201b949f085996ba5ed53d40f703aca4989476949cae891022e0ed6\n'
)
# Set up options
fdroidserver.common.options = Options
config = fdroidserver.common.read_config()
if 'apksigner' not in config: # TODO remove me for buildserver-bullseye
self.skipTest('SKIPPING test_update_with_AllowedAPKSigningKeys, apksigner not installed!')
config['repo_keyalias'] = 'sova'
config['keystorepass'] = 'r9aquRHYoI8+dYz6jKrLntQ5/NJNASFBacJh7Jv2BlI='
config['keypass'] = 'r9aquRHYoI8+dYz6jKrLntQ5/NJNASFBacJh7Jv2BlI='
config['keystore'] = os.path.join(self.basedir, 'keystore.jks')
self.assertTrue(os.path.exists(testapk))
# Test for non-deletion
with mock.patch('sys.argv', ['fdroid update', '--delete-unknown']):
fdroidserver.update.main()
self.assertTrue(os.path.exists(testapk))
# Copy and manipulate metadata file again
shutil.copy(os.path.join(self.basedir, metadatafile), metadatafile)
with open(metadatafile, 'a') as fp:
fp.write(
'\n\nAllowedAPKSigningKeys: fa4edeadfa4edeadfa4edeadfa4edeadfa4edeadfa4edeadfa4edeadfa4edead\n'
)
# Test for deletion
with mock.patch('sys.argv', ['fdroid update', '--delete-unknown']):
fdroidserver.update.main()
self.assertFalse(os.path.exists(testapk))
def test_translate_per_build_anti_features(self):
os.chdir(self.testdir)
shutil.copytree(os.path.join(self.basedir, 'repo'), 'repo')
shutil.copytree(os.path.join(self.basedir, 'metadata'), 'metadata')
config = dict()
fdroidserver.common.fill_config_defaults(config)
config['ndk_paths'] = dict()
fdroidserver.common.config = config
fdroidserver.update.config = config
fdroidserver.common.options = Options
fdroidserver.update.options = fdroidserver.common.options
fdroidserver.update.options.clean = True
fdroidserver.update.options.delete_unknown = True
apps = fdroidserver.metadata.read_metadata()
knownapks = fdroidserver.common.KnownApks()
apks, cachechanged = fdroidserver.update.process_apks({}, 'repo', knownapks, False)
fdroidserver.update.translate_per_build_anti_features(apps, apks)
self.assertEqual(len(apks), 17)
foundtest = False
for apk in apks:
if apk['packageName'] == 'com.politedroid' and apk['versionCode'] == 3:
antiFeatures = apk.get('antiFeatures')
self.assertTrue('KnownVuln' in antiFeatures)
self.assertEqual(3, len(antiFeatures))
foundtest = True
self.assertTrue(foundtest)
def test_create_metadata_from_template(self):
os.chdir(self.testdir)
os.mkdir('repo')
os.mkdir('metadata')
shutil.copy(os.path.join(localmodule, 'tests', 'urzip.apk'), 'repo')
config = dict()
fdroidserver.common.fill_config_defaults(config)
config['ndk_paths'] = dict()
fdroidserver.common.config = config
fdroidserver.update.config = config
fdroidserver.common.options = Options
fdroidserver.update.options = fdroidserver.common.options
fdroidserver.update.options.clean = True
knownapks = fdroidserver.common.KnownApks()
apks, cachechanged = fdroidserver.update.process_apks({}, 'repo', knownapks, False)
self.assertEqual(1, len(apks))
apk = apks[0]
testfile = 'metadata/info.guardianproject.urzip.yml'
# create empty 0 byte .yml file, run read_metadata, it should work
open(testfile, 'a').close()
apps = fdroidserver.metadata.read_metadata()
self.assertEqual(1, len(apps))
os.remove(testfile)
# test using internal template
apps = fdroidserver.metadata.read_metadata()
self.assertEqual(0, len(apps))
fdroidserver.update.create_metadata_from_template(apk)
self.assertTrue(os.path.exists(testfile))
apps = fdroidserver.metadata.read_metadata()
self.assertEqual(1, len(apps))
for app in apps.values():
self.assertEqual('urzip', app['Name'])
self.assertEqual(1, len(app['Categories']))
break
# test using external template.yml
os.remove(testfile)
self.assertFalse(os.path.exists(testfile))
shutil.copy(os.path.join(localmodule, 'examples', 'template.yml'), self.testdir)
fdroidserver.update.create_metadata_from_template(apk)
self.assertTrue(os.path.exists(testfile))
apps = fdroidserver.metadata.read_metadata()
self.assertEqual(1, len(apps))
for app in apps.values():
self.assertEqual('urzip', app['Name'])
self.assertEqual(1, len(app['Categories']))
self.assertEqual('Internet', app['Categories'][0])
break
with open(testfile) as fp:
data = yaml.load(fp, Loader=SafeLoader)
self.assertEqual('urzip', data['Name'])
self.assertEqual('urzip', data['Summary'])
def test_has_known_vulnerability(self):
good = [
'org.bitbucket.tickytacky.mirrormirror_1.apk',
'org.bitbucket.tickytacky.mirrormirror_2.apk',
'org.bitbucket.tickytacky.mirrormirror_3.apk',
'org.bitbucket.tickytacky.mirrormirror_4.apk',
'org.dyndns.fules.ck_20.apk',
'urzip.apk',
'urzip-badcert.apk',
'urzip-badsig.apk',
'urzip-release.apk',
'urzip-release-unsigned.apk',
'repo/com.politedroid_3.apk',
'repo/com.politedroid_4.apk',
'repo/com.politedroid_5.apk',
'repo/com.politedroid_6.apk',
'repo/obb.main.oldversion_1444412523.apk',
'repo/obb.mainpatch.current_1619_another-release-key.apk',
'repo/obb.mainpatch.current_1619.apk',
'repo/obb.main.twoversions_1101613.apk',
'repo/obb.main.twoversions_1101615.apk',
'repo/obb.main.twoversions_1101617.apk',
'repo/urzip-; Рахма́, [rɐxˈmanʲɪnəf] سيرجي_رخمانينوف 谢·.apk',
]
for f in good:
self.assertFalse(fdroidserver.update.has_known_vulnerability(f))
with self.assertRaises(fdroidserver.exception.FDroidException):
fdroidserver.update.has_known_vulnerability('janus.apk')
def test_get_apk_icon_when_src_is_none(self):
config = dict()
fdroidserver.common.fill_config_defaults(config)
fdroidserver.common.config = config
fdroidserver.update.config = config
# pylint: disable=protected-access
icons_src = fdroidserver.update._get_apk_icons_src('urzip-release.apk', None)
assert not icons_src
def test_strip_and_copy_image(self):
in_file = os.path.join(self.basedir, 'metadata', 'info.guardianproject.urzip', 'en-US', 'images', 'icon.png')
out_file = os.path.join(self.testdir, 'icon.png')
fdroidserver.update._strip_and_copy_image(in_file, out_file)
self.assertTrue(os.path.exists(out_file))
in_file = os.path.join(self.basedir, 'corrupt-featureGraphic.png')
out_file = os.path.join(self.testdir, 'corrupt-featureGraphic.png')
fdroidserver.update._strip_and_copy_image(in_file, out_file)
self.assertFalse(os.path.exists(out_file))
def test_create_metadata_from_template_empty_keys(self):
apk = {'packageName': 'rocks.janicerand'}
with tempfile.TemporaryDirectory() as tmpdir, TmpCwd(tmpdir):
os.mkdir('metadata')
with open('template.yml', 'w') as f:
f.write(
textwrap.dedent(
'''\
Disabled:
License:
AuthorName:
AuthorEmail:
AuthorWebSite:
WebSite:
SourceCode:
IssueTracker:
Translation:
Changelog:
Donate:
FlattrID:
Bitcoin:
Litecoin:
Name:
AutoName:
Summary:
RequiresRoot:
RepoType:
Repo:
Binaries:
Builds:
ArchivePolicy:
AutoUpdateMode:
UpdateCheckMode:
UpdateCheckIgnore:
VercodeOperation:
UpdateCheckName:
UpdateCheckData:
CurrentVersion:
CurrentVersionCode:
NoSourceSince:
'''
)
)
fdroidserver.update.create_metadata_from_template(apk)
with open(os.path.join('metadata', 'rocks.janicerand.yml')) as f:
metadata_content = yaml.load(f, Loader=SafeLoader)
self.maxDiff = None
self.assertDictEqual(
metadata_content,
{
'ArchivePolicy': None,
'AuthorEmail': '',
'AuthorName': '',
'AuthorWebSite': '',
'AutoName': 'rocks.janicerand',
'AutoUpdateMode': '',
'Binaries': '',
'Bitcoin': '',
'Builds': None,
'Changelog': '',
'CurrentVersion': '',
'CurrentVersionCode': None,
'Disabled': '',
'Donate': '',
'FlattrID': '',
'IssueTracker': '',
'License': '',
'Litecoin': '',
'Name': 'rocks.janicerand',
'NoSourceSince': '',
'Repo': '',
'RepoType': '',
'RequiresRoot': None,
'SourceCode': '',
'Summary': 'rocks.janicerand',
'Translation': '',
'UpdateCheckData': '',
'UpdateCheckIgnore': '',
'UpdateCheckMode': '',
'UpdateCheckName': '',
'VercodeOperation': None,
'WebSite': '',
},
)
def test_insert_funding_yml_donation_links(self):
os.chdir(self.testdir)
os.mkdir('build')
content = textwrap.dedent(
"""
community_bridge: ''
custom: [LINK1, LINK2]
github: USERNAME
issuehunt: USERNAME
ko_fi: USERNAME
liberapay: USERNAME
open_collective: USERNAME
otechie: USERNAME
patreon: USERNAME
"""
)
app = fdroidserver.metadata.App()
app.id = 'fake.app.id'
apps = {app.id: app}
os.mkdir(os.path.join('build', app.id))
fdroidserver.update.insert_funding_yml_donation_links(apps)
for field in DONATION_FIELDS:
self.assertFalse(app.get(field))
with open(os.path.join('build', app.id, 'FUNDING.yml'), 'w') as fp:
fp.write(content)
fdroidserver.update.insert_funding_yml_donation_links(apps)
for field in DONATION_FIELDS:
self.assertIsNotNone(app.get(field), field)
self.assertEqual('LINK1', app.get('Donate'))
self.assertEqual('USERNAME', app.get('Liberapay'))
self.assertEqual('USERNAME', app.get('OpenCollective'))
app['Donate'] = 'keepme'
app['Liberapay'] = 'keepme'
app['OpenCollective'] = 'keepme'
fdroidserver.update.insert_funding_yml_donation_links(apps)
for field in DONATION_FIELDS:
self.assertEqual('keepme', app.get(field))
def test_insert_funding_yml_donation_links_one_at_a_time(self):
"""Exercise the FUNDING.yml code one entry at a time"""
os.chdir(self.testdir)
os.mkdir('build')
app = fdroidserver.metadata.App()
app.id = 'fake.app.id'
apps = {app.id: app}
os.mkdir(os.path.join('build', app.id))
fdroidserver.update.insert_funding_yml_donation_links(apps)
for field in DONATION_FIELDS:
self.assertIsNone(app.get(field))
content = textwrap.dedent(
"""
community_bridge: 'blah-de-blah'
github: USERNAME
issuehunt: USERNAME
ko_fi: USERNAME
liberapay: USERNAME
open_collective: USERNAME
patreon: USERNAME
"""
)
for line in content.split('\n'):
if not line:
continue
app = fdroidserver.metadata.App()
app.id = 'fake.app.id'
apps = {app.id: app}
with open(os.path.join('build', app.id, 'FUNDING.yml'), 'w') as fp:
fp.write(line)
data = yaml.load(line, Loader=SafeLoader)
fdroidserver.update.insert_funding_yml_donation_links(apps)
if 'liberapay' in data:
self.assertEqual(data['liberapay'], app.get('Liberapay'))
elif 'open_collective' in data:
self.assertEqual(data['open_collective'], app.get('OpenCollective'))
else:
for v in data.values():
self.assertEqual(app.get('Donate', '').split('/')[-1], v)
def test_insert_funding_yml_donation_links_with_corrupt_file(self):
os.chdir(self.testdir)
os.mkdir('build')
app = fdroidserver.metadata.App()
app.id = 'fake.app.id'
apps = {app.id: app}
os.mkdir(os.path.join('build', app.id))
with open(os.path.join('build', app.id, 'FUNDING.yml'), 'w') as fp:
fp.write(
textwrap.dedent(
"""
opencollective: foo
custom: []
liberapay: :
"""
)
)
fdroidserver.update.insert_funding_yml_donation_links(apps)
for field in DONATION_FIELDS:
self.assertIsNone(app.get(field))
def test_sanitize_funding_yml(self):
with open(os.path.join(self.basedir, 'funding-usernames.yaml')) as fp:
data = yaml.load(fp, Loader=SafeLoader)
for k, entries in data.items():
for entry in entries:
if k in 'custom':
m = fdroidserver.update.sanitize_funding_yml_entry(entry)
else:
m = fdroidserver.update.sanitize_funding_yml_name(entry)
if k == 'bad':
self.assertIsNone(m)
else:
self.assertIsNotNone(m)
self.assertIsNone(fdroidserver.update.sanitize_funding_yml_entry('foo\nbar'))
self.assertIsNone(fdroidserver.update.sanitize_funding_yml_entry(
''.join(chr(random.randint(65, 90)) for _ in range(2049))))
# not recommended but valid entries
self.assertIsNotNone(fdroidserver.update.sanitize_funding_yml_entry(12345))
self.assertIsNotNone(fdroidserver.update.sanitize_funding_yml_entry(5.0))
self.assertIsNotNone(fdroidserver.update.sanitize_funding_yml_entry(' WhyIncludeWhitespace '))
self.assertIsNotNone(fdroidserver.update.sanitize_funding_yml_entry(['first', 'second']))
def test_set_localized_text_entry(self):
os.chdir(self.testdir)
config = dict()
fdroidserver.common.fill_config_defaults(config)
fdroidserver.update.config = config
fdroidserver.update.options = fdroidserver.common.options
files = {
'full-description.txt': 'description',
'short-description.txt': 'summary',
'title.txt': 'name',
'video-url.txt': 'video',
}
for f, key in files.items():
limit = config['char_limits'][key]
with open(f, 'w') as fp:
fp.write(''.join(random.choice(string.ascii_letters) for i in range(limit + 100)))
locale = 'ru_US'
app = dict()
fdroidserver.update._set_localized_text_entry(app, locale, key, f)
self.assertEqual(limit, len(app['localized'][locale][key]))
f = 'badlink-' + f
os.symlink('/path/to/nowhere', f)
app = dict()
fdroidserver.update._set_localized_text_entry(app, locale, key, f)
self.assertIsNone(app['localized'].get(locale, {}).get(key))
def test_set_author_entry(self):
os.chdir(self.testdir)
config = dict()
fdroidserver.common.fill_config_defaults(config)
fdroidserver.update.config = config
fdroidserver.update.options = fdroidserver.common.options
f = 'contact-website.txt'
key = 'author'
url = 'https://f-droid.org/'
limit = config['char_limits']['author']
with open(f, 'w') as fp:
fp.write(url)
fp.write('\n')
app = dict()
fdroidserver.update._set_author_entry(app, key, f)
self.assertEqual(url, app[key])
f = 'limits.txt'
key = 'author'
limit = config['char_limits']['author']
for key in ('authorEmail', 'authorPhone', 'authorWebSite'):
with open(f, 'w') as fp:
fp.write(''.join(random.choice(string.ascii_letters) for i in range(limit + 100)))
app = dict()
fdroidserver.update._set_author_entry(app, key, f)
self.assertEqual(limit, len(app[key]))
f = 'badlink.txt'
os.symlink('/path/to/nowhere', f)
app = dict()
fdroidserver.update._set_author_entry(app, key, f)
self.assertIsNone(app.get(key))
def test_status_update_json(self):
fdroidserver.common.config = {}
fdroidserver.update.config = {}
fdroidserver.update.options = Options
with tempfile.TemporaryDirectory() as tmpdir:
os.chdir(tmpdir)
with mock.patch('sys.argv', ['fdroid update', '']):
fdroidserver.update.status_update_json([], [])
with open('repo/status/update.json') as fp:
data = json.load(fp)
self.assertTrue('apksigner' in data)
fdroidserver.update.config = {
'apksigner': 'apksigner',
}
fdroidserver.update.status_update_json([], [])
with open('repo/status/update.json') as fp:
data = json.load(fp)
self.assertEqual(shutil.which(fdroidserver.update.config['apksigner']), data['apksigner'])
fdroidserver.update.config = {}
fdroidserver.common.fill_config_defaults(fdroidserver.update.config)
fdroidserver.update.status_update_json([], [])
with open('repo/status/update.json') as fp:
data = json.load(fp)
self.assertEqual(fdroidserver.update.config.get('apksigner'), data['apksigner'])
self.assertEqual(fdroidserver.update.config['jarsigner'], data['jarsigner'])
self.assertEqual(fdroidserver.update.config['keytool'], data['keytool'])
def test_scan_metadata_androguard(self):
def _create_apkmetadata_object(apkName):
"""Create an empty apk metadata object."""
apk = {}
apk['apkName'] = apkName
apk['uses-permission'] = []
apk['uses-permission-sdk-23'] = []
apk['features'] = []
apk['icons_src'] = {}
return apk
apkList = [
(
'org.dyndns.fules.ck_20.apk',
{
'apkName': 'org.dyndns.fules.ck_20.apk',
'uses-permission': [
fdroidserver.update.UsesPermission(
name='android.permission.BIND_INPUT_METHOD',
maxSdkVersion=None,
),
fdroidserver.update.UsesPermission(
name='android.permission.READ_EXTERNAL_STORAGE',
maxSdkVersion=None,
),
fdroidserver.update.UsesPermission(
name='android.permission.VIBRATE', maxSdkVersion=None
),
],
'uses-permission-sdk-23': [],
'features': [],
'icons_src': {
'240': 'res/drawable-hdpi-v4/icon_launcher.png',
'120': 'res/drawable-ldpi-v4/icon_launcher.png',
'160': 'res/drawable-mdpi-v4/icon_launcher.png',
'-1': 'res/drawable-mdpi-v4/icon_launcher.png',
},
'packageName': 'org.dyndns.fules.ck',
'versionCode': 20,
'versionName': 'v1.6pre2',
'minSdkVersion': 7,
'name': 'Compass Keyboard',
'targetSdkVersion': 8,
'nativecode': [
'arm64-v8a',
'armeabi',
'armeabi-v7a',
'mips',
'mips64',
'x86',
'x86_64',
],
},
)
]
for apkfile, apkaapt in apkList:
apkandroguard = _create_apkmetadata_object(apkfile)
fdroidserver.update.scan_apk_androguard(apkandroguard, apkfile)
self.maxDiff = None
self.assertEqual(apkaapt, apkandroguard)
def test_exclude_disabled_apks(self):
os.chdir(self.testdir)
os.mkdir('repo')
testapk = os.path.join('repo', 'com.politedroid_6.apk')
testapk_new = os.path.join('repo', 'Politedroid-1.5.apk')
shutil.copy(os.path.join(self.basedir, testapk), testapk_new)
config = dict()
fdroidserver.common.fill_config_defaults(config)
config['ndk_paths'] = dict()
fdroidserver.common.config = config
fdroidserver.update.config = config
fdroidserver.common.options = Options
fdroidserver.update.options = fdroidserver.common.options
fdroidserver.update.options.clean = True
app = fdroidserver.metadata.App()
app.id = 'com.politedroid'
apps = {app.id: app}
build = fdroidserver.metadata.Build()
build.versionCode = 6
build.disable = "disabled"
app['Builds'] = [build]
knownapks = fdroidserver.common.KnownApks()
apks, cachechanged = fdroidserver.update.process_apks({}, 'repo', knownapks, False, apps)
self.assertEqual([], apks)
def test_archive_old_apks_ArchivePolicy_0(self):
app = fdroidserver.metadata.App()
app.id = 'test'
app.ArchivePolicy = 0
apps = {app.id: app}
with self.assertLogs(level='DEBUG') as cm:
fdroidserver.update.archive_old_apks(apps, [], [], '', '', 3)
self.assertEqual(cm.output, [
"DEBUG:root:Checking archiving for test - apks:0, keepversions:0, archapks:0"
])
def test_archive_old_apks(self):
app = fdroidserver.metadata.App()
app.id = 'test'
app.VercodeOperation = ['%c+1', '%c+2', '%c+3', '%c+4']
apps = {app.id: app}
with self.assertLogs(level='DEBUG') as cm:
fdroidserver.update.archive_old_apks(apps, [], [], '', '', 3)
self.assertEqual(cm.output, [
"DEBUG:root:Checking archiving for test - apks:0, keepversions:12, archapks:0"
])
app = fdroidserver.metadata.App()
app.id = 'org.smssecure.smssecure'
app.CurrentVersionCode = 135
apps = {app.id: app}
with self.assertLogs(level='DEBUG') as cm:
fdroidserver.update.archive_old_apks(apps, [], [], '', '', 3)
self.assertEqual(cm.output, [
"DEBUG:root:Checking archiving for org.smssecure.smssecure - apks:0, keepversions:6, archapks:0"
])
def test_categories_txt_is_removed_by_delete_unknown(self):
"""categories.txt used to be a part of this system, now its nothing."""
os.chdir(self.testdir)
Path('config.yml').write_text('repo_pubkey: ffffffffffffffffffffffffffffffffffffffff')
categories_txt = Path('repo/categories.txt')
categories_txt.parent.mkdir()
categories_txt.write_text('placeholder')
self.assertTrue(categories_txt.exists())
with mock.patch('sys.argv', ['fdroid update', '--delete-unknown', '--nosign']):
fdroidserver.update.main()
self.assertFalse(categories_txt.exists())
def test_no_blank_auto_defined_categories(self):
"""When no app has Categories, there should be no definitions in the repo."""
os.chdir(self.testdir)
os.mkdir('metadata')
os.mkdir('repo')
Path('config.yml').write_text(
'repo_pubkey: ffffffffffffffffffffffffffffffffffffffff'
)
testapk = os.path.join('repo', 'com.politedroid_6.apk')
shutil.copy(os.path.join(self.basedir, testapk), testapk)
Path('metadata/com.politedroid.yml').write_text('Name: Polite')
with mock.patch('sys.argv', ['fdroid update', '--delete-unknown', '--nosign']):
fdroidserver.update.main()
with open('repo/index-v2.json') as fp:
index = json.load(fp)
self.assertFalse(CATEGORIES_CONFIG_NAME in index['repo'])
def test_auto_defined_categories(self):
"""Repos that don't define categories in config/ should use auto-generated."""
os.chdir(self.testdir)
os.mkdir('metadata')
os.mkdir('repo')
Path('config.yml').write_text(
'repo_pubkey: ffffffffffffffffffffffffffffffffffffffff'
)
testapk = os.path.join('repo', 'com.politedroid_6.apk')
shutil.copy(os.path.join(self.basedir, testapk), testapk)
Path('metadata/com.politedroid.yml').write_text('Categories: [Time]')
with mock.patch('sys.argv', ['fdroid update', '--delete-unknown', '--nosign']):
fdroidserver.update.main()
with open('repo/index-v2.json') as fp:
index = json.load(fp)
self.assertEqual(
{'Time': {'name': {'en-US': 'Time'}}},
index['repo'][CATEGORIES_CONFIG_NAME],
)
def test_auto_defined_categories_two_apps(self):
"""Repos that don't define categories in config/ should use auto-generated."""
os.chdir(self.testdir)
os.mkdir('metadata')
os.mkdir('repo')
Path('config.yml').write_text(
'repo_pubkey: ffffffffffffffffffffffffffffffffffffffff'
)
testapk = os.path.join('repo', 'com.politedroid_6.apk')
shutil.copy(os.path.join(self.basedir, testapk), testapk)
Path('metadata/com.politedroid.yml').write_text('Categories: [bar]')
testapk = os.path.join('repo', 'souch.smsbypass_9.apk')
shutil.copy(os.path.join(self.basedir, testapk), testapk)
Path('metadata/souch.smsbypass.yml').write_text('Categories: [foo, bar]')
with mock.patch('sys.argv', ['fdroid update', '--delete-unknown', '--nosign']):
fdroidserver.update.main()
with open('repo/index-v2.json') as fp:
index = json.load(fp)
self.assertEqual(
{'bar': {'name': {'en-US': 'bar'}}, 'foo': {'name': {'en-US': 'foo'}}},
index['repo'][CATEGORIES_CONFIG_NAME],
)
def test_auto_defined_categories_mix_into_config_categories(self):
"""Repos that don't define all categories in config/ also use auto-generated."""
os.chdir(self.testdir)
os.mkdir('config')
Path('config/categories.yml').write_text('System: {name: System Apps}')
os.mkdir('metadata')
os.mkdir('repo')
Path('config.yml').write_text(
'repo_pubkey: ffffffffffffffffffffffffffffffffffffffff'
)
testapk = os.path.join('repo', 'com.politedroid_6.apk')
shutil.copy(os.path.join(self.basedir, testapk), testapk)
Path('metadata/com.politedroid.yml').write_text('Categories: [Time]')
testapk = os.path.join('repo', 'souch.smsbypass_9.apk')
shutil.copy(os.path.join(self.basedir, testapk), testapk)
Path('metadata/souch.smsbypass.yml').write_text('Categories: [System, Time]')
with mock.patch('sys.argv', ['fdroid update', '--delete-unknown', '--nosign']):
fdroidserver.update.main()
with open('repo/index-v2.json') as fp:
index = json.load(fp)
self.assertEqual(
{
'System': {'name': {'en-US': 'System Apps'}},
'Time': {'name': {'en-US': 'Time'}},
},
index['repo'][CATEGORIES_CONFIG_NAME],
)
def test_empty_categories_not_in_index(self):
"""A category with no apps should be ignored, even if defined in config."""
os.chdir(self.testdir)
os.mkdir('config')
Path('config/categories.yml').write_text('System: {name: S}\nTime: {name: T}\n')
os.mkdir('metadata')
os.mkdir('repo')
Path('config.yml').write_text(
'repo_pubkey: ffffffffffffffffffffffffffffffffffffffff'
)
testapk = os.path.join('repo', 'com.politedroid_6.apk')
shutil.copy(os.path.join(self.basedir, testapk), testapk)
Path('metadata/com.politedroid.yml').write_text('Categories: [Time]')
with mock.patch('sys.argv', ['fdroid update', '--delete-unknown', '--nosign']):
fdroidserver.update.main()
with open('repo/index-v2.json') as fp:
index = json.load(fp)
self.assertEqual(
{'Time': {'name': {'en-US': 'T'}}},
index['repo'][CATEGORIES_CONFIG_NAME],
)
class TestParseIpa(unittest.TestCase):
def test_parse_ipa(self):
self.maxDiff = None
try:
import biplist # Fedora does not have a biplist package
biplist # silence the linters
except ImportError as e:
self.skipTest(str(e))
ipa_path = os.path.join(
os.path.dirname(os.path.abspath(__file__)),
'com.fake.IpaApp_1000000000001.ipa',
)
result = fdroidserver.update.parse_ipa(ipa_path, 'fake_size', 'fake_sha')
self.maxDiff = None
self.assertDictEqual(
result,
{
'apkName': 'com.fake.IpaApp_1000000000001.ipa',
'hash': 'fake_sha',
'hashType': 'sha256',
'packageName': 'org.onionshare.OnionShare',
'size': 'fake_size',
'versionCode': 1000000000001,
'versionName': '1.0.1',
'ipa_DTPlatformVersion': '16.4',
'ipa_MinimumOSVersion': '15.0',
'ipa_entitlements': set(),
'ipa_permissions': {
'NSCameraUsageDescription':
'Please allow access to your '
'camera, if you want to '
'create photos or videos for '
'direct sharing.',
'NSMicrophoneUsageDescription':
'Please allow access to '
'your microphone, if you '
'want to create videos '
'for direct sharing.',
'NSPhotoLibraryUsageDescription':
'Please allow access to '
'your photo library, if '
'you want to share '
'photos.',
},
'name': 'OnionShare',
},
)
class TestUpdateVersionStringToInt(unittest.TestCase):
def test_version_string_to_int(self):
self.assertEqual(
fdroidserver.update.version_string_to_int("1.2.3"), 1000002000003
)
self.assertEqual(fdroidserver.update.version_string_to_int("0.0.0003"), 3)
self.assertEqual(fdroidserver.update.version_string_to_int("0.0.0"), 0)
self.assertEqual(
fdroidserver.update.version_string_to_int("4321.321.21"), 4321000321000021
)
self.assertEqual(
fdroidserver.update.version_string_to_int("18446744.073709.551615"),
18446744073709551615,
)
def test_version_string_to_int_value_errors(self):
with self.assertRaises(ValueError):
fdroidserver.update.version_string_to_int("1.2.3a")
with self.assertRaises(ValueError):
fdroidserver.update.version_string_to_int("asdfasdf")
with self.assertRaises(ValueError):
fdroidserver.update.version_string_to_int("1.2.-3")
with self.assertRaises(ValueError):
fdroidserver.update.version_string_to_int("-1.2.-3")
with self.assertRaises(ValueError):
fdroidserver.update.version_string_to_int("0.0.0x3")
class TestScanRepoForIpas(unittest.TestCase):
def setUp(self):
self.maxDiff = None
def test_scan_repo_for_ipas_no_cache(self):
self.maxDiff = None
with tempfile.TemporaryDirectory() as tmpdir, TmpCwd(tmpdir):
os.mkdir("repo")
with open('repo/abc.Def_123.ipa', 'w') as f:
f.write('abc')
with open('repo/xyz.XXX_123.ipa', 'w') as f:
f.write('xyz')
apkcache = mock.MagicMock()
# apkcache['a'] = 1
repodir = "repo"
knownapks = mock.MagicMock()
def mocked_parse(p, s, c):
# pylint: disable=unused-argument
return {'packageName': 'abc' if 'abc' in p else 'xyz'}
with mock.patch('fdroidserver.update.parse_ipa', mocked_parse):
ipas, checkchanged = fdroidserver.update.scan_repo_for_ipas(
apkcache, repodir, knownapks
)
self.assertEqual(checkchanged, True)
self.assertEqual(len(ipas), 2)
package_names_in_ipas = [x['packageName'] for x in ipas]
self.assertTrue('abc' in package_names_in_ipas)
self.assertTrue('xyz' in package_names_in_ipas)
apkcache_setter_package_name = [
x.args[1]['packageName'] for x in apkcache.__setitem__.mock_calls
]
self.assertTrue('abc' in apkcache_setter_package_name)
self.assertTrue('xyz' in apkcache_setter_package_name)
self.assertEqual(apkcache.__setitem__.call_count, 2)
knownapks.recordapk.call_count = 2
self.assertTrue(
unittest.mock.call('abc.Def_123.ipa', 'abc')
in knownapks.recordapk.mock_calls
)
self.assertTrue(
unittest.mock.call('xyz.XXX_123.ipa', 'xyz')
in knownapks.recordapk.mock_calls
)
class TestParseIosScreenShotName(unittest.TestCase):
def setUp(self):
self.maxDiff = None
def test_parse_ios_screenshot_name_atforamt_iphone8(self):
self.assertEqual(
fdroidserver.update.parse_ios_screenshot_name(Path("iPhone 8+ @ iOS 16-1.png")),
("phoneScreenshots", "iPhone 8+", "iOS 16",),
)
def test_parse_ios_screenshot_name_atforamt_ipad13(self):
self.assertEqual(
fdroidserver.update.parse_ios_screenshot_name(Path("iPad Pro 12.9\" 2gen @ iOS 16-1.png")),
("tenInchScreenshots", "iPad Pro 12.9\" 2gen", "iOS 16",),
)
def test_parse_ios_screenshot_name_underscoreforamt_ipad(self):
self.assertEqual(
fdroidserver.update.parse_ios_screenshot_name(Path("1_ipadPro129_1.1.png")),
("tenInchScreenshots", "ipadpro129", "unknown",),
)
def test_parse_ios_screenshot_name_underscoreforamt_iphone(self):
self.assertEqual(
fdroidserver.update.parse_ios_screenshot_name(Path("1_iphone6Plus_1.1.png")),
("phoneScreenshots", "iphone6plus", "unknown",),
)
class TestInsertLocalizedIosAppMetadata(unittest.TestCase):
def test_insert_localized_ios_app_metadata(self):
self.maxDiff = None
self.apps_with_packages = {
"org.fake": {}
}
def _mock_discover(fastlane_dir):
self.assertEqual(
fastlane_dir,
Path('build/org.fake/fastlane'),
)
return {"fake screenshots": "fake"}
def _mock_copy(screenshots, package_name):
self.assertEqual(screenshots, {"fake screenshots": "fake"})
self.assertEqual(package_name, "org.fake")
with mock.patch('fdroidserver.update.discover_ios_screenshots', _mock_discover):
self.set_localized_mock = mock.Mock()
with mock.patch('fdroidserver.update.copy_ios_screenshots_to_repo', _mock_copy):
with mock.patch("fdroidserver.update._set_localized_text_entry", self.set_localized_mock):
return fdroidserver.update.insert_localized_ios_app_metadata(
self.apps_with_packages
)
self.assertListEqual(
self.set_localized_mock.call_args_list,
[
mock.call({}, 'en-US', 'name', Path('build/org.fake/fastlane/metadata/en-US/name.txt')),
mock.call({}, 'en-US', 'summary', Path('build/org.fake/fastlane/metadata/en-US/subtitle.txt')),
mock.call({}, 'en-US', 'description', Path('build/org.fake/fastlane/metadata/en-US/description.txt')),
mock.call({}, 'de-DE', 'name', Path('build/org.fake/fastlane/metadata/de-DE/name.txt')),
mock.call({}, 'de-DE', 'summary', Path('build/org.fake/fastlane/metadata/de-DE/subtitle.txt')),
mock.call({}, 'de-DE', 'description', Path('build/org.fake/fastlane/metadata/de-DE/description.txt')),
],
)
class TestDiscoverIosScreenshots(unittest.TestCase):
def test_discover_ios_screenshots(self):
self.maxDiff = None
with tempfile.TemporaryDirectory() as fastlane_dir:
fastlane_dir = Path(fastlane_dir)
(fastlane_dir / "screenshots/en-US").mkdir(parents=True)
with open(fastlane_dir / "screenshots/en-US/iPhone 8+ @ iOS 16-1.png", 'w') as f:
f.write("1")
with open(fastlane_dir / "screenshots/en-US/iPad Pro 12.9\" 2gen @ iOS 16-1.png", "w") as f:
f.write("2")
with open(fastlane_dir / "screenshots/en-US/iPad Pro 12.9\" 2gen @ iOS 16-2.png", "w") as f:
f.write("3")
(fastlane_dir / "screenshots/de-DE").mkdir(parents=True)
with open(fastlane_dir / "screenshots/de-DE/1_ipadPro129_1.1.png", "w") as f:
f.write("4")
screenshots = fdroidserver.update.discover_ios_screenshots(fastlane_dir)
self.assertDictEqual(
screenshots,
{
"en-US": {
"phoneScreenshots": [
fastlane_dir / "screenshots/en-US/iPhone 8+ @ iOS 16-1.png",
],
"tenInchScreenshots": [
fastlane_dir / "screenshots/en-US/iPad Pro 12.9\" 2gen @ iOS 16-1.png",
fastlane_dir / "screenshots/en-US/iPad Pro 12.9\" 2gen @ iOS 16-2.png",
],
},
"de-DE": {
"tenInchScreenshots": [
fastlane_dir / "screenshots/de-DE/1_ipadPro129_1.1.png",
],
},
},
)
class TestCopyIosScreenshotsToRepo(unittest.TestCase):
def test_copy_ios_screenshots_to_repo(self):
self.maxDiff = None
screenshot_dir_en = Path("build/org.fake/fastlane/screenshots/en-US")
s1 = screenshot_dir_en / "iPhone 8+ @ iOS 16-1.png"
s2 = screenshot_dir_en / "iPad Pro 12.9\" 2gen @ iOS 16-1.png"
s3 = screenshot_dir_en / "iPad Pro 12.9\" 2gen @ iOS 16-2.png"
screenshot_dir_de = Path("build/org.fake/fastlane/screenshots/de-DE")
s4 = screenshot_dir_de / "1_ipadPro129_1.1.png"
cmock = mock.Mock()
with mock.patch("fdroidserver.update._strip_and_copy_image", cmock):
fdroidserver.update.copy_ios_screenshots_to_repo(
{
"en-US": {
"phoneScreenshots": [s1],
"tenInchScreenshots": [s2, s3],
},
"de-DE": {
"tenInchScreenshots": [s4],
},
},
"org.fake",
)
self.assertListEqual(
cmock.call_args_list,
[
mock.call(
'build/org.fake/fastlane/screenshots/en-US/iPhone 8+ @ iOS 16-1.png',
'repo/org.fake/en-US/phoneScreenshots/iPhone_8+_@_iOS_16-1.png',
),
mock.call(
'build/org.fake/fastlane/screenshots/en-US/iPad Pro 12.9" 2gen @ iOS 16-1.png',
'repo/org.fake/en-US/tenInchScreenshots/iPad_Pro_12.9"_2gen_@_iOS_16-1.png',
),
mock.call(
'build/org.fake/fastlane/screenshots/en-US/iPad Pro 12.9" 2gen @ iOS 16-2.png',
'repo/org.fake/en-US/tenInchScreenshots/iPad_Pro_12.9"_2gen_@_iOS_16-2.png',
),
mock.call(
'build/org.fake/fastlane/screenshots/de-DE/1_ipadPro129_1.1.png',
'repo/org.fake/de-DE/tenInchScreenshots/1_ipadPro129_1.1.png',
),
],
)
class TestGetIpaIcon(unittest.TestCase):
def test_get_ipa_icon(self):
self.maxDiff = None
with tempfile.TemporaryDirectory() as tmpdir:
tmpdir = Path(tmpdir)
(tmpdir / 'OnionBrowser.xcodeproj').mkdir()
with open(tmpdir / 'OnionBrowser.xcodeproj/project.pbxproj', "w") as f:
f.write("")
icondir = tmpdir / "fake_icon.appiconset"
icondir.mkdir()
with open(icondir / "Contents.json", "w", encoding="utf-8") as f:
f.write("""
{"images": [
{"scale": "2x", "size": "128x128", "filename": "nope"},
{"scale": "1x", "size": "512x512", "filename": "nope"},
{"scale": "1x", "size": "16x16", "filename": "nope"},
{"scale": "1x", "size": "32x32", "filename": "yep"}
]}
""")
pfp = mock.Mock(return_value="fake_icon")
with mock.patch("fdroidserver.update._parse_from_pbxproj", pfp):
p = fdroidserver.update._get_ipa_icon(tmpdir)
self.assertEqual(str(icondir / "yep"), p)
class TestParseFromPbxproj(unittest.TestCase):
def test_parse_from_pbxproj(self):
self.maxDiff = None
with tempfile.TemporaryDirectory() as tmpdir:
with open(Path(tmpdir) / "asdf.pbxproj", 'w', encoding="utf-8") as f:
f.write("""
230jfaod=flc'
ASSETCATALOG_COMPILER_APPICON_NAME = MyIcon;
cm opa1c p[m
""")
v = fdroidserver.update._parse_from_pbxproj(
Path(tmpdir) / "asdf.pbxproj",
"ASSETCATALOG_COMPILER_APPICON_NAME"
)
self.assertEqual(v, "MyIcon")
if __name__ == "__main__":
os.chdir(os.path.dirname(__file__))
import argparse
parser = argparse.ArgumentParser()
parser.add_argument(
"-v",
"--verbose",
action="store_true",
default=False,
help="Spew out even more information than normal",
)
parse_args_for_test(parser, sys.argv)
newSuite = unittest.TestSuite()
newSuite.addTest(unittest.makeSuite(UpdateTest))
newSuite.addTest(unittest.makeSuite(TestUpdateVersionStringToInt))
newSuite.addTest(unittest.makeSuite(TestScanRepoForIpas))
newSuite.addTest(unittest.makeSuite(TestParseIosScreenShotName))
newSuite.addTest(unittest.makeSuite(TestInsertLocalizedIosAppMetadata))
newSuite.addTest(unittest.makeSuite(TestDiscoverIosScreenshots))
newSuite.addTest(unittest.makeSuite(TestGetIpaIcon))
unittest.main(failfast=False)
View Git Blame Copy Permalink