/* -*- Mode: C; indent-tabs-mode: t; c-basic-offset: 8; tab-width: 8 -*- */

/*

 * GData Client

 * Copyright (C) Philip Withnall 2008–2010, 2015 <philip@tecnocode.co.uk>

 *

 * GData Client is free software; you can redistribute it and/or

 * modify it under the terms of the GNU Lesser General Public

 * License as published by the Free Software Foundation; either

 * version 2.1 of the License, or (at your option) any later version.

 *

 * GData Client 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

 * Lesser General Public License for more details.

 *

 * You should have received a copy of the GNU Lesser General Public

 * License along with GData Client.  If not, see <http://www.gnu.org/licenses/>.

 */

#include <glib.h>

#include <string.h>

#include <unistd.h>

#include "gdata.h"

#include "common.h"

#include "gdata-dummy-authorizer.h"

static UhmServer *mock_server = NULL;

#undef CLIENT_ID  /* from common.h */

#define DEVELOPER_KEY "AI39si7Me3Q7zYs6hmkFvpRBD2nrkVjYYsUO5lh_3HdOkGRc9g6Z4nzxZatk_aAo2EsA21k7vrda0OO6oFg2rnhMedZXPyXoEw"

#define CLIENT_ID "352818697630-nqu2cmt5quqd6lr17ouoqmb684u84l1f.apps.googleusercontent.com"

#define CLIENT_SECRET "-fA4pHQJxR3zJ-FyAMPQsikg"

#define REDIRECT_URI "urn:ietf:wg:oauth:2.0:oob"

/* Effectively gdata_test_mock_server_start_trace() but calling uhm_server_run() instead of uhm_server_start_trace(). */

static void

gdata_test_mock_server_run (UhmServer *server)

{

	const gchar *ip_address;

	UhmResolver *resolver;

	uhm_server_run (server);

	gdata_test_set_https_port (server);

	if (uhm_server_get_enable_online (server) == FALSE) {

		/* Set up the expected domain names here. This should technically be split up between

		 * the different unit test suites, but that's too much effort. */

		ip_address = uhm_server_get_address (server);

		resolver = uhm_server_get_resolver (server);

		uhm_resolver_add_A (resolver, "www.google.com", ip_address);

		uhm_resolver_add_A (resolver, "gdata.youtube.com", ip_address);

		uhm_resolver_add_A (resolver, "uploads.gdata.youtube.com", ip_address);

	}

}

static void

test_authentication (void)

{

	GDataOAuth2Authorizer *authorizer = NULL;  /* owned */

	gchar *authentication_uri, *authorisation_code;

	gdata_test_mock_server_start_trace (mock_server, "authentication");

	authorizer = gdata_oauth2_authorizer_new (CLIENT_ID, CLIENT_SECRET,

	                                          REDIRECT_URI,

	                                          GDATA_TYPE_YOUTUBE_SERVICE);

	/* Get an authentication URI. */

	authentication_uri = gdata_oauth2_authorizer_build_authentication_uri (authorizer, NULL, FALSE);

	g_assert (authentication_uri != NULL);

	/* Get the authorisation code off the user. */

	if (uhm_server_get_enable_online (mock_server)) {

		authorisation_code = gdata_test_query_user_for_verifier (authentication_uri);

	} else {

		/* Hard coded, extracted from the trace file. */

		authorisation_code = g_strdup ("4/9qV_LanNEOUOL4sftMwUp4cfa_yeF"

		                               "assB6-ys5EkA5o.4rgOzrZMXgcboiIB"

		                               "eO6P2m-GWLMXmgI");

	}

	g_free (authentication_uri);

	if (authorisation_code == NULL) {

		/* Skip tests. */

		goto skip_test;

	}

	/* Authorise the token */

	g_assert (gdata_oauth2_authorizer_request_authorization (authorizer, authorisation_code, NULL, NULL) == TRUE);

	/* Check all is as it should be */

	g_assert (gdata_authorizer_is_authorized_for_domain (GDATA_AUTHORIZER (authorizer),

	                                                     gdata_youtube_service_get_primary_authorization_domain ()) == TRUE);

skip_test:

	g_free (authorisation_code);

	g_object_unref (authorizer);

	uhm_server_end_trace (mock_server);

}

static void

test_service_properties (void)

{

	GDataService *service;

	/* Create a service */

	service = GDATA_SERVICE (gdata_youtube_service_new (DEVELOPER_KEY, NULL));

	g_assert (service != NULL);

	g_assert (GDATA_IS_SERVICE (service));

	g_assert_cmpstr (gdata_youtube_service_get_developer_key (GDATA_YOUTUBE_SERVICE (service)), ==, DEVELOPER_KEY);

	g_object_unref (service);

}

