2307 lines
44 KiB
C
2307 lines
44 KiB
C
/******************************************************************************
|
|
* @file test_relation_dao.c
|
|
* @brief Tests du DAO des relations entre entités.
|
|
******************************************************************************/
|
|
|
|
#include "dao/entity_dao.h"
|
|
#include "dao/relation_dao.h"
|
|
|
|
#include "database/database.h"
|
|
#include "database/statement.h"
|
|
#include "models/entity_record.h"
|
|
#include "models/relation_record.h"
|
|
|
|
#include <assert.h>
|
|
#include <stdint.h>
|
|
#include <stdio.h>
|
|
#include <string.h>
|
|
|
|
#include <glib.h>
|
|
#include <glib/gstdio.h>
|
|
|
|
#define TEST_ENTITY_A_IDENTIFIER \
|
|
"10000000-0000-4000-8000-000000000001"
|
|
|
|
#define TEST_ENTITY_B_IDENTIFIER \
|
|
"20000000-0000-4000-8000-000000000001"
|
|
|
|
#define TEST_ENTITY_C_IDENTIFIER \
|
|
"30000000-0000-4000-8000-000000000001"
|
|
|
|
/**
|
|
* @brief Environnement temporaire d'un test RelationDao.
|
|
*/
|
|
typedef struct
|
|
{
|
|
char *temporary_directory;
|
|
char *database_path;
|
|
|
|
Database *database;
|
|
EntityDao *entity_dao;
|
|
RelationDao *relation_dao;
|
|
} TestRelationDaoFixture;
|
|
|
|
/**
|
|
* @brief Vérifie le domaine et le code d'une erreur RelationDao.
|
|
*/
|
|
static void test_relation_dao_assert_error(
|
|
const GError *error,
|
|
RelationDaoError expected_code
|
|
)
|
|
{
|
|
assert(error != NULL);
|
|
|
|
assert(
|
|
error->domain ==
|
|
RELATION_DAO_ERROR
|
|
);
|
|
|
|
assert(
|
|
error->code ==
|
|
(gint) expected_code
|
|
);
|
|
|
|
assert(error->message != NULL);
|
|
assert(error->message[0] != '\0');
|
|
}
|
|
|
|
/**
|
|
* @brief Crée une base temporaire et ses DAO.
|
|
*/
|
|
static TestRelationDaoFixture test_relation_dao_fixture_create(void)
|
|
{
|
|
TestRelationDaoFixture fixture =
|
|
{0};
|
|
|
|
GError *error =
|
|
NULL;
|
|
|
|
fixture.temporary_directory =
|
|
g_dir_make_tmp(
|
|
"labfy-relation-dao-test-XXXXXX",
|
|
&error
|
|
);
|
|
|
|
assert(fixture.temporary_directory != NULL);
|
|
assert(error == NULL);
|
|
|
|
fixture.database_path =
|
|
g_build_filename(
|
|
fixture.temporary_directory,
|
|
"Enquete.sqlite",
|
|
NULL
|
|
);
|
|
|
|
assert(fixture.database_path != NULL);
|
|
|
|
assert(
|
|
database_initialize(
|
|
fixture.database_path,
|
|
"Enquete_RelationDao",
|
|
fixture.temporary_directory
|
|
)
|
|
);
|
|
|
|
fixture.database =
|
|
database_open(
|
|
fixture.database_path
|
|
);
|
|
|
|
assert(fixture.database != NULL);
|
|
|
|
fixture.entity_dao =
|
|
entity_dao_new(
|
|
fixture.database,
|
|
&error
|
|
);
|
|
|
|
assert(fixture.entity_dao != NULL);
|
|
assert(error == NULL);
|
|
|
|
fixture.relation_dao =
|
|
relation_dao_new(
|
|
fixture.database,
|
|
&error
|
|
);
|
|
|
|
assert(fixture.relation_dao != NULL);
|
|
assert(error == NULL);
|
|
|
|
return fixture;
|
|
}
|
|
|
|
/**
|
|
* @brief Libère la fixture et supprime sa base temporaire.
|
|
*/
|
|
static void test_relation_dao_fixture_clear(
|
|
TestRelationDaoFixture *fixture
|
|
)
|
|
{
|
|
assert(fixture != NULL);
|
|
|
|
relation_dao_free(
|
|
fixture->relation_dao
|
|
);
|
|
|
|
entity_dao_free(
|
|
fixture->entity_dao
|
|
);
|
|
|
|
database_close(
|
|
fixture->database
|
|
);
|
|
|
|
assert(
|
|
g_remove(
|
|
fixture->database_path
|
|
) == 0
|
|
);
|
|
|
|
assert(
|
|
g_rmdir(
|
|
fixture->temporary_directory
|
|
) == 0
|
|
);
|
|
|
|
g_free(
|
|
fixture->database_path
|
|
);
|
|
|
|
g_free(
|
|
fixture->temporary_directory
|
|
);
|
|
|
|
fixture->relation_dao =
|
|
NULL;
|
|
|
|
fixture->entity_dao =
|
|
NULL;
|
|
|
|
fixture->database =
|
|
NULL;
|
|
|
|
fixture->database_path =
|
|
NULL;
|
|
|
|
fixture->temporary_directory =
|
|
NULL;
|
|
}
|
|
|
|
/**
|
|
* @brief Crée une entité de test.
|
|
*/
|
|
static EntityRecord *test_relation_dao_create_entity(
|
|
const char *identifier,
|
|
const char *value
|
|
)
|
|
{
|
|
EntityRecord *entity_record =
|
|
NULL;
|
|
|
|
GError *error =
|
|
NULL;
|
|
|
|
entity_record =
|
|
entity_record_new(
|
|
identifier,
|
|
"person",
|
|
value,
|
|
NULL,
|
|
NULL,
|
|
80,
|
|
"2026-07-20T20:00:00Z",
|
|
"2026-07-20T20:00:00Z",
|
|
ENTITY_STATUS_ACTIVE,
|
|
&error
|
|
);
|
|
|
|
assert(entity_record != NULL);
|
|
assert(error == NULL);
|
|
|
|
return entity_record;
|
|
}
|
|
|
|
/**
|
|
* @brief Insère une entité de test.
|
|
*/
|
|
static void test_relation_dao_insert_entity(
|
|
TestRelationDaoFixture *fixture,
|
|
const char *identifier,
|
|
const char *value
|
|
)
|
|
{
|
|
EntityRecord *entity_record =
|
|
NULL;
|
|
|
|
GError *error =
|
|
NULL;
|
|
|
|
assert(fixture != NULL);
|
|
|
|
entity_record =
|
|
test_relation_dao_create_entity(
|
|
identifier,
|
|
value
|
|
);
|
|
|
|
assert(
|
|
entity_dao_insert(
|
|
fixture->entity_dao,
|
|
entity_record,
|
|
&error
|
|
)
|
|
);
|
|
|
|
assert(error == NULL);
|
|
|
|
entity_record_free(
|
|
entity_record
|
|
);
|
|
}
|
|
|
|
/**
|
|
* @brief Insère les trois entités couramment utilisées par les tests.
|
|
*/
|
|
static void test_relation_dao_insert_standard_entities(
|
|
TestRelationDaoFixture *fixture
|
|
)
|
|
{
|
|
test_relation_dao_insert_entity(
|
|
fixture,
|
|
TEST_ENTITY_A_IDENTIFIER,
|
|
"Personne A"
|
|
);
|
|
|
|
test_relation_dao_insert_entity(
|
|
fixture,
|
|
TEST_ENTITY_B_IDENTIFIER,
|
|
"Personne B"
|
|
);
|
|
|
|
test_relation_dao_insert_entity(
|
|
fixture,
|
|
TEST_ENTITY_C_IDENTIFIER,
|
|
"Personne C"
|
|
);
|
|
}
|
|
|
|
/**
|
|
* @brief Crée une relation de test.
|
|
*/
|
|
static RelationRecord *test_relation_dao_create_relation(
|
|
const char *identifier,
|
|
const char *source_entity_identifier,
|
|
const char *target_entity_identifier,
|
|
const char *relation_type,
|
|
const char *label,
|
|
const char *justification,
|
|
gint confidence,
|
|
const char *created_at,
|
|
const char *updated_at,
|
|
RelationStatus status
|
|
)
|
|
{
|
|
RelationRecord *relation_record =
|
|
NULL;
|
|
|
|
GError *error =
|
|
NULL;
|
|
|
|
relation_record =
|
|
relation_record_new(
|
|
identifier,
|
|
source_entity_identifier,
|
|
target_entity_identifier,
|
|
relation_type,
|
|
label,
|
|
justification,
|
|
confidence,
|
|
created_at,
|
|
updated_at,
|
|
status,
|
|
&error
|
|
);
|
|
|
|
assert(relation_record != NULL);
|
|
assert(error == NULL);
|
|
|
|
return relation_record;
|
|
}
|
|
|
|
/**
|
|
* @brief Insère une relation et vérifie le succès.
|
|
*/
|
|
static void test_relation_dao_insert_relation(
|
|
TestRelationDaoFixture *fixture,
|
|
RelationRecord *relation_record
|
|
)
|
|
{
|
|
GError *error =
|
|
NULL;
|
|
|
|
assert(fixture != NULL);
|
|
assert(relation_record != NULL);
|
|
|
|
assert(
|
|
relation_dao_insert(
|
|
fixture->relation_dao,
|
|
relation_record,
|
|
&error
|
|
)
|
|
);
|
|
|
|
assert(error == NULL);
|
|
}
|
|
|
|
/**
|
|
* @brief Retourne le nombre de relations persistées.
|
|
*/
|
|
static int64_t test_relation_dao_count_rows(
|
|
Database *database
|
|
)
|
|
{
|
|
DatabaseStatement *statement =
|
|
NULL;
|
|
|
|
int64_t relation_count =
|
|
-1;
|
|
|
|
assert(database != NULL);
|
|
|
|
statement =
|
|
database_statement_prepare(
|
|
database,
|
|
"SELECT COUNT(*) "
|
|
"FROM relations;"
|
|
);
|
|
|
|
assert(statement != NULL);
|
|
|
|
assert(
|
|
database_statement_step(
|
|
statement
|
|
) == DATABASE_STATEMENT_STEP_ROW
|
|
);
|
|
|
|
assert(
|
|
database_statement_column_int64(
|
|
statement,
|
|
0,
|
|
&relation_count
|
|
)
|
|
);
|
|
|
|
assert(
|
|
database_statement_step(
|
|
statement
|
|
) == DATABASE_STATEMENT_STEP_DONE
|
|
);
|
|
|
|
database_statement_finalize(
|
|
statement
|
|
);
|
|
|
|
return relation_count;
|
|
}
|
|
|
|
/**
|
|
* @brief Vérifie le refus d'une connexion absente.
|
|
*/
|
|
static void test_relation_dao_new_null_database(void)
|
|
{
|
|
RelationDao *relation_dao =
|
|
NULL;
|
|
|
|
GError *error =
|
|
NULL;
|
|
|
|
relation_dao =
|
|
relation_dao_new(
|
|
NULL,
|
|
&error
|
|
);
|
|
|
|
assert(relation_dao == NULL);
|
|
|
|
test_relation_dao_assert_error(
|
|
error,
|
|
RELATION_DAO_ERROR_INVALID_ARGUMENT
|
|
);
|
|
|
|
g_clear_error(
|
|
&error
|
|
);
|
|
}
|
|
|
|
/**
|
|
* @brief Vérifie la création et la destruction du DAO.
|
|
*/
|
|
static void test_relation_dao_lifecycle(void)
|
|
{
|
|
Database *database =
|
|
NULL;
|
|
|
|
RelationDao *relation_dao =
|
|
NULL;
|
|
|
|
GError *error =
|
|
NULL;
|
|
|
|
database =
|
|
database_open(
|
|
":memory:"
|
|
);
|
|
|
|
assert(database != NULL);
|
|
|
|
relation_dao =
|
|
relation_dao_new(
|
|
database,
|
|
&error
|
|
);
|
|
|
|
assert(relation_dao != NULL);
|
|
assert(error == NULL);
|
|
|
|
relation_dao_free(
|
|
relation_dao
|
|
);
|
|
|
|
relation_dao_free(
|
|
NULL
|
|
);
|
|
|
|
database_close(
|
|
database
|
|
);
|
|
}
|
|
|
|
/**
|
|
* @brief Vérifie l'insertion complète d'une relation.
|
|
*/
|
|
static void test_relation_dao_insert_valid_full(void)
|
|
{
|
|
TestRelationDaoFixture fixture =
|
|
test_relation_dao_fixture_create();
|
|
|
|
RelationRecord *relation_record =
|
|
NULL;
|
|
|
|
DatabaseStatement *statement =
|
|
NULL;
|
|
|
|
char *identifier =
|
|
NULL;
|
|
|
|
char *source_identifier =
|
|
NULL;
|
|
|
|
char *target_identifier =
|
|
NULL;
|
|
|
|
char *relation_type =
|
|
NULL;
|
|
|
|
char *label =
|
|
NULL;
|
|
|
|
char *justification =
|
|
NULL;
|
|
|
|
char *created_at =
|
|
NULL;
|
|
|
|
char *updated_at =
|
|
NULL;
|
|
|
|
char *status =
|
|
NULL;
|
|
|
|
int64_t confidence =
|
|
-1;
|
|
|
|
test_relation_dao_insert_standard_entities(
|
|
&fixture
|
|
);
|
|
|
|
relation_record =
|
|
test_relation_dao_create_relation(
|
|
"40000000-0000-4000-8000-000000000001",
|
|
TEST_ENTITY_A_IDENTIFIER,
|
|
TEST_ENTITY_B_IDENTIFIER,
|
|
"uses",
|
|
"Utilise cette identité",
|
|
"Association observée dans une conversation.",
|
|
90,
|
|
"2026-07-20T20:10:00Z",
|
|
"2026-07-20T20:15:00Z",
|
|
RELATION_STATUS_DISPUTED
|
|
);
|
|
|
|
test_relation_dao_insert_relation(
|
|
&fixture,
|
|
relation_record
|
|
);
|
|
|
|
statement =
|
|
database_statement_prepare(
|
|
fixture.database,
|
|
"SELECT "
|
|
" id,"
|
|
" entite_source_id,"
|
|
" entite_cible_id,"
|
|
" type_relation,"
|
|
" label,"
|
|
" justification,"
|
|
" confiance,"
|
|
" created_at,"
|
|
" updated_at,"
|
|
" status "
|
|
"FROM relations "
|
|
"WHERE id = ?;"
|
|
);
|
|
|
|
assert(statement != NULL);
|
|
|
|
assert(
|
|
database_statement_bind_text(
|
|
statement,
|
|
1,
|
|
"40000000-0000-4000-8000-000000000001"
|
|
)
|
|
);
|
|
|
|
assert(
|
|
database_statement_step(
|
|
statement
|
|
) == DATABASE_STATEMENT_STEP_ROW
|
|
);
|
|
|
|
assert(
|
|
database_statement_column_text(
|
|
statement,
|
|
0,
|
|
&identifier
|
|
)
|
|
);
|
|
|
|
assert(
|
|
database_statement_column_text(
|
|
statement,
|
|
1,
|
|
&source_identifier
|
|
)
|
|
);
|
|
|
|
assert(
|
|
database_statement_column_text(
|
|
statement,
|
|
2,
|
|
&target_identifier
|
|
)
|
|
);
|
|
|
|
assert(
|
|
database_statement_column_text(
|
|
statement,
|
|
3,
|
|
&relation_type
|
|
)
|
|
);
|
|
|
|
assert(
|
|
database_statement_column_text(
|
|
statement,
|
|
4,
|
|
&label
|
|
)
|
|
);
|
|
|
|
assert(
|
|
database_statement_column_text(
|
|
statement,
|
|
5,
|
|
&justification
|
|
)
|
|
);
|
|
|
|
assert(
|
|
database_statement_column_int64(
|
|
statement,
|
|
6,
|
|
&confidence
|
|
)
|
|
);
|
|
|
|
assert(
|
|
database_statement_column_text(
|
|
statement,
|
|
7,
|
|
&created_at
|
|
)
|
|
);
|
|
|
|
assert(
|
|
database_statement_column_text(
|
|
statement,
|
|
8,
|
|
&updated_at
|
|
)
|
|
);
|
|
|
|
assert(
|
|
database_statement_column_text(
|
|
statement,
|
|
9,
|
|
&status
|
|
)
|
|
);
|
|
|
|
assert(
|
|
database_statement_step(
|
|
statement
|
|
) == DATABASE_STATEMENT_STEP_DONE
|
|
);
|
|
|
|
assert(
|
|
strcmp(
|
|
identifier,
|
|
"40000000-0000-4000-8000-000000000001"
|
|
) == 0
|
|
);
|
|
|
|
assert(
|
|
strcmp(
|
|
source_identifier,
|
|
TEST_ENTITY_A_IDENTIFIER
|
|
) == 0
|
|
);
|
|
|
|
assert(
|
|
strcmp(
|
|
target_identifier,
|
|
TEST_ENTITY_B_IDENTIFIER
|
|
) == 0
|
|
);
|
|
|
|
assert(
|
|
strcmp(
|
|
relation_type,
|
|
"uses"
|
|
) == 0
|
|
);
|
|
|
|
assert(
|
|
strcmp(
|
|
label,
|
|
"Utilise cette identité"
|
|
) == 0
|
|
);
|
|
|
|
assert(
|
|
strcmp(
|
|
justification,
|
|
"Association observée dans une conversation."
|
|
) == 0
|
|
);
|
|
|
|
assert(confidence == 90);
|
|
|
|
assert(
|
|
strcmp(
|
|
created_at,
|
|
"2026-07-20T20:10:00Z"
|
|
) == 0
|
|
);
|
|
|
|
assert(
|
|
strcmp(
|
|
updated_at,
|
|
"2026-07-20T20:15:00Z"
|
|
) == 0
|
|
);
|
|
|
|
assert(
|
|
strcmp(
|
|
status,
|
|
"disputed"
|
|
) == 0
|
|
);
|
|
|
|
database_statement_finalize(
|
|
statement
|
|
);
|
|
|
|
g_free(
|
|
status
|
|
);
|
|
|
|
g_free(
|
|
updated_at
|
|
);
|
|
|
|
g_free(
|
|
created_at
|
|
);
|
|
|
|
g_free(
|
|
justification
|
|
);
|
|
|
|
g_free(
|
|
label
|
|
);
|
|
|
|
g_free(
|
|
relation_type
|
|
);
|
|
|
|
g_free(
|
|
target_identifier
|
|
);
|
|
|
|
g_free(
|
|
source_identifier
|
|
);
|
|
|
|
g_free(
|
|
identifier
|
|
);
|
|
|
|
relation_record_free(
|
|
relation_record
|
|
);
|
|
|
|
test_relation_dao_fixture_clear(
|
|
&fixture
|
|
);
|
|
}
|
|
|
|
/**
|
|
* @brief Vérifie l'insertion avec champs facultatifs absents.
|
|
*/
|
|
static void test_relation_dao_insert_optional_null(void)
|
|
{
|
|
TestRelationDaoFixture fixture =
|
|
test_relation_dao_fixture_create();
|
|
|
|
RelationRecord *relation_record =
|
|
NULL;
|
|
|
|
DatabaseStatement *statement =
|
|
NULL;
|
|
|
|
bool label_is_null =
|
|
false;
|
|
|
|
bool justification_is_null =
|
|
false;
|
|
|
|
test_relation_dao_insert_standard_entities(
|
|
&fixture
|
|
);
|
|
|
|
relation_record =
|
|
test_relation_dao_create_relation(
|
|
"40000000-0000-4000-8000-000000000002",
|
|
TEST_ENTITY_A_IDENTIFIER,
|
|
TEST_ENTITY_B_IDENTIFIER,
|
|
"knows",
|
|
NULL,
|
|
NULL,
|
|
50,
|
|
"2026-07-20T20:20:00Z",
|
|
"2026-07-20T20:20:00Z",
|
|
RELATION_STATUS_ACTIVE
|
|
);
|
|
|
|
test_relation_dao_insert_relation(
|
|
&fixture,
|
|
relation_record
|
|
);
|
|
|
|
statement =
|
|
database_statement_prepare(
|
|
fixture.database,
|
|
"SELECT "
|
|
" label,"
|
|
" justification "
|
|
"FROM relations "
|
|
"WHERE id = ?;"
|
|
);
|
|
|
|
assert(statement != NULL);
|
|
|
|
assert(
|
|
database_statement_bind_text(
|
|
statement,
|
|
1,
|
|
"40000000-0000-4000-8000-000000000002"
|
|
)
|
|
);
|
|
|
|
assert(
|
|
database_statement_step(
|
|
statement
|
|
) == DATABASE_STATEMENT_STEP_ROW
|
|
);
|
|
|
|
assert(
|
|
database_statement_column_is_null(
|
|
statement,
|
|
0,
|
|
&label_is_null
|
|
)
|
|
);
|
|
|
|
assert(
|
|
database_statement_column_is_null(
|
|
statement,
|
|
1,
|
|
&justification_is_null
|
|
)
|
|
);
|
|
|
|
assert(label_is_null);
|
|
assert(justification_is_null);
|
|
|
|
database_statement_finalize(
|
|
statement
|
|
);
|
|
|
|
relation_record_free(
|
|
relation_record
|
|
);
|
|
|
|
test_relation_dao_fixture_clear(
|
|
&fixture
|
|
);
|
|
}
|
|
|
|
/**
|
|
* @brief Vérifie le refus d'un UUID de relation dupliqué.
|
|
*/
|
|
static void test_relation_dao_insert_duplicate_identifier(void)
|
|
{
|
|
TestRelationDaoFixture fixture =
|
|
test_relation_dao_fixture_create();
|
|
|
|
RelationRecord *first_record =
|
|
NULL;
|
|
|
|
RelationRecord *second_record =
|
|
NULL;
|
|
|
|
GError *error =
|
|
NULL;
|
|
|
|
test_relation_dao_insert_standard_entities(
|
|
&fixture
|
|
);
|
|
|
|
first_record =
|
|
test_relation_dao_create_relation(
|
|
"40000000-0000-4000-8000-000000000003",
|
|
TEST_ENTITY_A_IDENTIFIER,
|
|
TEST_ENTITY_B_IDENTIFIER,
|
|
"uses",
|
|
NULL,
|
|
NULL,
|
|
80,
|
|
"2026-07-20T20:30:00Z",
|
|
"2026-07-20T20:30:00Z",
|
|
RELATION_STATUS_ACTIVE
|
|
);
|
|
|
|
second_record =
|
|
test_relation_dao_create_relation(
|
|
"40000000-0000-4000-8000-000000000003",
|
|
TEST_ENTITY_A_IDENTIFIER,
|
|
TEST_ENTITY_C_IDENTIFIER,
|
|
"controls",
|
|
NULL,
|
|
NULL,
|
|
70,
|
|
"2026-07-20T20:31:00Z",
|
|
"2026-07-20T20:31:00Z",
|
|
RELATION_STATUS_ACTIVE
|
|
);
|
|
|
|
test_relation_dao_insert_relation(
|
|
&fixture,
|
|
first_record
|
|
);
|
|
|
|
assert(
|
|
!relation_dao_insert(
|
|
fixture.relation_dao,
|
|
second_record,
|
|
&error
|
|
)
|
|
);
|
|
|
|
test_relation_dao_assert_error(
|
|
error,
|
|
RELATION_DAO_ERROR_CONSTRAINT
|
|
);
|
|
|
|
assert(
|
|
strstr(
|
|
error->message,
|
|
"identifiant"
|
|
) != NULL
|
|
);
|
|
|
|
assert(
|
|
test_relation_dao_count_rows(
|
|
fixture.database
|
|
) == 1
|
|
);
|
|
|
|
g_clear_error(
|
|
&error
|
|
);
|
|
|
|
relation_record_free(
|
|
second_record
|
|
);
|
|
|
|
relation_record_free(
|
|
first_record
|
|
);
|
|
|
|
test_relation_dao_fixture_clear(
|
|
&fixture
|
|
);
|
|
}
|
|
|
|
/**
|
|
* @brief Vérifie le refus d'une entité source inexistante.
|
|
*/
|
|
static void test_relation_dao_insert_missing_source(void)
|
|
{
|
|
TestRelationDaoFixture fixture =
|
|
test_relation_dao_fixture_create();
|
|
|
|
RelationRecord *relation_record =
|
|
NULL;
|
|
|
|
GError *error =
|
|
NULL;
|
|
|
|
test_relation_dao_insert_entity(
|
|
&fixture,
|
|
TEST_ENTITY_B_IDENTIFIER,
|
|
"Personne B"
|
|
);
|
|
|
|
relation_record =
|
|
test_relation_dao_create_relation(
|
|
"40000000-0000-4000-8000-000000000004",
|
|
TEST_ENTITY_A_IDENTIFIER,
|
|
TEST_ENTITY_B_IDENTIFIER,
|
|
"uses",
|
|
NULL,
|
|
NULL,
|
|
80,
|
|
"2026-07-20T20:40:00Z",
|
|
"2026-07-20T20:40:00Z",
|
|
RELATION_STATUS_ACTIVE
|
|
);
|
|
|
|
assert(
|
|
!relation_dao_insert(
|
|
fixture.relation_dao,
|
|
relation_record,
|
|
&error
|
|
)
|
|
);
|
|
|
|
test_relation_dao_assert_error(
|
|
error,
|
|
RELATION_DAO_ERROR_CONSTRAINT
|
|
);
|
|
|
|
assert(
|
|
strstr(
|
|
error->message,
|
|
"source"
|
|
) != NULL
|
|
);
|
|
|
|
g_clear_error(
|
|
&error
|
|
);
|
|
|
|
relation_record_free(
|
|
relation_record
|
|
);
|
|
|
|
test_relation_dao_fixture_clear(
|
|
&fixture
|
|
);
|
|
}
|
|
|
|
/**
|
|
* @brief Vérifie le refus d'une entité cible inexistante.
|
|
*/
|
|
static void test_relation_dao_insert_missing_target(void)
|
|
{
|
|
TestRelationDaoFixture fixture =
|
|
test_relation_dao_fixture_create();
|
|
|
|
RelationRecord *relation_record =
|
|
NULL;
|
|
|
|
GError *error =
|
|
NULL;
|
|
|
|
test_relation_dao_insert_entity(
|
|
&fixture,
|
|
TEST_ENTITY_A_IDENTIFIER,
|
|
"Personne A"
|
|
);
|
|
|
|
relation_record =
|
|
test_relation_dao_create_relation(
|
|
"40000000-0000-4000-8000-000000000005",
|
|
TEST_ENTITY_A_IDENTIFIER,
|
|
TEST_ENTITY_B_IDENTIFIER,
|
|
"uses",
|
|
NULL,
|
|
NULL,
|
|
80,
|
|
"2026-07-20T20:50:00Z",
|
|
"2026-07-20T20:50:00Z",
|
|
RELATION_STATUS_ACTIVE
|
|
);
|
|
|
|
assert(
|
|
!relation_dao_insert(
|
|
fixture.relation_dao,
|
|
relation_record,
|
|
&error
|
|
)
|
|
);
|
|
|
|
test_relation_dao_assert_error(
|
|
error,
|
|
RELATION_DAO_ERROR_CONSTRAINT
|
|
);
|
|
|
|
assert(
|
|
strstr(
|
|
error->message,
|
|
"cible"
|
|
) != NULL
|
|
);
|
|
|
|
g_clear_error(
|
|
&error
|
|
);
|
|
|
|
relation_record_free(
|
|
relation_record
|
|
);
|
|
|
|
test_relation_dao_fixture_clear(
|
|
&fixture
|
|
);
|
|
}
|
|
|
|
/**
|
|
* @brief Vérifie le refus d'un doublon source, cible et type.
|
|
*/
|
|
static void test_relation_dao_insert_duplicate_triple(void)
|
|
{
|
|
TestRelationDaoFixture fixture =
|
|
test_relation_dao_fixture_create();
|
|
|
|
RelationRecord *first_record =
|
|
NULL;
|
|
|
|
RelationRecord *second_record =
|
|
NULL;
|
|
|
|
GError *error =
|
|
NULL;
|
|
|
|
test_relation_dao_insert_standard_entities(
|
|
&fixture
|
|
);
|
|
|
|
first_record =
|
|
test_relation_dao_create_relation(
|
|
"40000000-0000-4000-8000-000000000006",
|
|
TEST_ENTITY_A_IDENTIFIER,
|
|
TEST_ENTITY_B_IDENTIFIER,
|
|
"uses",
|
|
"Première relation",
|
|
NULL,
|
|
80,
|
|
"2026-07-20T21:00:00Z",
|
|
"2026-07-20T21:00:00Z",
|
|
RELATION_STATUS_ACTIVE
|
|
);
|
|
|
|
second_record =
|
|
test_relation_dao_create_relation(
|
|
"40000000-0000-4000-8000-000000000007",
|
|
TEST_ENTITY_A_IDENTIFIER,
|
|
TEST_ENTITY_B_IDENTIFIER,
|
|
"uses",
|
|
"Deuxième relation",
|
|
NULL,
|
|
40,
|
|
"2026-07-20T21:01:00Z",
|
|
"2026-07-20T21:01:00Z",
|
|
RELATION_STATUS_DISPUTED
|
|
);
|
|
|
|
test_relation_dao_insert_relation(
|
|
&fixture,
|
|
first_record
|
|
);
|
|
|
|
assert(
|
|
!relation_dao_insert(
|
|
fixture.relation_dao,
|
|
second_record,
|
|
&error
|
|
)
|
|
);
|
|
|
|
test_relation_dao_assert_error(
|
|
error,
|
|
RELATION_DAO_ERROR_CONSTRAINT
|
|
);
|
|
|
|
assert(
|
|
strstr(
|
|
error->message,
|
|
"orientée"
|
|
) != NULL
|
|
);
|
|
|
|
assert(
|
|
test_relation_dao_count_rows(
|
|
fixture.database
|
|
) == 1
|
|
);
|
|
|
|
g_clear_error(
|
|
&error
|
|
);
|
|
|
|
relation_record_free(
|
|
second_record
|
|
);
|
|
|
|
relation_record_free(
|
|
first_record
|
|
);
|
|
|
|
test_relation_dao_fixture_clear(
|
|
&fixture
|
|
);
|
|
}
|
|
|
|
/**
|
|
* @brief Vérifie plusieurs types et les deux orientations A-B et B-A.
|
|
*/
|
|
static void test_relation_dao_orientation_and_multiple_types(void)
|
|
{
|
|
TestRelationDaoFixture fixture =
|
|
test_relation_dao_fixture_create();
|
|
|
|
RelationRecord *first_record =
|
|
NULL;
|
|
|
|
RelationRecord *second_record =
|
|
NULL;
|
|
|
|
RelationRecord *reverse_record =
|
|
NULL;
|
|
|
|
test_relation_dao_insert_standard_entities(
|
|
&fixture
|
|
);
|
|
|
|
first_record =
|
|
test_relation_dao_create_relation(
|
|
"40000000-0000-4000-8000-000000000008",
|
|
TEST_ENTITY_A_IDENTIFIER,
|
|
TEST_ENTITY_B_IDENTIFIER,
|
|
"uses",
|
|
NULL,
|
|
NULL,
|
|
80,
|
|
"2026-07-20T21:10:00Z",
|
|
"2026-07-20T21:10:00Z",
|
|
RELATION_STATUS_ACTIVE
|
|
);
|
|
|
|
second_record =
|
|
test_relation_dao_create_relation(
|
|
"40000000-0000-4000-8000-000000000009",
|
|
TEST_ENTITY_A_IDENTIFIER,
|
|
TEST_ENTITY_B_IDENTIFIER,
|
|
"controls",
|
|
NULL,
|
|
NULL,
|
|
70,
|
|
"2026-07-20T21:11:00Z",
|
|
"2026-07-20T21:11:00Z",
|
|
RELATION_STATUS_ACTIVE
|
|
);
|
|
|
|
reverse_record =
|
|
test_relation_dao_create_relation(
|
|
"40000000-0000-4000-8000-000000000010",
|
|
TEST_ENTITY_B_IDENTIFIER,
|
|
TEST_ENTITY_A_IDENTIFIER,
|
|
"uses",
|
|
NULL,
|
|
NULL,
|
|
60,
|
|
"2026-07-20T21:12:00Z",
|
|
"2026-07-20T21:12:00Z",
|
|
RELATION_STATUS_ACTIVE
|
|
);
|
|
|
|
test_relation_dao_insert_relation(
|
|
&fixture,
|
|
first_record
|
|
);
|
|
|
|
test_relation_dao_insert_relation(
|
|
&fixture,
|
|
second_record
|
|
);
|
|
|
|
test_relation_dao_insert_relation(
|
|
&fixture,
|
|
reverse_record
|
|
);
|
|
|
|
assert(
|
|
test_relation_dao_count_rows(
|
|
fixture.database
|
|
) == 3
|
|
);
|
|
|
|
relation_record_free(
|
|
reverse_record
|
|
);
|
|
|
|
relation_record_free(
|
|
second_record
|
|
);
|
|
|
|
relation_record_free(
|
|
first_record
|
|
);
|
|
|
|
test_relation_dao_fixture_clear(
|
|
&fixture
|
|
);
|
|
}
|
|
|
|
/**
|
|
* @brief Vérifie la recherche d'une relation existante.
|
|
*/
|
|
static void test_relation_dao_find_existing(void)
|
|
{
|
|
TestRelationDaoFixture fixture =
|
|
test_relation_dao_fixture_create();
|
|
|
|
RelationRecord *inserted_record =
|
|
NULL;
|
|
|
|
RelationRecord *loaded_record =
|
|
NULL;
|
|
|
|
GError *error =
|
|
NULL;
|
|
|
|
test_relation_dao_insert_standard_entities(
|
|
&fixture
|
|
);
|
|
|
|
inserted_record =
|
|
test_relation_dao_create_relation(
|
|
"40000000-0000-4000-8000-000000000011",
|
|
TEST_ENTITY_A_IDENTIFIER,
|
|
TEST_ENTITY_C_IDENTIFIER,
|
|
"knows",
|
|
"Connaît cette personne",
|
|
"Déclaration issue d'un message.",
|
|
65,
|
|
"2026-07-20T21:20:00Z",
|
|
"2026-07-20T21:25:00Z",
|
|
RELATION_STATUS_ARCHIVED
|
|
);
|
|
|
|
test_relation_dao_insert_relation(
|
|
&fixture,
|
|
inserted_record
|
|
);
|
|
|
|
loaded_record =
|
|
relation_dao_find_by_identifier(
|
|
fixture.relation_dao,
|
|
"40000000-0000-4000-8000-000000000011",
|
|
&error
|
|
);
|
|
|
|
assert(loaded_record != NULL);
|
|
assert(error == NULL);
|
|
|
|
assert(
|
|
strcmp(
|
|
relation_record_get_identifier(
|
|
loaded_record
|
|
),
|
|
"40000000-0000-4000-8000-000000000011"
|
|
) == 0
|
|
);
|
|
|
|
assert(
|
|
strcmp(
|
|
relation_record_get_source_entity_identifier(
|
|
loaded_record
|
|
),
|
|
TEST_ENTITY_A_IDENTIFIER
|
|
) == 0
|
|
);
|
|
|
|
assert(
|
|
strcmp(
|
|
relation_record_get_target_entity_identifier(
|
|
loaded_record
|
|
),
|
|
TEST_ENTITY_C_IDENTIFIER
|
|
) == 0
|
|
);
|
|
|
|
assert(
|
|
strcmp(
|
|
relation_record_get_relation_type(
|
|
loaded_record
|
|
),
|
|
"knows"
|
|
) == 0
|
|
);
|
|
|
|
assert(
|
|
relation_record_get_confidence(
|
|
loaded_record
|
|
) == 65
|
|
);
|
|
|
|
assert(
|
|
relation_record_get_status(
|
|
loaded_record
|
|
) == RELATION_STATUS_ARCHIVED
|
|
);
|
|
|
|
relation_record_free(
|
|
loaded_record
|
|
);
|
|
|
|
relation_record_free(
|
|
inserted_record
|
|
);
|
|
|
|
test_relation_dao_fixture_clear(
|
|
&fixture
|
|
);
|
|
}
|
|
|
|
/**
|
|
* @brief Vérifie qu'une relation absente retourne NULL sans erreur.
|
|
*/
|
|
static void test_relation_dao_find_missing(void)
|
|
{
|
|
TestRelationDaoFixture fixture =
|
|
test_relation_dao_fixture_create();
|
|
|
|
RelationRecord *relation_record =
|
|
NULL;
|
|
|
|
GError *error =
|
|
NULL;
|
|
|
|
relation_record =
|
|
relation_dao_find_by_identifier(
|
|
fixture.relation_dao,
|
|
"40000000-0000-4000-8000-000000000012",
|
|
&error
|
|
);
|
|
|
|
assert(relation_record == NULL);
|
|
assert(error == NULL);
|
|
|
|
test_relation_dao_fixture_clear(
|
|
&fixture
|
|
);
|
|
}
|
|
|
|
/**
|
|
* @brief Vérifie le refus d'un identifiant de recherche invalide.
|
|
*/
|
|
static void test_relation_dao_find_invalid_identifier(void)
|
|
{
|
|
TestRelationDaoFixture fixture =
|
|
test_relation_dao_fixture_create();
|
|
|
|
RelationRecord *relation_record =
|
|
NULL;
|
|
|
|
GError *error =
|
|
NULL;
|
|
|
|
relation_record =
|
|
relation_dao_find_by_identifier(
|
|
fixture.relation_dao,
|
|
"relation-invalide",
|
|
&error
|
|
);
|
|
|
|
assert(relation_record == NULL);
|
|
|
|
test_relation_dao_assert_error(
|
|
error,
|
|
RELATION_DAO_ERROR_INVALID_ARGUMENT
|
|
);
|
|
|
|
g_clear_error(
|
|
&error
|
|
);
|
|
|
|
test_relation_dao_fixture_clear(
|
|
&fixture
|
|
);
|
|
}
|
|
|
|
/**
|
|
* @brief Vérifie le chargement d'une liste vide.
|
|
*/
|
|
static void test_relation_dao_list_empty(void)
|
|
{
|
|
TestRelationDaoFixture fixture =
|
|
test_relation_dao_fixture_create();
|
|
|
|
GPtrArray *relations =
|
|
NULL;
|
|
|
|
GError *error =
|
|
NULL;
|
|
|
|
relations =
|
|
relation_dao_list_all(
|
|
fixture.relation_dao,
|
|
&error
|
|
);
|
|
|
|
assert(relations != NULL);
|
|
assert(error == NULL);
|
|
assert(relations->len == 0);
|
|
|
|
g_ptr_array_unref(
|
|
relations
|
|
);
|
|
|
|
test_relation_dao_fixture_clear(
|
|
&fixture
|
|
);
|
|
}
|
|
|
|
/**
|
|
* @brief Vérifie l'ordre stable de la liste.
|
|
*/
|
|
static void test_relation_dao_list_order(void)
|
|
{
|
|
TestRelationDaoFixture fixture =
|
|
test_relation_dao_fixture_create();
|
|
|
|
RelationRecord *first_record =
|
|
NULL;
|
|
|
|
RelationRecord *second_record =
|
|
NULL;
|
|
|
|
RelationRecord *third_record =
|
|
NULL;
|
|
|
|
const RelationRecord *first_loaded =
|
|
NULL;
|
|
|
|
const RelationRecord *second_loaded =
|
|
NULL;
|
|
|
|
const RelationRecord *third_loaded =
|
|
NULL;
|
|
|
|
GPtrArray *relations =
|
|
NULL;
|
|
|
|
GError *error =
|
|
NULL;
|
|
|
|
test_relation_dao_insert_standard_entities(
|
|
&fixture
|
|
);
|
|
|
|
third_record =
|
|
test_relation_dao_create_relation(
|
|
"60000000-0000-4000-8000-000000000003",
|
|
TEST_ENTITY_C_IDENTIFIER,
|
|
TEST_ENTITY_A_IDENTIFIER,
|
|
"knows",
|
|
NULL,
|
|
NULL,
|
|
50,
|
|
"2026-07-20T22:00:00Z",
|
|
"2026-07-20T22:00:00Z",
|
|
RELATION_STATUS_ACTIVE
|
|
);
|
|
|
|
second_record =
|
|
test_relation_dao_create_relation(
|
|
"60000000-0000-4000-8000-000000000002",
|
|
TEST_ENTITY_B_IDENTIFIER,
|
|
TEST_ENTITY_C_IDENTIFIER,
|
|
"uses",
|
|
NULL,
|
|
NULL,
|
|
50,
|
|
"2026-07-20T21:50:00Z",
|
|
"2026-07-20T21:50:00Z",
|
|
RELATION_STATUS_ACTIVE
|
|
);
|
|
|
|
first_record =
|
|
test_relation_dao_create_relation(
|
|
"60000000-0000-4000-8000-000000000001",
|
|
TEST_ENTITY_A_IDENTIFIER,
|
|
TEST_ENTITY_B_IDENTIFIER,
|
|
"controls",
|
|
NULL,
|
|
NULL,
|
|
50,
|
|
"2026-07-20T21:50:00Z",
|
|
"2026-07-20T21:50:00Z",
|
|
RELATION_STATUS_ACTIVE
|
|
);
|
|
|
|
test_relation_dao_insert_relation(
|
|
&fixture,
|
|
third_record
|
|
);
|
|
|
|
test_relation_dao_insert_relation(
|
|
&fixture,
|
|
second_record
|
|
);
|
|
|
|
test_relation_dao_insert_relation(
|
|
&fixture,
|
|
first_record
|
|
);
|
|
|
|
relations =
|
|
relation_dao_list_all(
|
|
fixture.relation_dao,
|
|
&error
|
|
);
|
|
|
|
assert(relations != NULL);
|
|
assert(error == NULL);
|
|
assert(relations->len == 3);
|
|
|
|
first_loaded =
|
|
g_ptr_array_index(
|
|
relations,
|
|
0
|
|
);
|
|
|
|
second_loaded =
|
|
g_ptr_array_index(
|
|
relations,
|
|
1
|
|
);
|
|
|
|
third_loaded =
|
|
g_ptr_array_index(
|
|
relations,
|
|
2
|
|
);
|
|
|
|
assert(
|
|
strcmp(
|
|
relation_record_get_identifier(
|
|
first_loaded
|
|
),
|
|
"60000000-0000-4000-8000-000000000001"
|
|
) == 0
|
|
);
|
|
|
|
assert(
|
|
strcmp(
|
|
relation_record_get_identifier(
|
|
second_loaded
|
|
),
|
|
"60000000-0000-4000-8000-000000000002"
|
|
) == 0
|
|
);
|
|
|
|
assert(
|
|
strcmp(
|
|
relation_record_get_identifier(
|
|
third_loaded
|
|
),
|
|
"60000000-0000-4000-8000-000000000003"
|
|
) == 0
|
|
);
|
|
|
|
g_ptr_array_unref(
|
|
relations
|
|
);
|
|
|
|
relation_record_free(
|
|
first_record
|
|
);
|
|
|
|
relation_record_free(
|
|
second_record
|
|
);
|
|
|
|
relation_record_free(
|
|
third_record
|
|
);
|
|
|
|
test_relation_dao_fixture_clear(
|
|
&fixture
|
|
);
|
|
}
|
|
|
|
/**
|
|
* @brief Vérifie le comptage d'une table vide.
|
|
*/
|
|
static void test_relation_dao_count_empty(void)
|
|
{
|
|
TestRelationDaoFixture fixture =
|
|
test_relation_dao_fixture_create();
|
|
|
|
guint64 relation_count =
|
|
42;
|
|
|
|
GError *error =
|
|
NULL;
|
|
|
|
assert(
|
|
relation_dao_count(
|
|
fixture.relation_dao,
|
|
&relation_count,
|
|
&error
|
|
)
|
|
);
|
|
|
|
assert(error == NULL);
|
|
assert(relation_count == 0);
|
|
|
|
test_relation_dao_fixture_clear(
|
|
&fixture
|
|
);
|
|
}
|
|
|
|
/**
|
|
* @brief Vérifie le comptage de plusieurs relations.
|
|
*/
|
|
static void test_relation_dao_count_records(void)
|
|
{
|
|
TestRelationDaoFixture fixture =
|
|
test_relation_dao_fixture_create();
|
|
|
|
RelationRecord *first_record =
|
|
NULL;
|
|
|
|
RelationRecord *second_record =
|
|
NULL;
|
|
|
|
guint64 relation_count =
|
|
0;
|
|
|
|
GError *error =
|
|
NULL;
|
|
|
|
test_relation_dao_insert_standard_entities(
|
|
&fixture
|
|
);
|
|
|
|
first_record =
|
|
test_relation_dao_create_relation(
|
|
"70000000-0000-4000-8000-000000000001",
|
|
TEST_ENTITY_A_IDENTIFIER,
|
|
TEST_ENTITY_B_IDENTIFIER,
|
|
"uses",
|
|
NULL,
|
|
NULL,
|
|
50,
|
|
"2026-07-20T22:10:00Z",
|
|
"2026-07-20T22:10:00Z",
|
|
RELATION_STATUS_ACTIVE
|
|
);
|
|
|
|
second_record =
|
|
test_relation_dao_create_relation(
|
|
"70000000-0000-4000-8000-000000000002",
|
|
TEST_ENTITY_B_IDENTIFIER,
|
|
TEST_ENTITY_C_IDENTIFIER,
|
|
"controls",
|
|
NULL,
|
|
NULL,
|
|
50,
|
|
"2026-07-20T22:11:00Z",
|
|
"2026-07-20T22:11:00Z",
|
|
RELATION_STATUS_ACTIVE
|
|
);
|
|
|
|
test_relation_dao_insert_relation(
|
|
&fixture,
|
|
first_record
|
|
);
|
|
|
|
test_relation_dao_insert_relation(
|
|
&fixture,
|
|
second_record
|
|
);
|
|
|
|
assert(
|
|
relation_dao_count(
|
|
fixture.relation_dao,
|
|
&relation_count,
|
|
&error
|
|
)
|
|
);
|
|
|
|
assert(error == NULL);
|
|
assert(relation_count == 2);
|
|
|
|
relation_record_free(
|
|
second_record
|
|
);
|
|
|
|
relation_record_free(
|
|
first_record
|
|
);
|
|
|
|
test_relation_dao_fixture_clear(
|
|
&fixture
|
|
);
|
|
}
|
|
|
|
/**
|
|
* @brief Vérifie les arguments invalides des opérations publiques.
|
|
*/
|
|
static void test_relation_dao_invalid_arguments(void)
|
|
{
|
|
TestRelationDaoFixture fixture =
|
|
test_relation_dao_fixture_create();
|
|
|
|
GPtrArray *relations =
|
|
NULL;
|
|
|
|
guint64 relation_count =
|
|
123;
|
|
|
|
GError *error =
|
|
NULL;
|
|
|
|
assert(
|
|
!relation_dao_insert(
|
|
fixture.relation_dao,
|
|
NULL,
|
|
&error
|
|
)
|
|
);
|
|
|
|
test_relation_dao_assert_error(
|
|
error,
|
|
RELATION_DAO_ERROR_INVALID_ARGUMENT
|
|
);
|
|
|
|
g_clear_error(
|
|
&error
|
|
);
|
|
|
|
relations =
|
|
relation_dao_list_all(
|
|
NULL,
|
|
&error
|
|
);
|
|
|
|
assert(relations == NULL);
|
|
|
|
test_relation_dao_assert_error(
|
|
error,
|
|
RELATION_DAO_ERROR_INVALID_ARGUMENT
|
|
);
|
|
|
|
g_clear_error(
|
|
&error
|
|
);
|
|
|
|
assert(
|
|
!relation_dao_count(
|
|
fixture.relation_dao,
|
|
NULL,
|
|
&error
|
|
)
|
|
);
|
|
|
|
test_relation_dao_assert_error(
|
|
error,
|
|
RELATION_DAO_ERROR_INVALID_ARGUMENT
|
|
);
|
|
|
|
g_clear_error(
|
|
&error
|
|
);
|
|
|
|
assert(
|
|
!relation_dao_count(
|
|
NULL,
|
|
&relation_count,
|
|
&error
|
|
)
|
|
);
|
|
|
|
test_relation_dao_assert_error(
|
|
error,
|
|
RELATION_DAO_ERROR_INVALID_ARGUMENT
|
|
);
|
|
|
|
assert(relation_count == 123);
|
|
|
|
g_clear_error(
|
|
&error
|
|
);
|
|
|
|
test_relation_dao_fixture_clear(
|
|
&fixture
|
|
);
|
|
}
|
|
|
|
/**
|
|
* @brief Vérifie le signalement d'un schéma absent.
|
|
*/
|
|
static void test_relation_dao_missing_table(void)
|
|
{
|
|
Database *database =
|
|
NULL;
|
|
|
|
RelationDao *relation_dao =
|
|
NULL;
|
|
|
|
GPtrArray *relations =
|
|
NULL;
|
|
|
|
GError *error =
|
|
NULL;
|
|
|
|
database =
|
|
database_open(
|
|
":memory:"
|
|
);
|
|
|
|
assert(database != NULL);
|
|
|
|
relation_dao =
|
|
relation_dao_new(
|
|
database,
|
|
&error
|
|
);
|
|
|
|
assert(relation_dao != NULL);
|
|
assert(error == NULL);
|
|
|
|
g_test_expect_message(
|
|
NULL,
|
|
G_LOG_LEVEL_WARNING,
|
|
"*Impossible de préparer la requête SQL*"
|
|
);
|
|
|
|
relations =
|
|
relation_dao_list_all(
|
|
relation_dao,
|
|
&error
|
|
);
|
|
|
|
g_test_assert_expected_messages();
|
|
|
|
assert(relations == NULL);
|
|
|
|
test_relation_dao_assert_error(
|
|
error,
|
|
RELATION_DAO_ERROR_SCHEMA
|
|
);
|
|
|
|
g_clear_error(
|
|
&error
|
|
);
|
|
|
|
relation_dao_free(
|
|
relation_dao
|
|
);
|
|
|
|
database_close(
|
|
database
|
|
);
|
|
}
|
|
|
|
/**
|
|
* @brief Vérifie la contrainte interdisant une relation réflexive.
|
|
*
|
|
* Le modèle RelationRecord interdit déjà ce cas. Cette insertion directe
|
|
* vérifie que le schéma SQLite constitue également une seconde barrière.
|
|
*/
|
|
static void test_relation_dao_reflexive_schema_constraint(void)
|
|
{
|
|
TestRelationDaoFixture fixture =
|
|
test_relation_dao_fixture_create();
|
|
|
|
DatabaseStatement *statement =
|
|
NULL;
|
|
|
|
test_relation_dao_insert_entity(
|
|
&fixture,
|
|
TEST_ENTITY_A_IDENTIFIER,
|
|
"Personne A"
|
|
);
|
|
|
|
statement =
|
|
database_statement_prepare(
|
|
fixture.database,
|
|
"INSERT INTO relations"
|
|
"("
|
|
" id,"
|
|
" entite_source_id,"
|
|
" entite_cible_id,"
|
|
" type_relation,"
|
|
" confiance,"
|
|
" created_at,"
|
|
" updated_at,"
|
|
" status"
|
|
")"
|
|
"VALUES"
|
|
"("
|
|
" ?,"
|
|
" ?,"
|
|
" ?,"
|
|
" ?,"
|
|
" ?,"
|
|
" ?,"
|
|
" ?,"
|
|
" ?"
|
|
");"
|
|
);
|
|
|
|
assert(statement != NULL);
|
|
|
|
assert(
|
|
database_statement_bind_text(
|
|
statement,
|
|
1,
|
|
"80000000-0000-4000-8000-000000000001"
|
|
)
|
|
);
|
|
|
|
assert(
|
|
database_statement_bind_text(
|
|
statement,
|
|
2,
|
|
TEST_ENTITY_A_IDENTIFIER
|
|
)
|
|
);
|
|
|
|
assert(
|
|
database_statement_bind_text(
|
|
statement,
|
|
3,
|
|
TEST_ENTITY_A_IDENTIFIER
|
|
)
|
|
);
|
|
|
|
assert(
|
|
database_statement_bind_text(
|
|
statement,
|
|
4,
|
|
"uses"
|
|
)
|
|
);
|
|
|
|
assert(
|
|
database_statement_bind_int64(
|
|
statement,
|
|
5,
|
|
50
|
|
)
|
|
);
|
|
|
|
assert(
|
|
database_statement_bind_text(
|
|
statement,
|
|
6,
|
|
"2026-07-20T22:20:00Z"
|
|
)
|
|
);
|
|
|
|
assert(
|
|
database_statement_bind_text(
|
|
statement,
|
|
7,
|
|
"2026-07-20T22:20:00Z"
|
|
)
|
|
);
|
|
|
|
assert(
|
|
database_statement_bind_text(
|
|
statement,
|
|
8,
|
|
"active"
|
|
)
|
|
);
|
|
|
|
g_test_expect_message(
|
|
NULL,
|
|
G_LOG_LEVEL_WARNING,
|
|
"*CHECK constraint failed*"
|
|
);
|
|
|
|
assert(
|
|
database_statement_step(
|
|
statement
|
|
) == DATABASE_STATEMENT_STEP_ERROR
|
|
);
|
|
|
|
g_test_assert_expected_messages();
|
|
|
|
database_statement_finalize(
|
|
statement
|
|
);
|
|
|
|
assert(
|
|
test_relation_dao_count_rows(
|
|
fixture.database
|
|
) == 0
|
|
);
|
|
|
|
test_relation_dao_fixture_clear(
|
|
&fixture
|
|
);
|
|
}
|
|
|
|
/**
|
|
* @brief Vérifie les contraintes ON DELETE RESTRICT des deux entités.
|
|
*/
|
|
static void test_relation_dao_foreign_key_restrict(void)
|
|
{
|
|
TestRelationDaoFixture fixture =
|
|
test_relation_dao_fixture_create();
|
|
|
|
RelationRecord *relation_record =
|
|
NULL;
|
|
|
|
DatabaseStatement *statement =
|
|
NULL;
|
|
|
|
test_relation_dao_insert_standard_entities(
|
|
&fixture
|
|
);
|
|
|
|
relation_record =
|
|
test_relation_dao_create_relation(
|
|
"90000000-0000-4000-8000-000000000001",
|
|
TEST_ENTITY_A_IDENTIFIER,
|
|
TEST_ENTITY_B_IDENTIFIER,
|
|
"uses",
|
|
NULL,
|
|
NULL,
|
|
50,
|
|
"2026-07-20T22:30:00Z",
|
|
"2026-07-20T22:30:00Z",
|
|
RELATION_STATUS_ACTIVE
|
|
);
|
|
|
|
test_relation_dao_insert_relation(
|
|
&fixture,
|
|
relation_record
|
|
);
|
|
|
|
statement =
|
|
database_statement_prepare(
|
|
fixture.database,
|
|
"DELETE FROM entites "
|
|
"WHERE id = ?;"
|
|
);
|
|
|
|
assert(statement != NULL);
|
|
|
|
assert(
|
|
database_statement_bind_text(
|
|
statement,
|
|
1,
|
|
TEST_ENTITY_A_IDENTIFIER
|
|
)
|
|
);
|
|
|
|
g_test_expect_message(
|
|
NULL,
|
|
G_LOG_LEVEL_WARNING,
|
|
"*FOREIGN KEY constraint failed*"
|
|
);
|
|
|
|
assert(
|
|
database_statement_step(
|
|
statement
|
|
) == DATABASE_STATEMENT_STEP_ERROR
|
|
);
|
|
|
|
g_test_assert_expected_messages();
|
|
|
|
database_statement_finalize(
|
|
statement
|
|
);
|
|
|
|
statement =
|
|
database_statement_prepare(
|
|
fixture.database,
|
|
"DELETE FROM entites "
|
|
"WHERE id = ?;"
|
|
);
|
|
|
|
assert(statement != NULL);
|
|
|
|
assert(
|
|
database_statement_bind_text(
|
|
statement,
|
|
1,
|
|
TEST_ENTITY_B_IDENTIFIER
|
|
)
|
|
);
|
|
|
|
g_test_expect_message(
|
|
NULL,
|
|
G_LOG_LEVEL_WARNING,
|
|
"*FOREIGN KEY constraint failed*"
|
|
);
|
|
|
|
assert(
|
|
database_statement_step(
|
|
statement
|
|
) == DATABASE_STATEMENT_STEP_ERROR
|
|
);
|
|
|
|
g_test_assert_expected_messages();
|
|
|
|
database_statement_finalize(
|
|
statement
|
|
);
|
|
|
|
assert(
|
|
test_relation_dao_count_rows(
|
|
fixture.database
|
|
) == 1
|
|
);
|
|
|
|
relation_record_free(
|
|
relation_record
|
|
);
|
|
|
|
test_relation_dao_fixture_clear(
|
|
&fixture
|
|
);
|
|
}
|
|
|
|
/** @brief Vérifie la modification des attributs sans changer les extrémités. */
|
|
static void test_relation_dao_update_existing(void)
|
|
{
|
|
static const char identifier[] =
|
|
"90000000-0000-4000-8000-000000000001";
|
|
TestRelationDaoFixture fixture = test_relation_dao_fixture_create();
|
|
RelationRecord *initial = NULL;
|
|
RelationRecord *updated = NULL;
|
|
RelationRecord *stored = NULL;
|
|
GError *error = NULL;
|
|
|
|
test_relation_dao_insert_standard_entities(&fixture);
|
|
initial = test_relation_dao_create_relation(identifier,
|
|
TEST_ENTITY_A_IDENTIFIER, TEST_ENTITY_B_IDENTIFIER, "uses",
|
|
"Ancien libellé", "Ancienne justification", 40,
|
|
"2026-07-20T20:00:00Z", "2026-07-20T20:00:00Z",
|
|
RELATION_STATUS_ACTIVE);
|
|
test_relation_dao_insert_relation(&fixture, initial);
|
|
updated = test_relation_dao_create_relation(identifier,
|
|
TEST_ENTITY_A_IDENTIFIER, TEST_ENTITY_B_IDENTIFIER, "controls",
|
|
"Nouveau libellé", "Nouvelle justification", 90,
|
|
"2026-07-20T20:00:00Z", "2026-07-22T16:00:00Z",
|
|
RELATION_STATUS_ACTIVE);
|
|
assert(relation_dao_update(fixture.relation_dao, updated, &error));
|
|
assert(error == NULL);
|
|
stored = relation_dao_find_by_identifier(fixture.relation_dao,
|
|
identifier, &error);
|
|
assert(stored != NULL && error == NULL);
|
|
assert(strcmp(relation_record_get_relation_type(stored), "controls") == 0);
|
|
assert(strcmp(relation_record_get_label(stored), "Nouveau libellé") == 0);
|
|
assert(relation_record_get_confidence(stored) == 90);
|
|
assert(strcmp(relation_record_get_source_entity_identifier(stored),
|
|
TEST_ENTITY_A_IDENTIFIER) == 0);
|
|
assert(strcmp(relation_record_get_created_at(stored),
|
|
"2026-07-20T20:00:00Z") == 0);
|
|
relation_record_free(stored);
|
|
relation_record_free(updated);
|
|
relation_record_free(initial);
|
|
test_relation_dao_fixture_clear(&fixture);
|
|
}
|
|
|
|
int main(
|
|
int argc,
|
|
char **argv
|
|
)
|
|
{
|
|
g_test_init(
|
|
&argc,
|
|
&argv,
|
|
NULL
|
|
);
|
|
|
|
test_relation_dao_new_null_database();
|
|
test_relation_dao_lifecycle();
|
|
test_relation_dao_insert_valid_full();
|
|
test_relation_dao_insert_optional_null();
|
|
test_relation_dao_insert_duplicate_identifier();
|
|
test_relation_dao_insert_missing_source();
|
|
test_relation_dao_insert_missing_target();
|
|
test_relation_dao_insert_duplicate_triple();
|
|
test_relation_dao_orientation_and_multiple_types();
|
|
test_relation_dao_find_existing();
|
|
test_relation_dao_find_missing();
|
|
test_relation_dao_find_invalid_identifier();
|
|
test_relation_dao_list_empty();
|
|
test_relation_dao_list_order();
|
|
test_relation_dao_count_empty();
|
|
test_relation_dao_count_records();
|
|
test_relation_dao_invalid_arguments();
|
|
test_relation_dao_missing_table();
|
|
test_relation_dao_reflexive_schema_constraint();
|
|
test_relation_dao_foreign_key_restrict();
|
|
test_relation_dao_update_existing();
|
|
|
|
printf(
|
|
"RelationDao : tous les tests sont valides.\n"
|
|
);
|
|
|
|
return 0;
|
|
}
|