path: root/tests/backend-dbus/test-users.cc

/*
 * Copyright 2013 Canonical Ltd.
 *
 * Authors:
 *   Charles Kerr <charles.kerr@canonical.com>
 *
 * This program is free software: you can redistribute it and/or modify it
 * under the terms of the GNU General Public License version 3, as published
 * by the Free Software Foundation.
 *
 * This program is distributed in the hope that it will be useful, but
 * WITHOUT ANY WARRANTY; without even the implied warranties of
 * MERCHANTABILITY, SATISFACTORY QUALITY, 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, see <http://www.gnu.org/licenses/>.
 */

#include "gtest-mock-dbus-fixture.h"

#include "backend.h"
#include "backend-dbus/backend-dbus.h"

/***
****
***/

class Users: public GTestMockDBusFixture
{
  private:

    typedef GTestMockDBusFixture super;

  protected:

    GCancellable * cancellable;
    IndicatorSessionUsers * users;

    virtual void SetUp ()
    {
      super :: SetUp ();

      init_event_keys (0);

      // init 'users'
      cancellable = g_cancellable_new ();
      users = 0;
      backend_get (cancellable, NULL, &users, NULL);
      g_assert (users != 0);
      wait_msec (100);
    }

    virtual void TearDown ()
    {
      g_cancellable_cancel (cancellable);
      g_clear_object (&cancellable);
      g_clear_object (&users);

      super :: TearDown ();
    }

  protected:

    void compare_user (const MockUser * mu, const IndicatorSessionUser * isu, const std::string& user_state)
    {
      ASSERT_EQ (user_state, login1_seat->user_state (mu->uid()));
      ASSERT_EQ (mu->uid(), isu->uid);
      ASSERT_EQ (mu->login_frequency(), isu->login_frequency);
      ASSERT_STREQ (mu->username(), isu->user_name);
      ASSERT_STREQ (mu->realname(), isu->real_name);
      ASSERT_EQ (mu->uid(), isu->uid);
      ASSERT_EQ (user_state!="offline", isu->is_logged_in);
      ASSERT_EQ (user_state=="active", isu->is_current_user);
    }

    void compare_user (const MockUser * mu, const std::string& key, const std::string& user_state)
    {
      IndicatorSessionUser * isu;
      isu = indicator_session_users_get_user (users, key.c_str());
      compare_user (mu, isu, user_state);
      indicator_session_user_free (isu);
    }

  private:

    void init_event_keys (size_t n)
    {
      expected_event_count = n;
      event_keys.clear();
    }

    static gboolean
    wait_for_signals__timeout (gpointer name)
    {
      g_error ("%s: timed out waiting for signal '%s'", G_STRLOC, (char*)name);
      return G_SOURCE_REMOVE;
    }

    static void
    wait_for_signals__event (IndicatorSessionUser * u G_GNUC_UNUSED,
                            const char            * key,
                            gpointer                gself)
    {
      Users * self = static_cast<Users*>(gself);

      self->event_keys.push_back (key);

      if (self->event_keys.size() == self->expected_event_count)
        g_main_loop_quit (self->loop);
    }

  protected:

    std::vector<std::string> event_keys;
    size_t expected_event_count;

    void wait_for_signals (gpointer o, const gchar * name, size_t n)
    {
      const int timeout_seconds = 5; // arbitrary

      init_event_keys (n);

      guint handler_id = g_signal_connect (o, name,
                                           G_CALLBACK(wait_for_signals__event),
                                           this);
      gulong timeout_id = g_timeout_add_seconds (timeout_seconds,
                                                 wait_for_signals__timeout,
                                                 (gpointer)name);
      g_main_loop_run (loop);
      g_source_remove (timeout_id);
      g_signal_handler_disconnect (o, handler_id);
    }
};

/***
****
***/

/**
 * Confirm that the fixture's SetUp() and TearDown() work
 */
TEST_F (Users, HelloWorld)
{
  ASSERT_TRUE (true);
}

/**
 * Confirm that 'users' can get the cached users from our Mock Accounts
 */
TEST_F (Users, InitialUsers)
{
  GStrv keys = indicator_session_users_get_keys (users);

  ASSERT_EQ (12, g_strv_length (keys));

  for (int i=0; keys && keys[i]; ++i)
    {
      IndicatorSessionUser * isu = indicator_session_users_get_user (users, keys[i]);
      MockUser * mu = accounts->find_by_uid (isu->uid);
      compare_user (mu, isu, login1_seat->user_state (isu->uid));
      indicator_session_user_free (isu);
    }

  g_strfreev (keys);
}