static void

test_query_standard_feeds (gconstpointer service)

{

	GDataFeed *feed;

	GError *error = NULL;

	guint i;

	gulong filter_id;

	GDataYouTubeStandardFeedType feeds[] = {

		/* This must be kept up-to-date with GDataYouTubeStandardFeedType. */

		GDATA_YOUTUBE_TOP_RATED_FEED,

		GDATA_YOUTUBE_TOP_FAVORITES_FEED,

		GDATA_YOUTUBE_MOST_VIEWED_FEED,

		GDATA_YOUTUBE_MOST_POPULAR_FEED,

		GDATA_YOUTUBE_MOST_RECENT_FEED,

		GDATA_YOUTUBE_MOST_DISCUSSED_FEED,

		GDATA_YOUTUBE_MOST_LINKED_FEED,

		GDATA_YOUTUBE_MOST_RESPONDED_FEED,

		GDATA_YOUTUBE_RECENTLY_FEATURED_FEED,

		GDATA_YOUTUBE_WATCH_ON_MOBILE_FEED,

	};

	const gchar *ignore_query_param_values[] = {

		"publishedAfter",

		NULL,

	};

	filter_id = uhm_server_filter_ignore_parameter_values (mock_server,

	                                                       ignore_query_param_values);

	gdata_test_mock_server_start_trace (mock_server, "query-standard-feeds");

	for (i = 0; i < G_N_ELEMENTS (feeds); i++) {

		feed = gdata_youtube_service_query_standard_feed (GDATA_YOUTUBE_SERVICE (service), feeds[i], NULL, NULL, NULL, NULL, &error);

		g_assert_no_error (error);

		g_assert (GDATA_IS_FEED (feed));

		g_clear_error (&error);

		g_assert_cmpuint (g_list_length (gdata_feed_get_entries (feed)), >, 0);

		g_object_unref (feed);

	}

	uhm_server_end_trace (mock_server);

	uhm_server_compare_messages_remove_filter (mock_server, filter_id);

}

static void

test_query_standard_feed (gconstpointer service)

{

	GDataFeed *feed;

	GError *error = NULL;

	gulong filter_id;

	const gchar *ignore_query_param_values[] = {

		"publishedAfter",

		NULL,

	};

	filter_id = uhm_server_filter_ignore_parameter_values (mock_server,

	                                                       ignore_query_param_values);

	gdata_test_mock_server_start_trace (mock_server, "query-standard-feed");

	feed = gdata_youtube_service_query_standard_feed (GDATA_YOUTUBE_SERVICE (service), GDATA_YOUTUBE_TOP_RATED_FEED, NULL, NULL, NULL, NULL, &error);

	g_assert_no_error (error);

	g_assert (GDATA_IS_FEED (feed));

	g_clear_error (&error);

	g_assert_cmpuint (g_list_length (gdata_feed_get_entries (feed)), >, 0);

	g_object_unref (feed);

	uhm_server_end_trace (mock_server);

	uhm_server_compare_messages_remove_filter (mock_server, filter_id);

}

static void

test_query_standard_feed_with_query (gconstpointer service)

{

	GDataYouTubeQuery *query;

	GDataFeed *feed;

	GError *error = NULL;

	gulong filter_id;

	const gchar *ignore_query_param_values[] = {

		"publishedAfter",

		NULL,

	};

	filter_id = uhm_server_filter_ignore_parameter_values (mock_server,

	                                                       ignore_query_param_values);

	G_GNUC_BEGIN_IGNORE_DEPRECATIONS

	gdata_test_mock_server_start_trace (mock_server, "query-standard-feed-with-query");

	query = gdata_youtube_query_new (NULL);

	gdata_youtube_query_set_language (query, "fr");

	feed = gdata_youtube_service_query_standard_feed (GDATA_YOUTUBE_SERVICE (service), GDATA_YOUTUBE_TOP_RATED_FEED, GDATA_QUERY (query), NULL, NULL, NULL, &error);

	g_assert_no_error (error);

	g_assert (GDATA_IS_FEED (feed));

	g_clear_error (&error);

	g_assert_cmpuint (g_list_length (gdata_feed_get_entries (feed)), >, 0);

	g_object_unref (query);

	g_object_unref (feed);

	uhm_server_end_trace (mock_server);

	uhm_server_compare_messages_remove_filter (mock_server, filter_id);

	G_GNUC_END_IGNORE_DEPRECATIONS

}

