mirror of
https://github.com/Gnucash/gnucash.git
synced 2025-02-25 18:55:30 -06:00
[GSOC][Testing] Unit tests for qofsession
Author: Muslim Chochlov git-svn-id: svn+ssh://svn.gnucash.org/repo/gnucash/trunk@21830 57a11ea4-9604-0410-9ed3-97b8803252fd
This commit is contained in:
John Ralls
parent
5ed0fbb480
commit
614052092e
@ -22,13 +22,26 @@
|
||||
|
||||
#include "config.h"
|
||||
#include <glib.h>
|
||||
#include "test-stuff.h"
|
||||
#include "qof.h"
|
||||
#include "qofbackend-p.h"
|
||||
#include "qofsession-p.h"
|
||||
#include "qofclass-p.h"
|
||||
|
||||
static const gchar *suitename = "/qof/qofsession";
|
||||
void test_suite_qofsession ( void );
|
||||
|
||||
extern GHookList* get_session_closed_hooks (void);
|
||||
extern GSList* get_provider_list (void);
|
||||
extern gboolean get_qof_providers_initialized (void);
|
||||
extern void unregister_all_providers (void);
|
||||
|
||||
extern void (*p_qof_session_load_backend) (QofSession * session, const char * access_method);
|
||||
extern void (*p_qof_session_clear_error) (QofSession * session);
|
||||
extern void (*p_qof_session_destroy_backend) (QofSession * session);
|
||||
|
||||
extern void init_static_qofsession_pointers (void);
|
||||
|
||||
typedef struct
|
||||
{
|
||||
QofSession *session;
|
||||
@ -51,27 +64,937 @@ static void
|
||||
setup( Fixture *fixture, gconstpointer pData )
|
||||
{
|
||||
fixture->session = qof_session_new();
|
||||
fixture->session->backend = g_new0( QofBackend, 1 );
|
||||
fixture->session->backend->safe_sync = safe_sync;
|
||||
init_static_qofsession_pointers ();
|
||||
g_assert (p_qof_session_clear_error && p_qof_session_destroy_backend && p_qof_session_load_backend);
|
||||
}
|
||||
|
||||
static void
|
||||
teardown( Fixture *fixture, gconstpointer pData )
|
||||
{
|
||||
qof_session_destroy( fixture->session );
|
||||
p_qof_session_clear_error = NULL;
|
||||
p_qof_session_destroy_backend = NULL;
|
||||
p_qof_session_load_backend = NULL;
|
||||
}
|
||||
|
||||
static void
|
||||
test_qof_session_new_destroy (void)
|
||||
{
|
||||
QofSession *session = NULL;
|
||||
QofBook *book = NULL;
|
||||
|
||||
g_test_message ("Test session initialization");
|
||||
session = qof_session_new ();
|
||||
g_assert (session);
|
||||
g_assert_cmpstr (session->entity.e_type, ==, QOF_ID_SESSION);
|
||||
g_assert (session->book);
|
||||
book = (QofBook*) session->book;
|
||||
g_assert (book);
|
||||
g_assert (QOF_IS_BOOK (book));
|
||||
g_assert (!session->book_id);
|
||||
g_assert (!session->backend);
|
||||
g_assert_cmpint (session->lock, ==, 1);
|
||||
g_assert_cmpint (qof_session_get_error (session), ==, ERR_BACKEND_NO_ERR);
|
||||
|
||||
g_test_message ("Test session destroy");
|
||||
qof_session_destroy (session);
|
||||
/* all data structures of session get deallocated so we can't really test this place
|
||||
* instead qof_session_destroy_backend and qof_session_end are tested
|
||||
*/
|
||||
}
|
||||
|
||||
static void
|
||||
test_session_safe_save( Fixture *fixture, gconstpointer pData )
|
||||
{
|
||||
fixture->session->backend = g_new0 (QofBackend, 1);
|
||||
fixture->session->backend->safe_sync = safe_sync;
|
||||
qof_session_safe_save( fixture->session, percentage_fn );
|
||||
g_assert_cmpint( ERR_BACKEND_DATA_CORRUPT, == ,
|
||||
qof_session_get_error( fixture->session ));
|
||||
g_assert( NULL == qof_session_get_url( fixture->session ));
|
||||
}
|
||||
|
||||
static struct
|
||||
{
|
||||
QofBackend *be;
|
||||
gboolean data_compatible;
|
||||
gboolean check_data_type_called;
|
||||
gboolean backend_new_called;
|
||||
} load_backend_struct;
|
||||
|
||||
static gboolean
|
||||
mock_check_data_type (const char* book_id)
|
||||
{
|
||||
g_assert (book_id);
|
||||
g_assert_cmpstr (book_id, ==, "my book");
|
||||
load_backend_struct.check_data_type_called = TRUE;
|
||||
return load_backend_struct.data_compatible;
|
||||
}
|
||||
|
||||
static QofBackend*
|
||||
mock_backend_new (void)
|
||||
{
|
||||
QofBackend *be = NULL;
|
||||
|
||||
be = g_new0 (QofBackend, 1);
|
||||
g_assert (be);
|
||||
load_backend_struct.be = be;
|
||||
load_backend_struct.backend_new_called = TRUE;
|
||||
return be;
|
||||
}
|
||||
|
||||
static void
|
||||
test_qof_session_load_backend (Fixture *fixture, gconstpointer pData)
|
||||
{
|
||||
QofBackendProvider *prov = NULL;
|
||||
QofBook *book = NULL;
|
||||
|
||||
/* init */
|
||||
prov = g_new0 (QofBackendProvider, 1);
|
||||
|
||||
g_test_message ("Test when no provider is registered");
|
||||
g_assert (!get_qof_providers_initialized ());
|
||||
g_assert (get_provider_list () == NULL);
|
||||
p_qof_session_load_backend (fixture->session, "file");
|
||||
g_assert (get_qof_providers_initialized ());
|
||||
g_assert_cmpint (qof_session_get_error (fixture->session), ==, ERR_BACKEND_NO_HANDLER);
|
||||
g_assert_cmpstr (qof_session_get_error_message (fixture->session), ==, "failed to load 'file' using access_method");
|
||||
p_qof_session_clear_error (fixture->session);
|
||||
|
||||
g_test_message ("Test with provider registered but access method not supported");
|
||||
prov->access_method = "unsupported";
|
||||
qof_backend_register_provider (prov);
|
||||
g_assert (get_provider_list ());
|
||||
g_assert_cmpint (g_slist_length (get_provider_list ()), ==, 1);
|
||||
p_qof_session_load_backend (fixture->session, "file");
|
||||
g_assert_cmpint (qof_session_get_error (fixture->session), ==, ERR_BACKEND_NO_HANDLER);
|
||||
g_assert_cmpstr (qof_session_get_error_message (fixture->session), ==, "failed to load 'file' using access_method");
|
||||
p_qof_session_clear_error (fixture->session);
|
||||
|
||||
g_test_message ("Test with access method supported but type incompatible");
|
||||
prov->access_method = "file";
|
||||
prov->check_data_type = mock_check_data_type;
|
||||
load_backend_struct.data_compatible = FALSE;
|
||||
load_backend_struct.check_data_type_called = FALSE;
|
||||
fixture->session->book_id = g_strdup ("my book");
|
||||
p_qof_session_load_backend (fixture->session, "file");
|
||||
g_assert (load_backend_struct.check_data_type_called);
|
||||
g_assert_cmpint (qof_session_get_error (fixture->session), ==, ERR_BACKEND_NO_HANDLER);
|
||||
g_assert_cmpstr (qof_session_get_error_message (fixture->session), ==, "failed to load 'file' using access_method");
|
||||
p_qof_session_clear_error (fixture->session);
|
||||
|
||||
g_test_message ("Test with type compatible but backend_new not set");
|
||||
prov->backend_new = NULL;
|
||||
load_backend_struct.data_compatible = TRUE;
|
||||
load_backend_struct.check_data_type_called = FALSE;
|
||||
p_qof_session_load_backend (fixture->session, "file");
|
||||
g_assert (load_backend_struct.check_data_type_called);
|
||||
g_assert_cmpint (qof_session_get_error (fixture->session), ==, ERR_BACKEND_NO_HANDLER);
|
||||
g_assert_cmpstr (qof_session_get_error_message (fixture->session), ==, "failed to load 'file' using access_method");
|
||||
p_qof_session_clear_error (fixture->session);
|
||||
|
||||
g_test_message ("Test with type compatible backend_new set");
|
||||
prov->backend_new = mock_backend_new;
|
||||
load_backend_struct.be = NULL;
|
||||
load_backend_struct.data_compatible = TRUE;
|
||||
load_backend_struct.check_data_type_called = FALSE;
|
||||
load_backend_struct.backend_new_called = FALSE;
|
||||
g_assert (fixture->session->backend == NULL);
|
||||
book = qof_session_get_book (fixture->session);
|
||||
g_assert (book);
|
||||
g_assert (qof_book_get_backend (book) == NULL);
|
||||
p_qof_session_load_backend (fixture->session, "file");
|
||||
g_assert (load_backend_struct.check_data_type_called);
|
||||
g_assert (load_backend_struct.backend_new_called);
|
||||
g_assert (load_backend_struct.be);
|
||||
g_assert (load_backend_struct.be == fixture->session->backend);
|
||||
g_assert (prov == fixture->session->backend->provider);
|
||||
g_assert (qof_book_get_backend (book) == load_backend_struct.be);
|
||||
g_assert_cmpint (qof_session_get_error (fixture->session), ==, ERR_BACKEND_NO_ERR);
|
||||
|
||||
unregister_all_providers ();
|
||||
g_assert_cmpint (g_slist_length (get_provider_list ()), ==, 0);
|
||||
}
|
||||
|
||||
static struct
|
||||
{
|
||||
QofBackend *be;
|
||||
QofBook *oldbook;
|
||||
gboolean error;
|
||||
gboolean load_called;
|
||||
} load_session_struct;
|
||||
|
||||
static void
|
||||
mock_load (QofBackend *be, QofBook *book, QofBackendLoadType type)
|
||||
{
|
||||
g_assert (be);
|
||||
g_assert (book);
|
||||
g_assert (be == load_session_struct.be);
|
||||
g_assert (book != load_session_struct.oldbook);
|
||||
g_assert (qof_book_get_backend (book) == be);
|
||||
if (load_session_struct.error)
|
||||
qof_backend_set_error (be, ERR_BACKEND_DATA_CORRUPT); /* just any valid error */
|
||||
load_session_struct.load_called = TRUE;
|
||||
}
|
||||
|
||||
static void
|
||||
test_qof_session_load (Fixture *fixture, gconstpointer pData)
|
||||
{
|
||||
/* Method initializes a new book and loads data into it
|
||||
* if load fails old books are restored
|
||||
*/
|
||||
QofBackend *be = NULL;
|
||||
QofBook *newbook = NULL;
|
||||
|
||||
/* init */
|
||||
fixture->session->book_id = g_strdup ("my book");
|
||||
be = g_new0 (QofBackend, 1);
|
||||
g_assert (be);
|
||||
fixture->session->backend = be;
|
||||
be->load = mock_load;
|
||||
|
||||
g_test_message ("Test when no error is produced");
|
||||
g_assert (be->percentage == NULL);
|
||||
load_session_struct.be = be;
|
||||
load_session_struct.oldbook = qof_session_get_book (fixture->session);
|
||||
g_assert (fixture->session->book);
|
||||
load_session_struct.error = FALSE;
|
||||
load_session_struct.load_called = FALSE;
|
||||
qof_session_load (fixture->session, percentage_fn);
|
||||
newbook = qof_session_get_book (fixture->session);
|
||||
g_assert (newbook);
|
||||
g_assert (load_session_struct.oldbook != newbook);
|
||||
g_assert (fixture->session->book);
|
||||
g_assert (load_session_struct.load_called);
|
||||
|
||||
g_test_message ("Test when no is produced");
|
||||
load_session_struct.oldbook = qof_session_get_book (fixture->session);
|
||||
g_assert (fixture->session->book);
|
||||
load_session_struct.error = TRUE;
|
||||
load_session_struct.load_called = FALSE;
|
||||
qof_session_load (fixture->session, percentage_fn);
|
||||
newbook = qof_session_get_book (fixture->session);
|
||||
g_assert (newbook);
|
||||
g_assert (load_session_struct.oldbook == newbook);
|
||||
g_assert (fixture->session->book);
|
||||
g_assert (load_session_struct.load_called);
|
||||
}
|
||||
|
||||
static struct
|
||||
{
|
||||
QofBackend *be;
|
||||
QofSession *session;
|
||||
const char *book_id;
|
||||
gboolean backend_new_called;
|
||||
gboolean session_begin_called;
|
||||
gboolean produce_error;
|
||||
} session_begin_struct;
|
||||
|
||||
static void
|
||||
mock_session_begin (QofBackend *be, QofSession *session, const char *book_id,
|
||||
gboolean ignore_lock, gboolean create, gboolean force)
|
||||
{
|
||||
g_assert (be);
|
||||
g_assert (be == session_begin_struct.be);
|
||||
g_assert (session);
|
||||
g_assert (session == session_begin_struct.session);
|
||||
g_assert (book_id);
|
||||
g_assert_cmpstr (book_id, ==, session_begin_struct.book_id);
|
||||
g_assert (ignore_lock);
|
||||
g_assert (!create);
|
||||
g_assert (force);
|
||||
if (session_begin_struct.produce_error)
|
||||
{
|
||||
qof_backend_set_error (be, ERR_BACKEND_DATA_CORRUPT);
|
||||
qof_backend_set_message (be, "push any error");
|
||||
}
|
||||
session_begin_struct.session_begin_called = TRUE;
|
||||
}
|
||||
|
||||
static QofBackend*
|
||||
mock_backend_new_for_begin (void)
|
||||
{
|
||||
QofBackend *be = NULL;
|
||||
|
||||
be = g_new0 (QofBackend, 1);
|
||||
g_assert (be);
|
||||
be->session_begin = mock_session_begin;
|
||||
session_begin_struct.be = be;
|
||||
session_begin_struct.backend_new_called = TRUE;
|
||||
return be;
|
||||
}
|
||||
|
||||
static void
|
||||
test_qof_session_begin (Fixture *fixture, gconstpointer pData)
|
||||
{
|
||||
gboolean ignore_lock, create, force;
|
||||
QofBackend *be = NULL;
|
||||
QofBackendProvider *prov = NULL;
|
||||
|
||||
/* setup */
|
||||
ignore_lock = TRUE;
|
||||
create = FALSE;
|
||||
force = TRUE;
|
||||
|
||||
be = g_new0 (QofBackend, 1);
|
||||
g_assert (be);
|
||||
g_assert_cmpint (g_slist_length (get_provider_list ()), ==, 0);
|
||||
prov = g_new0 (QofBackendProvider, 1);
|
||||
prov->backend_new = mock_backend_new_for_begin;
|
||||
|
||||
/* run tests */
|
||||
g_test_message ("Test when book_id is set backend is not changed");
|
||||
fixture->session->backend = be;
|
||||
fixture->session->book_id = g_strdup ("my book");
|
||||
qof_session_begin (fixture->session, "my book", ignore_lock, create, force);
|
||||
g_assert (fixture->session->backend == be);
|
||||
|
||||
g_test_message ("Test when session book_id is not set and book_id passed is null backend is not changed");
|
||||
g_free (fixture->session->book_id);
|
||||
fixture->session->book_id = NULL;
|
||||
qof_session_begin (fixture->session, NULL, ignore_lock, create, force);
|
||||
g_assert (fixture->session->backend == be);
|
||||
|
||||
g_test_message ("Test default access_method parsing");
|
||||
/* routine will destroy old backend
|
||||
* parse access_method as 'file' and try to find backend
|
||||
* as there is no backend registered error will be raised
|
||||
*/
|
||||
qof_session_begin (fixture->session, "default_should_be_file", ignore_lock, create, force);
|
||||
g_assert (fixture->session->backend == NULL);
|
||||
g_assert (fixture->session->book_id == NULL);
|
||||
g_assert_cmpint (qof_session_get_error (fixture->session), ==, ERR_BACKEND_NO_HANDLER);
|
||||
g_assert_cmpstr (qof_session_get_error_message (fixture->session), ==, "failed to load 'file' using access_method");
|
||||
|
||||
g_test_message ("Test access_method parsing");
|
||||
qof_session_begin (fixture->session, "postgres://localhost:8080", ignore_lock, create, force);
|
||||
g_assert (fixture->session->backend == NULL);
|
||||
g_assert (fixture->session->book_id == NULL);
|
||||
g_assert_cmpint (qof_session_get_error (fixture->session), ==, ERR_BACKEND_NO_HANDLER);
|
||||
g_assert_cmpstr (qof_session_get_error_message (fixture->session), ==, "failed to load 'postgres' using access_method");
|
||||
|
||||
g_test_message ("Test with valid backend returned and session begin set; error is produced");
|
||||
session_begin_struct.session = fixture->session;
|
||||
session_begin_struct.book_id = "postgres://localhost:8080";
|
||||
session_begin_struct.backend_new_called = FALSE;
|
||||
session_begin_struct.session_begin_called = FALSE;
|
||||
session_begin_struct.produce_error = TRUE;
|
||||
prov->access_method = "postgres";
|
||||
qof_backend_register_provider (prov);
|
||||
qof_session_begin (fixture->session, "postgres://localhost:8080", ignore_lock, create, force);
|
||||
g_assert (fixture->session->backend);
|
||||
g_assert (session_begin_struct.be == fixture->session->backend);
|
||||
g_assert (session_begin_struct.backend_new_called == TRUE);
|
||||
g_assert (session_begin_struct.session_begin_called == TRUE);
|
||||
g_assert (fixture->session->book_id == NULL);
|
||||
g_assert_cmpint (qof_session_get_error (fixture->session), ==, ERR_BACKEND_DATA_CORRUPT);
|
||||
g_assert_cmpstr (qof_session_get_error_message (fixture->session), ==, "push any error");
|
||||
|
||||
g_test_message ("Test normal session_begin execution");
|
||||
session_begin_struct.backend_new_called = FALSE;
|
||||
session_begin_struct.session_begin_called = FALSE;
|
||||
session_begin_struct.produce_error = FALSE;
|
||||
qof_session_begin (fixture->session, "postgres://localhost:8080", ignore_lock, create, force);
|
||||
g_assert (fixture->session->backend);
|
||||
g_assert (session_begin_struct.be == fixture->session->backend);
|
||||
g_assert (session_begin_struct.backend_new_called == TRUE);
|
||||
g_assert (session_begin_struct.session_begin_called == TRUE);
|
||||
g_assert (fixture->session->book_id);
|
||||
g_assert_cmpstr (fixture->session->book_id, ==, "postgres://localhost:8080");
|
||||
g_assert_cmpint (qof_session_get_error (fixture->session), ==, ERR_BACKEND_NO_ERR);
|
||||
|
||||
unregister_all_providers ();
|
||||
}
|
||||
|
||||
static struct
|
||||
{
|
||||
QofBackend *be;
|
||||
QofBook *book;
|
||||
QofSession *session;
|
||||
const char *book_id;
|
||||
gboolean sync_called;
|
||||
gboolean backend_new_called;
|
||||
gboolean session_begin_called;
|
||||
} session_save_struct;
|
||||
|
||||
static void
|
||||
mock_sync (QofBackend *be, QofBook *book)
|
||||
{
|
||||
g_assert (be);
|
||||
g_assert (book);
|
||||
g_assert (be == session_save_struct.be);
|
||||
g_assert (book == session_save_struct.book);
|
||||
session_save_struct.sync_called = TRUE;
|
||||
}
|
||||
|
||||
static void
|
||||
mock_session_begin_for_save (QofBackend *be, QofSession *session, const char *book_id,
|
||||
gboolean ignore_lock, gboolean create, gboolean force)
|
||||
{
|
||||
g_assert (be);
|
||||
g_assert (be == session_save_struct.be);
|
||||
g_assert (session);
|
||||
g_assert (session == session_save_struct.session);
|
||||
g_assert (book_id);
|
||||
g_assert_cmpstr (book_id, ==, session_save_struct.book_id);
|
||||
g_assert (ignore_lock);
|
||||
g_assert (create);
|
||||
g_assert (force);
|
||||
session_save_struct.session_begin_called = TRUE;
|
||||
}
|
||||
|
||||
static QofBackend*
|
||||
mock_backend_new_for_save (void)
|
||||
{
|
||||
QofBackend *be = NULL;
|
||||
|
||||
be = g_new0 (QofBackend, 1);
|
||||
g_assert (be);
|
||||
be->session_begin = mock_session_begin_for_save;
|
||||
be->sync = mock_sync;
|
||||
session_save_struct.be = be;
|
||||
session_save_struct.backend_new_called = TRUE;
|
||||
return be;
|
||||
}
|
||||
|
||||
static void
|
||||
test_qof_session_save (Fixture *fixture, gconstpointer pData)
|
||||
{
|
||||
QofBook *book = NULL;
|
||||
QofBackend *be = NULL;
|
||||
QofBackendProvider *prov = NULL, *reg_prov = NULL;
|
||||
|
||||
g_test_message ("Test when book not partial and backend not set");
|
||||
g_assert (fixture->session->backend == NULL);
|
||||
book = qof_session_get_book (fixture->session);
|
||||
g_assert (book);
|
||||
qof_book_set_data (book, PARTIAL_QOFBOOK, GINT_TO_POINTER (FALSE));
|
||||
qof_session_push_error (fixture->session, ERR_BACKEND_DATA_CORRUPT, "push any error");
|
||||
g_assert_cmpint (fixture->session->lock, ==, 1);
|
||||
qof_session_save (fixture->session, NULL);
|
||||
g_assert_cmpint (qof_session_get_error (fixture->session), ==, ERR_BACKEND_NO_HANDLER);
|
||||
g_assert_cmpstr (qof_session_get_error_message (fixture->session), ==, "failed to load backend");
|
||||
g_assert_cmpint (fixture->session->lock, ==, 1);
|
||||
|
||||
g_test_message ("Test when book not partial and backend set; imitate error");
|
||||
be = g_new0 (QofBackend, 1);
|
||||
g_assert (be);
|
||||
be->sync = mock_sync;
|
||||
fixture->session->backend = be;
|
||||
g_assert_cmpint (fixture->session->lock, ==, 1);
|
||||
session_save_struct.sync_called = FALSE;
|
||||
session_save_struct.be = be;
|
||||
session_save_struct.book = book;
|
||||
qof_backend_set_error (be, ERR_BACKEND_DATA_CORRUPT);
|
||||
qof_backend_set_message (be, "push any error");
|
||||
qof_session_save (fixture->session, percentage_fn);
|
||||
g_assert (qof_book_get_backend (book) == be);
|
||||
g_assert (be->percentage == percentage_fn);
|
||||
g_assert (session_save_struct.sync_called);
|
||||
g_assert_cmpint (fixture->session->lock, ==, 1);
|
||||
g_assert_cmpint (qof_session_get_error (fixture->session), ==, ERR_BACKEND_DATA_CORRUPT);
|
||||
g_assert_cmpstr (qof_session_get_error_message (fixture->session), ==, "");
|
||||
|
||||
g_test_message ("Test when book not partial and backend set; successful save");
|
||||
g_assert_cmpint (fixture->session->lock, ==, 1);
|
||||
session_save_struct.sync_called = FALSE;
|
||||
qof_session_save (fixture->session, percentage_fn);
|
||||
g_assert (qof_book_get_backend (book) == be);
|
||||
g_assert (be->percentage == percentage_fn);
|
||||
g_assert (session_save_struct.sync_called);
|
||||
g_assert_cmpint (fixture->session->lock, ==, 1);
|
||||
g_assert_cmpint (qof_session_get_error (fixture->session), ==, ERR_BACKEND_NO_ERR);
|
||||
|
||||
/* change backend testing
|
||||
* code probably should be moved to separate routine or some existing code can be reused
|
||||
* for example: qof_session_load_backend
|
||||
*/
|
||||
g_test_message ("Test when book is partial and current backend supports it; successful save backend not changed");
|
||||
prov = g_new0 (QofBackendProvider, 1);
|
||||
prov->partial_book_supported = TRUE;
|
||||
fixture->session->backend->provider = prov;
|
||||
g_assert_cmpint (fixture->session->lock, ==, 1);
|
||||
qof_book_set_data (book, PARTIAL_QOFBOOK, GINT_TO_POINTER (TRUE));
|
||||
session_save_struct.sync_called = FALSE;
|
||||
qof_session_save (fixture->session, percentage_fn);
|
||||
g_assert (fixture->session->backend == be);
|
||||
g_assert (fixture->session->backend->provider == prov);
|
||||
g_assert (qof_book_get_backend (book) == be);
|
||||
g_assert (be->percentage == percentage_fn);
|
||||
g_assert (session_save_struct.sync_called);
|
||||
g_assert_cmpint (fixture->session->lock, ==, 1);
|
||||
g_assert_cmpint (qof_session_get_error (fixture->session), ==, ERR_BACKEND_NO_ERR);
|
||||
|
||||
g_test_message ("Test when book is partial and current backend does not support it; backend should be changed");
|
||||
prov->partial_book_supported = FALSE;
|
||||
g_assert_cmpint (fixture->session->lock, ==, 1);
|
||||
reg_prov = g_new0 (QofBackendProvider, 1);
|
||||
reg_prov->partial_book_supported = TRUE;
|
||||
reg_prov->backend_new = mock_backend_new_for_save;
|
||||
qof_backend_register_provider (reg_prov);
|
||||
g_assert_cmpint (g_slist_length (get_provider_list ()), ==, 1);
|
||||
session_save_struct.book = book;
|
||||
session_save_struct.session = fixture->session;
|
||||
fixture->session->book_id = g_strdup ("my book");
|
||||
session_save_struct.book_id = "my book";
|
||||
session_save_struct.sync_called = FALSE;
|
||||
session_save_struct.backend_new_called = FALSE;
|
||||
session_save_struct.session_begin_called = FALSE;
|
||||
|
||||
qof_session_save (fixture->session, percentage_fn);
|
||||
|
||||
g_assert (session_save_struct.backend_new_called);
|
||||
g_assert (fixture->session->backend == session_save_struct.be);
|
||||
g_assert (fixture->session->backend->provider == reg_prov);
|
||||
g_assert (fixture->session->book_id == NULL);
|
||||
g_assert (session_save_struct.session_begin_called);
|
||||
g_assert (qof_book_get_backend (book) == session_save_struct.be);
|
||||
g_assert (session_save_struct.sync_called);
|
||||
g_assert_cmpint (fixture->session->lock, ==, 1);
|
||||
g_assert_cmpint (qof_session_get_error (fixture->session), ==, ERR_BACKEND_NO_ERR);
|
||||
|
||||
unregister_all_providers ();
|
||||
g_free (prov);
|
||||
}
|
||||
|
||||
static struct
|
||||
{
|
||||
QofBackend *be;
|
||||
gboolean called;
|
||||
} destroy_backend_struct;
|
||||
|
||||
static void
|
||||
mock_destroy_backend (QofBackend *be)
|
||||
{
|
||||
g_assert (be);
|
||||
g_assert (destroy_backend_struct.be == be);
|
||||
destroy_backend_struct.called = TRUE;
|
||||
}
|
||||
|
||||
static void
|
||||
test_qof_session_destroy_backend (Fixture *fixture, gconstpointer pData)
|
||||
{
|
||||
QofBackend *be = NULL;
|
||||
|
||||
g_test_message ("Test with destroy backend callback not set");
|
||||
be = g_new0 (QofBackend, 1);
|
||||
g_assert (be);
|
||||
fixture->session->backend = be;
|
||||
p_qof_session_destroy_backend (fixture->session);
|
||||
g_assert (!fixture->session->backend);
|
||||
|
||||
g_test_message ("Test with destroy backend callback set");
|
||||
be = g_new0 (QofBackend, 1);
|
||||
g_assert (be);
|
||||
be->destroy_backend = mock_destroy_backend;
|
||||
fixture->session->backend = be;
|
||||
destroy_backend_struct.called = FALSE;
|
||||
destroy_backend_struct.be = be;
|
||||
p_qof_session_destroy_backend (fixture->session);
|
||||
g_assert (!fixture->session->backend);
|
||||
g_assert (destroy_backend_struct.called);
|
||||
}
|
||||
|
||||
static struct
|
||||
{
|
||||
QofBackend *be;
|
||||
gboolean called;
|
||||
} session_end_struct;
|
||||
|
||||
static void
|
||||
mock_session_end (QofBackend *be)
|
||||
{
|
||||
g_assert (be);
|
||||
g_assert (session_end_struct.be == be);
|
||||
session_end_struct.called = TRUE;
|
||||
}
|
||||
|
||||
static void
|
||||
test_qof_session_end (Fixture *fixture, gconstpointer pData)
|
||||
{
|
||||
QofBackend *be = NULL;
|
||||
|
||||
g_test_message ("Test backend is closed, errors cleared and book_id removed");
|
||||
be = g_new0 (QofBackend, 1);
|
||||
g_assert (be);
|
||||
be->session_end = mock_session_end;
|
||||
fixture->session->backend = be;
|
||||
qof_session_push_error (fixture->session, ERR_BACKEND_DATA_CORRUPT, "push any error");
|
||||
fixture->session->book_id = g_strdup ("my book");
|
||||
session_end_struct.called = FALSE;
|
||||
session_end_struct.be = be;
|
||||
qof_session_end (fixture->session);
|
||||
g_assert (session_end_struct.called);
|
||||
g_assert_cmpint (qof_session_get_error (fixture->session), ==, ERR_BACKEND_NO_ERR);
|
||||
g_assert (!fixture->session->book_id);
|
||||
}
|
||||
|
||||
static struct
|
||||
{
|
||||
QofBackend *be;
|
||||
QofBook *book;
|
||||
gboolean called;
|
||||
} session_export_struct;
|
||||
|
||||
static void
|
||||
mock_export (QofBackend *be, QofBook *book)
|
||||
{
|
||||
g_assert (be);
|
||||
g_assert (session_export_struct.be == be);
|
||||
g_assert (book);
|
||||
g_assert (session_export_struct.book == book);
|
||||
session_export_struct.called = TRUE;
|
||||
}
|
||||
|
||||
static void
|
||||
test_qof_session_export (Fixture *fixture, gconstpointer pData)
|
||||
{
|
||||
QofSession *real_session = NULL;
|
||||
QofBook *tmp_book = NULL, *real_book = NULL;
|
||||
QofBackend *be = NULL;
|
||||
|
||||
real_session = qof_session_new ();
|
||||
g_assert (real_session);
|
||||
|
||||
g_test_message ("Test null checks");
|
||||
g_assert (!qof_session_export (NULL, real_session, percentage_fn));
|
||||
g_assert (!qof_session_export (fixture->session, NULL, percentage_fn));
|
||||
|
||||
g_test_message ("Test with backend not set");
|
||||
tmp_book = qof_session_get_book (fixture->session);
|
||||
g_assert (tmp_book);
|
||||
be = qof_book_get_backend (tmp_book);
|
||||
g_assert (!be);
|
||||
g_assert (!qof_session_export (fixture->session, real_session, percentage_fn));
|
||||
|
||||
g_test_message ("Test with backend set");
|
||||
be = g_new0 (QofBackend, 1);
|
||||
g_assert (be);
|
||||
fixture->session->backend = be;
|
||||
qof_book_set_backend (tmp_book, be);
|
||||
g_assert (!be->percentage);
|
||||
g_assert (qof_session_export (fixture->session, real_session, percentage_fn));
|
||||
g_assert (be->percentage == percentage_fn);
|
||||
|
||||
g_test_message ("Test with backend export function set and error is produced");
|
||||
be->export_fn = mock_export;
|
||||
qof_backend_set_error (be, ERR_BACKEND_DATA_CORRUPT);
|
||||
qof_backend_set_message (be, "push any error");
|
||||
session_export_struct.called = FALSE;
|
||||
real_book = qof_session_get_book (real_session);
|
||||
g_assert (real_book);
|
||||
session_export_struct.be = be;
|
||||
session_export_struct.book = real_book;
|
||||
g_assert (!qof_session_export (fixture->session, real_session, percentage_fn));
|
||||
g_assert (session_export_struct.called);
|
||||
|
||||
g_test_message ("Test with backend export function set and no error produced");
|
||||
p_qof_session_clear_error (fixture->session);
|
||||
session_export_struct.called = FALSE;
|
||||
g_assert (qof_session_export (fixture->session, real_session, percentage_fn));
|
||||
g_assert (session_export_struct.called);
|
||||
|
||||
qof_session_destroy (real_session);
|
||||
}
|
||||
|
||||
static void
|
||||
test_qof_session_swap_data (Fixture *fixture, gconstpointer pData)
|
||||
{
|
||||
QofSession *session2 = NULL;
|
||||
QofBackend *be1 = NULL, *be2 = NULL;
|
||||
QofBook *book1 = NULL, *book2 = NULL;
|
||||
GList *node;
|
||||
|
||||
/* init */
|
||||
g_assert (fixture->session);
|
||||
session2 = qof_session_new ();
|
||||
g_assert (session2);
|
||||
g_assert (fixture->session != session2);
|
||||
be1 = g_new0 (QofBackend, 1);
|
||||
g_assert (be1);
|
||||
be2 = g_new0 (QofBackend, 1);
|
||||
g_assert (be2);
|
||||
fixture->session->backend = be1;
|
||||
session2->backend = be2;
|
||||
book1 = fixture->session->book;
|
||||
book2 = session2->book;
|
||||
g_assert (book1);
|
||||
g_assert (book2);
|
||||
qof_book_set_backend (book1, fixture->session->backend);
|
||||
qof_book_set_backend (book2, session2->backend);
|
||||
|
||||
|
||||
g_test_message ("Test book lists are swapped and backend for each book is swapped");
|
||||
qof_session_swap_data (fixture->session, session2);
|
||||
g_assert (fixture->session->book == book2);
|
||||
g_assert (session2->book == book1);
|
||||
|
||||
qof_session_destroy (session2);
|
||||
}
|
||||
|
||||
static struct
|
||||
{
|
||||
QofBackend *be;
|
||||
gboolean called;
|
||||
} events_struct;
|
||||
|
||||
static gboolean
|
||||
mock_events_fn (QofBackend *be)
|
||||
{
|
||||
g_assert (be);
|
||||
g_assert (be == events_struct.be);
|
||||
events_struct.called = TRUE;
|
||||
return TRUE;
|
||||
}
|
||||
|
||||
static void
|
||||
test_qof_session_events (Fixture *fixture, gconstpointer pData)
|
||||
{
|
||||
QofBackend *be = NULL;
|
||||
|
||||
g_test_message ("Test pending events null checks");
|
||||
g_assert (!qof_session_events_pending (NULL));
|
||||
g_assert (!fixture->session->backend);
|
||||
g_assert (!qof_session_events_pending (fixture->session));
|
||||
be = g_new0 (QofBackend, 1);
|
||||
g_assert (be);
|
||||
be->events_pending = NULL;
|
||||
fixture->session->backend = be;
|
||||
g_assert (!qof_session_events_pending (fixture->session));
|
||||
|
||||
g_test_message ("Test pending events callback");
|
||||
be->events_pending = mock_events_fn;
|
||||
events_struct.called = FALSE;
|
||||
events_struct.be = be;
|
||||
g_assert (qof_session_events_pending (fixture->session));
|
||||
g_assert (events_struct.called);
|
||||
|
||||
g_test_message ("Test process events null checks");
|
||||
g_assert (!qof_session_process_events (NULL));
|
||||
fixture->session->backend = NULL;
|
||||
g_assert (!qof_session_process_events (fixture->session));
|
||||
be->process_events = NULL;
|
||||
fixture->session->backend = be;
|
||||
g_assert (!qof_session_process_events (fixture->session));
|
||||
|
||||
g_test_message ("Test process events callback");
|
||||
be->process_events = mock_events_fn;
|
||||
events_struct.called = FALSE;
|
||||
events_struct.be = be;
|
||||
g_assert (qof_session_process_events (fixture->session));
|
||||
g_assert (events_struct.called);
|
||||
}
|
||||
|
||||
static struct
|
||||
{
|
||||
QofBackend *be;
|
||||
QofBook *book;
|
||||
gboolean called;
|
||||
} data_load_struct;
|
||||
|
||||
static void
|
||||
mock_all_data_load (QofBackend *be, QofBook *book, QofBackendLoadType type)
|
||||
{
|
||||
g_assert (be);
|
||||
g_assert (book);
|
||||
g_assert (be == data_load_struct.be);
|
||||
g_assert (book == data_load_struct.book);
|
||||
g_assert_cmpint (type, ==, LOAD_TYPE_LOAD_ALL);
|
||||
qof_backend_set_error (be, ERR_BACKEND_DATA_CORRUPT);
|
||||
data_load_struct.called = TRUE;
|
||||
}
|
||||
|
||||
static void
|
||||
test_qof_session_data_loaded (Fixture *fixture, gconstpointer pData)
|
||||
{
|
||||
QofBackend *be = NULL;
|
||||
|
||||
be = g_new0 (QofBackend, 1);
|
||||
g_assert (be);
|
||||
be->load = mock_all_data_load;
|
||||
fixture->session->backend = be;
|
||||
|
||||
g_test_message ("Test load callback and artificial error");
|
||||
data_load_struct.be = be;
|
||||
data_load_struct.book = qof_session_get_book (fixture->session);
|
||||
data_load_struct.called = FALSE;
|
||||
qof_session_ensure_all_data_loaded (fixture->session);
|
||||
g_assert (data_load_struct.called);
|
||||
g_assert_cmpint (qof_session_get_error (fixture->session), ==, ERR_BACKEND_DATA_CORRUPT);
|
||||
g_assert_cmpstr (qof_session_get_error_message (fixture->session), ==, "");
|
||||
}
|
||||
|
||||
static void
|
||||
test_qof_backend_get_access_method_list (Fixture *fixture, gconstpointer pData)
|
||||
{
|
||||
GList *list = NULL;
|
||||
const char *access_methods[4] = { "file", "http", "postgres", "sqlite" };
|
||||
int i;
|
||||
|
||||
for (i = 0; i < 4; i++)
|
||||
{
|
||||
QofBackendProvider *prov = g_new0 (QofBackendProvider, 1);
|
||||
g_assert (prov);
|
||||
prov->access_method = access_methods[ i ];
|
||||
qof_backend_register_provider (prov);
|
||||
g_assert_cmpint (g_slist_length (get_provider_list ()), ==, (i + 1));
|
||||
}
|
||||
g_assert_cmpint (g_slist_length (get_provider_list ()), ==, 4);
|
||||
|
||||
g_test_message ("Test list of access methods is returned");
|
||||
list = qof_backend_get_registered_access_method_list ();
|
||||
g_assert (list);
|
||||
g_assert_cmpint (g_list_length (list), ==, 4);
|
||||
g_assert_cmpstr (g_list_nth_data (list, 0), ==, "file");
|
||||
g_assert_cmpstr (g_list_nth_data (list, 1), ==, "http");
|
||||
g_assert_cmpstr (g_list_nth_data (list, 2), ==, "postgres");
|
||||
g_assert_cmpstr (g_list_nth_data (list, 3), ==, "sqlite");
|
||||
|
||||
g_list_free (list);
|
||||
unregister_all_providers ();
|
||||
}
|
||||
|
||||
|
||||
static void
|
||||
test_qof_session_get_book (Fixture *fixture, gconstpointer pData)
|
||||
{
|
||||
QofBook *book = NULL;
|
||||
|
||||
g_test_message ("Test null check");
|
||||
g_assert (!qof_session_get_book (NULL));
|
||||
|
||||
g_test_message ("Test open book is returned");
|
||||
g_assert (fixture->session->book);
|
||||
book = qof_session_get_book (fixture->session);
|
||||
g_assert (book);
|
||||
g_assert_cmpuint (book->book_open, ==, 'y');
|
||||
|
||||
g_test_message ("Test when book is closed null returned");
|
||||
qof_book_mark_closed (book);
|
||||
g_assert (!qof_session_get_book (fixture->session));
|
||||
|
||||
}
|
||||
|
||||
static void
|
||||
test_qof_session_get_error (Fixture *fixture, gconstpointer pData)
|
||||
{
|
||||
QofBackend *be = NULL;
|
||||
|
||||
g_test_message ("Test if session is null");
|
||||
g_assert_cmpint (qof_session_get_error (NULL), ==, ERR_BACKEND_NO_BACKEND);
|
||||
|
||||
g_test_message ("Test when there is a local error");
|
||||
fixture->session->last_err = ERR_BACKEND_DATA_CORRUPT; /* just any error */
|
||||
g_assert_cmpint (qof_session_get_error (fixture->session), ==, ERR_BACKEND_DATA_CORRUPT);
|
||||
|
||||
g_test_message ("Test if session backend is null");
|
||||
g_assert (!fixture->session->backend);
|
||||
fixture->session->last_err = ERR_BACKEND_NO_ERR;
|
||||
g_assert_cmpint (qof_session_get_error (fixture->session), ==, ERR_BACKEND_NO_ERR);
|
||||
|
||||
g_test_message ("Test for backend error");
|
||||
be = g_new0 (QofBackend, 1);
|
||||
g_assert (be);
|
||||
qof_backend_set_error (be, ERR_BACKEND_CANT_CONNECT);
|
||||
fixture->session->backend = be;
|
||||
g_assert_cmpint (qof_session_get_error (fixture->session), ==, ERR_BACKEND_CANT_CONNECT);
|
||||
}
|
||||
|
||||
static void
|
||||
test_qof_session_clear_error (Fixture *fixture, gconstpointer pData)
|
||||
{
|
||||
QofBackend *be = NULL;
|
||||
|
||||
be = g_new0 (QofBackend, 1);
|
||||
g_assert (be);
|
||||
|
||||
g_test_message ("Test session and backend errors are cleared");
|
||||
qof_session_push_error (fixture->session, ERR_BACKEND_NO_SUCH_DB, "push any error");
|
||||
fixture->session->backend = be;
|
||||
qof_backend_set_error (be, ERR_BACKEND_CANT_CONNECT);
|
||||
p_qof_session_clear_error (fixture->session);
|
||||
g_assert_cmpint (qof_session_get_error (fixture->session), ==, ERR_BACKEND_NO_ERR);
|
||||
g_assert_cmpstr (qof_session_get_error_message (fixture->session), ==, "");
|
||||
g_assert (!fixture->session->error_message);
|
||||
g_assert_cmpint (qof_backend_get_error (be), ==, ERR_BACKEND_NO_ERR);
|
||||
}
|
||||
|
||||
static struct
|
||||
{
|
||||
QofSession *session;
|
||||
gpointer data1;
|
||||
gpointer data2;
|
||||
gpointer data3;
|
||||
guint call_count;
|
||||
} hooks_struct;
|
||||
|
||||
static void
|
||||
mock_hook_fn (gpointer data, gpointer user_data)
|
||||
{
|
||||
QofSession *session;
|
||||
|
||||
g_assert (data);
|
||||
g_assert (user_data);
|
||||
session = (QofSession*) data;
|
||||
g_assert (session == hooks_struct.session);
|
||||
if (hooks_struct.call_count == 0)
|
||||
g_assert (hooks_struct.data1 == user_data);
|
||||
if (hooks_struct.call_count == 1)
|
||||
g_assert (hooks_struct.data2 == user_data);
|
||||
if (hooks_struct.call_count == 2)
|
||||
g_assert (hooks_struct.data3 == user_data);
|
||||
hooks_struct.call_count++;
|
||||
}
|
||||
|
||||
static void
|
||||
test_qof_session_close_hooks (Fixture *fixture, gconstpointer pData)
|
||||
{
|
||||
gint data1, data2, data3;
|
||||
|
||||
g_test_message ("Test hooks list is initialized and hooks are added");
|
||||
g_assert (!get_session_closed_hooks ());
|
||||
qof_session_add_close_hook (mock_hook_fn, (gpointer) &data1);
|
||||
g_assert (get_session_closed_hooks ());
|
||||
g_assert (g_hook_find_func_data (get_session_closed_hooks (), FALSE, mock_hook_fn, (gpointer) &data1));
|
||||
qof_session_add_close_hook (mock_hook_fn, (gpointer) &data2);
|
||||
g_assert (g_hook_find_func_data (get_session_closed_hooks (), FALSE, mock_hook_fn, (gpointer) &data2));
|
||||
qof_session_add_close_hook (mock_hook_fn, (gpointer) &data3);
|
||||
g_assert (g_hook_find_func_data (get_session_closed_hooks (), FALSE, mock_hook_fn, (gpointer) &data3));
|
||||
|
||||
g_test_message ("Test all close hooks are called");
|
||||
hooks_struct.session = fixture->session;
|
||||
hooks_struct.data1 = (gpointer) &data1;
|
||||
hooks_struct.data2 = (gpointer) &data2;
|
||||
hooks_struct.data3 = (gpointer) &data3;
|
||||
hooks_struct.call_count = 0;
|
||||
qof_session_call_close_hooks (fixture->session);
|
||||
g_assert_cmpuint (hooks_struct.call_count, ==, 3);
|
||||
|
||||
/* currently qofsession does not provide a way to clear hooks list
|
||||
* g_hook_list_clear is used to destroy list and all of it's elements
|
||||
* though i' not sure if it frees all the memory allocated
|
||||
*/
|
||||
g_hook_list_clear (get_session_closed_hooks ());
|
||||
}
|
||||
|
||||
void
|
||||
test_suite_qofsession ( void )
|
||||
{
|
||||
g_test_add( suitename, Fixture, NULL, setup, test_session_safe_save, teardown );
|
||||
GNC_TEST_ADD_FUNC (suitename, "qof session new and destroy", test_qof_session_new_destroy);
|
||||
GNC_TEST_ADD (suitename, "qof session safe save", Fixture, NULL, setup, test_session_safe_save, teardown);
|
||||
GNC_TEST_ADD (suitename, "qof session load backend", Fixture, NULL, setup, test_qof_session_load_backend, teardown);
|
||||
GNC_TEST_ADD (suitename, "qof session load", Fixture, NULL, setup, test_qof_session_load, teardown);
|
||||
GNC_TEST_ADD (suitename, "qof session begin", Fixture, NULL, setup, test_qof_session_begin, teardown);
|
||||
GNC_TEST_ADD (suitename, "qof session save", Fixture, NULL, setup, test_qof_session_save, teardown);
|
||||
GNC_TEST_ADD (suitename, "qof session destroy backend", Fixture, NULL, setup, test_qof_session_destroy_backend, teardown);
|
||||
GNC_TEST_ADD (suitename, "qof session end", Fixture, NULL, setup, test_qof_session_end, teardown);
|
||||
GNC_TEST_ADD (suitename, "qof session export", Fixture, NULL, setup, test_qof_session_export, teardown);
|
||||
GNC_TEST_ADD (suitename, "qof session swap data", Fixture, NULL, setup, test_qof_session_swap_data, teardown);
|
||||
GNC_TEST_ADD (suitename, "qof session events", Fixture, NULL, setup, test_qof_session_events, teardown);
|
||||
GNC_TEST_ADD (suitename, "qof session data loaded", Fixture, NULL, setup, test_qof_session_data_loaded, teardown);
|
||||
GNC_TEST_ADD (suitename, "qof backend access method list", Fixture, NULL, setup, test_qof_backend_get_access_method_list, teardown);
|
||||
GNC_TEST_ADD (suitename, "qof session get book", Fixture, NULL, setup, test_qof_session_get_book, teardown);
|
||||
GNC_TEST_ADD (suitename, "qof session get error", Fixture, NULL, setup, test_qof_session_get_error, teardown);
|
||||
GNC_TEST_ADD (suitename, "qof session clear error", Fixture, NULL, setup, test_qof_session_clear_error, teardown);
|
||||
GNC_TEST_ADD (suitename, "qof session close hooks", Fixture, NULL, setup, test_qof_session_close_hooks, teardown);
|
||||
}
|
||||
|
||||
Loading…
Reference in New Issue
Block a user