r21830 - gnucash/trunk/src/libqof/qof/test - [GSOC][Testing] Unit tests for qofsession
John Ralls
jralls at code.gnucash.org
Mon Jan 9 18:09:57 EST 2012
Author: jralls
Date: 2012-01-09 18:09:57 -0500 (Mon, 09 Jan 2012)
New Revision: 21830
Trac: http://svn.gnucash.org/trac/changeset/21830
Modified:
gnucash/trunk/src/libqof/qof/test/test-qofsession.c
Log:
[GSOC][Testing] Unit tests for qofsession
Author: Muslim Chochlov
Modified: gnucash/trunk/src/libqof/qof/test/test-qofsession.c
===================================================================
--- gnucash/trunk/src/libqof/qof/test/test-qofsession.c 2012-01-09 23:09:47 UTC (rev 21829)
+++ gnucash/trunk/src/libqof/qof/test/test-qofsession.c 2012-01-09 23:09:57 UTC (rev 21830)
@@ -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 @@
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);
}
More information about the gnucash-changes
mailing list