/* HTTP message responses and the expected associated GData error domain/code. */

static const GDataTestRequestErrorData query_standard_feed_errors[] = {

	/* Generic network errors. */

	{ SOUP_STATUS_BAD_REQUEST, "Bad Request", "Invalid parameter ‘foobar’.",

	  gdata_service_error_quark, GDATA_SERVICE_ERROR_PROTOCOL_ERROR },

	{ SOUP_STATUS_NOT_FOUND, "Not Found", "Login page wasn't found for no good reason at all.",

	  gdata_service_error_quark, GDATA_SERVICE_ERROR_NOT_FOUND },

	{ SOUP_STATUS_PRECONDITION_FAILED, "Precondition Failed", "Not allowed to log in at this time, possibly.",

	  gdata_service_error_quark, GDATA_SERVICE_ERROR_CONFLICT },

	{ SOUP_STATUS_INTERNAL_SERVER_ERROR, "Internal Server Error", "Whoops.",

	  gdata_service_error_quark, GDATA_SERVICE_ERROR_PROTOCOL_ERROR },

#if 0

FIXME

	/* Specific query errors. */

	{ SOUP_STATUS_FORBIDDEN, "Too Many Calls",

	  "<errors><error><domain>yt:quota</domain>too_many_recent_calls</error></errors>",

	  gdata_youtube_service_error_quark, GDATA_YOUTUBE_SERVICE_ERROR_API_QUOTA_EXCEEDED },

	{ SOUP_STATUS_FORBIDDEN, "Too Many Entries",

	  "<errors><error><domain>yt:quota</domain>too_many_entries</error></errors>",

	  gdata_youtube_service_error_quark, GDATA_YOUTUBE_SERVICE_ERROR_ENTRY_QUOTA_EXCEEDED },

	{ SOUP_STATUS_SERVICE_UNAVAILABLE, "Maintenance",

	  "<errors><error><domain>yt:service</domain>disabled_in_maintenance_mode</error></errors>",

	  gdata_service_error_quark, GDATA_SERVICE_ERROR_UNAVAILABLE },

	{ SOUP_STATUS_FORBIDDEN, "YouTube Signup Required",

	  "<errors><error><domain>yt:service</domain>youtube_signup_required</error></errors>",

	  gdata_youtube_service_error_quark, GDATA_YOUTUBE_SERVICE_ERROR_CHANNEL_REQUIRED },

	{ SOUP_STATUS_FORBIDDEN, "Forbidden",

	  "<errors><error><domain>yt:authentication</domain>TokenExpired"

	  "<location type='header'>Authorization: GoogleLogin</location></error></errors>",

	  gdata_service_error_quark, GDATA_SERVICE_ERROR_AUTHENTICATION_REQUIRED },

	/* Malformed YouTube errors to test parser error handling. */

	{ SOUP_STATUS_INTERNAL_SERVER_ERROR, "Malformed XML",

	  "<errors>",

	  gdata_service_error_quark, GDATA_SERVICE_ERROR_PROTOCOL_ERROR },

	{ SOUP_STATUS_FORBIDDEN, "Empty Response", "",

	  gdata_service_error_quark, GDATA_SERVICE_ERROR_AUTHENTICATION_REQUIRED },

	{ SOUP_STATUS_INTERNAL_SERVER_ERROR, "Unknown Element",

	  "<errors> <error> <foobar /> </error> </errors>",

	  gdata_service_error_quark, GDATA_SERVICE_ERROR_PROTOCOL_ERROR },

	{ SOUP_STATUS_INTERNAL_SERVER_ERROR, "Wrong Top-Level Element",

	  "<nonerrors></nonerrors>",

	  gdata_service_error_quark, GDATA_SERVICE_ERROR_PROTOCOL_ERROR },

	{ SOUP_STATUS_FORBIDDEN, "Unknown Error Code (Service)",

	  "<errors><error><domain>yt:service</domain>UnknownCode</error></errors>",

	  gdata_service_error_quark, GDATA_SERVICE_ERROR_PROTOCOL_ERROR },

	{ SOUP_STATUS_FORBIDDEN, "Unknown Error Code (Quota)",

	  "<errors><error><domain>yt:quota</domain>UnknownCode</error></errors>",

	  gdata_service_error_quark, GDATA_SERVICE_ERROR_PROTOCOL_ERROR },

	{ SOUP_STATUS_FORBIDDEN, "Unknown Error Domain",

	  "<errors><error><domain>yt:foobaz</domain>TokenExpired</error></errors>",

	  gdata_service_error_quark, GDATA_SERVICE_ERROR_PROTOCOL_ERROR },

#endif

};