/**
 * Confirm that 'users' can tell when a new user is added
 */
TEST_F (Users, UserAdded)
{
  MockUser * mu;

  mu = new MockUser (loop, conn, "pcushing", "Peter Cushing", 2);
  accounts->add_user (mu);
  ASSERT_EQ (0, event_keys.size());
  wait_for_signals (users, INDICATOR_SESSION_USERS_SIGNAL_USER_ADDED, 1);
  ASSERT_EQ (1, event_keys.size());
  compare_user (mu, event_keys[0], "offline");
}

/**
 * Confirm that 'users' can tell when a user is removed
 */
TEST_F (Users, UserRemoved)
{
  MockUser * mu = accounts->find_by_username ("pdavison");

  /* confirm that users knows about pdavison */
  bool found = false;
  GStrv keys = indicator_session_users_get_keys (users);
  ASSERT_EQ (12, g_strv_length (keys));
  for (int i=0; !found && keys && keys[i]; i++)
    {
      IndicatorSessionUser * isu = indicator_session_users_get_user (users, keys[i]);
      found = isu->uid == mu->uid();
      indicator_session_user_free (isu);
    }
  g_strfreev (keys);
  ASSERT_TRUE (found);

  /* on the bus, remove pdavison. */
  accounts->remove_user (mu);

  /* now, users should emit a 'user removed' signal... */
  ASSERT_EQ (0, event_keys.size());
  wait_for_signals (users, INDICATOR_SESSION_USERS_SIGNAL_USER_REMOVED, 1);
  ASSERT_EQ (1, event_keys.size());

  /* confirm that users doesn't know about pdavison */
  keys = indicator_session_users_get_keys (users);
  ASSERT_EQ (11, g_strv_length (keys));
  for (int i=0; keys && keys[i]; i++)
    {
      IndicatorSessionUser * isu = indicator_session_users_get_user (users, keys[i]);
      ASSERT_NE (event_keys[0], keys[i]);
      ASSERT_NE (mu->uid(), isu->uid);
      indicator_session_user_free (isu);
    }
  g_strfreev (keys);

  delete mu;
}

/**
 * Confirm that 'users' notices when a user's real name changes
 */
TEST_F (Users, RealnameChanged)
{
  MockUser * mu;

  mu = accounts->find_by_username ("pdavison");
  const char * const realname = "Peter M. G. Moffett";
  mu->set_realname (realname);
  ASSERT_NE (mu->realname(), realname);
  ASSERT_STREQ (mu->realname(), realname);
  wait_for_signals (users, INDICATOR_SESSION_USERS_SIGNAL_USER_CHANGED, 1);
  ASSERT_EQ (1, event_keys.size());
  compare_user (mu, event_keys[0], "offline");
}

/**
 * Confirm that 'users' notices when users log in and out
 */
TEST_F (Users, LogInLogOut)
{
  // The fist doctor logs in.
  // Confirm that 'users' notices.
  MockUser * mu = accounts->find_by_username ("whartnell");
  ASSERT_EQ (login1_seat->user_state (mu->uid()), "offline");
  const int session_tag = login1_manager->add_session (login1_seat, mu);
  wait_for_signals (users, INDICATOR_SESSION_USERS_SIGNAL_USER_CHANGED, 1);
  ASSERT_EQ (1, event_keys.size());
  compare_user (mu, event_keys[0], "online");

  // The first doctor logs out.
  // Confirm that 'users' notices.
  login1_manager->remove_session (login1_seat, session_tag);
  wait_for_signals (users, INDICATOR_SESSION_USERS_SIGNAL_USER_CHANGED, 1);
  ASSERT_EQ (1, event_keys.size());
  compare_user (mu, event_keys[0], "offline");
}

/**
 * Confirm that 'users' notices when the active session changes
 */
