kamp/fdroidserver
1
0
Fork 0
mirror of https://gitlab.com/fdroid/fdroidserver.git synced 2024-11-09 00:40:11 +01:00
Code Activity
bb43dcf00e
fdroidserver/tests/common.TestCase

1313 lines
66 KiB
Plaintext
Raw Normal View History

tests: switch to python3
2016-01-04 21:17:58 +01:00
#!/usr/bin/env python3
added test case for common.isApkDebuggable() Just getting into the habit of adding tests to everything that I change... Also, it should be useful to have an unsigned APK in the test collection, since `fdroid update` should handle it gracefully and give a warning of some kind.
2014-12-08 22:55:14 +01:00
# http://www.drdobbs.com/testing/unit-testing-with-python/240165163
build: fix bad regexs when removing signingConfig from srclibs I went through the source of all apps in fdroiddata for examples, and found some that use readLine() for things totally unrelated to signingConfigs. https://gitlab.com/fdroid/fdroiddata/merge_requests/4775#note_234132902
2019-10-23 12:23:37 +02:00
import difflib
handle package: line output from aapt v28 fdroid/fdroiddata!3484 fdroid/fdroiddata!3562 fdroid/fdroidserver!548
2018-09-17 23:12:51 +02:00
import glob
added test case for common.isApkDebuggable() Just getting into the habit of adding tests to everything that I change... Also, it should be useful to have an unsigned APK in the test collection, since `fdroid update` should handle it gracefully and give a warning of some kind.
2014-12-08 22:55:14 +01:00
import inspect
integration test for creating and deploying status JSON files ----------------------------
2020-02-18 23:50:52 +01:00
import json
tests: add setUp() method to common to handle standard stuff
2017-09-25 16:28:22 +02:00
import logging
added test case for common.isApkDebuggable() Just getting into the habit of adding tests to everything that I change... Also, it should be useful to have an unsigned APK in the test collection, since `fdroid update` should handle it gracefully and give a warning of some kind.
2014-12-08 22:55:14 +01:00
import optparse
import os
test new common.regsub_file() method that replaces sed calls
2015-07-30 22:13:36 +02:00
import re
build: improve regsub pattern for setting buildToolsVersion This addresses the discussion in !64 https://gitlab.com/fdroid/fdroidserver/merge_requests/64 Sometimes, buildToolsVersion is a kind of gradle macro call, and other times it is a variable assignment. This regsub pattern now handles both of those cases.
2015-08-11 15:33:03 +02:00
import shutil
integration test for creating and deploying status JSON files ----------------------------
2020-02-18 23:50:52 +01:00
import subprocess
added test case for common.isApkDebuggable() Just getting into the habit of adding tests to everything that I change... Also, it should be useful to have an unsigned APK in the test collection, since `fdroid update` should handle it gracefully and give a warning of some kind.
2014-12-08 22:55:14 +01:00
import sys
build: improve regsub pattern for setting buildToolsVersion This addresses the discussion in !64 https://gitlab.com/fdroid/fdroidserver/merge_requests/64 Sometimes, buildToolsVersion is a kind of gradle macro call, and other times it is a variable assignment. This regsub pattern now handles both of those cases.
2015-08-11 15:33:03 +02:00
import tempfile
integration test for creating and deploying status JSON files ----------------------------
2020-02-18 23:50:52 +01:00
import time
added test case for common.isApkDebuggable() Just getting into the habit of adding tests to everything that I change... Also, it should be useful to have an unsigned APK in the test collection, since `fdroid update` should handle it gracefully and give a warning of some kind.
2014-12-08 22:55:14 +01:00
import unittest
avoid duplicate value assignments when updating config files
2017-04-02 12:08:01 +02:00
import textwrap
tests: test setting up app git repo like `fdroid build` does I wrote this to try to find #379 but this test didn't trigger that bug.
2017-09-25 16:34:25 +02:00
import yaml
deploying build logs to server after each individual build run
2018-06-12 16:18:21 +02:00
import gzip
verify: ensure only a single signature is in compared APK The ZIP format allows multiple entries with the exact same filename, and on top of that, it does not allow deleting or updating entries. To make the `fdroid verify` procedure failsafe, it needs to create a new temporary APK that is made up on the contents of the "unsigned APK" and the signature from the "signed APK". Since it would be possible to give a signed APK as in the unsigned one's position, `fdroid verify` was not able to update the signature since it was just adding the new signature to the end of the ZIP file. When reading a ZIP, the first entry is used.
2016-12-19 16:54:32 +01:00
from zipfile import ZipFile
added helper function for uploading build logs with rsync
2018-06-10 23:23:43 +02:00
from unittest import mock
added test case for common.isApkDebuggable() Just getting into the habit of adding tests to everything that I change... Also, it should be useful to have an unsigned APK in the test collection, since `fdroid update` should handle it gracefully and give a warning of some kind.
2014-12-08 22:55:14 +01:00
Move index signing methods into signindex.py
2017-03-29 17:11:40 +02:00
add test files to pre-commit hook and fix pep8 errors
2015-07-22 08:19:56 +02:00
localmodule = os.path.realpath(
os.path.join(os.path.dirname(inspect.getfile(inspect.currentframe())), '..'))
added test case for common.isApkDebuggable() Just getting into the habit of adding tests to everything that I change... Also, it should be useful to have an unsigned APK in the test collection, since `fdroid update` should handle it gracefully and give a warning of some kind.
2014-12-08 22:55:14 +01:00
print('localmodule: ' + localmodule)
if localmodule not in sys.path:
add test files to pre-commit hook and fix pep8 errors
2015-07-22 08:19:56 +02:00
sys.path.insert(0, localmodule)
added test case for common.isApkDebuggable() Just getting into the habit of adding tests to everything that I change... Also, it should be useful to have an unsigned APK in the test collection, since `fdroid update` should handle it gracefully and give a warning of some kind.
2014-12-08 22:55:14 +01:00
handle jarsigner/apksigner output cleanly for rational logging These were both spamming the output with lots of confusing messages, even when --verbose was not used. Jarsigner especially has confusing messages, since it has warnings that do not pertain to APK signatures at all, like the ones about timestamps and missing Certificate Authority. closes #405
2017-12-07 17:32:14 +01:00
import fdroidserver.index
avoid duplicate value assignments when updating config files
2017-04-02 12:08:01 +02:00
import fdroidserver.signindex
added test case for common.isApkDebuggable() Just getting into the habit of adding tests to everything that I change... Also, it should be useful to have an unsigned APK in the test collection, since `fdroid update` should handle it gracefully and give a warning of some kind.
2014-12-08 22:55:14 +01:00
import fdroidserver.common
test new common.regsub_file() method that replaces sed calls
2015-07-30 22:13:36 +02:00
import fdroidserver.metadata
better error message in publish when repo_key is not set
2017-10-16 18:11:57 +02:00
from testcommon import TmpCwd
srclib: add test for getsrclibvcs
2019-12-16 19:17:46 +01:00
from fdroidserver.exception import FDroidException, VCSException
added test case for common.isApkDebuggable() Just getting into the habit of adding tests to everything that I change... Also, it should be useful to have an unsigned APK in the test collection, since `fdroid update` should handle it gracefully and give a warning of some kind.
2014-12-08 22:55:14 +01:00
add test files to pre-commit hook and fix pep8 errors
2015-07-22 08:19:56 +02:00
added test case for common.isApkDebuggable() Just getting into the habit of adding tests to everything that I change... Also, it should be useful to have an unsigned APK in the test collection, since `fdroid update` should handle it gracefully and give a warning of some kind.
2014-12-08 22:55:14 +01:00
class CommonTest(unittest.TestCase):
'''fdroidserver/common.py'''
tests: add setUp() method to common to handle standard stuff
2017-09-25 16:28:22 +02:00
def setUp(self):
logging.basicConfig(level=logging.DEBUG)
self.basedir = os.path.join(localmodule, 'tests')
self.tmpdir = os.path.abspath(os.path.join(self.basedir, '..', '.testfiles'))
if not os.path.exists(self.tmpdir):
os.makedirs(self.tmpdir)
os.chdir(self.basedir)
git_mirror_size_limit config option to set max git mirror size GitHub and GitLab have some kinds of limits on how big a git repo can be, this makes that option configurable. This also is very useful for tests.
2020-01-13 11:48:23 +01:00
def test_parse_human_readable_size(self):
for k, v in ((9827, 9827), (123.456, 123), ('123b', 123), ('1.2', 1),
('10.43 KiB', 10680), ('11GB', 11000000000), ('59kb', 59000),
('343.1 mb', 343100000), ('99.9GiB', 107266808217)):
self.assertEqual(fdroidserver.common.parse_human_readable_size(k), v)
for v in ((12, 123), '0xfff', [], None, '12,123', '123GG', '982374bb', self):
with self.assertRaises(ValueError):
fdroidserver.common.parse_human_readable_size(v)
better error message in publish when repo_key is not set
2017-10-16 18:11:57 +02:00
def test_assert_config_keystore(self):
with tempfile.TemporaryDirectory() as tmpdir, TmpCwd(tmpdir):
with self.assertRaises(FDroidException):
fdroidserver.common.assert_config_keystore({})
with tempfile.TemporaryDirectory() as tmpdir, TmpCwd(tmpdir):
c = {'repo_keyalias': 'localhost',
'keystore': 'keystore.jks',
'keystorepass': '12345',
'keypass': '12345'}
with open('keystore.jks', 'w'):
pass
fdroidserver.common.assert_config_keystore(c)
find cmds from SDK build-tools in a more flexible way, on the fly This is a more flexible approach than testing for the complete SDK and build-tools up front. This will only test for the commands that are actually being run, so that if you only have `aapt` installed, you can do `fdroid update` without errors, but other commands will still give appropriate errors. This also makes the build_tools item in config.py optional, it is only needed if you want to force a specific version of the build-tools.
2014-12-09 14:12:41 +01:00
def _set_build_tools(self):
build_tools = os.path.join(fdroidserver.common.config['sdk_path'], 'build-tools')
if os.path.exists(build_tools):
fdroidserver.common.config['build_tools'] = ''
for f in sorted(os.listdir(build_tools), reverse=True):
versioned = os.path.join(build_tools, f)
if os.path.isdir(versioned) \
and os.path.isfile(os.path.join(versioned, 'aapt')):
fdroidserver.common.config['build_tools'] = versioned
break
return True
else:
Make pre-commit hook pass after python3 switch
2016-01-04 17:28:55 +01:00
print('no build-tools found: ' + build_tools)
find cmds from SDK build-tools in a more flexible way, on the fly This is a more flexible approach than testing for the complete SDK and build-tools up front. This will only test for the commands that are actually being run, so that if you only have `aapt` installed, you can do `fdroid update` without errors, but other commands will still give appropriate errors. This also makes the build_tools item in config.py optional, it is only needed if you want to force a specific version of the build-tools.
2014-12-09 14:12:41 +01:00
return False
def _find_all(self):
fix tests to work when only Debian Android SDK is installed jenkins.debian.net only had `apt install android-sdk`, it does not have any of Google's packages installed.
2017-11-08 13:51:03 +01:00
tools = ['aapt', 'adb', 'zipalign']
if os.path.exists(os.path.join(os.getenv('ANDROID_HOME'), 'tools', 'android')):
tools.append('android')
for cmd in tools:
find cmds from SDK build-tools in a more flexible way, on the fly This is a more flexible approach than testing for the complete SDK and build-tools up front. This will only test for the commands that are actually being run, so that if you only have `aapt` installed, you can do `fdroid update` without errors, but other commands will still give appropriate errors. This also makes the build_tools item in config.py optional, it is only needed if you want to force a specific version of the build-tools.
2014-12-09 14:12:41 +01:00
path = fdroidserver.common.find_sdk_tools_cmd(cmd)
if path is not None:
self.assertTrue(os.path.exists(path))
self.assertTrue(os.path.isfile(path))
def test_find_sdk_tools_cmd(self):
fdroidserver.common.config = dict()
# TODO add this once everything works without sdk_path set in config
add test files to pre-commit hook and fix pep8 errors
2015-07-22 08:19:56 +02:00
# self._find_all()
find cmds from SDK build-tools in a more flexible way, on the fly This is a more flexible approach than testing for the complete SDK and build-tools up front. This will only test for the commands that are actually being run, so that if you only have `aapt` installed, you can do `fdroid update` without errors, but other commands will still give appropriate errors. This also makes the build_tools item in config.py optional, it is only needed if you want to force a specific version of the build-tools.
2014-12-09 14:12:41 +01:00
sdk_path = os.getenv('ANDROID_HOME')
if os.path.exists(sdk_path):
fdroidserver.common.config['sdk_path'] = sdk_path
build_tools = os.path.join(sdk_path, 'build-tools')
common.testCase: fix find_sdk_tools when aapt is installed in /usr/bin The testlogic was broken when having both aapt in /usr/bin and also as part of the android sdk.
2017-12-03 15:01:48 +01:00
if self._set_build_tools() or os.path.exists('/usr/bin/aapt'):
find cmds from SDK build-tools in a more flexible way, on the fly This is a more flexible approach than testing for the complete SDK and build-tools up front. This will only test for the commands that are actually being run, so that if you only have `aapt` installed, you can do `fdroid update` without errors, but other commands will still give appropriate errors. This also makes the build_tools item in config.py optional, it is only needed if you want to force a specific version of the build-tools.
2014-12-09 14:12:41 +01:00
self._find_all()
else:
Make pre-commit hook pass after python3 switch
2016-01-04 17:28:55 +01:00
print('no build-tools found: ' + build_tools)
find cmds from SDK build-tools in a more flexible way, on the fly This is a more flexible approach than testing for the complete SDK and build-tools up front. This will only test for the commands that are actually being run, so that if you only have `aapt` installed, you can do `fdroid update` without errors, but other commands will still give appropriate errors. This also makes the build_tools item in config.py optional, it is only needed if you want to force a specific version of the build-tools.
2014-12-09 14:12:41 +01:00
choose the most recent available version of Java This came about testing on OSX, where there are often multiple versions of the JDK installed. This was choosing the oldest version. It should choose the most recent version.
2017-10-20 11:35:48 +02:00
def test_find_java_root_path(self):
tests: name temp test dir after test function that used it
2017-11-30 09:59:02 +01:00
testdir = tempfile.mkdtemp(prefix=inspect.currentframe().f_code.co_name, dir=self.tmpdir)
os.chdir(testdir)
choose the most recent available version of Java This came about testing on OSX, where there are often multiple versions of the JDK installed. This was choosing the oldest version. It should choose the most recent version.
2017-10-20 11:35:48 +02:00
all_pathlists = [
([ # Debian
'/usr/lib/jvm/java-1.5.0-gcj-5-amd64',
'/usr/lib/jvm/java-8-openjdk-amd64',
'/usr/lib/jvm/java-1.8.0-openjdk-amd64',
], '/usr/lib/jvm/java-8-openjdk-amd64'),
([ # OSX
Added newer ndks, gradles, latest sdk-license, and update java 1.8 version
2019-03-30 22:10:21 +01:00
'/Library/Java/JavaVirtualMachines/jdk1.8.0_202.jdk',
choose the most recent available version of Java This came about testing on OSX, where there are often multiple versions of the JDK installed. This was choosing the oldest version. It should choose the most recent version.
2017-10-20 11:35:48 +02:00
'/Library/Java/JavaVirtualMachines/jdk1.8.0_45.jdk',
Added newer ndks, gradles, latest sdk-license, and update java 1.8 version
2019-03-30 22:10:21 +01:00
'/System/Library/Java/JavaVirtualMachines/jdk1.7.0_80.jdk',
], '/Library/Java/JavaVirtualMachines/jdk1.8.0_202.jdk'),
choose the most recent available version of Java This came about testing on OSX, where there are often multiple versions of the JDK installed. This was choosing the oldest version. It should choose the most recent version.
2017-10-20 11:35:48 +02:00
]
for pathlist, choice in all_pathlists:
# strip leading / to make relative paths to test without root
pathlist = [p[1:] for p in pathlist]
# create test file used in common._add_java_paths_to_config()
for p in pathlist:
if p.startswith('/System') or p.startswith('/Library'):
basedir = os.path.join(p, 'Contents', 'Home', 'bin')
else:
basedir = os.path.join(p, 'bin')
os.makedirs(basedir)
open(os.path.join(basedir, 'javac'), 'w').close()
config = dict()
config['java_paths'] = dict()
fdroidserver.common._add_java_paths_to_config(pathlist, config)
self.assertEqual(config['java_paths']['8'], choice[1:])
use androguard primitives to speed up finding debuggable flag androguard parses the whole APK before handing the instance back, this uses the primitives to just find the <application android:debuggable=""> value, then stop parsing. #557
2018-09-18 15:59:49 +02:00
def test_is_apk_and_debuggable(self):
added test case for common.isApkDebuggable() Just getting into the habit of adding tests to everything that I change... Also, it should be useful to have an unsigned APK in the test collection, since `fdroid update` should handle it gracefully and give a warning of some kind.
2014-12-08 22:55:14 +01:00
config = dict()
refactor env handling for FDroidPopen to support .fdroid.* metadata The start up sequence of processes that are based on the .fdroid.* metadata is a bit different, so this ensures that the environment variables get properly initialized in all cases. This also creates a single function where the environment is set. Before it was being set in multiple places across multiple files.
2015-08-05 14:39:58 +02:00
fdroidserver.common.fill_config_defaults(config)
find cmds from SDK build-tools in a more flexible way, on the fly This is a more flexible approach than testing for the complete SDK and build-tools up front. This will only test for the commands that are actually being run, so that if you only have `aapt` installed, you can do `fdroid update` without errors, but other commands will still give appropriate errors. This also makes the build_tools item in config.py optional, it is only needed if you want to force a specific version of the build-tools.
2014-12-09 14:12:41 +01:00
fdroidserver.common.config = config
add test files to pre-commit hook and fix pep8 errors
2015-07-22 08:19:56 +02:00
self._set_build_tools()
common: fix tests when running without any Android SDK installed fdroid/fdroidserver!552 fdroid/fdroidserver#541
2018-08-07 14:51:42 +02:00
try:
config['aapt'] = fdroidserver.common.find_sdk_tools_cmd('aapt')
except fdroidserver.exception.FDroidException:
pass # aapt is not required if androguard is present
added test case for common.isApkDebuggable() Just getting into the habit of adding tests to everything that I change... Also, it should be useful to have an unsigned APK in the test collection, since `fdroid update` should handle it gracefully and give a warning of some kind.
2014-12-08 22:55:14 +01:00
# these are set debuggable
testfiles = []
tests: add setUp() method to common to handle standard stuff
2017-09-25 16:28:22 +02:00
testfiles.append(os.path.join(self.basedir, 'urzip.apk'))
testfiles.append(os.path.join(self.basedir, 'urzip-badsig.apk'))
testfiles.append(os.path.join(self.basedir, 'urzip-badcert.apk'))
added test case for common.isApkDebuggable() Just getting into the habit of adding tests to everything that I change... Also, it should be useful to have an unsigned APK in the test collection, since `fdroid update` should handle it gracefully and give a warning of some kind.
2014-12-08 22:55:14 +01:00
for apkfile in testfiles:
make is_apk_and_debuggable() default to using androguard before aapt
2018-02-22 15:08:53 +01:00
debuggable = fdroidserver.common.is_apk_and_debuggable(apkfile)
added test case for common.isApkDebuggable() Just getting into the habit of adding tests to everything that I change... Also, it should be useful to have an unsigned APK in the test collection, since `fdroid update` should handle it gracefully and give a warning of some kind.
2014-12-08 22:55:14 +01:00
self.assertTrue(debuggable,
"debuggable APK state was not properly parsed!")
use androguard primitives to speed up finding debuggable flag androguard parses the whole APK before handing the instance back, this uses the primitives to just find the <application android:debuggable=""> value, then stop parsing. #557
2018-09-18 15:59:49 +02:00
if 'aapt' in config:
self.assertTrue(fdroidserver.common.is_apk_and_debuggable_aapt(apkfile),
'aapt parsing missed <application android:debuggable="">!')
if fdroidserver.common.use_androguard():
self.assertTrue(fdroidserver.common.is_apk_and_debuggable_androguard(apkfile),
'androguard missed <application android:debuggable="">!')
added test case for common.isApkDebuggable() Just getting into the habit of adding tests to everything that I change... Also, it should be useful to have an unsigned APK in the test collection, since `fdroid update` should handle it gracefully and give a warning of some kind.
2014-12-08 22:55:14 +01:00
# these are set NOT debuggable
testfiles = []
tests: add setUp() method to common to handle standard stuff
2017-09-25 16:28:22 +02:00
testfiles.append(os.path.join(self.basedir, 'urzip-release.apk'))
testfiles.append(os.path.join(self.basedir, 'urzip-release-unsigned.apk'))
support APK Signature V2 when apksigner is installed This was done with much help from @uniqx. This is the first level of supporting APK Signatures v1, v2, and v3. This is enough to include APKs with any combo of v1/v2/v3 signatures. For this to work at all, apksigner and androguard 3.3.3+ must be installed. closes #399
2019-01-30 16:48:35 +01:00
testfiles.append(os.path.join(self.basedir, 'v2.only.sig_2.apk'))
added test case for common.isApkDebuggable() Just getting into the habit of adding tests to everything that I change... Also, it should be useful to have an unsigned APK in the test collection, since `fdroid update` should handle it gracefully and give a warning of some kind.
2014-12-08 22:55:14 +01:00
for apkfile in testfiles:
make is_apk_and_debuggable() default to using androguard before aapt
2018-02-22 15:08:53 +01:00
debuggable = fdroidserver.common.is_apk_and_debuggable(apkfile)
added test case for common.isApkDebuggable() Just getting into the habit of adding tests to everything that I change... Also, it should be useful to have an unsigned APK in the test collection, since `fdroid update` should handle it gracefully and give a warning of some kind.
2014-12-08 22:55:14 +01:00
self.assertFalse(debuggable,
"debuggable APK state was not properly parsed!")
use androguard primitives to speed up finding debuggable flag androguard parses the whole APK before handing the instance back, this uses the primitives to just find the <application android:debuggable=""> value, then stop parsing. #557
2018-09-18 15:59:49 +02:00
if 'aapt' in config:
self.assertFalse(fdroidserver.common.is_apk_and_debuggable_aapt(apkfile),
'aapt parsing missed <application android:debuggable="">!')
if fdroidserver.common.use_androguard():
self.assertFalse(fdroidserver.common.is_apk_and_debuggable_androguard(apkfile),
'androguard missed <application android:debuggable="">!')
added test case for common.isApkDebuggable() Just getting into the habit of adding tests to everything that I change... Also, it should be useful to have an unsigned APK in the test collection, since `fdroid update` should handle it gracefully and give a warning of some kind.
2014-12-08 22:55:14 +01:00
fix strict Application ID checks * upper case letters are allowed at all positions * there must be a "." separator
2018-09-24 16:20:57 +02:00
VALID_STRICT_PACKAGE_NAMES = [
"An.stop",
"SpeedoMeterApp.main",
"a2dp.Vol",
"au.com.darkside.XServer",
"click.dummer.UartSmartwatch",
"com.Bisha.TI89EmuDonation",
"com.MarcosDiez.shareviahttp",
"com.Pau.ImapNotes2",
"com.app.Zensuren",
"com.darshancomputing.BatteryIndicator",
"com.geecko.QuickLyric",
"com.genonbeta.TrebleShot",
"com.gpl.rpg.AndorsTrail",
"com.hobbyone.HashDroid",
"com.moez.QKSMS",
"com.platypus.SAnd",
"com.prhlt.aemus.Read4SpeechExperiments",
"de.syss.MifareClassicTool",
"org.fdroid.fdroid",
"org.f_droid.fdr0ID",
]
validate appid when reading metadata files The metadata file must be named after the Application ID of the app it is describing, and Android Application IDs must be valid Java Package Names.
2018-09-01 12:08:37 +02:00
def test_is_valid_package_name(self):
fix strict Application ID checks * upper case letters are allowed at all positions * there must be a "." separator
2018-09-24 16:20:57 +02:00
for name in self.VALID_STRICT_PACKAGE_NAMES + [
"_SpeedoMeterApp.main",
"05041684efd9b16c2888b1eddbadd0359f655f311b89bdd1737f560a10d20fb8"]:
Ensure package names are valid
2015-01-26 19:29:39 +01:00
self.assertTrue(fdroidserver.common.is_valid_package_name(name),
add test files to pre-commit hook and fix pep8 errors
2015-07-22 08:19:56 +02:00
"{0} should be a valid package name".format(name))
Ensure package names are valid
2015-01-26 19:29:39 +01:00
for name in ["0rg.fdroid.fdroid",
".f_droid.fdr0ID",
fix strict Application ID checks * upper case letters are allowed at all positions * there must be a "." separator
2018-09-24 16:20:57 +02:00
"trailingdot.",
Ensure package names are valid
2015-01-26 19:29:39 +01:00
"org.fdroid/fdroid",
"/org.fdroid.fdroid"]:
self.assertFalse(fdroidserver.common.is_valid_package_name(name),
add test files to pre-commit hook and fix pep8 errors
2015-07-22 08:19:56 +02:00
"{0} should not be a valid package name".format(name))
added test case for common.isApkDebuggable() Just getting into the habit of adding tests to everything that I change... Also, it should be useful to have an unsigned APK in the test collection, since `fdroid update` should handle it gracefully and give a warning of some kind.
2014-12-08 22:55:14 +01:00
add strict, tested validation of Android/F-Droid package names Android has stricter rules than Java for Package Names, but anything the Python regex thinks is valid must be valid according to Java's rules too. https://developer.android.com/studio/build/application-id
2018-09-07 14:17:39 +02:00
def test_is_strict_application_id(self):
"""see also tests/valid-package-names/"""
fix strict Application ID checks * upper case letters are allowed at all positions * there must be a "." separator
2018-09-24 16:20:57 +02:00
for name in self.VALID_STRICT_PACKAGE_NAMES:
add strict, tested validation of Android/F-Droid package names Android has stricter rules than Java for Package Names, but anything the Python regex thinks is valid must be valid according to Java's rules too. https://developer.android.com/studio/build/application-id
2018-09-07 14:17:39 +02:00
self.assertTrue(fdroidserver.common.is_strict_application_id(name),
"{0} should be a strict application id".format(name))
validate appid when reading metadata files The metadata file must be named after the Application ID of the app it is describing, and Android Application IDs must be valid Java Package Names.
2018-09-01 12:08:37 +02:00
for name in ["0rg.fdroid.fdroid",
".f_droid.fdr0ID",
add strict, tested validation of Android/F-Droid package names Android has stricter rules than Java for Package Names, but anything the Python regex thinks is valid must be valid according to Java's rules too. https://developer.android.com/studio/build/application-id
2018-09-07 14:17:39 +02:00
"oneword",
fix strict Application ID checks * upper case letters are allowed at all positions * there must be a "." separator
2018-09-24 16:20:57 +02:00
"trailingdot.",
add strict, tested validation of Android/F-Droid package names Android has stricter rules than Java for Package Names, but anything the Python regex thinks is valid must be valid according to Java's rules too. https://developer.android.com/studio/build/application-id
2018-09-07 14:17:39 +02:00
"cafebabe",
validate appid when reading metadata files The metadata file must be named after the Application ID of the app it is describing, and Android Application IDs must be valid Java Package Names.
2018-09-01 12:08:37 +02:00
"org.fdroid/fdroid",
"/org.fdroid.fdroid",
fix strict Application ID checks * upper case letters are allowed at all positions * there must be a "." separator
2018-09-24 16:20:57 +02:00
"_SpeedoMeterApp.main",
validate appid when reading metadata files The metadata file must be named after the Application ID of the app it is describing, and Android Application IDs must be valid Java Package Names.
2018-09-01 12:08:37 +02:00
"05041684efd9b16c2888b1eddbadd0359f655f311b89bdd1737f560a10d20fb8"]:
add strict, tested validation of Android/F-Droid package names Android has stricter rules than Java for Package Names, but anything the Python regex thinks is valid must be valid according to Java's rules too. https://developer.android.com/studio/build/application-id
2018-09-07 14:17:39 +02:00
self.assertFalse(fdroidserver.common.is_strict_application_id(name),
"{0} should not be a strict application id".format(name))
validate appid when reading metadata files The metadata file must be named after the Application ID of the app it is describing, and Android Application IDs must be valid Java Package Names.
2018-09-01 12:08:37 +02:00
test new common.regsub_file() method that replaces sed calls
2015-07-30 22:13:36 +02:00
def test_prepare_sources(self):
testint = 99999999
teststr = 'FAKE_STR_FOR_TESTING'
build: improve regsub pattern for setting buildToolsVersion This addresses the discussion in !64 https://gitlab.com/fdroid/fdroidserver/merge_requests/64 Sometimes, buildToolsVersion is a kind of gradle macro call, and other times it is a variable assignment. This regsub pattern now handles both of those cases.
2015-08-11 15:33:03 +02:00
tests: use standard dir setup so all tests start in same dir
2017-11-30 10:14:38 +01:00
testdir = tempfile.mkdtemp(prefix=inspect.currentframe().f_code.co_name, dir=self.tmpdir)
tests: add setUp() method to common to handle standard stuff
2017-09-25 16:28:22 +02:00
shutil.copytree(os.path.join(self.basedir, 'source-files'),
tests: use standard dir setup so all tests start in same dir
2017-11-30 10:14:38 +01:00
os.path.join(testdir, 'source-files'))
build: improve regsub pattern for setting buildToolsVersion This addresses the discussion in !64 https://gitlab.com/fdroid/fdroidserver/merge_requests/64 Sometimes, buildToolsVersion is a kind of gradle macro call, and other times it is a variable assignment. This regsub pattern now handles both of those cases.
2015-08-11 15:33:03 +02:00
tests: use standard dir setup so all tests start in same dir
2017-11-30 10:14:38 +01:00
fdroidclient_testdir = os.path.join(testdir, 'source-files', 'fdroid', 'fdroidclient')
test new common.regsub_file() method that replaces sed calls
2015-07-30 22:13:36 +02:00
config = dict()
config['sdk_path'] = os.getenv('ANDROID_HOME')
Rework build into a class This simplifies usage, goes from build['flag'] to build.flag Also makes static analyzers able to detect invalid attributes as the set is now limited in the class definition. As a bonus, setting of the default field values is now done in the constructor, not separately and manually. While at it, unify "build", "thisbuild", "info", "thisinfo", etc into just "build".
2015-11-28 17:55:27 +01:00
config['ndk_paths'] = {'r10d': os.getenv('ANDROID_NDK_HOME')}
test new common.regsub_file() method that replaces sed calls
2015-07-30 22:13:36 +02:00
config['build_tools'] = 'FAKE_BUILD_TOOLS_VERSION'
fdroidserver.common.config = config
Rework app into a class This simplifies usage, goes from app['Foo'] to app.Foo Also makes static analyzers able to detect invalid attributes as the set is now limited in the class definition. As a bonus, setting of the default field values is now done in the constructor, not separately and manually.
2015-11-28 13:09:47 +01:00
app = fdroidserver.metadata.App()
app.id = 'org.fdroid.froid'
Rework build into a class This simplifies usage, goes from build['flag'] to build.flag Also makes static analyzers able to detect invalid attributes as the set is now limited in the class definition. As a bonus, setting of the default field values is now done in the constructor, not separately and manually. While at it, unify "build", "thisbuild", "info", "thisinfo", etc into just "build".
2015-11-28 17:55:27 +01:00
build = fdroidserver.metadata.Build()
build.commit = 'master'
build.forceversion = True
build.forcevercode = True
build.gradle = ['yes']
build.target = 'android-' + str(testint)
rename Build fields: version -> versionName, vercode -> versionCode Since the YAML/JSON/etc. field names are now exactly the same as the field names used in the internal dict in the Build class, this is a global rename This keeps with the standard names used in Android: https://developer.android.com/guide/topics/manifest/manifest-element.html
2016-11-23 17:52:04 +01:00
build.versionName = teststr
build.versionCode = testint
test new common.regsub_file() method that replaces sed calls
2015-07-30 22:13:36 +02:00
class FakeVcs():
# no need to change to the correct commit here
def gotorevision(self, rev, refresh=True):
pass
# no srclib info needed, but it could be added...
def getsrclib(self):
return None
tests: use standard dir setup so all tests start in same dir
2017-11-30 10:14:38 +01:00
fdroidserver.common.prepare_source(FakeVcs(), app, build,
fdroidclient_testdir, fdroidclient_testdir, fdroidclient_testdir)
test new common.regsub_file() method that replaces sed calls
2015-07-30 22:13:36 +02:00
tests: use standard dir setup so all tests start in same dir
2017-11-30 10:14:38 +01:00
with open(os.path.join(fdroidclient_testdir, 'build.gradle'), 'r') as f:
tests: close files
2015-10-08 13:20:35 +02:00
filedata = f.read()
fix PEP8 W605 invalid escape sequence Python 3.7 will get a lot stricter with escape sequences. They must be valid. * https://lintlyci.github.io/Flake8Rules/rules/W605.html * https://docs.python.org/3/whatsnew/3.6.html#deprecated-python-behavior
2018-05-29 13:51:47 +02:00
self.assertIsNotNone(re.search(r"\s+compileSdkVersion %s\s+" % testint, filedata))
test new common.regsub_file() method that replaces sed calls
2015-07-30 22:13:36 +02:00
tests: use standard dir setup so all tests start in same dir
2017-11-30 10:14:38 +01:00
with open(os.path.join(fdroidclient_testdir, 'AndroidManifest.xml')) as f:
tests: close files
2015-10-08 13:20:35 +02:00
filedata = f.read()
test new common.regsub_file() method that replaces sed calls
2015-07-30 22:13:36 +02:00
self.assertIsNone(re.search('android:debuggable', filedata))
rename Build fields: version -> versionName, vercode -> versionCode Since the YAML/JSON/etc. field names are now exactly the same as the field names used in the internal dict in the Build class, this is a global rename This keeps with the standard names used in Android: https://developer.android.com/guide/topics/manifest/manifest-element.html
2016-11-23 17:52:04 +01:00
self.assertIsNotNone(re.search('android:versionName="%s"' % build.versionName, filedata))
self.assertIsNotNone(re.search('android:versionCode="%s"' % build.versionCode, filedata))
test new common.regsub_file() method that replaces sed calls
2015-07-30 22:13:36 +02:00
tests: test setting up app git repo like `fdroid build` does I wrote this to try to find #379 but this test didn't trigger that bug.
2017-09-25 16:34:25 +02:00
def test_prepare_sources_refresh(self):
packageName = 'org.fdroid.ci.test.app'
tests: name temp test dir after test function that used it
2017-11-30 09:59:02 +01:00
testdir = tempfile.mkdtemp(prefix=inspect.currentframe().f_code.co_name, dir=self.tmpdir)
tests: test setting up app git repo like `fdroid build` does I wrote this to try to find #379 but this test didn't trigger that bug.
2017-09-25 16:34:25 +02:00
print('testdir', testdir)
os.chdir(testdir)
os.mkdir('build')
os.mkdir('metadata')
# use a local copy if available to avoid hitting the network
tmprepo = os.path.join(self.basedir, 'tmp', 'importer')
if os.path.exists(tmprepo):
git_url = tmprepo
else:
git_url = 'https://gitlab.com/fdroid/ci-test-app.git'
metadata = dict()
metadata['Description'] = 'This is just a test app'
metadata['RepoType'] = 'git'
metadata['Repo'] = git_url
with open(os.path.join('metadata', packageName + '.yml'), 'w') as fp:
yaml.dump(metadata, fp)
gitrepo = os.path.join(testdir, 'build', packageName)
vcs0 = fdroidserver.common.getvcs('git', git_url, gitrepo)
vcs0.gotorevision('0.3', refresh=True)
vcs1 = fdroidserver.common.getvcs('git', git_url, gitrepo)
vcs1.gotorevision('0.3', refresh=False)
Add FDroidPopen usage test
2016-02-17 21:45:06 +01:00
def test_fdroid_popen_stderr_redirect(self):
tests: add setUp() method to common to handle standard stuff
2017-09-25 16:28:22 +02:00
config = dict()
fdroidserver.common.fill_config_defaults(config)
fdroidserver.common.config = config
Add FDroidPopen usage test
2016-02-17 21:45:06 +01:00
commands = ['sh', '-c', 'echo stdout message && echo stderr message 1>&2']
p = fdroidserver.common.FDroidPopen(commands)
self.assertEqual(p.output, 'stdout message\nstderr message\n')
p = fdroidserver.common.FDroidPopen(commands, stderr_to_stdout=False)
self.assertEqual(p.output, 'stdout message\n')
test new common.regsub_file() method that replaces sed calls
2015-07-30 22:13:36 +02:00
move update.signjar() to common so it can also be used in signindex
2017-03-15 21:23:44 +01:00
def test_signjar(self):
fdroidserver.common.config = None
config = fdroidserver.common.read_config(fdroidserver.common.options)
config['jarsigner'] = fdroidserver.common.find_sdk_tools_cmd('jarsigner')
fdroidserver.common.config = config
Move index signing methods into signindex.py
2017-03-29 17:11:40 +02:00
fdroidserver.signindex.config = config
move update.signjar() to common so it can also be used in signindex
2017-03-15 21:23:44 +01:00
tests: add setUp() method to common to handle standard stuff
2017-09-25 16:28:22 +02:00
sourcedir = os.path.join(self.basedir, 'signindex')
tests: name temp test dir after test function that used it
2017-11-30 09:59:02 +01:00
testsdir = tempfile.mkdtemp(prefix=inspect.currentframe().f_code.co_name, dir=self.tmpdir)
move update.signjar() to common so it can also be used in signindex
2017-03-15 21:23:44 +01:00
for f in ('testy.jar', 'guardianproject.jar',):
sourcefile = os.path.join(sourcedir, f)
testfile = os.path.join(testsdir, f)
shutil.copy(sourcefile, testsdir)
Move index signing methods into signindex.py
2017-03-29 17:11:40 +02:00
fdroidserver.signindex.sign_jar(testfile)
move update.signjar() to common so it can also be used in signindex
2017-03-15 21:23:44 +01:00
# these should be resigned, and therefore different
self.assertNotEqual(open(sourcefile, 'rb').read(), open(testfile, 'rb').read())
prefer apksigner if installed, jarsigner sucks Google has their own utility for verifying APK signatures on a desktop machine since Java's jarsigner is bad for the task. For example, it acts as if an unsigned APK validates. And to check whether an APK is unsigned using jarsigner is difficult. apksigner also does the v2 signatures, so it will have to be used eventually anyway. It is already in Debian/stretch and can be available in jessie-backports if need be. https://android.googlesource.com/platform/tools/apksig https://packages.debian.org/apksigner
2017-01-09 17:35:58 +01:00
def test_verify_apk_signature(self):
fdroidserver.common.config = None
config = fdroidserver.common.read_config(fdroidserver.common.options)
config['jarsigner'] = fdroidserver.common.find_sdk_tools_cmd('jarsigner')
fdroidserver.common.config = config
handle jarsigner/apksigner output cleanly for rational logging These were both spamming the output with lots of confusing messages, even when --verbose was not used. Jarsigner especially has confusing messages, since it has warnings that do not pertain to APK signatures at all, like the ones about timestamps and missing Certificate Authority. closes #405
2017-12-07 17:32:14 +01:00
self.assertTrue(fdroidserver.common.verify_apk_signature('bad-unicode-πÇÇ现代通用字-български-عربي1.apk'))
tests: handle when apksigner considers MD5 signatures valid
2019-07-01 11:43:18 +02:00
if 'apksigner' in fdroidserver.common.config: # apksigner considers MD5 signatures valid
self.assertTrue(fdroidserver.common.verify_apk_signature('org.bitbucket.tickytacky.mirrormirror_1.apk'))
self.assertTrue(fdroidserver.common.verify_apk_signature('org.bitbucket.tickytacky.mirrormirror_2.apk'))
self.assertTrue(fdroidserver.common.verify_apk_signature('org.bitbucket.tickytacky.mirrormirror_3.apk'))
self.assertTrue(fdroidserver.common.verify_apk_signature('org.bitbucket.tickytacky.mirrormirror_4.apk'))
else:
self.assertFalse(fdroidserver.common.verify_apk_signature('org.bitbucket.tickytacky.mirrormirror_1.apk'))
self.assertFalse(fdroidserver.common.verify_apk_signature('org.bitbucket.tickytacky.mirrormirror_2.apk'))
self.assertFalse(fdroidserver.common.verify_apk_signature('org.bitbucket.tickytacky.mirrormirror_3.apk'))
self.assertFalse(fdroidserver.common.verify_apk_signature('org.bitbucket.tickytacky.mirrormirror_4.apk'))
handle jarsigner/apksigner output cleanly for rational logging These were both spamming the output with lots of confusing messages, even when --verbose was not used. Jarsigner especially has confusing messages, since it has warnings that do not pertain to APK signatures at all, like the ones about timestamps and missing Certificate Authority. closes #405
2017-12-07 17:32:14 +01:00
self.assertTrue(fdroidserver.common.verify_apk_signature('org.dyndns.fules.ck_20.apk'))
prefer apksigner if installed, jarsigner sucks Google has their own utility for verifying APK signatures on a desktop machine since Java's jarsigner is bad for the task. For example, it acts as if an unsigned APK validates. And to check whether an APK is unsigned using jarsigner is difficult. apksigner also does the v2 signatures, so it will have to be used eventually anyway. It is already in Debian/stretch and can be available in jessie-backports if need be. https://android.googlesource.com/platform/tools/apksig https://packages.debian.org/apksigner
2017-01-09 17:35:58 +01:00
self.assertTrue(fdroidserver.common.verify_apk_signature('urzip.apk'))
self.assertFalse(fdroidserver.common.verify_apk_signature('urzip-badcert.apk'))
self.assertFalse(fdroidserver.common.verify_apk_signature('urzip-badsig.apk'))
self.assertTrue(fdroidserver.common.verify_apk_signature('urzip-release.apk'))
self.assertFalse(fdroidserver.common.verify_apk_signature('urzip-release-unsigned.apk'))
handle jarsigner/apksigner output cleanly for rational logging These were both spamming the output with lots of confusing messages, even when --verbose was not used. Jarsigner especially has confusing messages, since it has warnings that do not pertain to APK signatures at all, like the ones about timestamps and missing Certificate Authority. closes #405
2017-12-07 17:32:14 +01:00
def test_verify_old_apk_signature(self):
fdroidserver.common.config = None
config = fdroidserver.common.read_config(fdroidserver.common.options)
config['jarsigner'] = fdroidserver.common.find_sdk_tools_cmd('jarsigner')
fdroidserver.common.config = config
self.assertTrue(fdroidserver.common.verify_old_apk_signature('bad-unicode-πÇÇ现代通用字-български-عربي1.apk'))
self.assertTrue(fdroidserver.common.verify_old_apk_signature('org.bitbucket.tickytacky.mirrormirror_1.apk'))
self.assertTrue(fdroidserver.common.verify_old_apk_signature('org.bitbucket.tickytacky.mirrormirror_2.apk'))
self.assertTrue(fdroidserver.common.verify_old_apk_signature('org.bitbucket.tickytacky.mirrormirror_3.apk'))
self.assertTrue(fdroidserver.common.verify_old_apk_signature('org.bitbucket.tickytacky.mirrormirror_4.apk'))
self.assertTrue(fdroidserver.common.verify_old_apk_signature('org.dyndns.fules.ck_20.apk'))
self.assertTrue(fdroidserver.common.verify_old_apk_signature('urzip.apk'))
self.assertFalse(fdroidserver.common.verify_old_apk_signature('urzip-badcert.apk'))
self.assertFalse(fdroidserver.common.verify_old_apk_signature('urzip-badsig.apk'))
self.assertTrue(fdroidserver.common.verify_old_apk_signature('urzip-release.apk'))
self.assertFalse(fdroidserver.common.verify_old_apk_signature('urzip-release-unsigned.apk'))
def test_verify_jar_signature_succeeds(self):
fdroidserver.common.config = None
config = fdroidserver.common.read_config(fdroidserver.common.options)
config['jarsigner'] = fdroidserver.common.find_sdk_tools_cmd('jarsigner')
fdroidserver.common.config = config
source_dir = os.path.join(self.basedir, 'signindex')
for f in ('testy.jar', 'guardianproject.jar'):
testfile = os.path.join(source_dir, f)
fdroidserver.common.verify_jar_signature(testfile)
def test_verify_jar_signature_fails(self):
fdroidserver.common.config = None
config = fdroidserver.common.read_config(fdroidserver.common.options)
config['jarsigner'] = fdroidserver.common.find_sdk_tools_cmd('jarsigner')
fdroidserver.common.config = config
source_dir = os.path.join(self.basedir, 'signindex')
testfile = os.path.join(source_dir, 'unsigned.jar')
with self.assertRaises(fdroidserver.index.VerificationException):
fdroidserver.common.verify_jar_signature(testfile)
verify: ensure only a single signature is in compared APK The ZIP format allows multiple entries with the exact same filename, and on top of that, it does not allow deleting or updating entries. To make the `fdroid verify` procedure failsafe, it needs to create a new temporary APK that is made up on the contents of the "unsigned APK" and the signature from the "signed APK". Since it would be possible to give a signed APK as in the unsigned one's position, `fdroid verify` was not able to update the signature since it was just adding the new signature to the end of the ZIP file. When reading a ZIP, the first entry is used.
2016-12-19 16:54:32 +01:00
def test_verify_apks(self):
fdroidserver.common.config = None
config = fdroidserver.common.read_config(fdroidserver.common.options)
config['jarsigner'] = fdroidserver.common.find_sdk_tools_cmd('jarsigner')
fdroidserver.common.config = config
tests: add setUp() method to common to handle standard stuff
2017-09-25 16:28:22 +02:00
sourceapk = os.path.join(self.basedir, 'urzip.apk')
verify: ensure only a single signature is in compared APK The ZIP format allows multiple entries with the exact same filename, and on top of that, it does not allow deleting or updating entries. To make the `fdroid verify` procedure failsafe, it needs to create a new temporary APK that is made up on the contents of the "unsigned APK" and the signature from the "signed APK". Since it would be possible to give a signed APK as in the unsigned one's position, `fdroid verify` was not able to update the signature since it was just adding the new signature to the end of the ZIP file. When reading a ZIP, the first entry is used.
2016-12-19 16:54:32 +01:00
tests: name temp test dir after test function that used it
2017-11-30 09:59:02 +01:00
testdir = tempfile.mkdtemp(prefix=inspect.currentframe().f_code.co_name, dir=self.tmpdir)
verify: ensure only a single signature is in compared APK The ZIP format allows multiple entries with the exact same filename, and on top of that, it does not allow deleting or updating entries. To make the `fdroid verify` procedure failsafe, it needs to create a new temporary APK that is made up on the contents of the "unsigned APK" and the signature from the "signed APK". Since it would be possible to give a signed APK as in the unsigned one's position, `fdroid verify` was not able to update the signature since it was just adding the new signature to the end of the ZIP file. When reading a ZIP, the first entry is used.
2016-12-19 16:54:32 +01:00
print('testdir', testdir)
copyapk = os.path.join(testdir, 'urzip-copy.apk')
shutil.copy(sourceapk, copyapk)
self.assertTrue(fdroidserver.common.verify_apk_signature(copyapk))
tests: add setUp() method to common to handle standard stuff
2017-09-25 16:28:22 +02:00
self.assertIsNone(fdroidserver.common.verify_apks(sourceapk, copyapk, self.tmpdir))
verify: ensure only a single signature is in compared APK The ZIP format allows multiple entries with the exact same filename, and on top of that, it does not allow deleting or updating entries. To make the `fdroid verify` procedure failsafe, it needs to create a new temporary APK that is made up on the contents of the "unsigned APK" and the signature from the "signed APK". Since it would be possible to give a signed APK as in the unsigned one's position, `fdroid verify` was not able to update the signature since it was just adding the new signature to the end of the ZIP file. When reading a ZIP, the first entry is used.
2016-12-19 16:54:32 +01:00
unsignedapk = os.path.join(testdir, 'urzip-unsigned.apk')
with ZipFile(sourceapk, 'r') as apk:
with ZipFile(unsignedapk, 'w') as testapk:
for info in apk.infolist():
if not info.filename.startswith('META-INF/'):
testapk.writestr(info, apk.read(info.filename))
tests: add setUp() method to common to handle standard stuff
2017-09-25 16:28:22 +02:00
self.assertIsNone(fdroidserver.common.verify_apks(sourceapk, unsignedapk, self.tmpdir))
verify: ensure only a single signature is in compared APK The ZIP format allows multiple entries with the exact same filename, and on top of that, it does not allow deleting or updating entries. To make the `fdroid verify` procedure failsafe, it needs to create a new temporary APK that is made up on the contents of the "unsigned APK" and the signature from the "signed APK". Since it would be possible to give a signed APK as in the unsigned one's position, `fdroid verify` was not able to update the signature since it was just adding the new signature to the end of the ZIP file. When reading a ZIP, the first entry is used.
2016-12-19 16:54:32 +01:00
twosigapk = os.path.join(testdir, 'urzip-twosig.apk')
tests: add setUp() method to common to handle standard stuff
2017-09-25 16:28:22 +02:00
otherapk = ZipFile(os.path.join(self.basedir, 'urzip-release.apk'), 'r')
verify: ensure only a single signature is in compared APK The ZIP format allows multiple entries with the exact same filename, and on top of that, it does not allow deleting or updating entries. To make the `fdroid verify` procedure failsafe, it needs to create a new temporary APK that is made up on the contents of the "unsigned APK" and the signature from the "signed APK". Since it would be possible to give a signed APK as in the unsigned one's position, `fdroid verify` was not able to update the signature since it was just adding the new signature to the end of the ZIP file. When reading a ZIP, the first entry is used.
2016-12-19 16:54:32 +01:00
with ZipFile(sourceapk, 'r') as apk:
with ZipFile(twosigapk, 'w') as testapk:
for info in apk.infolist():
testapk.writestr(info, apk.read(info.filename))
if info.filename.startswith('META-INF/'):
testapk.writestr(info, otherapk.read(info.filename))
otherapk.close()
self.assertFalse(fdroidserver.common.verify_apk_signature(twosigapk))
tests: add setUp() method to common to handle standard stuff
2017-09-25 16:28:22 +02:00
self.assertIsNone(fdroidserver.common.verify_apks(sourceapk, twosigapk, self.tmpdir))
verify: ensure only a single signature is in compared APK The ZIP format allows multiple entries with the exact same filename, and on top of that, it does not allow deleting or updating entries. To make the `fdroid verify` procedure failsafe, it needs to create a new temporary APK that is made up on the contents of the "unsigned APK" and the signature from the "signed APK". Since it would be possible to give a signed APK as in the unsigned one's position, `fdroid verify` was not able to update the signature since it was just adding the new signature to the end of the ZIP file. When reading a ZIP, the first entry is used.
2016-12-19 16:54:32 +01:00
avoid duplicate value assignments when updating config files
2017-04-02 12:08:01 +02:00
def test_write_to_config(self):
with tempfile.TemporaryDirectory() as tmpPath:
cfgPath = os.path.join(tmpPath, 'config.py')
remove redundant open() arg: encoding='utf8' By default, open() returns a str: https://docs.python.org/3/library/functions.html#open By default, str is UTF-8: https://docs.python.org/3/library/stdtypes.html#str This used to matter on Python 2.x, but this code is 3.x only now.
2018-10-19 15:01:34 +02:00
with open(cfgPath, 'w') as f:
avoid duplicate value assignments when updating config files
2017-04-02 12:08:01 +02:00
f.write(textwrap.dedent("""\
# abc
# test = 'example value'
default_me= '%%%'
# comment
do_not_touch = "good value"
default_me="!!!"
key="123" # inline"""))
cfg = {'key': '111', 'default_me_orig': 'orig'}
fdroidserver.common.write_to_config(cfg, 'key', config_file=cfgPath)
fdroidserver.common.write_to_config(cfg, 'default_me', config_file=cfgPath)
fdroidserver.common.write_to_config(cfg, 'test', value='test value', config_file=cfgPath)
fdroidserver.common.write_to_config(cfg, 'new_key', value='new', config_file=cfgPath)
remove redundant open() arg: encoding='utf8' By default, open() returns a str: https://docs.python.org/3/library/functions.html#open By default, str is UTF-8: https://docs.python.org/3/library/stdtypes.html#str This used to matter on Python 2.x, but this code is 3.x only now.
2018-10-19 15:01:34 +02:00
with open(cfgPath, 'r') as f:
avoid duplicate value assignments when updating config files
2017-04-02 12:08:01 +02:00
self.assertEqual(f.read(), textwrap.dedent("""\
# abc
test = 'test value'
default_me = 'orig'
# comment
do_not_touch = "good value"
key = "111" # inline
new_key = "new"
"""))
def test_write_to_config_when_empty(self):
with tempfile.TemporaryDirectory() as tmpPath:
cfgPath = os.path.join(tmpPath, 'config.py')
with open(cfgPath, 'w') as f:
pass
fdroidserver.common.write_to_config({}, 'key', 'val', cfgPath)
remove redundant open() arg: encoding='utf8' By default, open() returns a str: https://docs.python.org/3/library/functions.html#open By default, str is UTF-8: https://docs.python.org/3/library/stdtypes.html#str This used to matter on Python 2.x, but this code is 3.x only now.
2018-10-19 15:01:34 +02:00
with open(cfgPath, 'r') as f:
avoid duplicate value assignments when updating config files
2017-04-02 12:08:01 +02:00
self.assertEqual(f.read(), textwrap.dedent("""\
key = "val"
"""))
regexs for getting packageName and versionCode from filenames This is useful for parsing APK files, which can include packageName, versionCode, and optionally 7 char signing key ID (i.e. <sig>). This also can set the packageName and versionCoe for non APK files, so that it is easy to assign them to metadata files, and to allow for upgrades by setting the versionCode in the filename.
2017-05-31 23:02:28 +02:00
def test_apk_name_regex(self):
good = [
'urzipπÇÇπÇÇ现代汉语通用字българскиعربي1234ö_-123456.apk',
'urzipπÇÇπÇÇ现代汉语通用字българскиعربي1234ö_123456_abcdef0.apk',
'urzip_-123456.apk',
'a0_0.apk',
'Z0_0.apk',
'a0_0_abcdef0.apk',
'a_a_a_a_0_abcdef0.apk',
'a_____0.apk',
'a_____123456_abcdef0.apk',
'org.fdroid.fdroid_123456.apk',
# valid, but "_99999" is part of packageName rather than versionCode
'org.fdroid.fdroid_99999_123456.apk',
# should be valid, but I can't figure out the regex since \w includes digits
# 'πÇÇπÇÇ现代汉语通用字българскиعربي1234ö_0_123bafd.apk',
]
for name in good:
m = fdroidserver.common.APK_NAME_REGEX.match(name)
self.assertIsNotNone(m)
self.assertIn(m.group(2), ('-123456', '0', '123456'))
self.assertIn(m.group(3), ('abcdef0', None))
bad = [
'urzipπÇÇπÇÇ现代汉语通用字българскиعربي1234ö_123456_abcdefg.apk',
'urzip-_-198274.apk',
'urzip-_0_123bafd.apk',
'no spaces allowed_123.apk',
'0_0.apk',
'0_0_abcdef0.apk',
]
for name in bad:
self.assertIsNone(fdroidserver.common.APK_NAME_REGEX.match(name))
def test_standard_file_name_regex(self):
good = [
'urzipπÇÇπÇÇ现代汉语通用字българскиعربي1234ö_-123456.mp3',
'urzipπÇÇπÇÇ现代汉语通用字българскиعربي1234ö_123456.mov',
'Document_-123456.pdf',
'WTF_0.MOV',
'Z0_0.ebk',
'a_a_a_a_0.txt',
'org.fdroid.fdroid.privileged.ota_123456.zip',
'πÇÇπÇÇ现代汉语通用字българскиعربي1234ö_0.jpeg',
'a_____0.PNG',
# valid, but "_99999" is part of packageName rather than versionCode
'a_____99999_123456.zip',
'org.fdroid.fdroid_99999_123456.zip',
]
for name in good:
m = fdroidserver.common.STANDARD_FILE_NAME_REGEX.match(name)
self.assertIsNotNone(m)
self.assertIn(m.group(2), ('-123456', '0', '123456'))
bad = [
'urzipπÇÇπÇÇ现代汉语通用字българскиعربي1234ö_abcdefg.JPEG',
'urzip-_-198274.zip',
'urzip-_123bafd.pdf',
'no spaces allowed_123.foobar',
'a_____0.',
]
for name in bad:
self.assertIsNone(fdroidserver.common.STANDARD_FILE_NAME_REGEX.match(name))
common function for fetching sha256 signing-key fingerprint
2017-09-23 09:02:50 +02:00
def test_apk_signer_fingerprint(self):
# fingerprints fetched with: keytool -printcert -file ____.RSA
testapks = (('repo/obb.main.oldversion_1444412523.apk',
'818e469465f96b704e27be2fee4c63ab9f83ddf30e7a34c7371a4728d83b0bc1'),
('repo/obb.main.twoversions_1101613.apk',
'32a23624c201b949f085996ba5ed53d40f703aca4989476949cae891022e0ed6'),
('repo/obb.main.twoversions_1101617.apk',
'32a23624c201b949f085996ba5ed53d40f703aca4989476949cae891022e0ed6'))
for apkfile, keytoolcertfingerprint in testapks:
self.assertEqual(keytoolcertfingerprint,
fdroidserver.common.apk_signer_fingerprint(apkfile))
add common functions for dealing with apk signatures
2017-09-23 09:36:22 +02:00
def test_apk_signer_fingerprint_short(self):
# fingerprints fetched with: keytool -printcert -file ____.RSA
testapks = (('repo/obb.main.oldversion_1444412523.apk', '818e469'),
('repo/obb.main.twoversions_1101613.apk', '32a2362'),
('repo/obb.main.twoversions_1101617.apk', '32a2362'))
for apkfile, keytoolcertfingerprint in testapks:
self.assertEqual(keytoolcertfingerprint,
fdroidserver.common.apk_signer_fingerprint_short(apkfile))
add common.sign_apk() for nighly as test for using in publish Since the MD5 migration was quite a bit of work, it makes sense to start on moving away from SHA1 as much as possible while it is easy to do. SHA256 will only work in APK signatures on android-18 (4.3) or newer. So if an APK has a minSdkVersion of 18 or newer, then sign with SHA256. https://issuetracker.google.com/issues/36956587 https://android-review.googlesource.com/c/platform/libcore/+/44491
2017-11-30 21:10:41 +01:00
def test_sign_apk(self):
common: fix tests when running without any Android SDK installed fdroid/fdroidserver!552 fdroid/fdroidserver#541
2018-08-07 14:51:42 +02:00
try:
tests: common.test_sign_apk requires aapt to run
2019-07-01 22:07:15 +02:00
fdroidserver.common.find_sdk_tools_cmd('aapt')
common: fix tests when running without any Android SDK installed fdroid/fdroidserver!552 fdroid/fdroidserver#541
2018-08-07 14:51:42 +02:00
fdroidserver.common.find_sdk_tools_cmd('zipalign')
except fdroidserver.exception.FDroidException:
print('\n\nSKIPPING test_sign_apk, zipalign is not installed!\n')
return
add common.sign_apk() for nighly as test for using in publish Since the MD5 migration was quite a bit of work, it makes sense to start on moving away from SHA1 as much as possible while it is easy to do. SHA256 will only work in APK signatures on android-18 (4.3) or newer. So if an APK has a minSdkVersion of 18 or newer, then sign with SHA256. https://issuetracker.google.com/issues/36956587 https://android-review.googlesource.com/c/platform/libcore/+/44491
2017-11-30 21:10:41 +01:00
fdroidserver.common.config = None
config = fdroidserver.common.read_config(fdroidserver.common.options)
config['jarsigner'] = fdroidserver.common.find_sdk_tools_cmd('jarsigner')
config['keyalias'] = 'sova'
config['keystorepass'] = 'r9aquRHYoI8+dYz6jKrLntQ5/NJNASFBacJh7Jv2BlI='
config['keypass'] = 'r9aquRHYoI8+dYz6jKrLntQ5/NJNASFBacJh7Jv2BlI='
config['keystore'] = os.path.join(self.basedir, 'keystore.jks')
fdroidserver.common.config = config
fdroidserver.signindex.config = config
testdir = tempfile.mkdtemp(prefix=inspect.currentframe().f_code.co_name, dir=self.tmpdir)
unsigned = os.path.join(testdir, 'urzip-release-unsigned.apk')
signed = os.path.join(testdir, 'urzip-release.apk')
self.assertFalse(fdroidserver.common.verify_apk_signature(unsigned))
shutil.copy(os.path.join(self.basedir, 'urzip-release-unsigned.apk'), testdir)
fdroidserver.common.sign_apk(unsigned, signed, config['keyalias'])
self.assertTrue(os.path.isfile(signed))
self.assertFalse(os.path.isfile(unsigned))
self.assertTrue(fdroidserver.common.verify_apk_signature(signed))
common: fix bug in new SHA-256 signatures for >= android-18 Luckily, this is only used in `fdroid nightly` so far.
2017-12-22 17:49:36 +01:00
# now sign an APK with minSdkVersion >= 18
unsigned = os.path.join(testdir, 'duplicate.permisssions_9999999-unsigned.apk')
signed = os.path.join(testdir, 'duplicate.permisssions_9999999.apk')
shutil.copy(os.path.join(self.basedir, 'repo', 'duplicate.permisssions_9999999.apk'),
os.path.join(unsigned))
fdroidserver.common.apk_strip_signatures(unsigned, strip_manifest=True)
fdroidserver.common.sign_apk(unsigned, signed, config['keyalias'])
self.assertTrue(os.path.isfile(signed))
self.assertFalse(os.path.isfile(unsigned))
self.assertTrue(fdroidserver.common.verify_apk_signature(signed))
common: fix tests when running without any Android SDK installed fdroid/fdroidserver!552 fdroid/fdroidserver#541
2018-08-07 14:51:42 +02:00
try:
fdroidserver.common.find_sdk_tools_cmd('aapt')
self.assertEqual(18, fdroidserver.common.get_minSdkVersion_aapt(signed))
except fdroidserver.exception.FDroidException:
print('\n\nSKIPPING test_sign_apk min SDK check, aapt is not installed!\n')
return
common: fix bug in new SHA-256 signatures for >= android-18 Luckily, this is only used in `fdroid nightly` so far.
2017-12-22 17:49:36 +01:00
handle package: line output from aapt v28 fdroid/fdroiddata!3484 fdroid/fdroiddata!3562 fdroid/fdroidserver!548
2018-09-17 23:12:51 +02:00
def test_get_apk_id(self):
test for common.get_app_id_aapt
2017-09-12 18:17:46 +02:00
config = dict()
fdroidserver.common.fill_config_defaults(config)
fdroidserver.common.config = config
self._set_build_tools()
common: fix tests when running without any Android SDK installed fdroid/fdroidserver!552 fdroid/fdroidserver#541
2018-08-07 14:51:42 +02:00
try:
config['aapt'] = fdroidserver.common.find_sdk_tools_cmd('aapt')
except fdroidserver.exception.FDroidException:
pass # aapt is not required if androguard is present
test for common.get_app_id_aapt
2017-09-12 18:17:46 +02:00
signatures: future-proof fetching app ID info from APK We're not using platformBuildVersionName and it might go away just like it appeared: with no good reason or announcement.
2018-02-22 14:30:39 +01:00
testcases = [
('repo/obb.main.twoversions_1101613.apk', 'obb.main.twoversions', '1101613', '0.1'),
('org.bitbucket.tickytacky.mirrormirror_1.apk', 'org.bitbucket.tickytacky.mirrormirror', '1', '1.0'),
('org.bitbucket.tickytacky.mirrormirror_2.apk', 'org.bitbucket.tickytacky.mirrormirror', '2', '1.0.1'),
('org.bitbucket.tickytacky.mirrormirror_3.apk', 'org.bitbucket.tickytacky.mirrormirror', '3', '1.0.2'),
('org.bitbucket.tickytacky.mirrormirror_4.apk', 'org.bitbucket.tickytacky.mirrormirror', '4', '1.0.3'),
('org.dyndns.fules.ck_20.apk', 'org.dyndns.fules.ck', '20', 'v1.6pre2'),
('urzip.apk', 'info.guardianproject.urzip', '100', '0.1'),
('urzip-badcert.apk', 'info.guardianproject.urzip', '100', '0.1'),
('urzip-badsig.apk', 'info.guardianproject.urzip', '100', '0.1'),
('urzip-release.apk', 'info.guardianproject.urzip', '100', '0.1'),
('urzip-release-unsigned.apk', 'info.guardianproject.urzip', '100', '0.1'),
('repo/com.politedroid_3.apk', 'com.politedroid', '3', '1.2'),
('repo/com.politedroid_4.apk', 'com.politedroid', '4', '1.3'),
('repo/com.politedroid_5.apk', 'com.politedroid', '5', '1.4'),
('repo/com.politedroid_6.apk', 'com.politedroid', '6', '1.5'),
fix intermittent test failure For some reason, the parser stopped working intermittently, even though the format has been the same since aapt 23 or earlier. Then also, some of the test cases pointed to symlinks that were no longer generated, and one test app now has a blank versionName. Strange that this wasn't caught in the gitlab-ci runs. !484 FAIL: test_get_api_id_aapt (__main__.CommonTest) ---------------------------------------------------------------------- Traceback (most recent call last): File "./common.TestCase", line 578, in testA_get_api_id_aapt self.assertEqual(versionName, vn) AssertionError: '0.1' != "0.1' platformBuildVersionName='4.3.1-1425645" - 0.1 + 0.1' platformBuildVersionName='4.3.1-1425645
2018-05-03 13:30:03 +02:00
('repo/duplicate.permisssions_9999999.apk', 'duplicate.permisssions', '9999999', ''),
signatures: future-proof fetching app ID info from APK We're not using platformBuildVersionName and it might go away just like it appeared: with no good reason or announcement.
2018-02-22 14:30:39 +01:00
('repo/info.zwanenburg.caffeinetile_4.apk', 'info.zwanenburg.caffeinetile', '4', '1.3'),
('repo/obb.main.oldversion_1444412523.apk', 'obb.main.oldversion', '1444412523', '0.1'),
('repo/obb.mainpatch.current_1619_another-release-key.apk', 'obb.mainpatch.current', '1619', '0.1'),
('repo/obb.mainpatch.current_1619.apk', 'obb.mainpatch.current', '1619', '0.1'),
('repo/obb.main.twoversions_1101613.apk', 'obb.main.twoversions', '1101613', '0.1'),
('repo/obb.main.twoversions_1101615.apk', 'obb.main.twoversions', '1101615', '0.1'),
('repo/obb.main.twoversions_1101617.apk', 'obb.main.twoversions', '1101617', '0.1'),
tests: rename unicode test file to fix "file name too long" errors pristine-tar and mkdir barf on this file.
2018-05-25 17:27:58 +02:00
('repo/urzip-; Рахма́, [rɐxˈmanʲɪnəf] سيرجي_رخمانينوف 谢·.apk', 'info.guardianproject.urzip', '100', '0.1'),
signatures: future-proof fetching app ID info from APK We're not using platformBuildVersionName and it might go away just like it appeared: with no good reason or announcement.
2018-02-22 14:30:39 +01:00
]
for apkfilename, appid, versionCode, versionName in testcases:
implement common.get_apk_id() using androguard
2018-05-03 13:33:37 +02:00
if 'aapt' in config:
a, vc, vn = fdroidserver.common.get_apk_id_aapt(apkfilename)
use partial androguard binary XML parsing to speed up APK ID lookup Normally, androguard parses the entire APK before it is possible to get any values from it. This uses androguard primitives to only attempt to parse the AndroidManifest.xml, then to quit as soon as it gets what it needs. This greatly speeds up the parsing (1 minute vs 60 minutes). fdroid/fdroidserver#557
2018-09-18 15:29:24 +02:00
self.assertEqual(appid, a, 'aapt appid parsing failed for ' + apkfilename)
self.assertEqual(versionCode, vc, 'aapt versionCode parsing failed for ' + apkfilename)
self.assertEqual(versionName, vn, 'aapt versionName parsing failed for ' + apkfilename)
implement common.get_apk_id() using androguard
2018-05-03 13:33:37 +02:00
if fdroidserver.common.use_androguard():
use partial androguard binary XML parsing to speed up APK ID lookup Normally, androguard parses the entire APK before it is possible to get any values from it. This uses androguard primitives to only attempt to parse the AndroidManifest.xml, then to quit as soon as it gets what it needs. This greatly speeds up the parsing (1 minute vs 60 minutes). fdroid/fdroidserver#557
2018-09-18 15:29:24 +02:00
a, vc, vn = fdroidserver.common.get_apk_id(apkfilename)
self.assertEqual(appid, a, 'androguard appid parsing failed for ' + apkfilename)
self.assertEqual(versionName, vn, 'androguard versionName parsing failed for ' + apkfilename)
self.assertEqual(versionCode, vc, 'androguard versionCode parsing failed for ' + apkfilename)
test for common.get_app_id_aapt
2017-09-12 18:17:46 +02:00
with self.assertRaises(FDroidException):
implement common.get_apk_id() using androguard
2018-05-03 13:33:37 +02:00
fdroidserver.common.get_apk_id('nope')
test for common.get_app_id_aapt
2017-09-12 18:17:46 +02:00
handle package: line output from aapt v28 fdroid/fdroiddata!3484 fdroid/fdroiddata!3562 fdroid/fdroidserver!548
2018-09-17 23:12:51 +02:00
def test_get_apk_id_aapt_regex(self):
files = glob.glob(os.path.join(self.basedir, 'build-tools', '[1-9]*.*', '*.txt'))
self.assertNotEqual(0, len(files))
for f in files:
appid, versionCode = os.path.splitext(os.path.basename(f))[0][12:].split('_')
with open(f) as fp:
m = fdroidserver.common.APK_ID_TRIPLET_REGEX.match(fp.read())
if m:
self.assertEqual(appid, m.group(1))
self.assertEqual(versionCode, m.group(2))
else:
self.fail('could not parse aapt output: {}'.format(f))
build: reuse common methods for getting metadata from APKs This splits out the code that gets the list of native ABIs supported, then uses the standard methods for the rest.
2018-09-17 22:44:53 +02:00
def test_get_native_code(self):
testcases = [
('repo/obb.main.twoversions_1101613.apk', []),
('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', ['arm64-v8a', 'armeabi', 'armeabi-v7a', 'mips', 'mips64', 'x86', 'x86_64']),
('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/duplicate.permisssions_9999999.apk', []),
('repo/info.zwanenburg.caffeinetile_4.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 apkfilename, native_code in testcases:
nc = fdroidserver.common.get_native_code(apkfilename)
self.assertEqual(native_code, nc)
add common.sign_apk() for nighly as test for using in publish Since the MD5 migration was quite a bit of work, it makes sense to start on moving away from SHA1 as much as possible while it is easy to do. SHA256 will only work in APK signatures on android-18 (4.3) or newer. So if an APK has a minSdkVersion of 18 or newer, then sign with SHA256. https://issuetracker.google.com/issues/36956587 https://android-review.googlesource.com/c/platform/libcore/+/44491
2017-11-30 21:10:41 +01:00
def test_get_minSdkVersion_aapt(self):
config = dict()
fdroidserver.common.fill_config_defaults(config)
fdroidserver.common.config = config
self._set_build_tools()
common: fix tests when running without any Android SDK installed fdroid/fdroidserver!552 fdroid/fdroidserver#541
2018-08-07 14:51:42 +02:00
try: # get_minSdkVersion_aapt requires aapt
config['aapt'] = fdroidserver.common.find_sdk_tools_cmd('aapt')
except fdroidserver.exception.FDroidException:
print('\n\nSKIPPING test_sign_apk, aapt is not installed!\n')
return
add common.sign_apk() for nighly as test for using in publish Since the MD5 migration was quite a bit of work, it makes sense to start on moving away from SHA1 as much as possible while it is easy to do. SHA256 will only work in APK signatures on android-18 (4.3) or newer. So if an APK has a minSdkVersion of 18 or newer, then sign with SHA256. https://issuetracker.google.com/issues/36956587 https://android-review.googlesource.com/c/platform/libcore/+/44491
2017-11-30 21:10:41 +01:00
minSdkVersion = fdroidserver.common.get_minSdkVersion_aapt('bad-unicode-πÇÇ现代通用字-български-عربي1.apk')
self.assertEqual(4, minSdkVersion)
minSdkVersion = fdroidserver.common.get_minSdkVersion_aapt('org.bitbucket.tickytacky.mirrormirror_1.apk')
self.assertEqual(14, minSdkVersion)
minSdkVersion = fdroidserver.common.get_minSdkVersion_aapt('org.bitbucket.tickytacky.mirrormirror_2.apk')
self.assertEqual(14, minSdkVersion)
minSdkVersion = fdroidserver.common.get_minSdkVersion_aapt('org.bitbucket.tickytacky.mirrormirror_3.apk')
self.assertEqual(14, minSdkVersion)
minSdkVersion = fdroidserver.common.get_minSdkVersion_aapt('org.bitbucket.tickytacky.mirrormirror_4.apk')
self.assertEqual(14, minSdkVersion)
minSdkVersion = fdroidserver.common.get_minSdkVersion_aapt('org.dyndns.fules.ck_20.apk')
self.assertEqual(7, minSdkVersion)
minSdkVersion = fdroidserver.common.get_minSdkVersion_aapt('urzip.apk')
self.assertEqual(4, minSdkVersion)
minSdkVersion = fdroidserver.common.get_minSdkVersion_aapt('urzip-badcert.apk')
self.assertEqual(4, minSdkVersion)
minSdkVersion = fdroidserver.common.get_minSdkVersion_aapt('urzip-badsig.apk')
self.assertEqual(4, minSdkVersion)
minSdkVersion = fdroidserver.common.get_minSdkVersion_aapt('urzip-release.apk')
self.assertEqual(4, minSdkVersion)
minSdkVersion = fdroidserver.common.get_minSdkVersion_aapt('urzip-release-unsigned.apk')
self.assertEqual(4, minSdkVersion)
minSdkVersion = fdroidserver.common.get_minSdkVersion_aapt('repo/com.politedroid_3.apk')
self.assertEqual(3, minSdkVersion)
minSdkVersion = fdroidserver.common.get_minSdkVersion_aapt('repo/com.politedroid_4.apk')
self.assertEqual(3, minSdkVersion)
minSdkVersion = fdroidserver.common.get_minSdkVersion_aapt('repo/com.politedroid_5.apk')
self.assertEqual(3, minSdkVersion)
minSdkVersion = fdroidserver.common.get_minSdkVersion_aapt('repo/com.politedroid_6.apk')
self.assertEqual(14, minSdkVersion)
minSdkVersion = fdroidserver.common.get_minSdkVersion_aapt('repo/obb.main.oldversion_1444412523.apk')
self.assertEqual(4, minSdkVersion)
minSdkVersion = fdroidserver.common.get_minSdkVersion_aapt('repo/obb.mainpatch.current_1619_another-release-key.apk')
self.assertEqual(4, minSdkVersion)
minSdkVersion = fdroidserver.common.get_minSdkVersion_aapt('repo/obb.mainpatch.current_1619.apk')
self.assertEqual(4, minSdkVersion)
minSdkVersion = fdroidserver.common.get_minSdkVersion_aapt('repo/obb.main.twoversions_1101613.apk')
self.assertEqual(4, minSdkVersion)
minSdkVersion = fdroidserver.common.get_minSdkVersion_aapt('repo/obb.main.twoversions_1101615.apk')
self.assertEqual(4, minSdkVersion)
minSdkVersion = fdroidserver.common.get_minSdkVersion_aapt('repo/obb.main.twoversions_1101617.apk')
self.assertEqual(4, minSdkVersion)
tests: rename unicode test file to fix "file name too long" errors pristine-tar and mkdir barf on this file.
2018-05-25 17:27:58 +02:00
minSdkVersion = fdroidserver.common.get_minSdkVersion_aapt('repo/urzip-; Рахма́, [rɐxˈmanʲɪnəf] سيرجي_رخمانينوف 谢·.apk')
add common.sign_apk() for nighly as test for using in publish Since the MD5 migration was quite a bit of work, it makes sense to start on moving away from SHA1 as much as possible while it is easy to do. SHA256 will only work in APK signatures on android-18 (4.3) or newer. So if an APK has a minSdkVersion of 18 or newer, then sign with SHA256. https://issuetracker.google.com/issues/36956587 https://android-review.googlesource.com/c/platform/libcore/+/44491
2017-11-30 21:10:41 +01:00
with self.assertRaises(FDroidException):
fdroidserver.common.get_minSdkVersion_aapt('nope')
added parse release filename function
2017-09-23 13:10:52 +02:00
def test_apk_release_name(self):
appid, vercode, sigfp = fdroidserver.common.apk_parse_release_filename('com.serwylo.lexica_905.apk')
self.assertEqual(appid, 'com.serwylo.lexica')
self.assertEqual(vercode, '905')
self.assertEqual(sigfp, None)
appid, vercode, sigfp = fdroidserver.common.apk_parse_release_filename('com.serwylo.lexica_905_c82e0f6.apk')
self.assertEqual(appid, 'com.serwylo.lexica')
self.assertEqual(vercode, '905')
self.assertEqual(sigfp, 'c82e0f6')
appid, vercode, sigfp = fdroidserver.common.apk_parse_release_filename('beverly_hills-90210.apk')
self.assertEqual(appid, None)
self.assertEqual(vercode, None)
self.assertEqual(sigfp, None)
added some developer-signing key metadata to tests
2017-07-04 10:53:16 +02:00
def test_metadata_find_developer_signature(self):
sig = fdroidserver.common.metadata_find_developer_signature('org.smssecure.smssecure')
self.assertEqual('b30bb971af0d134866e158ec748fcd553df97c150f58b0a963190bbafbeb0868', sig)
use defusedxml to avoid DoS attacks while loading XML
2018-08-29 17:27:04 +02:00
def test_parse_xml(self):
manifest = os.path.join('source-files', 'fdroid', 'fdroidclient', 'AndroidManifest.xml')
parsed = fdroidserver.common.parse_xml(manifest)
self.assertIsNotNone(parsed)
self.assertEqual(str(type(parsed)), "<class 'xml.etree.ElementTree.Element'>")
gradle file: use flavour specific versionCode/versionName, fall back to parsing line by line
2017-12-23 14:36:38 +01:00
def test_parse_androidmanifests(self):
app = fdroidserver.metadata.App()
app.id = 'org.fdroid.fdroid'
paths = [
make common.TestCase run independant of cwd
2018-06-08 02:56:18 +02:00
os.path.join('source-files', 'fdroid', 'fdroidclient', 'AndroidManifest.xml'),
os.path.join('source-files', 'fdroid', 'fdroidclient', 'build.gradle'),
gradle file: use flavour specific versionCode/versionName, fall back to parsing line by line
2017-12-23 14:36:38 +01:00
]
for path in paths:
self.assertTrue(os.path.isfile(path))
self.assertEqual(('0.94-test', '940', 'org.fdroid.fdroid'),
fdroidserver.common.parse_androidmanifests(paths, app))
import: make it work most of the time with git repos This includes real tests too.
2020-01-31 23:49:50 +01:00
app = fdroidserver.metadata.App()
app.AutoName = 'android-chat'
app.RepoType = 'git'
url = 'https://github.com/wildfirechat/android-chat.git'
app.SourceCode = url.rstrip('.git')
app.Repo = url
paths = [
os.path.join('source-files', 'cn.wildfirechat.chat', 'avenginekit', 'build.gradle'),
os.path.join('source-files', 'cn.wildfirechat.chat', 'build.gradle'),
os.path.join('source-files', 'cn.wildfirechat.chat', 'client', 'build.gradle'),
os.path.join('source-files', 'cn.wildfirechat.chat', 'client', 'src', 'main', 'AndroidManifest.xml'),
os.path.join('source-files', 'cn.wildfirechat.chat', 'emojilibrary', 'build.gradle'),
os.path.join('source-files', 'cn.wildfirechat.chat', 'gradle', 'build_libraries.gradle'),
os.path.join('source-files', 'cn.wildfirechat.chat', 'imagepicker', 'build.gradle'),
os.path.join('source-files', 'cn.wildfirechat.chat', 'mars-core-release', 'build.gradle'),
os.path.join('source-files', 'cn.wildfirechat.chat', 'push', 'build.gradle'),
os.path.join('source-files', 'cn.wildfirechat.chat', 'settings.gradle'),
os.path.join('source-files', 'cn.wildfirechat.chat', 'chat', 'build.gradle'),
]
for path in paths:
self.assertTrue(os.path.isfile(path))
self.assertEqual(('0.6.9', '23', 'cn.wildfirechat.chat'),
fdroidserver.common.parse_androidmanifests(paths, app))
prefer build.gradle with Android Plugin as source of package/version/code These days, the location that overrides all the others is in the android{} block of the build.gradle file that loads the com.android.application plugin. So this should be the preferred place to read these values. test files GPL licensed: https://github.com/Integreight/1Sheeld-Android-App
2020-02-03 21:13:26 +01:00
app = fdroidserver.metadata.App()
app.Repo = 'https://github.com/Integreight/1Sheeld-Android-App'
paths = [
os.path.join('source-files', 'com.integreight.onesheeld', 'pagerIndicator', 'src', 'main', 'AndroidManifest.xml'),
os.path.join('source-files', 'com.integreight.onesheeld', 'pagerIndicator', 'build.gradle'),
os.path.join('source-files', 'com.integreight.onesheeld', 'oneSheeld', 'src', 'main', 'AndroidManifest.xml'),
os.path.join('source-files', 'com.integreight.onesheeld', 'oneSheeld', 'build.gradle'),
os.path.join('source-files', 'com.integreight.onesheeld', 'localeapi', 'src', 'main', 'AndroidManifest.xml'),
os.path.join('source-files', 'com.integreight.onesheeld', 'localeapi', 'build.gradle'),
os.path.join('source-files', 'com.integreight.onesheeld', 'build.gradle'),
os.path.join('source-files', 'com.integreight.onesheeld', 'settings.gradle'),
os.path.join('source-files', 'com.integreight.onesheeld', 'quickReturnHeader', 'src', 'main', 'AndroidManifest.xml'),
os.path.join('source-files', 'com.integreight.onesheeld', 'quickReturnHeader', 'build.gradle'),
os.path.join('source-files', 'com.integreight.onesheeld', 'pullToRefreshlibrary', 'src', 'main', 'AndroidManifest.xml'),
os.path.join('source-files', 'com.integreight.onesheeld', 'pullToRefreshlibrary', 'build.gradle'),
]
for path in paths:
self.assertTrue(os.path.isfile(path))
self.assertEqual(('1.9.0', '170521', 'com.integreight.onesheeld'),
fdroidserver.common.parse_androidmanifests(paths, app))
common add parse_androidmanifests_ignore test
2019-07-23 22:44:45 +02:00
def test_parse_androidmanifests_ignore(self):
app = fdroidserver.metadata.App()
app.id = 'org.fdroid.fdroid'
app.UpdateCheckIgnore = '-test'
paths = [
os.path.join('source-files', 'fdroid', 'fdroidclient', 'AndroidManifest.xml'),
os.path.join('source-files', 'fdroid', 'fdroidclient', 'build.gradle'),
]
for path in paths:
self.assertTrue(os.path.isfile(path))
self.assertEqual(('Ignore', None, 'org.fdroid.fdroid'),
fdroidserver.common.parse_androidmanifests(paths, app))
gradle file: use flavour specific versionCode/versionName, fall back to parsing line by line
2017-12-23 14:36:38 +01:00
def test_parse_androidmanifests_with_flavor(self):
app = fdroidserver.metadata.App()
build = fdroidserver.metadata.Build()
build.gradle = ['devVersion']
app.builds = [build]
app.id = 'org.fdroid.fdroid.dev'
paths = [
make common.TestCase run independant of cwd
2018-06-08 02:56:18 +02:00
os.path.join('source-files', 'fdroid', 'fdroidclient', 'AndroidManifest.xml'),
os.path.join('source-files', 'fdroid', 'fdroidclient', 'build.gradle'),
gradle file: use flavour specific versionCode/versionName, fall back to parsing line by line
2017-12-23 14:36:38 +01:00
]
for path in paths:
self.assertTrue(os.path.isfile(path))
self.assertEqual(('0.95-dev', '949', 'org.fdroid.fdroid.dev'),
fdroidserver.common.parse_androidmanifests(paths, app))
app = fdroidserver.metadata.App()
build = fdroidserver.metadata.Build()
build.gradle = ['free']
app.builds = [build]
app.id = 'eu.siacs.conversations'
paths = [
make common.TestCase run independant of cwd
2018-06-08 02:56:18 +02:00
os.path.join('source-files', 'eu.siacs.conversations', 'build.gradle'),
gradle file: use flavour specific versionCode/versionName, fall back to parsing line by line
2017-12-23 14:36:38 +01:00
]
for path in paths:
self.assertTrue(os.path.isfile(path))
self.assertEqual(('1.23.1', '245', 'eu.siacs.conversations'),
fdroidserver.common.parse_androidmanifests(paths, app))
Add Nextcloud and DavDroid test case
2017-12-24 11:55:56 +01:00
app = fdroidserver.metadata.App()
build = fdroidserver.metadata.Build()
build.gradle = ['generic']
app.builds = [build]
app.id = 'com.nextcloud.client'
paths = [
make common.TestCase run independant of cwd
2018-06-08 02:56:18 +02:00
os.path.join('source-files', 'com.nextcloud.client', 'build.gradle'),
Add Nextcloud and DavDroid test case
2017-12-24 11:55:56 +01:00
]
for path in paths:
self.assertTrue(os.path.isfile(path))
self.assertEqual(('2.0.0', '20000099', 'com.nextcloud.client'),
fdroidserver.common.parse_androidmanifests(paths, app))
app = fdroidserver.metadata.App()
build = fdroidserver.metadata.Build()
build.gradle = ['versionDev']
app.builds = [build]
app.id = 'com.nextcloud.android.beta'
paths = [
make common.TestCase run independant of cwd
2018-06-08 02:56:18 +02:00
os.path.join('source-files', 'com.nextcloud.client', 'build.gradle'),
Add Nextcloud and DavDroid test case
2017-12-24 11:55:56 +01:00
]
for path in paths:
self.assertTrue(os.path.isfile(path))
self.assertEqual(('20171223', '20171223', 'com.nextcloud.android.beta'),
fdroidserver.common.parse_androidmanifests(paths, app))
app = fdroidserver.metadata.App()
build = fdroidserver.metadata.Build()
build.gradle = ['standard']
app.builds = [build]
app.id = 'at.bitfire.davdroid'
paths = [
make common.TestCase run independant of cwd
2018-06-08 02:56:18 +02:00
os.path.join('source-files', 'at.bitfire.davdroid', 'build.gradle'),
Add Nextcloud and DavDroid test case
2017-12-24 11:55:56 +01:00
]
for path in paths:
self.assertTrue(os.path.isfile(path))
self.assertEqual(('1.9.8.1-ose', '197', 'at.bitfire.davdroid'),
fdroidserver.common.parse_androidmanifests(paths, app))
Fix applicationIdSuffix / versionNameSuffix #455
2018-03-26 19:45:06 +02:00
app = fdroidserver.metadata.App()
build = fdroidserver.metadata.Build()
build.gradle = ['libre']
app.builds = [build]
app.id = 'com.kunzisoft.fdroidtest.applicationidsuffix.libre'
paths = [
make common.TestCase run independant of cwd
2018-06-08 02:56:18 +02:00
os.path.join('source-files', 'com.kunzisoft.testcase', 'build.gradle'),
Fix applicationIdSuffix / versionNameSuffix #455
2018-03-26 19:45:06 +02:00
]
for path in paths:
self.assertTrue(os.path.isfile(path))
self.assertEqual(('1.0-libre', '1', 'com.kunzisoft.fdroidtest.applicationidsuffix.libre'),
fdroidserver.common.parse_androidmanifests(paths, app))
app = fdroidserver.metadata.App()
build = fdroidserver.metadata.Build()
build.gradle = ['pro']
app.builds = [build]
app.id = 'com.kunzisoft.fdroidtest.applicationidsuffix.pro'
paths = [
make common.TestCase run independant of cwd
2018-06-08 02:56:18 +02:00
os.path.join('source-files', 'com.kunzisoft.testcase', 'build.gradle'),
Fix applicationIdSuffix / versionNameSuffix #455
2018-03-26 19:45:06 +02:00
]
for path in paths:
self.assertTrue(os.path.isfile(path))
self.assertEqual(('20180430-pro', '20180430', 'com.kunzisoft.fdroidtest.applicationidsuffix.pro'),
fdroidserver.common.parse_androidmanifests(paths, app))
app = fdroidserver.metadata.App()
build = fdroidserver.metadata.Build()
build.gradle = ['free']
app.builds = [build]
app.id = 'com.kunzisoft.fdroidtest.applicationidsuffix'
paths = [
make common.TestCase run independant of cwd
2018-06-08 02:56:18 +02:00
os.path.join('source-files', 'com.kunzisoft.testcase', 'build.gradle'),
Fix applicationIdSuffix / versionNameSuffix #455
2018-03-26 19:45:06 +02:00
]
for path in paths:
self.assertTrue(os.path.isfile(path))
self.assertEqual(('1.0-free', '1', 'com.kunzisoft.fdroidtest.applicationidsuffix'),
fdroidserver.common.parse_androidmanifests(paths, app))
import: mv reusable functions to common.py to avoid import_proxy.py import is a strict keyword in Python, so it is not possible to import a module called 'import', even with things like: * import fdroidserver.import * from fdroidserver import import
2020-02-26 17:07:12 +01:00
def test_get_all_gradle_and_manifests(self):
a = fdroidserver.common.get_all_gradle_and_manifests(os.path.join('source-files', 'cn.wildfirechat.chat'))
paths = [
os.path.join('source-files', 'cn.wildfirechat.chat', 'avenginekit', 'build.gradle'),
os.path.join('source-files', 'cn.wildfirechat.chat', 'build.gradle'),
os.path.join('source-files', 'cn.wildfirechat.chat', 'chat', 'build.gradle'),
os.path.join('source-files', 'cn.wildfirechat.chat', 'client', 'build.gradle'),
os.path.join('source-files', 'cn.wildfirechat.chat', 'client', 'src', 'main', 'AndroidManifest.xml'),
os.path.join('source-files', 'cn.wildfirechat.chat', 'emojilibrary', 'build.gradle'),
os.path.join('source-files', 'cn.wildfirechat.chat', 'gradle', 'build_libraries.gradle'),
os.path.join('source-files', 'cn.wildfirechat.chat', 'imagepicker', 'build.gradle'),
os.path.join('source-files', 'cn.wildfirechat.chat', 'mars-core-release', 'build.gradle'),
os.path.join('source-files', 'cn.wildfirechat.chat', 'push', 'build.gradle'),
os.path.join('source-files', 'cn.wildfirechat.chat', 'settings.gradle'),
]
self.assertEqual(sorted(paths), sorted(a))
def test_get_gradle_subdir(self):
subdirs = {
'cn.wildfirechat.chat': 'chat',
'com.anpmech.launcher': 'app',
'org.tasks': 'app',
'ut.ewh.audiometrytest': 'app',
}
for f in ('cn.wildfirechat.chat', 'com.anpmech.launcher', 'org.tasks', 'ut.ewh.audiometrytest'):
build_dir = os.path.join('source-files', f)
paths = fdroidserver.common.get_all_gradle_and_manifests(build_dir)
logging.info(paths)
subdir = fdroidserver.common.get_gradle_subdir(build_dir, paths)
self.assertEqual(subdirs[f], subdir)
def test_bad_urls(self):
for url in ('asdf',
'file://thing.git',
'https:///github.com/my/project',
'git:///so/many/slashes',
'ssh:/notabug.org/missing/a/slash',
'git:notabug.org/missing/some/slashes',
'https//github.com/bar/baz'):
with self.assertRaises(ValueError):
fdroidserver.common.get_app_from_url(url)
build: fix bad regexs when removing signingConfig from srclibs I went through the source of all apps in fdroiddata for examples, and found some that use readLine() for things totally unrelated to signingConfigs. https://gitlab.com/fdroid/fdroiddata/merge_requests/4775#note_234132902
2019-10-23 12:23:37 +02:00
def test_remove_signing_keys(self):
testdir = tempfile.mkdtemp(prefix=inspect.currentframe().f_code.co_name, dir=self.tmpdir)
print(testdir)
shutil.copytree(os.path.join(self.basedir, 'source-files'),
os.path.join(testdir, 'source-files'))
os.chdir(testdir)
with_signingConfigs = [
'source-files/com.seafile.seadroid2/app/build.gradle',
'source-files/eu.siacs.conversations/build.gradle',
'source-files/info.guardianproject.ripple/build.gradle',
'source-files/open-keychain/open-keychain/build.gradle',
'source-files/open-keychain/open-keychain/OpenKeychain/build.gradle',
fix remove_signing_keys() for Kotlin gradles files (*.gradle.kts)
2020-02-13 22:28:39 +01:00
'source-files/org.tasks/app/build.gradle.kts',
build: fix bad regexs when removing signingConfig from srclibs I went through the source of all apps in fdroiddata for examples, and found some that use readLine() for things totally unrelated to signingConfigs. https://gitlab.com/fdroid/fdroiddata/merge_requests/4775#note_234132902
2019-10-23 12:23:37 +02:00
'source-files/osmandapp/osmand/build.gradle',
'source-files/ut.ewh.audiometrytest/app/build.gradle',
]
for f in with_signingConfigs:
build_dir = os.path.join(*f.split(os.sep)[:2])
if not os.path.isdir(build_dir):
continue
fdroidserver.common.remove_signing_keys(build_dir)
fromfile = os.path.join(self.basedir, f)
with open(f) as fp:
content = fp.read()
if 'signingConfig' in content:
with open(f) as fp:
b = fp.readlines()
with open(fromfile) as fp:
a = fp.readlines()
diff = difflib.unified_diff(a, b, fromfile, f)
sys.stdout.writelines(diff)
self.assertFalse(True)
do_not_modify = [
'source-files/Zillode/syncthing-silk/build.gradle',
'source-files/at.bitfire.davdroid/build.gradle',
'source-files/com.kunzisoft.testcase/build.gradle',
'source-files/com.nextcloud.client/build.gradle',
'source-files/fdroid/fdroidclient/build.gradle',
'source-files/firebase-suspect/app/build.gradle',
'source-files/firebase-suspect/build.gradle',
'source-files/firebase-whitelisted/app/build.gradle',
'source-files/firebase-whitelisted/build.gradle',
'source-files/org.mozilla.rocket/app/build.gradle',
'source-files/realm/react-native/android/build.gradle',
'triple-t-2/build/org.piwigo.android/app/build.gradle',
]
for f in do_not_modify:
build_dir = os.path.join(*f.split(os.sep)[:2])
if not os.path.isdir(build_dir):
continue
fdroidserver.common.remove_signing_keys(build_dir)
fromfile = os.path.join(self.basedir, f)
with open(fromfile) as fp:
a = fp.readlines()
with open(f) as fp:
b = fp.readlines()
diff = list(difflib.unified_diff(a, b, fromfile, f))
self.assertEqual(0, len(diff), 'This file should not have been modified:\n' + ''.join(diff))
added tests for common.calculate_math_string
2018-05-22 13:24:37 +02:00
def test_calculate_math_string(self):
replace unneeded eval() call and support negative versionCodes
2018-08-29 16:07:02 +02:00
self.assertEqual(1234,
fdroidserver.common.calculate_math_string('1234'))
self.assertEqual((1 + 1) * 2,
fdroidserver.common.calculate_math_string('(1 + 1) * 2'))
self.assertEqual((1 - 1) * 2 + 3 * 1 - 1,
fdroidserver.common.calculate_math_string('(1 - 1) * 2 + 3 * 1 - 1'))
self.assertEqual(0 - 12345,
fdroidserver.common.calculate_math_string('0 - 12345'))
self.assertEqual(0xffff,
fdroidserver.common.calculate_math_string('0xffff'))
self.assertEqual(0xcafe * 123,
fdroidserver.common.calculate_math_string('0xcafe * 123'))
self.assertEqual(-1,
fdroidserver.common.calculate_math_string('-1'))
added tests for common.calculate_math_string
2018-05-22 13:24:37 +02:00
with self.assertRaises(SyntaxError):
fdroidserver.common.calculate_math_string('__import__("urllib")')
with self.assertRaises(SyntaxError):
fdroidserver.common.calculate_math_string('self')
replace unneeded eval() call and support negative versionCodes
2018-08-29 16:07:02 +02:00
with self.assertRaises(SyntaxError):
fdroidserver.common.calculate_math_string('Ox9()')
added tests for common.calculate_math_string
2018-05-22 13:24:37 +02:00
with self.assertRaises(SyntaxError):
fdroidserver.common.calculate_math_string('1+1; print(1)')
with self.assertRaises(SyntaxError):
fdroidserver.common.calculate_math_string('1-1 # no comment')
applied review suggestions for deploying (build) logs
2018-06-19 15:18:13 +02:00
def test_deploy_build_log_with_rsync_with_id_file(self):
added helper function for uploading build logs with rsync
2018-06-10 23:23:43 +02:00
deploying build logs to server after each individual build run
2018-06-12 16:18:21 +02:00
mocklogcontent = bytes(textwrap.dedent("""\
added helper function for uploading build logs with rsync
2018-06-10 23:23:43 +02:00
build started
building...
build completed
deploying build logs to server after each individual build run
2018-06-12 16:18:21 +02:00
profit!"""), 'utf-8')
added helper function for uploading build logs with rsync
2018-06-10 23:23:43 +02:00
fdroidserver.common.options = mock.Mock()
fdroidserver.common.options.verbose = False
fdroidserver.common.options.quiet = False
fdroidserver.common.config = {}
fdroidserver.common.config['serverwebroot'] = [
build: rsync buildlogs to <webroot>/repo
2019-06-26 17:00:01 +02:00
'example.com:/var/www/fdroid/',
'example.com:/var/www/fbot/']
applied review suggestions for deploying (build) logs
2018-06-19 15:18:13 +02:00
fdroidserver.common.config['deploy_process_logs'] = True
added helper function for uploading build logs with rsync
2018-06-10 23:23:43 +02:00
fdroidserver.common.config['identity_file'] = 'ssh/id_rsa'
assert_subprocess_call_iteration = 0
def assert_subprocess_call(cmd):
nonlocal assert_subprocess_call_iteration
logging.debug(cmd)
if assert_subprocess_call_iteration == 0:
self.assertListEqual(['rsync',
'--archive',
'--delete-after',
'--safe-links',
'-e',
'ssh -oBatchMode=yes -oIdentitiesOnly=yes -i ssh/id_rsa',
cmd[6],
build: rsync buildlogs to <webroot>/repo
2019-06-26 17:00:01 +02:00
'example.com:/var/www/fdroid/repo/'],
added helper function for uploading build logs with rsync
2018-06-10 23:23:43 +02:00
cmd)
deploy build logs: no timestamps
2019-07-03 16:22:14 +02:00
self.assertTrue(cmd[6].endswith('/com.example.app_4711.log.gz'))
deploying build logs to server after each individual build run
2018-06-12 16:18:21 +02:00
with gzip.open(cmd[6], 'r') as f:
self.assertTrue(f.read(), mocklogcontent)
added helper function for uploading build logs with rsync
2018-06-10 23:23:43 +02:00
elif assert_subprocess_call_iteration == 1:
self.assertListEqual(['rsync',
'--archive',
'--delete-after',
'--safe-links',
'-e',
'ssh -oBatchMode=yes -oIdentitiesOnly=yes -i ssh/id_rsa',
cmd[6],
build: rsync buildlogs to <webroot>/repo
2019-06-26 17:00:01 +02:00
'example.com:/var/www/fbot/repo/'],
added helper function for uploading build logs with rsync
2018-06-10 23:23:43 +02:00
cmd)
deploy build logs: no timestamps
2019-07-03 16:22:14 +02:00
self.assertTrue(cmd[6].endswith('/com.example.app_4711.log.gz'))
deploying build logs to server after each individual build run
2018-06-12 16:18:21 +02:00
with gzip.open(cmd[6], 'r') as f:
self.assertTrue(f.read(), mocklogcontent)
added helper function for uploading build logs with rsync
2018-06-10 23:23:43 +02:00
else:
self.fail('unexpected subprocess.call invocation ({})'
.format(assert_subprocess_call_iteration))
assert_subprocess_call_iteration += 1
return 0
deploying build logs to server after each individual build run
2018-06-12 16:18:21 +02:00
with mock.patch('subprocess.call',
side_effect=assert_subprocess_call):
update tests for fixed log deployment+changelog
2019-10-15 15:19:18 +02:00
with tempfile.TemporaryDirectory() as tmpdir, TmpCwd(tmpdir):
fdroidserver.common.deploy_build_log_with_rsync(
'com.example.app', '4711', mocklogcontent)
expected_log_path = os.path.join(tmpdir, 'repo', 'com.example.app_4711.log.gz')
self.assertTrue(os.path.isfile(expected_log_path))
with gzip.open(expected_log_path, 'r') as f:
self.assertEqual(f.read(), mocklogcontent)
added helper function for uploading build logs with rsync
2018-06-10 23:23:43 +02:00
integration test for creating and deploying status JSON files ----------------------------
2020-02-18 23:50:52 +01:00
def test_deploy_status_json(self):
testdir = tempfile.mkdtemp(prefix=inspect.currentframe().f_code.co_name, dir=self.tmpdir)
fakesubcommand = 'fakesubcommand'
fake_timestamp = 1234567890
fakeserver = 'example.com:/var/www/fbot/'
expected_dir = os.path.join(testdir, fakeserver.replace(':', ''), 'repo', 'status')
fdroidserver.common.options = mock.Mock()
fdroidserver.common.config = {}
fdroidserver.common.config['serverwebroot'] = [fakeserver]
fdroidserver.common.config['identity_file'] = 'ssh/id_rsa'
def assert_subprocess_call(cmd):
dest_path = os.path.join(testdir, cmd[-1].replace(':', ''))
if not os.path.exists(dest_path):
os.makedirs(dest_path)
return subprocess.run(cmd[:-1] + [dest_path]).returncode
with mock.patch('subprocess.call', side_effect=assert_subprocess_call):
with mock.patch.object(sys, 'argv', ['fdroid ' + fakesubcommand]):
output = fdroidserver.common.setup_status_output(time.localtime(fake_timestamp))
self.assertFalse(os.path.exists(os.path.join(expected_dir, 'running.json')))
with mock.patch.object(sys, 'argv', ['fdroid ' + fakesubcommand]):
fdroidserver.common.write_status_json(output)
self.assertFalse(os.path.exists(os.path.join(expected_dir, fakesubcommand + '.json')))
fdroidserver.common.config['deploy_process_logs'] = True
output = fdroidserver.common.setup_status_output(time.localtime(fake_timestamp))
expected_path = os.path.join(expected_dir, 'running.json')
self.assertTrue(os.path.isfile(expected_path))
with open(expected_path) as fp:
data = json.load(fp)
self.assertEqual(fake_timestamp * 1000, data['startTimestamp'])
self.assertFalse('endTimestamp' in data)
testvalue = 'asdfasd'
output['testvalue'] = testvalue
fdroidserver.common.write_status_json(output)
expected_path = os.path.join(expected_dir, fakesubcommand + '.json')
self.assertTrue(os.path.isfile(expected_path))
with open(expected_path) as fp:
data = json.load(fp)
self.assertEqual(fake_timestamp * 1000, data['startTimestamp'])
self.assertTrue('endTimestamp' in data)
self.assertEqual(testvalue, output.get('testvalue'))
Add unit test for string_is_integer()
2019-12-03 21:49:44 +01:00
def test_string_is_integer(self):
self.assertTrue(fdroidserver.common.string_is_integer('0x10'))
self.assertTrue(fdroidserver.common.string_is_integer('010'))
self.assertTrue(fdroidserver.common.string_is_integer('123'))
self.assertFalse(fdroidserver.common.string_is_integer('0xgg'))
self.assertFalse(fdroidserver.common.string_is_integer('01g'))
self.assertFalse(fdroidserver.common.string_is_integer('o123'))
checkupdates: split out vercode parsing into testable function
2019-12-03 23:51:48 +01:00
def test_version_code_string_to_int(self):
self.assertEqual(16, fdroidserver.common.version_code_string_to_int('0x10'))
self.assertEqual(198712389, fdroidserver.common.version_code_string_to_int('198712389'))
self.assertEqual(8, fdroidserver.common.version_code_string_to_int('0o10'))
self.assertEqual(10, fdroidserver.common.version_code_string_to_int('010'))
self.assertEqual(123, fdroidserver.common.version_code_string_to_int('0000123'))
self.assertEqual(-42, fdroidserver.common.version_code_string_to_int('-42'))
srclib: add test for getsrclibvcs
2019-12-16 19:17:46 +01:00
def test_getsrclibvcs(self):
fdroidserver.metadata.srclibs = {'somelib': {'RepoType': 'git'},
'yeslib': {'RepoType': 'hg'},
'nolib': {'RepoType': 'git-svn'}}
self.assertEqual(fdroidserver.common.getsrclibvcs('somelib'), 'git')
self.assertEqual(fdroidserver.common.getsrclibvcs('yeslib'), 'hg')
self.assertEqual(fdroidserver.common.getsrclibvcs('nolib'), 'git-svn')
with self.assertRaises(VCSException):
fdroidserver.common.getsrclibvcs('nonexistentlib')
scrlib: add test for getsrclib
2019-12-19 22:55:14 +01:00
def test_getsrclib_not_found(self):
fdroidserver.common.config = {'sdk_path': '',
'java_paths': {}}
fdroidserver.metadata.srclibs = {}
with self.assertRaisesRegex(VCSException, 'srclib SDL not found.'):
fdroidserver.common.getsrclib('SDL@release-2.0.3', 'srclib')
def test_getsrclib_gotorevision_raw(self):
fdroidserver.common.config = {'sdk_path': '',
'java_paths': {}}
fdroidserver.metadata.srclibs = {'SDL': {'RepoType': 'git',
'Repo': ''}}
vcs = mock.Mock()
with tempfile.TemporaryDirectory() as tmpdir, TmpCwd(tmpdir):
os.makedirs(os.path.join('srclib', 'SDL'))
with mock.patch('fdroidserver.common.getvcs', return_value=vcs):
ret = fdroidserver.common.getsrclib('SDL', 'srclib', raw=True)
self.assertEqual(vcs.srclib, ('SDL', None, 'srclib/SDL'))
self.assertEqual(ret, vcs)
def test_getsrclib_gotorevision_ref(self):
fdroidserver.common.config = {'sdk_path': '',
'java_paths': {}}
fdroidserver.metadata.srclibs = {'ACRA': {'RepoType': 'git',
'Repo': 'https://github.com/ACRA/acra.git',
'Subdir': None,
'Prepare': None}}
vcs = mock.Mock()
skm = mock.Mock()
dfm = mock.Mock()
with tempfile.TemporaryDirectory() as tmpdir, TmpCwd(tmpdir):
os.makedirs(os.path.join('srclib', 'ACRA'))
with mock.patch('fdroidserver.common.getvcs', return_value=vcs):
with mock.patch('fdroidserver.common.remove_signing_keys', skm):
with mock.patch('fdroidserver.common.remove_debuggable_flags', dfm):
ret = fdroidserver.common.getsrclib('ACRA@acra-4.6.2', 'srclib')
self.assertEqual(vcs.srclib, ('ACRA', None, 'srclib/ACRA'))
vcs.gotorevision.assert_called_once_with('acra-4.6.2', True)
skm.assert_called_once_with('srclib/ACRA')
dfm.assert_called_once_with('srclib/ACRA')
self.assertEqual(ret, ('ACRA', None, 'srclib/ACRA'))
PEP8 fixes
2017-11-30 13:42:37 +01:00
added test case for common.isApkDebuggable() Just getting into the habit of adding tests to everything that I change... Also, it should be useful to have an unsigned APK in the test collection, since `fdroid update` should handle it gracefully and give a warning of some kind.
2014-12-08 22:55:14 +01:00
if __name__ == "__main__":
make common.TestCase run independant of cwd
2018-06-08 02:56:18 +02:00
os.chdir(os.path.dirname(__file__))
added test case for common.isApkDebuggable() Just getting into the habit of adding tests to everything that I change... Also, it should be useful to have an unsigned APK in the test collection, since `fdroid update` should handle it gracefully and give a warning of some kind.
2014-12-08 22:55:14 +01:00
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(CommonTest))
tests: use standard dir setup so all tests start in same dir
2017-11-30 10:14:38 +01:00
unittest.main(failfast=False)
Copy Permalink