static void

test_query_standard_feed_error (gconstpointer service)

{

	GDataFeed *feed;

	GError *error = NULL;

	gulong handler_id, filter_id;

	guint i;

	const gchar *ignore_query_param_values[] = {

		"publishedAfter",

		NULL,

	};

	if (uhm_server_get_enable_logging (mock_server) == TRUE) {

		g_test_message ("Ignoring test due to logging being enabled.");

		return;

	} else if (uhm_server_get_enable_online (mock_server) == TRUE) {

		g_test_message ("Ignoring test due to running online and test not being reproducible.");

		return;

	}

	filter_id = uhm_server_filter_ignore_parameter_values (mock_server,

	                                                       ignore_query_param_values);

	for (i = 0; i < G_N_ELEMENTS (query_standard_feed_errors); i++) {

		const GDataTestRequestErrorData *data = &query_standard_feed_errors[i];

		handler_id = g_signal_connect (mock_server, "handle-message", (GCallback) gdata_test_mock_server_handle_message_error, (gpointer) data);

		gdata_test_mock_server_run (mock_server);

		/* Query the feed. */

		feed = gdata_youtube_service_query_standard_feed (GDATA_YOUTUBE_SERVICE (service), GDATA_YOUTUBE_TOP_RATED_FEED, NULL, NULL, NULL, NULL, &error);

		g_assert_error (error, data->error_domain_func (), data->error_code);

		g_assert (feed == NULL);

		g_clear_error (&error);

		uhm_server_stop (mock_server);

		g_signal_handler_disconnect (mock_server, handler_id);

	}

	uhm_server_compare_messages_remove_filter (mock_server, filter_id);

}

static void

test_query_standard_feed_timeout (gconstpointer service)

{

	GDataFeed *feed;

	GError *error = NULL;

	gulong handler_id, filter_id;

	const gchar *ignore_query_param_values[] = {

		"publishedAfter",

		NULL,

	};

	if (uhm_server_get_enable_logging (mock_server) == TRUE) {

		g_test_message ("Ignoring test due to logging being enabled.");

		return;

	} else if (uhm_server_get_enable_online (mock_server) == TRUE) {

		g_test_message ("Ignoring test due to running online and test not being reproducible.");

		return;

	}

	filter_id = uhm_server_filter_ignore_parameter_values (mock_server,

	                                                       ignore_query_param_values);

	handler_id = g_signal_connect (mock_server, "handle-message", (GCallback) gdata_test_mock_server_handle_message_timeout, NULL);

	gdata_test_mock_server_run (mock_server);

	/* Set the service's timeout as low as possible (1 second). */

	gdata_service_set_timeout (GDATA_SERVICE (service), 1);

	/* Query the feed. */

	feed = gdata_youtube_service_query_standard_feed (GDATA_YOUTUBE_SERVICE (service), GDATA_YOUTUBE_TOP_RATED_FEED, NULL, NULL, NULL, NULL, &error);

	g_assert_error (error, GDATA_SERVICE_ERROR, GDATA_SERVICE_ERROR_NETWORK_ERROR);

	g_assert (feed == NULL);

	g_clear_error (&error);

	uhm_server_stop (mock_server);

	g_signal_handler_disconnect (mock_server, handler_id);

	uhm_server_compare_messages_remove_filter (mock_server, filter_id);

}

typedef struct {

	GDataAsyncTestData async_data;

	gulong filter_id;

} StandardFeedData;

static void

set_up_standard_feed_async (StandardFeedData *standard_feed_data,

                            gconstpointer test_data)

{

	const gchar *ignore_query_param_values[] = {

		"publishedAfter",

		NULL,

	};

	gdata_set_up_async_test_data (&standard_feed_data->async_data,

	                              test_data);

	standard_feed_data->filter_id =

		uhm_server_filter_ignore_parameter_values (mock_server,

		                                           ignore_query_param_values);

}

static void

tear_down_standard_feed_async (StandardFeedData *standard_feed_data,

                               gconstpointer test_data)

{

	uhm_server_compare_messages_remove_filter (mock_server,

	                                           standard_feed_data->filter_id);

	gdata_tear_down_async_test_data (&standard_feed_data->async_data,

	                                 test_data);

}