TEST_F (Users, ActivateSession)
{
  // confirm preconditions: msmith is active, msmith is offline
  MockUser * const whartnell = accounts->find_by_username ("whartnell");
  ASSERT_EQ (login1_seat->user_state (whartnell->uid()), "offline");
  MockUser * const msmith = accounts->find_by_username ("msmith");
  ASSERT_EQ (login1_seat->user_state (msmith->uid()), "active");

  // whartnell logs in... confirm that 'users' notices
  login1_manager->add_session (login1_seat, whartnell);
  wait_for_signals (users, INDICATOR_SESSION_USERS_SIGNAL_USER_CHANGED, 1);
  ASSERT_EQ (1, event_keys.size());
  compare_user (whartnell, event_keys[0], "online");

  // activate whartnell's session... confirm that 'users' sees:
  //  1. msmith changes from 'active' to 'online'
  //  2. whartnell changes from 'online' to 'active'
  login1_seat->switch_to_user (whartnell->username());
  wait_for_signals (users, INDICATOR_SESSION_USERS_SIGNAL_USER_CHANGED, 2);
  ASSERT_EQ (2, event_keys.size());
  compare_user (msmith, event_keys[0], "online");
  compare_user (whartnell, event_keys[1], "active");

  // reverse the test
  login1_seat->switch_to_user (msmith->username());
  wait_for_signals (users, INDICATOR_SESSION_USERS_SIGNAL_USER_CHANGED, 2);
  ASSERT_EQ (2, event_keys.size());
  compare_user (whartnell, event_keys[0], "online");
  compare_user (msmith, event_keys[1], "active");
}

#if 0
/**
 * Confirm that we can change the active session via users' API.
 * This is nearly the same as ActivateSession but uses users' API
 */
TEST_F (Users, ActivateUser)
{
  // The fist doctor logs in.
  // Confirm that 'users' notices.
  MockUser * mu = accounts->find_by_username ("whartnell");
  compare_user (mu->path(), mu, false, false);
  MockConsoleKitSession * session = ck_seat->add_session_by_user (mu);
  wait_for_signals (users, INDICATOR_SESSION_USERS_SIGNAL_USER_CHANGED, 1);
  ASSERT_STREQ (mu->path(), event_keys[0].c_str());
  compare_user (mu->path(), mu, true, false);

  // activate the first doctor's session.
  // confirm that 'users' sees he's active and that ck_session isn't.
  // this should come in the form of two 'user-changed' events
  indicator_session_users_activate_user (users, mu->path());
  ck_seat->activate_session (session);
  wait_for_signals (users, INDICATOR_SESSION_USERS_SIGNAL_USER_CHANGED, 2);
  ASSERT_EQ (2, event_keys.size());
  compare_user (event_keys[0], ck_session->user(), true, false);
  compare_user (event_keys[1], mu, true, true);

  // switch back to the previous
  // confirm that 'users' sees it's active and the first doctor's session isn't
  // this should come in the form of two 'user-changed' events
  indicator_session_users_activate_user (users, ck_session->user()->path());
  ck_seat->activate_session (ck_session);
  wait_for_signals (users, INDICATOR_SESSION_USERS_SIGNAL_USER_CHANGED, 2);
  ASSERT_EQ (2, event_keys.size());
  compare_user (event_keys[0], mu, true, false);
  compare_user (event_keys[1], ck_session->user(), true, true);
}

/**
 * Confirm that adding a Guest doesn't show up in the users list
 */
TEST_F (Users, UnwantedGuest)
{
  GStrv keys;

  keys = indicator_session_users_get_keys (users);
  const size_t n = g_strv_length (keys);
  g_strfreev (keys);

  MockUser * mu = new MockUser (loop, conn, "guest-jjbEVV", "Guest", 1);
  mu->set_system_account (true);
  accounts->add_user (mu);
  wait_msec (50);

  keys = indicator_session_users_get_keys (users);
  ASSERT_EQ (n, g_strv_length (keys));
  g_strfreev (keys);
}


/**
 * Confirm that we can detect live sessions
 */
TEST_F (Users, LiveSession)
{
  gboolean b;

  // not initially a live session
  ASSERT_FALSE (indicator_session_users_is_live_session (users));
  g_object_get (users, INDICATOR_SESSION_USERS_PROP_IS_LIVE_SESSION, &b, NULL);
  ASSERT_FALSE (b);

  // now add the criteria for a live session
  MockUser * live_user = new MockUser (loop, conn, "ubuntu", "Ubuntu", 1, 999);
  live_user->set_system_account (true);
  accounts->add_user (live_user);
  MockConsoleKitSession * session = ck_seat->add_session_by_user (live_user);
  wait_msec (100);
  ck_seat->activate_session (session);
  wait_for_signal (users, "notify::" INDICATOR_SESSION_USERS_PROP_IS_LIVE_SESSION);

  // confirm the backend thinks it's a live session
  ASSERT_TRUE (indicator_session_users_is_live_session (users));
  g_object_get (users, INDICATOR_SESSION_USERS_PROP_IS_LIVE_SESSION, &b, NULL);
  ASSERT_TRUE (b);
}
#endif