NNTPGrab

/* 

    Copyright (C) 2005-2011  Erik van Pienbroek

    This program is free software; you can redistribute it and/or modify

    it under the terms of the GNU General Public License as published by

    the Free Software Foundation; either version 2 of the License, or

    (at your option) any later version.

    This program is distributed in the hope that it will be useful,

    but WITHOUT ANY WARRANTY; without even the implied warranty of

    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

    GNU General Public License for more details.

    You should have received a copy of the GNU General Public License

    along with this program; if not, write to the Free Software

    Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA

*/

#include 

#include 

#include 

#include "common.h"

#include "test_download_queue.h"

#include "nntpgrab_utils.h"

#include "download_queue.h"

void

test_download_queue_setup_one_server_before(void *data, gconstpointer user_data)

{

    char *errmsg = NULL;

    NGConfigServer server;

    g_assert(configuration_get_avail_servers(config) == NULL);

    memset(&server, 0, sizeof(server));

    strcpy(server.servername, "server1");

    strcpy(server.hostname, "host1");

    server.port = 119;

    server.enabled = TRUE;

    server.max_threads = 3;

    server.priority = SERVER_PRIORITY_HIGH;

    if (!configuration_add_server(config, server, &errmsg)) {

        FAIL_TEST("Unable to add server: %s\n", errmsg);

        g_free(errmsg);

        return;

    }

    fill_queue_with_dummy_data();

}

void

test_download_queue_setup_one_server_after(void *data, gconstpointer user_data)

{

    char *errmsg = NULL;

    NGConfigServer server;

    g_assert(configuration_get_avail_servers(config) == NULL);

    memset(&server, 0, sizeof(server));

    strcpy(server.servername, "server1");

    strcpy(server.hostname, "host1");

    server.port = 119;

    server.enabled = TRUE;

    server.max_threads = 1;

    server.priority = SERVER_PRIORITY_HIGH;

    fill_queue_with_dummy_data();

    if (!configuration_add_server(config, server, &errmsg)) {

        FAIL_TEST("Unable to add server: %s\n", errmsg);

        g_free(errmsg);

        return;

    }

}

void

test_download_queue_teardown_one_server(void *data, gconstpointer user_data)

{

    char *errmsg = NULL;

    g_assert(configuration_get_avail_servers(config) != NULL);

    drop_dummy_data_from_queue();

    if (!configuration_del_server(config, "server1", &errmsg)) {

        FAIL_TEST("Unable to remove server: %s\n", errmsg);

        g_free(errmsg);

        return;

    }

}

static void

test_download_queue_one_server_generic(gboolean all_available)

{

    /* There should be 10 files with 4 parts each in the download queue now */

    int i, j;

    NNTPCollection *prev_collection = NULL;

    NNTPFile *prev_file = NULL;

    NNTPCollection *collection = NULL;

    NNTPFile *file = NULL;

    NNTPPart *part = NULL;

    gboolean nothing_to_download_or_active = FALSE;

    GList *list, *files = NULL;

    for (i = 1; i <= 10; i++) {

        prev_file = NULL;

        for (j = 1; j <= 4; j++) {

            /* There is 1 server configured at the moment, so a request for the next part for server_id 0 

             * should return TRUE and nothing_do_download should_or_active be FALSE */

            if (!download_queue_get_next_part_to_download(&collection, &file, &part, 0, ¬hing_to_download_or_active)) {

                g_test_message("nothing_to_download = %i", nothing_to_download_or_active);

                FAIL_TEST("download_queue_get_next_part_to_download returned FALSE while it isn't expected");

                return;

            } else {

                char *expected_subject = g_strdup_printf("file %i", i);

                g_assert_cmpint(nothing_to_download_or_active, ==, FALSE);

                g_assert(collection != NULL);

                g_assert(file != NULL);

                g_assert(part != NULL);

                g_assert_cmpint(part->part_num, ==, j);

                g_assert_cmpstr(file->subject, ==, expected_subject);

                g_free(expected_subject);

                if (prev_collection == NULL) {

                    prev_collection = collection;

                } else {

                    g_assert(prev_collection == collection);

                }

                if (prev_file == NULL) {

                    prev_file = file;

                    files = g_list_append(files, file);

                } else {

                    g_assert(prev_file == file);

                }

            }

            /* Update the status of the part */

            if (!all_available && j % 2 == 0) {

                /* Indicate the every second part isn't available on the server and it shouldn't be retried again */

                download_queue_update_part_status("server1", 0, collection, file, part, 0, FALSE, FALSE, TRUE);

            } else {

                /* Indicate that the file was downloaded succesfully */

                download_queue_update_part_status("server1", 0, collection, file, part, 0, TRUE, FALSE, FALSE);

            }

            collection = NULL;

            file = NULL;

            part = NULL;

        }

    }

    /* We processed all files now. If we try to request another part it should indicate that there's nothing to download anymore */

    if (!download_queue_get_next_part_to_download(&collection, &file, &part, 0, ¬hing_to_download_or_active)) {

        /* Nothing is returned which is good */

        /* The flag nothing_to_download_or_active should be FALSE as all files are downloaded, but not decoded yet */

        g_assert_cmpint(nothing_to_download_or_active, ==, FALSE);

        g_assert(collection == NULL);

        g_assert(file == NULL);

        g_assert(part == NULL);

    } else {

        FAIL_TEST("download_queue_get_next_part_to_download returned TRUE while it isn't expected");

        return;

    }

    /* Mark all files as finished (downloaded+decoded) */

    list = files;

    while (list) {

        file = (NNTPFile*) list->data;

        if (!all_available && g_list_index(files, file) % 2 == 0) {

            /* Indicate that not all parts were available */

            download_queue_mark_file_as_decoded_and_unref(prev_collection, file, "somefilename", TASK_STATE_FINISHED_INCOMPLETE);

        } else {

            /* Indicate that all parts were decoded succesfully */

            download_queue_mark_file_as_decoded_and_unref(prev_collection, file, "somefilename", TASK_STATE_FINISHED_COMPLETE);

        }

        list = g_list_next(list);

    }

    g_list_free(files);

    /* Verify that nothing_to_download_or_active is TRUE now */

    if (!download_queue_get_next_part_to_download(&collection, &file, &part, 0, ¬hing_to_download_or_active)) {

        /* Nothing is returned which is good */

        g_assert_cmpint(nothing_to_download_or_active, ==, TRUE);

        g_assert(collection == NULL);

        g_assert(file == NULL);

        g_assert(part == NULL);

    } else {

        FAIL_TEST("download_queue_get_next_part_to_download returned TRUE while it isn't expected");

        return;

    }

}

void

test_download_queue_one_server_all_available(void *data, gconstpointer user_data)

{

    /* Assume for this testcase that all parts are available on the server */

    test_download_queue_one_server_generic(TRUE);

}

void

test_download_queue_one_server_some_available(void *data, gconstpointer user_data)

{

    /* Assume for this testcase that some parts are available on the server */

    test_download_queue_one_server_generic(FALSE);

}