GDATA_ASYNC_TEST_FUNCTIONS (query_standard_feed, void,

G_STMT_START {

	gdata_youtube_service_query_standard_feed_async (GDATA_YOUTUBE_SERVICE (service), GDATA_YOUTUBE_TOP_RATED_FEED, NULL, cancellable,

	                                                 NULL, NULL, NULL, async_ready_callback, async_data);

} G_STMT_END,

G_STMT_START {

	GDataFeed *feed;

	feed = gdata_service_query_finish (GDATA_SERVICE (obj), async_result, &error);

	if (error == NULL) {

		g_assert (GDATA_IS_FEED (feed));

		g_assert_cmpuint (g_list_length (gdata_feed_get_entries (feed)), >, 0);

		g_object_unref (feed);

	} else {

		g_assert (feed == NULL);

	}

} G_STMT_END);

static void

test_query_standard_feed_async_progress_closure (gconstpointer service)

{

	GDataAsyncProgressClosure *data = g_slice_new0 (GDataAsyncProgressClosure);

	gulong filter_id;

	const gchar *ignore_query_param_values[] = {

		"publishedAfter",

		NULL,

	};

	g_assert (service != NULL);

	filter_id = uhm_server_filter_ignore_parameter_values (mock_server,

	                                                       ignore_query_param_values);

	gdata_test_mock_server_start_trace (mock_server, "query-standard-feed-async-progress-closure");

	data->main_loop = g_main_loop_new (NULL, TRUE);

	gdata_youtube_service_query_standard_feed_async (GDATA_YOUTUBE_SERVICE (service), GDATA_YOUTUBE_TOP_RATED_FEED, NULL, NULL,

	                                                 (GDataQueryProgressCallback) gdata_test_async_progress_callback,

	                                                 data, (GDestroyNotify) gdata_test_async_progress_closure_free,

	                                                 (GAsyncReadyCallback) gdata_test_async_progress_finish_callback, data);

	g_main_loop_run (data->main_loop);

	g_main_loop_unref (data->main_loop);

	/* Check that both callbacks were called exactly once */

	g_assert_cmpuint (data->progress_destroy_notify_count, ==, 1);

	g_assert_cmpuint (data->async_ready_notify_count, ==, 1);

	g_slice_free (GDataAsyncProgressClosure, data);

	uhm_server_end_trace (mock_server);

	uhm_server_compare_messages_remove_filter (mock_server, filter_id);

}

static GDataYouTubeVideo *

get_video_for_related (void)

{

	GDataYouTubeVideo *video;

	GError *error = NULL;

	video = GDATA_YOUTUBE_VIDEO (gdata_parsable_new_from_json (GDATA_TYPE_YOUTUBE_VIDEO,

		"{"

			"'kind': 'youtube#video',"

			"'id': 'q1UPMEmCqZo'"

		"}", -1, &error));

	g_assert_no_error (error);

	g_assert (GDATA_IS_YOUTUBE_VIDEO (video));

	g_clear_error (&error);

	return video;

}

static void

test_query_related (gconstpointer service)

{

	GDataFeed *feed;

	GDataYouTubeVideo *video;

	GError *error = NULL;

	gdata_test_mock_server_start_trace (mock_server, "query-related");

	video = get_video_for_related ();

	feed = gdata_youtube_service_query_related (GDATA_YOUTUBE_SERVICE (service), video, NULL, NULL, NULL, NULL, &error);

	g_assert_no_error (error);

	g_assert (GDATA_IS_FEED (feed));

	g_clear_error (&error);

	/* TODO: check entries and feed properties */

	g_object_unref (video);

	g_object_unref (feed);

	uhm_server_end_trace (mock_server);

}

GDATA_ASYNC_TEST_FUNCTIONS (query_related, void,

G_STMT_START {

	GDataYouTubeVideo *video;

	video = get_video_for_related ();

	gdata_youtube_service_query_related_async (GDATA_YOUTUBE_SERVICE (service), video, NULL, cancellable, NULL,

	                                           NULL, NULL, async_ready_callback, async_data);

	g_object_unref (video);

} G_STMT_END,

G_STMT_START {

	GDataFeed *feed;

	feed = gdata_service_query_finish (GDATA_SERVICE (obj), async_result, &error);

	if (error == NULL) {

		g_assert (GDATA_IS_FEED (feed));

		/* TODO: Tests? */

		g_object_unref (feed);

	} else {

		g_assert (feed == NULL);

	}

} G_STMT_END);

static void

test_query_related_async_progress_closure (gconstpointer service)

