downloader: Actually fail if the checksum doesn't match

[pakfire.git] / tests / testsuite.c

/*#############################################################################
#                                                                             #
# Pakfire - The IPFire package management system                              #
# Copyright (C) 2017 Pakfire development team                                 #
#                                                                             #
# This program is free software: you can redistribute it and/or modify        #
# it under the terms of the GNU General Public License as published by        #
# the Free Software Foundation, either version 3 of the License, or           #
# (at your option) any later version.                                         #
#                                                                             #
# This program is distributed in the hope that it will be useful,             #
# but WITHOUT ANY WARRANTY; without even the implied warranty of              #
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the               #
# GNU General Public License for more details.                                #
#                                                                             #
# You should have received a copy of the GNU General Public License           #
# along with this program.  If not, see <http://www.gnu.org/licenses/>.       #
#                                                                             #
#############################################################################*/

#include <errno.h>
#include <linux/limits.h>
#include <stdlib.h>

#include "testsuite.h"

#include <pakfire/logging.h>
#include <pakfire/pakfire.h>
#include <pakfire/util.h>

struct testsuite ts;

static int test_run(int i, struct test* t) {
	char root[PATH_MAX];
	int r;

	// Create test root directory
	snprintf(root, PATH_MAX - 1, "%s/pakfire-test-XXXXXX", TEST_ROOTFS);
	char* tmp = pakfire_mkdtemp(root);
	if (!tmp) {
		LOG("Could not create temporary directory %s: %m\n", root);
		exit(1);
	}

	LOG("running %s (%s)\n", t->name, root);

	// Create a pakfire instance
	r = pakfire_create(&t->pakfire, root, NULL, TEST_SRC_PATH "/pakfire.conf", 0,
		pakfire_log_stderr, NULL);
	if (r) {
		LOG("ERROR: Could not initialize pakfire: %m\n");
		exit(1);
	}

	// Enable debug logging
	pakfire_log_set_priority(t->pakfire, LOG_DEBUG);

	r = t->func(t);
	if (r)
		LOG("Test failed with error code: %d\n", r);

	// Release pakfire
	struct pakfire* p = pakfire_unref(t->pakfire);

	// Check if Pakfire was actually released
	if (p) {
		LOG("Error: Pakfire instance was not released in test %d\n", i);
		return 1;
	}

	// Cleanup root
	// TODO

	return r;
}

int __testsuite_add_test(const char* name, int (*func)(const struct test* t)) {
	// Check if any space is left
	if (ts.num >= MAX_TESTS) {
		LOG("ERROR: We are out of space for tests\n");
		exit(EXIT_FAILURE);
	}

	struct test* test = &ts.tests[ts.num++];

	// Set parameters
	test->name = name;
	test->func = func;

	return 0;
}

int testsuite_run() {
	for (unsigned int i = 0; i < ts.num; i++) {
		int r = test_run(i, &ts.tests[i]);
		if (r)
			exit(r);
	}

	return EXIT_SUCCESS;
}

FILE* test_mktemp() {
	char path[] = "/tmp/.pakfire-test.XXXXXX";

	int fd = mkstemp(path);
	if (fd < 0)
		return NULL;

	return fdopen(fd, "w+");
}

char* test_mkdtemp() {
	char path[] = "/tmp/.pakfire-test.XXXXXX";

	char* p = mkdtemp(path);
	if (!p)
		return NULL;

	return strdup(path);
}