END_TEST
START_TEST (test_empathy_chatroom_manager_remove)
{
EmpathyChatroomManager *mgr;
gchar *file;
EmpathyAccount *account;
struct chatroom_t chatrooms[] = {
{ "name2", "room2", FALSE, TRUE }};
EmpathyChatroom *chatroom;
EmpathyAccountManager *account_mgr;
account_mgr = empathy_account_manager_dup_singleton ();
account = get_test_account ();
copy_xml_file (CHATROOM_SAMPLE, CHATROOM_FILE);
file = get_user_xml_file (CHATROOM_FILE);
/* change the chatrooms XML file to use the account we just created */
fail_unless (change_account_name_in_file (account, file));
mgr = empathy_chatroom_manager_dup_singleton (file);
/* remove room1 */
chatroom = empathy_chatroom_manager_find (mgr, account, "room1");
fail_if (chatroom == NULL);
empathy_chatroom_manager_remove (mgr, chatroom);
check_chatrooms_list (mgr, account, chatrooms, 1);
/* reload chatrooms file */
g_object_unref (mgr);
mgr = empathy_chatroom_manager_dup_singleton (file);
check_chatrooms_list (mgr, account, chatrooms, 1);
/* remove room1 */
chatroom = empathy_chatroom_manager_find (mgr, account, "room2");
fail_if (chatroom == NULL);
empathy_chatroom_manager_remove (mgr, chatroom);
check_chatrooms_list (mgr, account, chatrooms, 0);
/* reload chatrooms file */
g_object_unref (mgr);
mgr = empathy_chatroom_manager_dup_singleton (file);
check_chatrooms_list (mgr, account, chatrooms, 0);
g_object_unref (mgr);
g_free (file);
g_object_unref (account);
g_object_unref (account_mgr);
}
static void
main_window_favorite_chatroom_menu_setup (EmpathyMainWindow *window)
{
GList *chatrooms, *l;
GtkWidget *room;
window->chatroom_manager = empathy_chatroom_manager_dup_singleton (NULL);
chatrooms = empathy_chatroom_manager_get_chatrooms (window->chatroom_manager, NULL);
room = gtk_ui_manager_get_widget (window->ui_manager,
"/menubar/room");
window->room_menu = gtk_menu_item_get_submenu (GTK_MENU_ITEM (room));
window->room_separator = gtk_ui_manager_get_widget (window->ui_manager,
"/menubar/room/room_separator");
for (l = chatrooms; l; l = l->next) {
main_window_favorite_chatroom_menu_add (window, l->data);
}
if (!chatrooms) {
gtk_widget_hide (window->room_separator);
}
gtk_action_set_sensitive (window->room_join_favorites, chatrooms != NULL);
g_signal_connect (window->chatroom_manager, "chatroom-added",
G_CALLBACK (main_window_favorite_chatroom_menu_added_cb),
window);
g_signal_connect (window->chatroom_manager, "chatroom-removed",
G_CALLBACK (main_window_favorite_chatroom_menu_removed_cb),
window);
g_list_free (chatrooms);
}
GtkWidget *
empathy_contact_invite_menu_item_new (EmpathyContact *contact)
{
GtkWidget *item;
GtkWidget *image;
GtkWidget *room_item;
EmpathyChatroomManager *mgr;
GList *rooms, *l;
GtkWidget *submenu = NULL;
g_return_val_if_fail (EMPATHY_IS_CONTACT (contact), NULL);
item = gtk_image_menu_item_new_with_mnemonic (_("_Invite to Chat Room"));
image = gtk_image_new_from_icon_name (EMPATHY_IMAGE_GROUP_MESSAGE,
GTK_ICON_SIZE_MENU);
gtk_image_menu_item_set_image (GTK_IMAGE_MENU_ITEM (item), image);
if (empathy_contact_is_user (contact)) {
gtk_widget_set_sensitive (item, FALSE);
gtk_widget_show (image);
return item;
}
mgr = empathy_chatroom_manager_dup_singleton (NULL);
rooms = empathy_chatroom_manager_get_chatrooms (mgr,
empathy_contact_get_account (contact));
for (l = rooms; l != NULL; l = g_list_next (l)) {
EmpathyChatroom *chatroom = l->data;
if (empathy_chatroom_get_tp_chat (chatroom) != NULL) {
if (G_UNLIKELY (submenu == NULL))
submenu = gtk_menu_new ();
room_item = create_room_sub_menu (contact, chatroom);
gtk_menu_shell_append ((GtkMenuShell *) submenu, room_item);
gtk_widget_show (room_item);
}
}
if (submenu) {
gtk_menu_item_set_submenu (GTK_MENU_ITEM (item), submenu);
} else {
gtk_widget_set_sensitive (item, FALSE);
}
gtk_widget_show (image);
g_object_unref (mgr);
g_list_free (rooms);
return item;
}
static void
empathy_chat_manager_init (EmpathyChatManager *self)
{
EmpathyChatManagerPriv *priv = GET_PRIV (self);
TpAccountManager *am;
GError *error = NULL;
priv->closed_queue = g_queue_new ();
priv->messages = g_hash_table_new_full (g_str_hash, g_str_equal,
g_free, (GDestroyNotify) g_hash_table_unref);
am = tp_account_manager_dup ();
priv->chatroom_mgr = empathy_chatroom_manager_dup_singleton (NULL);
/* Text channels handler */
priv->handler = tp_simple_handler_new_with_am (am, FALSE, FALSE,
EMPATHY_CHAT_BUS_NAME_SUFFIX, FALSE, handle_channels, self, NULL);
g_object_unref (am);
tp_base_client_take_handler_filter (priv->handler, tp_asv_new (
TP_PROP_CHANNEL_CHANNEL_TYPE, G_TYPE_STRING, TP_IFACE_CHANNEL_TYPE_TEXT,
TP_PROP_CHANNEL_TARGET_HANDLE_TYPE, G_TYPE_UINT, TP_HANDLE_TYPE_CONTACT,
NULL));
tp_base_client_take_handler_filter (priv->handler, tp_asv_new (
TP_PROP_CHANNEL_CHANNEL_TYPE, G_TYPE_STRING, TP_IFACE_CHANNEL_TYPE_TEXT,
TP_PROP_CHANNEL_TARGET_HANDLE_TYPE, G_TYPE_UINT, TP_HANDLE_TYPE_ROOM,
NULL));
tp_base_client_take_handler_filter (priv->handler, tp_asv_new (
TP_PROP_CHANNEL_CHANNEL_TYPE, G_TYPE_STRING, TP_IFACE_CHANNEL_TYPE_TEXT,
TP_PROP_CHANNEL_TARGET_HANDLE_TYPE, G_TYPE_UINT, TP_HANDLE_TYPE_NONE,
NULL));
if (!tp_base_client_register (priv->handler, &error))
{
g_critical ("Failed to register text handler: %s", error->message);
g_error_free (error);
}
}
int
main (int argc, char *argv[])
{
guint32 startup_timestamp;
EmpathyStatusIcon *icon;
EmpathyDispatcher *dispatcher;
EmpathyChatroomManager *chatroom_manager;
EmpathyCallFactory *call_factory;
GtkWidget *window;
MissionControl *mc;
EmpathyIdle *idle;
gboolean autoconnect = TRUE;
gboolean no_connect = FALSE;
gboolean hide_contact_list = FALSE;
gboolean accounts_dialog = FALSE;
GError *error = NULL;
GOptionEntry options[] = {
{ "no-connect", 'n',
0, G_OPTION_ARG_NONE, &no_connect,
N_("Don't connect on startup"),
NULL },
{ "hide-contact-list", 'h',
0, G_OPTION_ARG_NONE, &hide_contact_list,
N_("Don't show the contact list on startup"),
NULL },
{ "accounts", 'a',
0, G_OPTION_ARG_NONE, &accounts_dialog,
N_("Show the accounts dialog"),
NULL },
{ "version", 'v',
G_OPTION_FLAG_NO_ARG, G_OPTION_ARG_CALLBACK, show_version_cb, NULL, NULL },
{ NULL }
};
/* Init */
g_thread_init (NULL);
empathy_init ();
if (!gtk_init_with_args (&argc, &argv,
N_("- Empathy Instant Messenger"),
options, GETTEXT_PACKAGE, &error)) {
g_warning ("Error in empathy init: %s", error->message);
return EXIT_FAILURE;
}
empathy_gtk_init ();
g_set_application_name (_(PACKAGE_NAME));
gst_init (&argc, &argv);
gtk_window_set_default_icon_name ("empathy");
textdomain (GETTEXT_PACKAGE);
/* Setting up the bacon connection */
startup_timestamp = get_startup_timestamp ();
connection = bacon_message_connection_new ("empathy");
if (connection != NULL) {
if (!bacon_message_connection_get_is_server (connection)) {
gchar *message;
if (accounts_dialog) {
DEBUG ("Showing accounts dialog from existing Empathy instance");
message = g_strdup ("accounts");
} else {
DEBUG ("Activating existing instance");
message = g_strdup_printf ("%" G_GUINT32_FORMAT,
startup_timestamp);
}
bacon_message_connection_send (connection, message);
/* We never popup a window, so tell startup-notification
* that we are done. */
gdk_notify_startup_complete ();
g_free (message);
bacon_message_connection_free (connection);
return EXIT_SUCCESS;
}
} else {
g_warning ("Cannot create the 'empathy' bacon connection.");
}
/* Setting up MC */
mc = empathy_mission_control_dup_singleton ();
g_signal_connect (mc, "ServiceEnded",
G_CALLBACK (service_ended_cb),
NULL);
g_signal_connect (mc, "Error",
G_CALLBACK (operation_error_cb),
NULL);
if (accounts_dialog) {
GtkWidget *dialog;
dialog = empathy_accounts_dialog_show (NULL, NULL);
g_signal_connect (dialog, "destroy",
G_CALLBACK (gtk_main_quit),
NULL);
gtk_main ();
return 0;
}
/* Setting up Idle */
idle = empathy_idle_dup_singleton ();
empathy_idle_set_auto_away (idle, TRUE);
use_nm_notify_cb (empathy_conf_get (), EMPATHY_PREFS_USE_NM, idle);
empathy_conf_notify_add (empathy_conf_get (), EMPATHY_PREFS_USE_NM,
use_nm_notify_cb, idle);
/* Autoconnect */
empathy_conf_get_bool (empathy_conf_get(),
EMPATHY_PREFS_AUTOCONNECT,
&autoconnect);
if (autoconnect && ! no_connect &&
empathy_idle_get_state (idle) <= MC_PRESENCE_OFFLINE) {
empathy_idle_set_state (idle, MC_PRESENCE_AVAILABLE);
}
create_salut_account ();
/* Setting up UI */
window = empathy_main_window_show ();
icon = empathy_status_icon_new (GTK_WINDOW (window), hide_contact_list);
if (connection) {
/* We se the callback here because we need window */
bacon_message_connection_set_callback (connection,
on_bacon_message_received,
window);
}
/* Handle channels */
dispatcher = empathy_dispatcher_dup_singleton ();
g_signal_connect (dispatcher, "dispatch", G_CALLBACK (dispatch_cb), NULL);
chatroom_manager = empathy_chatroom_manager_dup_singleton (NULL);
empathy_chatroom_manager_observe (chatroom_manager, dispatcher);
notify_init (_(PACKAGE_NAME));
/* Create the call factory */
call_factory = empathy_call_factory_initialise ();
g_signal_connect (G_OBJECT (call_factory), "new-call-handler",
G_CALLBACK (new_call_handler_cb), NULL);
gtk_main ();
empathy_idle_set_state (idle, MC_PRESENCE_OFFLINE);
g_object_unref (mc);
g_object_unref (idle);
g_object_unref (icon);
g_object_unref (dispatcher);
g_object_unref (chatroom_manager);
notify_uninit ();
return EXIT_SUCCESS;
}
int
main (int argc, char *argv[])
{
#if HAVE_GEOCLUE
EmpathyLocationManager *location_manager = NULL;
#endif
EmpathyStatusIcon *icon;
EmpathyDispatcher *dispatcher;
TpAccountManager *account_manager;
EmpathyLogManager *log_manager;
EmpathyChatroomManager *chatroom_manager;
EmpathyCallFactory *call_factory;
EmpathyFTFactory *ft_factory;
GtkWidget *window;
EmpathyIdle *idle;
EmpathyConnectivity *connectivity;
GError *error = NULL;
TpDBusDaemon *dbus_daemon;
UniqueApp *unique_app;
gboolean chatroom_manager_ready;
GOptionContext *optcontext;
GOptionEntry options[] = {
{ "no-connect", 'n',
0, G_OPTION_ARG_NONE, &no_connect,
N_("Don't connect on startup"),
NULL },
{ "start-hidden", 'h',
0, G_OPTION_ARG_NONE, &start_hidden,
N_("Don't display the contact list or any other dialogs on startup"),
NULL },
{ "accounts", 'a',
0, G_OPTION_ARG_NONE, &account_dialog_only,
N_("Show the accounts dialog"),
NULL },
{ "version", 'v',
G_OPTION_FLAG_NO_ARG, G_OPTION_ARG_CALLBACK, show_version_cb,
NULL, NULL },
{ NULL }
};
/* Init */
g_thread_init (NULL);
empathy_init ();
optcontext = g_option_context_new (N_("- Empathy IM Client"));
g_option_context_add_group (optcontext, gst_init_get_option_group ());
g_option_context_add_group (optcontext, gtk_get_option_group (TRUE));
g_option_context_add_main_entries (optcontext, options, GETTEXT_PACKAGE);
if (!g_option_context_parse (optcontext, &argc, &argv, &error)) {
g_print ("%s\nRun '%s --help' to see a full list of available command line options.\n",
error->message, argv[0]);
g_warning ("Error in empathy init: %s", error->message);
return EXIT_FAILURE;
}
g_option_context_free (optcontext);
empathy_gtk_init ();
g_set_application_name (_(PACKAGE_NAME));
g_setenv ("PULSE_PROP_media.role", "phone", TRUE);
#if HAVE_LIBCHAMPLAIN
gtk_clutter_init (&argc, &argv);
#endif
gtk_window_set_default_icon_name ("empathy");
textdomain (GETTEXT_PACKAGE);
#ifdef ENABLE_DEBUG
/* Set up debugger */
g_log_set_default_handler (default_log_handler, NULL);
#endif
unique_app = unique_app_new_with_commands ("org.gnome.Empathy",
NULL, "accounts_dialog", COMMAND_ACCOUNTS_DIALOG, NULL);
if (unique_app_is_running (unique_app))
{
unique_app_send_message (unique_app, account_dialog_only ?
COMMAND_ACCOUNTS_DIALOG : UNIQUE_ACTIVATE, NULL);
g_object_unref (unique_app);
return EXIT_SUCCESS;
}
/* Take well-known name */
dbus_daemon = tp_dbus_daemon_dup (&error);
if (error == NULL)
{
if (!tp_dbus_daemon_request_name (dbus_daemon,
"org.gnome.Empathy", TRUE, &error))
{
DEBUG ("Failed to request well-known name: %s",
error ? error->message : "no message");
g_clear_error (&error);
}
g_object_unref (dbus_daemon);
}
else
{
DEBUG ("Failed to dup dbus daemon: %s",
error ? error->message : "no message");
g_clear_error (&error);
}
if (account_dialog_only)
{
account_manager = tp_account_manager_dup ();
show_accounts_ui (NULL, TRUE);
gtk_main ();
g_object_unref (account_manager);
return 0;
}
notify_init (_(PACKAGE_NAME));
/* Setting up Idle */
idle = empathy_idle_dup_singleton ();
empathy_idle_set_auto_away (idle, TRUE);
/* Setting up Connectivity */
connectivity = empathy_connectivity_dup_singleton ();
use_conn_notify_cb (empathy_conf_get (), EMPATHY_PREFS_USE_CONN,
connectivity);
empathy_conf_notify_add (empathy_conf_get (), EMPATHY_PREFS_USE_CONN,
use_conn_notify_cb, connectivity);
/* account management */
account_manager = tp_account_manager_dup ();
tp_account_manager_prepare_async (account_manager, NULL,
account_manager_ready_cb, NULL);
/* Handle channels */
dispatcher = setup_dispatcher ();
g_signal_connect (dispatcher, "dispatch", G_CALLBACK (dispatch_cb), NULL);
migrate_config_to_xdg_dir ();
/* Setting up UI */
window = empathy_main_window_show ();
icon = empathy_status_icon_new (GTK_WINDOW (window), start_hidden);
g_signal_connect (unique_app, "message-received",
G_CALLBACK (unique_app_message_cb), window);
/* Logging */
log_manager = empathy_log_manager_dup_singleton ();
empathy_log_manager_observe (log_manager, dispatcher);
chatroom_manager = empathy_chatroom_manager_dup_singleton (NULL);
empathy_chatroom_manager_observe (chatroom_manager, dispatcher);
g_object_get (chatroom_manager, "ready", &chatroom_manager_ready, NULL);
if (!chatroom_manager_ready)
{
g_signal_connect (G_OBJECT (chatroom_manager), "notify::ready",
G_CALLBACK (chatroom_manager_ready_cb), account_manager);
}
else
{
chatroom_manager_ready_cb (chatroom_manager, NULL, account_manager);
}
/* Create the call factory */
call_factory = empathy_call_factory_initialise ();
g_signal_connect (G_OBJECT (call_factory), "new-call-handler",
G_CALLBACK (new_call_handler_cb), NULL);
/* Create the FT factory */
ft_factory = empathy_ft_factory_dup_singleton ();
g_signal_connect (ft_factory, "new-ft-handler",
G_CALLBACK (new_ft_handler_cb), NULL);
g_signal_connect (ft_factory, "new-incoming-transfer",
G_CALLBACK (new_incoming_transfer_cb), NULL);
/* Location mananger */
#if HAVE_GEOCLUE
location_manager = empathy_location_manager_dup_singleton ();
#endif
gtk_main ();
empathy_idle_set_state (idle, TP_CONNECTION_PRESENCE_TYPE_OFFLINE);
g_object_unref (idle);
g_object_unref (connectivity);
g_object_unref (icon);
g_object_unref (account_manager);
g_object_unref (log_manager);
g_object_unref (dispatcher);
g_object_unref (chatroom_manager);
#if HAVE_GEOCLUE
g_object_unref (location_manager);
#endif
g_object_unref (ft_factory);
g_object_unref (unique_app);
notify_uninit ();
return EXIT_SUCCESS;
}
void
empathy_chatrooms_window_show (GtkWindow *parent)
{
static EmpathyChatroomsWindow *window = NULL;
GtkBuilder *gui;
gchar *filename;
if (window) {
gtk_window_present (GTK_WINDOW (window->window));
return;
}
window = g_new0 (EmpathyChatroomsWindow, 1);
filename = empathy_file_lookup ("empathy-chatrooms-window.ui", "src");
gui = empathy_builder_get_file (filename,
"chatrooms_window", &window->window,
"hbox_account", &window->hbox_account,
"label_account", &window->label_account,
"treeview", &window->treeview,
"button_remove", &window->button_remove,
"button_close", &window->button_close,
NULL);
g_free (filename);
empathy_builder_connect (gui, window,
"chatrooms_window", "destroy", chatrooms_window_destroy_cb,
"button_remove", "clicked", chatrooms_window_button_remove_clicked_cb,
"button_close", "clicked", chatrooms_window_button_close_clicked_cb,
NULL);
g_object_unref (gui);
g_object_add_weak_pointer (G_OBJECT (window->window), (gpointer) &window);
/* Get the session and chat room manager */
window->manager = empathy_chatroom_manager_dup_singleton (NULL);
g_signal_connect (window->manager, "chatroom-added",
G_CALLBACK (chatrooms_window_chatroom_added_cb),
window);
g_signal_connect (window->manager, "chatroom-removed",
G_CALLBACK (chatrooms_window_chatroom_removed_cb),
window);
/* Account chooser for chat rooms */
window->account_chooser = empathy_account_chooser_new ();
empathy_account_chooser_set_filter (EMPATHY_ACCOUNT_CHOOSER (window->account_chooser),
empathy_account_chooser_filter_is_connected,
NULL);
g_object_set (window->account_chooser,
"has-all-option", TRUE,
NULL);
empathy_account_chooser_set_account (EMPATHY_ACCOUNT_CHOOSER (window->account_chooser), NULL);
gtk_box_pack_start (GTK_BOX (window->hbox_account),
window->account_chooser,
TRUE, TRUE, 0);
g_signal_connect (window->account_chooser, "changed",
G_CALLBACK (chatrooms_window_account_changed_cb),
window);
gtk_widget_show (window->account_chooser);
/* Set up chatrooms */
chatrooms_window_model_setup (window);
/* Set focus */
gtk_widget_grab_focus (window->treeview);
/* Last touches */
if (parent) {
gtk_window_set_transient_for (GTK_WINDOW (window->window),
GTK_WINDOW (parent));
}
gtk_widget_show (window->window);
}
END_TEST
START_TEST (test_empathy_chatroom_manager_change_chatroom)
{
EmpathyChatroomManager *mgr;
gchar *file;
EmpathyAccount *account;
EmpathyAccountManager *account_manager;
struct chatroom_t chatrooms[] = {
{ "name1", "room1", TRUE, TRUE },
{ "name2", "room2", FALSE, TRUE }};
EmpathyChatroom *chatroom;
account_manager = empathy_account_manager_dup_singleton ();
account = get_test_account ();
copy_xml_file (CHATROOM_SAMPLE, "foo.xml");
file = get_user_xml_file ("foo.xml");
/* change the chatrooms XML file to use the account we just created */
fail_unless (change_account_name_in_file (account, file));
mgr = empathy_chatroom_manager_dup_singleton (file);
check_chatrooms_list (mgr, account, chatrooms, 2);
/* change room2 name */
chatroom = empathy_chatroom_manager_find (mgr, account, "room2");
fail_if (chatroom == NULL);
empathy_chatroom_set_name (chatroom, "new_name");
/* reload chatrooms file */
g_object_unref (mgr);
mgr = empathy_chatroom_manager_dup_singleton (file);
chatrooms[1].name = "new_name";
check_chatrooms_list (mgr, account, chatrooms, 2);
/* change room2 auto-connect status */
chatroom = empathy_chatroom_manager_find (mgr, account, "room2");
fail_if (chatroom == NULL);
empathy_chatroom_set_auto_connect (chatroom, TRUE);
/* reload chatrooms file */
g_object_unref (mgr);
mgr = empathy_chatroom_manager_dup_singleton (file);
chatrooms[1].auto_connect = TRUE;
check_chatrooms_list (mgr, account, chatrooms, 2);
/* change room2 room */
chatroom = empathy_chatroom_manager_find (mgr, account, "room2");
fail_if (chatroom == NULL);
empathy_chatroom_set_room (chatroom, "new_room");
/* reload chatrooms file */
g_object_unref (mgr);
mgr = empathy_chatroom_manager_dup_singleton (file);
chatrooms[1].room = "new_room";
check_chatrooms_list (mgr, account, chatrooms, 2);
g_object_unref (mgr);
g_free (file);
g_object_unref (account);
g_object_unref (account_manager);
}
END_TEST
START_TEST (test_empathy_chatroom_manager_change_favorite)
{
EmpathyChatroomManager *mgr;
gchar *file;
EmpathyAccount *account;
EmpathyAccountManager *account_manager;
struct chatroom_t chatrooms[] = {
{ "name1", "room1", TRUE, TRUE },
{ "name2", "room2", FALSE, FALSE }};
EmpathyChatroom *chatroom;
account_manager = empathy_account_manager_dup_singleton ();
account = get_test_account ();
copy_xml_file (CHATROOM_SAMPLE, CHATROOM_FILE);
file = get_user_xml_file (CHATROOM_FILE);
/* change the chatrooms XML file to use the account we just created */
fail_unless (change_account_name_in_file (account, file));
mgr = empathy_chatroom_manager_dup_singleton (file);
/* room2 is not favorite anymore */
chatroom = empathy_chatroom_manager_find (mgr, account, "room2");
fail_if (chatroom == NULL);
g_object_set (chatroom, "favorite", FALSE, NULL);
check_chatrooms_list (mgr, account, chatrooms, 2);
/* reload chatrooms file */
g_object_unref (mgr);
mgr = empathy_chatroom_manager_dup_singleton (file);
/* room2 is not present in the XML file anymore as it's not a favorite */
check_chatrooms_list (mgr, account, chatrooms, 1);
/* re-add room2 */
chatroom = empathy_chatroom_new_full (account, "room2", "name2", FALSE);
empathy_chatroom_manager_add (mgr, chatroom);
check_chatrooms_list (mgr, account, chatrooms, 2);
/* set room2 as favorite */
g_object_set (chatroom, "favorite", TRUE, NULL);
chatrooms[1].favorite = TRUE;
check_chatrooms_list (mgr, account, chatrooms, 2);
/* reload chatrooms file */
g_object_unref (mgr);
mgr = empathy_chatroom_manager_dup_singleton (file);
/* room2 is back in the XML file now */
check_chatrooms_list (mgr, account, chatrooms, 2);
g_object_unref (mgr);
g_object_unref (chatroom);
g_free (file);
g_object_unref (account_manager);
g_object_unref (account);
}
END_TEST
START_TEST (test_empathy_chatroom_manager_add)
{
EmpathyChatroomManager *mgr;
gchar *file;
EmpathyAccount *account;
EmpathyAccountManager *account_manager;
struct chatroom_t chatrooms[] = {
{ "name1", "room1", TRUE, TRUE },
{ "name2", "room2", FALSE, TRUE },
{ "name3", "room3", FALSE, TRUE },
{ "name4", "room4", FALSE, FALSE }};
EmpathyChatroom *chatroom;
account_manager = empathy_account_manager_dup_singleton ();
account = get_test_account ();
copy_xml_file (CHATROOM_SAMPLE, CHATROOM_FILE);
file = get_user_xml_file (CHATROOM_FILE);
/* change the chatrooms XML file to use the account we just created */
fail_unless (change_account_name_in_file (account, file));
mgr = empathy_chatroom_manager_dup_singleton (file);
/* add a favorite chatroom */
chatroom = empathy_chatroom_new_full (account, "room3", "name3", FALSE);
g_object_set (chatroom, "favorite", TRUE, NULL);
empathy_chatroom_manager_add (mgr, chatroom);
g_object_unref (chatroom);
check_chatrooms_list (mgr, account, chatrooms, 3);
/* reload chatrooms file */
g_object_unref (mgr);
mgr = empathy_chatroom_manager_dup_singleton (file);
/* chatroom has been added to the XML file as it's a favorite */
check_chatrooms_list (mgr, account, chatrooms, 3);
/* add a non favorite chatroom */
chatroom = empathy_chatroom_new_full (account, "room4", "name4", FALSE);
g_object_set (chatroom, "favorite", FALSE, NULL);
empathy_chatroom_manager_add (mgr, chatroom);
g_object_unref (chatroom);
check_chatrooms_list (mgr, account, chatrooms, 4);
/* reload chatrooms file */
g_object_unref (mgr);
mgr = empathy_chatroom_manager_dup_singleton (file);
/* chatrooms has not been added to the XML file */
check_chatrooms_list (mgr, account, chatrooms, 3);
g_object_unref (mgr);
g_free (file);
g_object_unref (account_manager);
g_object_unref (account);
}