{

	GDataAsyncProgressClosure *data = g_slice_new0 (GDataAsyncProgressClosure);

	GDataYouTubeVideo *video;

	g_assert (service != NULL);

	gdata_test_mock_server_start_trace (mock_server, "query-related-async-progress-closure");

	data->main_loop = g_main_loop_new (NULL, TRUE);

	video = get_video_for_related ();

	gdata_youtube_service_query_related_async (GDATA_YOUTUBE_SERVICE (service), video, NULL, NULL,

	                                           (GDataQueryProgressCallback) gdata_test_async_progress_callback,

	                                           data, (GDestroyNotify) gdata_test_async_progress_closure_free,

	                                           (GAsyncReadyCallback) gdata_test_async_progress_finish_callback, data);

	g_object_unref (video);

	g_main_loop_run (data->main_loop);

	g_main_loop_unref (data->main_loop);

	/* Check that both callbacks were called exactly once */

	g_assert_cmpuint (data->progress_destroy_notify_count, ==, 1);

	g_assert_cmpuint (data->async_ready_notify_count, ==, 1);

	g_slice_free (GDataAsyncProgressClosure, data);

	uhm_server_end_trace (mock_server);

}

typedef struct {

	GDataYouTubeService *service;

	GDataYouTubeVideo *video;

	GDataYouTubeVideo *updated_video;

	GFile *video_file;

	gchar *slug;

	gchar *content_type;

} UploadData;

static void

set_up_upload (UploadData *data, gconstpointer service)

{

	GDataMediaCategory *category;

	GFileInfo *file_info;

	const gchar * const tags[] = { "toast", "wedding", NULL };

	gchar *path = NULL;

	GError *error = NULL;

	data->service = g_object_ref ((gpointer) service);

	/* Create the metadata for the video being uploaded */

	data->video = gdata_youtube_video_new (NULL);

	gdata_entry_set_title (GDATA_ENTRY (data->video), "Bad Wedding Toast");

	gdata_youtube_video_set_description (data->video, "I gave a bad toast at my friend's wedding.");

	category = gdata_media_category_new ("22", NULL, NULL);

	gdata_youtube_video_set_category (data->video, category);

	g_object_unref (category);

	gdata_youtube_video_set_keywords (data->video, tags);

	/* Get a file to upload */

	/* TODO: fix the path */

	path = g_test_build_filename (G_TEST_DIST, "sample.ogg", NULL);

	data->video_file = g_file_new_for_path (path);

	g_free (path);

	/* Get the file's info */

	file_info = g_file_query_info (data->video_file, G_FILE_ATTRIBUTE_STANDARD_DISPLAY_NAME "," G_FILE_ATTRIBUTE_STANDARD_CONTENT_TYPE,

	                               G_FILE_QUERY_INFO_NONE, NULL, &error);

	g_assert_no_error (error);

	g_assert (G_IS_FILE_INFO (file_info));

	data->slug = g_strdup (g_file_info_get_display_name (file_info));

	data->content_type = g_strdup (g_file_info_get_content_type (file_info));

	g_object_unref (file_info);

}

static void

tear_down_upload (UploadData *data, gconstpointer service)

{

	gdata_test_mock_server_start_trace (mock_server, "teardown-upload");

	/* Delete the uploaded video, if possible */

	if (data->updated_video != NULL) {

		gdata_service_delete_entry (GDATA_SERVICE (service), gdata_youtube_service_get_primary_authorization_domain (),

		                            GDATA_ENTRY (data->updated_video), NULL, NULL);

		g_object_unref (data->updated_video);

	}

	g_object_unref (data->video);

	g_object_unref (data->video_file);

	g_free (data->slug);

	g_free (data->content_type);

	g_object_unref (data->service);

	uhm_server_end_trace (mock_server);

}

static void

test_upload_simple (UploadData *data, gconstpointer service)

