Assert.java

package org.fdroid.fdroid;

import android.content.ContentValues;
import android.content.Context;
import android.database.Cursor;
import android.net.Uri;

import junit.framework.AssertionFailedError;

import org.fdroid.fdroid.data.ApkProvider;
import org.fdroid.fdroid.data.App;
import org.fdroid.fdroid.data.AppProvider;
import org.fdroid.fdroid.data.InstalledAppProvider;
import org.fdroid.fdroid.data.Schema.ApkTable;
import org.fdroid.fdroid.data.Schema.AppMetadataTable;
import org.fdroid.fdroid.data.Schema.InstalledAppTable;
import org.robolectric.shadows.ShadowContentResolver;

import java.util.ArrayList;
import java.util.Collections;
import java.util.List;

import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertNotNull;
import static org.junit.Assert.assertNull;
import static org.junit.Assert.fail;

public class Assert {

    public static <T extends Comparable> void assertContainsOnly(List<T> actualList, T[] expectedArray) {
        List<T> expectedList = new ArrayList<>(expectedArray.length);
        Collections.addAll(expectedList, expectedArray);
        assertContainsOnly(actualList, expectedList);
    }

    public static <T extends Comparable> void assertContainsOnly(T[] actualArray, List<T> expectedList) {
        List<T> actualList = new ArrayList<>(actualArray.length);
        Collections.addAll(actualList, actualArray);
        assertContainsOnly(actualList, expectedList);
    }

    public static <T extends Comparable> void assertContainsOnly(T[] actualArray, T[] expectedArray) {
        List<T> expectedList = new ArrayList<>(expectedArray.length);
        Collections.addAll(expectedList, expectedArray);
        assertContainsOnly(actualArray, expectedList);
    }

    public static <T> String listToString(List<T> list) {
        String string = "[";
        for (int i = 0; i < list.size(); i++) {
            if (i > 0) {
                string += ", ";
            }
            string += "'" + list.get(i) + "'";
        }
        string += "]";
        return string;
    }

    public static <T extends Comparable> void assertContainsOnly(List<T> actualList, List<T> expectedContains) {
        if (actualList.size() != expectedContains.size()) {
            String message =
                    "List sizes don't match.\n" +
                            "Expected: " +
                            listToString(expectedContains) + "\n" +
                            "Actual:   " +
                            listToString(actualList);
            throw new AssertionFailedError(message);
        }
        for (T required : expectedContains) {
            boolean containsRequired = false;
            for (T itemInList : actualList) {
                if (required.equals(itemInList)) {
                    containsRequired = true;
                    break;
                }
            }
            if (!containsRequired) {
                String message =
                        "List doesn't contain \"" + required + "\".\n" +
                                "Expected: " +
                                listToString(expectedContains) + "\n" +
                                "Actual:   " +
                                listToString(actualList);
                throw new AssertionFailedError(message);
            }
        }
    }

    public static void assertCantDelete(ShadowContentResolver resolver, Uri uri) {
        try {
            resolver.delete(uri, null, null);
            fail();
        } catch (UnsupportedOperationException e) {
            // Successful condition
        } catch (Exception e) {
            fail();
        }
    }

    public static void assertCantUpdate(ShadowContentResolver resolver, Uri uri) {
        try {
            resolver.update(uri, new ContentValues(), null, null);
            fail();
        } catch (UnsupportedOperationException e) {
            // Successful condition
        } catch (Exception e) {
            fail();
        }
    }

    public static void assertInvalidUri(ShadowContentResolver resolver, String uri) {
        assertInvalidUri(resolver, Uri.parse(uri));
    }

    public static void assertValidUri(ShadowContentResolver resolver, String uri, String[] projection) {
        assertValidUri(resolver, Uri.parse(uri), projection);
    }

    public static void assertInvalidUri(ShadowContentResolver resolver, Uri uri) {
        Cursor cursor = resolver.query(uri, new String[] {}, null, null, null);
        assertNull(cursor);
    }

    public static void assertValidUri(ShadowContentResolver resolver, Uri uri, String[] projection) {
        Cursor cursor = resolver.query(uri, projection, null, null, null);
        assertNotNull(cursor);
        cursor.close();
    }

    public static void assertValidUri(ShadowContentResolver resolver, Uri actualUri, String expectedUri, String[] projection) {
        assertValidUri(resolver, actualUri, projection);
        assertEquals(expectedUri, actualUri.toString());
    }

    public static void assertResultCount(ShadowContentResolver resolver, int expectedCount, Uri uri) {
        assertResultCount(resolver, expectedCount, uri, new String[] {});
    }

