360 lines
7.7 KiB
C
360 lines
7.7 KiB
C
/******************************************************************************
|
|
* @file test_database.c
|
|
* @brief Tests d'intégration du module Database.
|
|
******************************************************************************/
|
|
|
|
#include "database/database.h"
|
|
|
|
#include <assert.h>
|
|
#include <stdio.h>
|
|
#include <string.h>
|
|
|
|
#include <glib.h>
|
|
#include <glib/gstdio.h>
|
|
#include <sqlite3.h>
|
|
|
|
/**
|
|
* @brief Lit une valeur unique retournée par une requête SQL.
|
|
*
|
|
* @param database Base SQLite ouverte.
|
|
* @param sql Requête retournant une seule colonne et une seule ligne.
|
|
*
|
|
* @return Une nouvelle chaîne à libérer avec g_free(), ou NULL.
|
|
*/
|
|
static char *test_database_read_single_text(
|
|
sqlite3 *database,
|
|
const char *sql
|
|
)
|
|
{
|
|
sqlite3_stmt *statement = NULL;
|
|
const unsigned char *text = NULL;
|
|
char *result_text = NULL;
|
|
int result = SQLITE_ERROR;
|
|
|
|
assert(database != NULL);
|
|
assert(sql != NULL);
|
|
|
|
result = sqlite3_prepare_v2(
|
|
database,
|
|
sql,
|
|
-1,
|
|
&statement,
|
|
NULL
|
|
);
|
|
|
|
assert(result == SQLITE_OK);
|
|
assert(statement != NULL);
|
|
|
|
result = sqlite3_step(statement);
|
|
|
|
assert(result == SQLITE_ROW);
|
|
|
|
text = sqlite3_column_text(
|
|
statement,
|
|
0
|
|
);
|
|
|
|
assert(text != NULL);
|
|
|
|
result_text = g_strdup(
|
|
(const char *)text
|
|
);
|
|
|
|
assert(result_text != NULL);
|
|
|
|
result = sqlite3_finalize(statement);
|
|
|
|
assert(result == SQLITE_OK);
|
|
|
|
return result_text;
|
|
}
|
|
|
|
/**
|
|
* @brief Vérifie qu'une table existe.
|
|
*/
|
|
static void test_database_assert_table_exists(
|
|
sqlite3 *database,
|
|
const char *table_name
|
|
)
|
|
{
|
|
sqlite3_stmt *statement = NULL;
|
|
int result = SQLITE_ERROR;
|
|
|
|
assert(database != NULL);
|
|
assert(table_name != NULL);
|
|
|
|
result = sqlite3_prepare_v2(
|
|
database,
|
|
"SELECT COUNT(*) "
|
|
"FROM sqlite_master "
|
|
"WHERE type = 'table' AND name = ?;",
|
|
-1,
|
|
&statement,
|
|
NULL
|
|
);
|
|
|
|
assert(result == SQLITE_OK);
|
|
assert(statement != NULL);
|
|
|
|
result = sqlite3_bind_text(
|
|
statement,
|
|
1,
|
|
table_name,
|
|
-1,
|
|
SQLITE_TRANSIENT
|
|
);
|
|
|
|
assert(result == SQLITE_OK);
|
|
|
|
result = sqlite3_step(statement);
|
|
|
|
assert(result == SQLITE_ROW);
|
|
assert(sqlite3_column_int(statement, 0) == 1);
|
|
|
|
result = sqlite3_finalize(statement);
|
|
|
|
assert(result == SQLITE_OK);
|
|
}
|
|
|
|
/**
|
|
* @brief Vérifie l'initialisation complète d'une base.
|
|
*/
|
|
static void test_database_initialize_valid_database(void)
|
|
{
|
|
char *temporary_directory = NULL;
|
|
char *database_path = NULL;
|
|
|
|
char *schema_version = NULL;
|
|
char *application_name = NULL;
|
|
char *created_at = NULL;
|
|
char *investigation_uuid = NULL;
|
|
char *investigation_name = NULL;
|
|
char *investigation_root_path = NULL;
|
|
char *investigation_created_at = NULL;
|
|
char *investigation_id = NULL;
|
|
char *investigation_count = NULL;
|
|
|
|
sqlite3 *database = NULL;
|
|
GError *error = NULL;
|
|
int result = SQLITE_ERROR;
|
|
|
|
temporary_directory = g_dir_make_tmp(
|
|
"labfy-database-test-XXXXXX",
|
|
&error
|
|
);
|
|
|
|
assert(temporary_directory != NULL);
|
|
assert(error == NULL);
|
|
|
|
database_path = g_build_filename(
|
|
temporary_directory,
|
|
"Enquete.sqlite",
|
|
NULL
|
|
);
|
|
|
|
assert(database_path != NULL);
|
|
|
|
assert(
|
|
database_initialize(
|
|
database_path,
|
|
"Enquete_Test",
|
|
temporary_directory
|
|
)
|
|
);
|
|
|
|
assert(
|
|
g_file_test(
|
|
database_path,
|
|
G_FILE_TEST_IS_REGULAR
|
|
)
|
|
);
|
|
|
|
result = sqlite3_open_v2(
|
|
database_path,
|
|
&database,
|
|
SQLITE_OPEN_READONLY,
|
|
NULL
|
|
);
|
|
|
|
assert(result == SQLITE_OK);
|
|
assert(database != NULL);
|
|
|
|
test_database_assert_table_exists(
|
|
database,
|
|
"metadata"
|
|
);
|
|
|
|
test_database_assert_table_exists(
|
|
database,
|
|
"investigation"
|
|
);
|
|
|
|
schema_version = test_database_read_single_text(
|
|
database,
|
|
"SELECT value FROM metadata "
|
|
"WHERE key = 'schema_version';"
|
|
);
|
|
|
|
application_name = test_database_read_single_text(
|
|
database,
|
|
"SELECT value FROM metadata "
|
|
"WHERE key = 'application';"
|
|
);
|
|
|
|
created_at = test_database_read_single_text(
|
|
database,
|
|
"SELECT value FROM metadata "
|
|
"WHERE key = 'created_at';"
|
|
);
|
|
|
|
investigation_uuid = test_database_read_single_text(
|
|
database,
|
|
"SELECT value FROM metadata "
|
|
"WHERE key = 'investigation_uuid';"
|
|
);
|
|
|
|
investigation_name = test_database_read_single_text(
|
|
database,
|
|
"SELECT name FROM investigation "
|
|
"LIMIT 1;"
|
|
);
|
|
|
|
investigation_root_path = test_database_read_single_text(
|
|
database,
|
|
"SELECT root_path FROM investigation "
|
|
"LIMIT 1;"
|
|
);
|
|
|
|
investigation_created_at = test_database_read_single_text(
|
|
database,
|
|
"SELECT created_at FROM investigation "
|
|
"LIMIT 1;"
|
|
);
|
|
|
|
investigation_id = test_database_read_single_text(
|
|
database,
|
|
"SELECT id FROM investigation "
|
|
"LIMIT 1;"
|
|
);
|
|
|
|
investigation_count = test_database_read_single_text(
|
|
database,
|
|
"SELECT CAST(COUNT(*) AS TEXT) "
|
|
"FROM investigation;"
|
|
);
|
|
|
|
assert(strcmp(schema_version, "1") == 0);
|
|
assert(strcmp(application_name, "Labfy Investigation") == 0);
|
|
|
|
assert(created_at[0] != '\0');
|
|
assert(investigation_uuid[0] != '\0');
|
|
|
|
assert(strcmp(investigation_name, "Enquete_Test") == 0);
|
|
assert(strcmp(investigation_root_path, temporary_directory) == 0);
|
|
assert(strcmp(investigation_created_at, created_at) == 0);
|
|
|
|
result = sqlite3_close(database);
|
|
|
|
assert(result == SQLITE_OK);
|
|
|
|
assert(g_remove(database_path) == 0);
|
|
assert(g_rmdir(temporary_directory) == 0);
|
|
|
|
assert(investigation_id[0] != '\0');
|
|
assert(g_uuid_string_is_valid(investigation_id));
|
|
|
|
assert(strcmp(investigation_count, "1") == 0);
|
|
|
|
g_free(investigation_created_at);
|
|
g_free(investigation_root_path);
|
|
g_free(investigation_name);
|
|
g_free(investigation_uuid);
|
|
g_free(created_at);
|
|
g_free(application_name);
|
|
g_free(schema_version);
|
|
g_free(database_path);
|
|
g_free(temporary_directory);
|
|
g_free(investigation_id);
|
|
g_free(investigation_count);
|
|
}
|
|
|
|
/**
|
|
* @brief Vérifie le refus des paramètres invalides.
|
|
*/
|
|
static void test_database_initialize_invalid_parameters(void)
|
|
{
|
|
assert(
|
|
!database_initialize(
|
|
NULL,
|
|
"Enquete",
|
|
"/tmp/Enquete"
|
|
)
|
|
);
|
|
|
|
assert(
|
|
!database_initialize(
|
|
"",
|
|
"Enquete",
|
|
"/tmp/Enquete"
|
|
)
|
|
);
|
|
|
|
assert(
|
|
!database_initialize(
|
|
"/tmp/Enquete.sqlite",
|
|
NULL,
|
|
"/tmp/Enquete"
|
|
)
|
|
);
|
|
|
|
assert(
|
|
!database_initialize(
|
|
"/tmp/Enquete.sqlite",
|
|
"",
|
|
"/tmp/Enquete"
|
|
)
|
|
);
|
|
|
|
assert(
|
|
!database_initialize(
|
|
"/tmp/Enquete.sqlite",
|
|
"Enquete",
|
|
NULL
|
|
)
|
|
);
|
|
|
|
assert(
|
|
!database_initialize(
|
|
"/tmp/Enquete.sqlite",
|
|
"Enquete",
|
|
""
|
|
)
|
|
);
|
|
}
|
|
|
|
/**
|
|
* @brief Vérifie l'échec sur un chemin dont le parent n'existe pas.
|
|
*/
|
|
static void test_database_initialize_missing_parent(void)
|
|
{
|
|
assert(
|
|
!database_initialize(
|
|
"/tmp/labfy-missing-parent/database/Enquete.sqlite",
|
|
"Enquete",
|
|
"/tmp/labfy-missing-parent"
|
|
)
|
|
);
|
|
}
|
|
|
|
int main(void)
|
|
{
|
|
test_database_initialize_valid_database();
|
|
test_database_initialize_invalid_parameters();
|
|
test_database_initialize_missing_parent();
|
|
|
|
printf(
|
|
"Database : tous les tests sont valides.\n"
|
|
);
|
|
|
|
return 0;
|
|
}
|