{

	GDataUploadStream *upload_stream;

	GFileInputStream *file_stream;

	const gchar * const *tags, * const *tags2;

	gssize transfer_size;

	GError *error = NULL;

	gdata_test_mock_server_start_trace (mock_server, "upload-simple");

	/* Prepare the upload stream */

	upload_stream = gdata_youtube_service_upload_video (GDATA_YOUTUBE_SERVICE (service), data->video, data->slug, data->content_type, NULL,

	                                                    &error);

	g_assert_no_error (error);

	g_assert (GDATA_IS_UPLOAD_STREAM (upload_stream));

	/* Get an input stream for the file */

	file_stream = g_file_read (data->video_file, NULL, &error);

	g_assert_no_error (error);

	g_assert (G_IS_FILE_INPUT_STREAM (file_stream));

	/* Upload the video */

	transfer_size = g_output_stream_splice (G_OUTPUT_STREAM (upload_stream), G_INPUT_STREAM (file_stream),

	                                        G_OUTPUT_STREAM_SPLICE_CLOSE_SOURCE | G_OUTPUT_STREAM_SPLICE_CLOSE_TARGET, NULL, &error);

	g_assert_no_error (error);

	g_assert_cmpint (transfer_size, >, 0);

	/* Finish off the upload */

	data->updated_video = gdata_youtube_service_finish_video_upload (GDATA_YOUTUBE_SERVICE (service), upload_stream, &error);

	g_assert_no_error (error);

	g_assert (GDATA_IS_YOUTUBE_VIDEO (data->updated_video));

	g_object_unref (file_stream);

	g_object_unref (upload_stream);

	/* Check the video's properties */

	g_assert (gdata_entry_is_inserted (GDATA_ENTRY (data->updated_video)));

	g_assert_cmpstr (gdata_entry_get_title (GDATA_ENTRY (data->updated_video)), ==, gdata_entry_get_title (GDATA_ENTRY (data->video)));

	g_assert_cmpstr (gdata_youtube_video_get_description (data->updated_video), ==, gdata_youtube_video_get_description (data->video));

	g_assert_cmpstr (gdata_media_category_get_category (gdata_youtube_video_get_category (data->updated_video)), ==,

	                 gdata_media_category_get_category (gdata_youtube_video_get_category (data->video)));

	tags = gdata_youtube_video_get_keywords (data->video);

	tags2 = gdata_youtube_video_get_keywords (data->updated_video);

	g_assert_cmpuint (g_strv_length ((gchar**) tags2), ==, g_strv_length ((gchar**) tags));

	g_assert_cmpstr (tags2[0], ==, tags[0]);

	g_assert_cmpstr (tags2[1], ==, tags[1]);

	g_assert_cmpstr (tags2[2], ==, tags[2]);

	uhm_server_end_trace (mock_server);

}

GDATA_ASYNC_CLOSURE_FUNCTIONS (upload, UploadData);

GDATA_ASYNC_TEST_FUNCTIONS (upload, UploadData,

G_STMT_START {

	GDataUploadStream *upload_stream;

	GFileInputStream *file_stream;

	GError *error = NULL;

	/* Prepare the upload stream */

	upload_stream = gdata_youtube_service_upload_video (GDATA_YOUTUBE_SERVICE (service), data->video, data->slug,

	                                                    data->content_type, cancellable, &error);

	g_assert_no_error (error);

	g_assert (GDATA_IS_UPLOAD_STREAM (upload_stream));

	/* Get an input stream for the file */

	file_stream = g_file_read (data->video_file, NULL, &error);

	g_assert_no_error (error);

	g_assert (G_IS_FILE_INPUT_STREAM (file_stream));

	/* Upload the video asynchronously */

	g_output_stream_splice_async (G_OUTPUT_STREAM (upload_stream), G_INPUT_STREAM (file_stream),

	                              G_OUTPUT_STREAM_SPLICE_CLOSE_TARGET, G_PRIORITY_DEFAULT, NULL,

	                              async_ready_callback, async_data);

	g_object_unref (file_stream);

	g_object_unref (upload_stream);

} G_STMT_END,

G_STMT_START {

	GOutputStream *stream = G_OUTPUT_STREAM (obj);

	const gchar * const *tags;

	const gchar * const *tags2;

	gssize transfer_size;

	GError *upload_error = NULL;

	/* Finish off the transfer */

	transfer_size = g_output_stream_splice_finish (stream, async_result, &error);

	if (error == NULL) {

		g_assert_cmpint (transfer_size, >, 0);

		/* Finish off the upload */

		data->updated_video = gdata_youtube_service_finish_video_upload (data->service, GDATA_UPLOAD_STREAM (stream), &upload_error);

		g_assert_no_error (upload_error);

		g_assert (GDATA_IS_YOUTUBE_VIDEO (data->updated_video));

		/* Check the video's properties */

		g_assert (gdata_entry_is_inserted (GDATA_ENTRY (data->updated_video)));

		g_assert_cmpstr (gdata_entry_get_title (GDATA_ENTRY (data->updated_video)), ==, gdata_entry_get_title (GDATA_ENTRY (data->video)));

		g_assert_cmpstr (gdata_youtube_video_get_description (data->updated_video), ==, gdata_youtube_video_get_description (data->video));

		g_assert_cmpstr (gdata_media_category_get_category (gdata_youtube_video_get_category (data->updated_video)), ==,

		                 gdata_media_category_get_category (gdata_youtube_video_get_category (data->video)));

		tags = gdata_youtube_video_get_keywords (data->video);

		tags2 = gdata_youtube_video_get_keywords (data->updated_video);

		g_assert_cmpuint (g_strv_length ((gchar**) tags2), ==, g_strv_length ((gchar**) tags));

		g_assert_cmpstr (tags2[0], ==, tags[0]);

		g_assert_cmpstr (tags2[1], ==, tags[1]);

		g_assert_cmpstr (tags2[2], ==, tags[2]);

	} else {

		g_assert_cmpint (transfer_size, ==, -1);

		/* Finish off the upload */

		data->updated_video = gdata_youtube_service_finish_video_upload (data->service, GDATA_UPLOAD_STREAM (stream), &upload_error);

		g_assert_no_error (upload_error);

		g_assert (data->updated_video == NULL);

	}

	g_clear_error (&upload_error);

} G_STMT_END);

