Karl/BobStore
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Cleanup tests by extracting common code, and test canUpdate query.

Browse Source
This commit is contained in:
Peter Serwylo 2017-06-13 10:46:26 +10:00
parent 0409a7dcd6
commit 5a292b8e77
1 changed files with 54 additions and 116 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

170
app/src/test/java/org/fdroid/fdroid/data/SuggestedVersionTest.java
View File

@ -18,10 +18,9 @@ import org.robolectric.RobolectricTestRunner;
import org.robolectric.annotation.Config;
import java.security.NoSuchAlgorithmException;
import java.util.List;
import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertNull;
import static org.junit.Assert.assertTrue;
@Config(constants = BuildConfig.class, application = Application.class, sdk = 24)
@RunWith(RobolectricTestRunner.class)
@ -65,71 +64,12 @@ public class SuggestedVersionTest extends FDroidProviderTest {
insertApk(context, singleApp, 1, FDROID_SIG);
insertApk(context, singleApp, 2, FDROID_SIG);
insertApk(context, singleApp, 3, FDROID_SIG);
AppProvider.Helper.calcSuggestedApks(context);
App found2 = findApp(singleApp);
assertEquals(2, found2.suggestedVersionCode);
Apk found2Apk = findApk(found2);
assertEquals(2, found2Apk.versionCode);
assertEquals(FDROID_SIG, found2Apk.sig);
assertSuggested("single.app", 2);
// By enabling unstable updates, the "upstreamVersionCode" should get ignored, and we should
// suggest the latest version (3).
Preferences.get().setUnstableUpdates(true);
AppProvider.Helper.calcSuggestedApks(context);
App found3 = findApp(singleApp);
assertEquals(3, found3.suggestedVersionCode);
Apk found3Apk = findApk(found3);
assertEquals(3, found3Apk.versionCode);
assertEquals(FDROID_SIG, found3Apk.sig);
}
private App findApp(App app) {
return AppProvider.Helper.findSpecificApp(context.getContentResolver(), app.packageName, app.repoId);
}
private Apk findApk(App app) {
return ApkProvider.Helper.findSuggestedApk(context, app);
}
@Test
public void suggestedApkQuery() {
App singleApp = insertApp(context, "single.app", "Single App", 0, "https://simple.repo");
insertApk(context, singleApp, 1, FDROID_SIG);
insertApk(context, singleApp, 1, UPSTREAM_SIG);
insertApk(context, singleApp, 2, FDROID_SIG);
insertApk(context, singleApp, 2, UPSTREAM_SIG);
insertApk(context, singleApp, 3, FDROID_SIG);
insertApk(context, singleApp, 3, UPSTREAM_SIG);
insertApk(context, singleApp, 3, THIRD_PARTY_SIG);
insertApk(context, singleApp, 4, FDROID_SIG);
insertApk(context, singleApp, 4, UPSTREAM_SIG);
insertApk(context, singleApp, 4, THIRD_PARTY_SIG);
insertApk(context, singleApp, 5, FDROID_SIG);
insertApk(context, singleApp, 5, UPSTREAM_SIG);
AppProvider.Helper.calcSuggestedApks(context);
App notInstalled = findApp(singleApp);
Apk suggestedApkForNotInstalled = findApk(notInstalled);
assertNull(notInstalled.installedSig);
// It could be either of these, I think it is actually non-deterministic as to which is chosen.
// TODO: Make it deterministic based on repo priority.
assertTrue(FDROID_SIG.equals(suggestedApkForNotInstalled.sig) ||
UPSTREAM_SIG.equals(suggestedApkForNotInstalled.sig));
assertEquals(5, suggestedApkForNotInstalled.versionCode);
InstalledAppTestUtils.install(context, "single.app", 3, "v1", THIRD_PARTY_CERT);
AppProvider.Helper.calcSuggestedApks(context);
App installed = findApp(singleApp);
Apk suggestedApkForInstalled = findApk(installed);
assertEquals(THIRD_PARTY_SIG, installed.installedSig);
assertEquals(4, installed.suggestedVersionCode);
assertEquals(THIRD_PARTY_SIG, suggestedApkForInstalled.sig);
assertEquals(4, suggestedApkForInstalled.versionCode);
assertSuggested("single.app", 3);
}
@Test
@ -143,58 +83,25 @@ public class SuggestedVersionTest extends FDroidProviderTest {
insertApk(context, singleApp, 3, FDROID_SIG);
insertApk(context, singleApp, 4, UPSTREAM_SIG);
insertApk(context, singleApp, 5, UPSTREAM_SIG);
AppProvider.Helper.calcSuggestedApks(context);
// Given we aren't installed yet, we don't care which signature.
// Just get as close to upstreamVersionCode as possible.
App suggestUpstream4 = findApp(singleApp);
assertEquals(4, suggestUpstream4.suggestedVersionCode);
Apk suggestedUpstream4Apk = findApk(suggestUpstream4);
assertEquals(4, suggestedUpstream4Apk.versionCode);
assertEquals(UPSTREAM_SIG, suggestedUpstream4Apk.sig);
assertSuggested("single.app", 4);
// Now install v1 with the f-droid signature. In response, we should only suggest
// apps with that sig in the future. That is, version 4 from upstream is not considered.
InstalledAppTestUtils.install(context, "single.app", 1, "v1", FDROID_CERT);
AppProvider.Helper.calcSuggestedApks(context);
App suggestFDroid3 = findApp(singleApp);
assertEquals(3, suggestFDroid3.suggestedVersionCode);
Apk suggestedFDroid3Apk = findApk(suggestFDroid3);
assertEquals(3, suggestedFDroid3Apk.versionCode);
assertEquals(FDROID_SIG, suggestedFDroid3Apk.sig);
assertSuggested("single.app", 3, FDROID_SIG, 1);
// This adds the "upstreamVersionCode" version of the app, but signed by f-droid.
insertApk(context, singleApp, 4, FDROID_SIG);
insertApk(context, singleApp, 5, FDROID_SIG);
AppProvider.Helper.calcSuggestedApks(context);
App suggestFDroid4 = findApp(singleApp);
assertEquals(4, suggestFDroid4.suggestedVersionCode);
Apk suggestedFDroid4Apk = findApk(suggestFDroid4);
assertEquals(4, suggestedFDroid4Apk.versionCode);
assertEquals(FDROID_SIG, suggestedFDroid4Apk.sig);
assertSuggested("single.app", 4, FDROID_SIG, 1);
// Version 5 from F-Droid is not the "upstreamVersionCode", but with beta updates it should
// still become the suggested version now.
Preferences.get().setUnstableUpdates(true);
AppProvider.Helper.calcSuggestedApks(context);
App suggestFDroid5 = findApp(singleApp);
assertEquals(5, suggestFDroid5.suggestedVersionCode);
Apk suggestedFDroid5Apk = findApk(suggestFDroid5);
assertEquals(5, suggestedFDroid5Apk.versionCode);
assertEquals(FDROID_SIG, suggestedFDroid5Apk.sig);
}
private void recalculateMetadata() {
AppProvider.Helper.calcSuggestedApks(context);
AppProvider.Helper.recalculatePreferredMetadata(context);
}
private App highestPriorityApp(String packageName) {
return AppProvider.Helper.findHighestPriorityMetadata(context.getContentResolver(), packageName);
assertSuggested("single.app", 5, FDROID_SIG, 1);
}
@Test
@ -216,41 +123,72 @@ public class SuggestedVersionTest extends FDroidProviderTest {
insertApk(context, thirdPartyApp, 5, THIRD_PARTY_SIG);
insertApk(context, thirdPartyApp, 6, THIRD_PARTY_SIG);
recalculateMetadata();
// Given we aren't installed yet, we don't care which signature or even which repo.
// Just get as close to upstreamVersionCode as possible.
App suggestAnyVersion4 = highestPriorityApp("single.app");
assertEquals(4, suggestAnyVersion4.suggestedVersionCode);
assertSuggested("single.app", 4);
// Now install v1 with the f-droid signature. In response, we should only suggest
// apps with that sig in the future. That is, version 4 from upstream is not considered.
InstalledAppTestUtils.install(context, "single.app", 1, "v1", FDROID_CERT);
recalculateMetadata();
App suggestFDroid3 = highestPriorityApp("single.app");
assertEquals(3, suggestFDroid3.suggestedVersionCode);
assertSuggested("single.app", 3, FDROID_SIG, 1);
// This adds the "upstreamVersionCode" version of the app, but signed by f-droid.
insertApk(context, mainApp, 4, FDROID_SIG);
insertApk(context, mainApp, 5, FDROID_SIG);
recalculateMetadata();
App suggestFDroid4 = highestPriorityApp("single.app");
assertEquals(4, suggestFDroid4.suggestedVersionCode);
assertSuggested("single.app", 4, FDROID_SIG, 1);
// Uninstalling the F-Droid build and installing v3 of the third party means we can now go
// back to suggesting version 4.
InstalledAppProviderService.deleteAppFromDb(context, "single.app");
InstalledAppTestUtils.install(context, "single.app", 3, "v3", THIRD_PARTY_CERT);
recalculateMetadata();
suggestAnyVersion4 = highestPriorityApp("single.app");
assertEquals(4, suggestAnyVersion4.suggestedVersionCode);
assertSuggested("single.app", 4, THIRD_PARTY_SIG, 3);
// Version 6 from the 3rd party repo is not the "upstreamVersionCode", but with beta updates
// it should still become the suggested version now.
Preferences.get().setUnstableUpdates(true);
recalculateMetadata();
App suggest3rdParty6 = highestPriorityApp("single.app");
assertEquals(6, suggest3rdParty6.suggestedVersionCode);
assertSuggested("single.app", 6, THIRD_PARTY_SIG, 3);
}
/**
* Same as {@link #assertSuggested(String, int, String, int)} except only for non installed apps.
* @see #assertSuggested(String, int, String, int)
*/
private void assertSuggested(String packageName, int suggestedVersion) {
assertSuggested(packageName, suggestedVersion, null, 0);
}
/**
* Checks that the app exists, that its suggested version code is correct, and that the apk which is "suggested"
* has the correct signature.
*
* If {@param installedSig} is null then {@param installedVersion} is ignored and the signature of the suggested
* apk is not checked.
*/
public void assertSuggested(String packageName, int suggestedVersion, String installedSig, int installedVersion) {
AppProvider.Helper.calcSuggestedApks(context);
AppProvider.Helper.recalculatePreferredMetadata(context);
App suggestedApp = AppProvider.Helper.findHighestPriorityMetadata(context.getContentResolver(), packageName);
assertEquals("Suggested version on App", suggestedVersion, suggestedApp.suggestedVersionCode);
assertEquals("Installed signature on App", installedSig, suggestedApp.installedSig);
Apk suggestedApk = ApkProvider.Helper.findSuggestedApk(context, suggestedApp);
assertEquals("Suggested version on Apk", suggestedVersion, suggestedApk.versionCode);
if (installedSig != null) {
assertEquals("Installed signature on Apk", installedSig, suggestedApk.sig);
}
List<App> appsToUpdate = AppProvider.Helper.findCanUpdate(context, Schema.AppMetadataTable.Cols.ALL);
if (installedSig == null) {
assertEquals("Should not be able to update anything", 0, appsToUpdate.size());
} else {
assertEquals("Apps to update", 1, appsToUpdate.size());
App canUpdateApp = appsToUpdate.get(0);
assertEquals("Package name of updatable app", packageName, canUpdateApp.packageName);
assertEquals("Installed version of updatable app", installedVersion, canUpdateApp.installedVersionCode);
assertEquals("Suggested version to update to", suggestedVersion, canUpdateApp.suggestedVersionCode);
assertEquals("Installed signature of updatable app", installedSig, canUpdateApp.installedSig);
}
}
private void insertApk(Context context, App app, int versionCode, String signature) {