    public static void assertResultCount(ShadowContentResolver resolver, int expectedCount, Uri uri, String[] projection) {
        Cursor cursor = resolver.query(uri, projection, null, null, null);
        assertResultCount(expectedCount, cursor);
        cursor.close();
    }

    public static void assertResultCount(int expectedCount, List items) {
        assertNotNull(items);
        assertEquals(expectedCount, items.size());
    }

    public static void assertResultCount(int expectedCount, Cursor result) {
        assertNotNull(result);
        assertEquals(expectedCount, result.getCount());
    }

    public static void assertIsInstalledVersionInDb(ShadowContentResolver resolver, String appId, int versionCode, String versionName) {
        Uri uri = InstalledAppProvider.getAppUri(appId);

        String[] projection = {
                InstalledAppTable.Cols.PACKAGE_NAME,
                InstalledAppTable.Cols.VERSION_CODE,
                InstalledAppTable.Cols.VERSION_NAME,
                InstalledAppTable.Cols.APPLICATION_LABEL,
        };

        Cursor cursor = resolver.query(uri, projection, null, null, null);

        assertNotNull(cursor);
        assertEquals("App \"" + appId + "\" not installed", 1, cursor.getCount());

        cursor.moveToFirst();

        assertEquals(appId, cursor.getString(cursor.getColumnIndex(InstalledAppTable.Cols.PACKAGE_NAME)));
        assertEquals(versionCode, cursor.getInt(cursor.getColumnIndex(InstalledAppTable.Cols.VERSION_CODE)));
        assertEquals(versionName, cursor.getString(cursor.getColumnIndex(InstalledAppTable.Cols.VERSION_NAME)));
        cursor.close();
    }

    public static App insertApp(Context context, String packageName, String name) {
        return insertApp(context, packageName, name, new ContentValues());
    }

    public static App insertApp(Context context, String packageName, String name, ContentValues additionalValues) {

        ContentValues values = new ContentValues();
        values.put(AppMetadataTable.Cols.REPO_ID, 1);
        values.put(AppMetadataTable.Cols.Package.PACKAGE_NAME, packageName);
        values.put(AppMetadataTable.Cols.NAME, name);

        // Required fields (NOT NULL in the database).
        values.put(AppMetadataTable.Cols.SUMMARY, "test summary");
        values.put(AppMetadataTable.Cols.DESCRIPTION, "test description");
        values.put(AppMetadataTable.Cols.LICENSE, "GPL?");
        values.put(AppMetadataTable.Cols.IS_COMPATIBLE, 1);

        values.putAll(additionalValues);

        Uri uri = AppProvider.getContentUri();

        context.getContentResolver().insert(uri, values);
        return AppProvider.Helper.findSpecificApp(context.getContentResolver(), packageName, 1, AppMetadataTable.Cols.ALL);
    }

    public static App ensureApp(Context context, String packageName) {
        App app = AppProvider.Helper.findSpecificApp(context.getContentResolver(), packageName, 1, AppMetadataTable.Cols.ALL);
        if (app == null) {
            insertApp(context, packageName, packageName);
            app = AppProvider.Helper.findSpecificApp(context.getContentResolver(), packageName, 1, AppMetadataTable.Cols.ALL);
        }
        assertNotNull(app);
        return app;
    }

    public static Uri insertApk(Context context, String packageName, int versionCode) {
        return insertApk(context, ensureApp(context, packageName), versionCode);
    }

    public static Uri insertApk(Context context, String packageName, int versionCode, ContentValues additionalValues) {
        return insertApk(context, ensureApp(context, packageName), versionCode, additionalValues);
    }

    public static Uri insertApk(Context context, App app, int versionCode) {
        return insertApk(context, app, versionCode, new ContentValues());
    }

    public static Uri insertApk(Context context, App app, int versionCode, ContentValues additionalValues) {

        ContentValues values = new ContentValues();

        values.put(ApkTable.Cols.APP_ID, app.getId());
        values.put(ApkTable.Cols.VERSION_CODE, versionCode);

        // Required fields (NOT NULL in the database).
        values.put(ApkTable.Cols.REPO_ID, 1);
        values.put(ApkTable.Cols.VERSION_NAME, "The good one");
        values.put(ApkTable.Cols.HASH, "11111111aaaaaaaa");
        values.put(ApkTable.Cols.NAME, "Test Apk");
        values.put(ApkTable.Cols.SIZE, 10000);
        values.put(ApkTable.Cols.IS_COMPATIBLE, 1);

        values.putAll(additionalValues);

        Uri uri = ApkProvider.getContentUri();

        return context.getContentResolver().insert(uri, values);
    }

}