static void

test_parsing_app_control (void)

{

	GDataYouTubeVideo *video;

	GDataYouTubeState *state;

	GError *error = NULL;

	video = GDATA_YOUTUBE_VIDEO (gdata_parsable_new_from_json (GDATA_TYPE_YOUTUBE_VIDEO,

		"{"

			"'kind': 'youtube#video',"

			"'etag': '\"tbWC5XrSXxe1WOAx6MK9z4hHSU8/X_byq2BdOVgHzCA-ScpZbTWmgfQ\"',"

			"'id': 'JAagedeKdcQ',"

			"'snippet': {"

				"'publishedAt': '2006-05-16T14:06:37.000Z',"

				"'channelId': 'UCCS6UQvicRHyn1whEUDEMUQ',"

				"'title': 'Judas Priest - Painkiller',"

				"'description': 'Videoclip de Judas Priest',"

				"'thumbnails': {"

					"'default': {"

						"'url': 'https://i.ytimg.com/vi/JAagedeKdcQ/default.jpg',"

						"'width': 120,"

						"'height': 90"

					"},"

					"'medium': {"

						"'url': 'https://i.ytimg.com/vi/JAagedeKdcQ/mqdefault.jpg',"

						"'width': 320,"

						"'height': 180"

					"},"

					"'high': {"

						"'url': 'https://i.ytimg.com/vi/JAagedeKdcQ/hqdefault.jpg',"

						"'width': 480,"

						"'height': 360"

					"}"

				"},"

				"'channelTitle': 'eluves',"

				"'categoryId': '10',"

				"'liveBroadcastContent': 'none',"

				"'localized': {"

					"'title': 'Judas Priest - Painkiller',"

					"'description': 'Videoclip de Judas Priest'"

				"}"

			"},"

			"'contentDetails': {"

				"'duration': 'PT6M',"

				"'dimension': '2d',"

				"'definition': 'sd',"

				"'caption': 'false',"

				"'licensedContent': false,"

				"'regionRestriction': {"

					"'blocked': ["

						"'RU',"

						"'RW',"

						"'RS',"

						"'RO',"

						"'RE',"

						"'BL',"

						"'BM',"

						"'BN',"

						"'BO',"

						"'JP',"

						"'BI',"

						"'BJ',"

						"'BD',"

						"'BE',"

						"'BF',"

						"'BG',"

						"'YT',"

						"'BB',"

						"'CX',"

						"'JE',"

						"'BY',"

						"'BZ',"

						"'BT',"

						"'JM',"

						"'BV',"

						"'BW',"

						"'YE',"

						"'BQ',"

						"'BR',"

						"'BS',"

						"'IM',"

						"'IL',"

						"'IO',"

						"'IN',"

						"'IE',"

						"'ID',"

						"'QA',"

						"'TM',"

						"'IQ',"

						"'IS',"

						"'IR',"

						"'IT',"

						"'TK',"

						"'AE',"

						"'AD',"

						"'AG',"

						"'AF',"

						"'AI',"

						"'AM',"

						"'AL',"

						"'AO',"

						"'AQ',"

						"'AS',"

						"'AR',"

						"'AU',"

						"'AT',"

						"'AW',"

						"'TG',"

						"'AX',"

						"'AZ',"

						"'PR',"

						"'HK',"

						"'HN',"

						"'PW',"

						"'PT',"

						"'HM',"

						"'PY',"

						"'PA',"

						"'PF',"

						"'PG',"

						"'PE',"

						"'HR',"

						"'PK',"

						"'PH',"

						"'PN',"

						"'HT',"

						"'HU',"

						"'OM',"

						"'WS',"

						"'WF',"

						"'BH',"

						"'KP',"

						"'TT',"

						"'GG',"

						"'GF',"

						"'GE',"

						"'GD',"

						"'GB',"

						"'VN',"

						"'VA',"