← Back to branch summary

~unity8-desktop-session-team/indicator-session/indicator-session-using-upstart

« back to all changes in this revision

Viewing changes to tests/backend-dbus/test-users.cc

  • Committer: Charles Kerr
  • Date: 2013-06-25 16:16:34 UTC
  • mto: This revision was merged to the branch mainline in revision 399.
  • Revision ID: charles.kerr@canonical.com-20130625161634-ht9ef3n5s63rnmmr
in IndicatorSessionUsers, use the uid as the user's key. Users.ActivateUser is now green.

Show diffs side-by-side

added added

removed removed

Lines of Context:
tests/backend-dbus/test-users.cc
74
74
      ASSERT_EQ (user_state=="active", isu->is_current_user);
75
75
    }
76
76
 
77
 
    void compare_user (const MockUser * mu, const std::string& key, const std::string& user_state)
 
77
    void compare_user (const MockUser * mu, guint uid, const std::string& user_state)
78
78
    {
79
79
      IndicatorSessionUser * isu;
80
 
      isu = indicator_session_users_get_user (users, key.c_str());
 
80
      isu = indicator_session_users_get_user (users, uid);
 
81
      compare_user (mu, isu, user_state);
 
82
      indicator_session_user_free (isu);
 
83
    }
 
84
 
 
85
    void compare_user (guint uid, const std::string& user_state)
 
86
    {
 
87
      IndicatorSessionUser * isu = indicator_session_users_get_user (users, uid);
 
88
      MockUser * mu = accounts->find_by_uid (uid);
81
89
      compare_user (mu, isu, user_state);
82
90
      indicator_session_user_free (isu);
83
91
    }
99
107
 
100
108
    static void
101
109
    wait_for_signals__event (IndicatorSessionUser * u G_GNUC_UNUSED,
102
 
                            const char            * key,
103
 
                            gpointer                gself)
 
110
                             guint                  uid,
 
111
                             gpointer               gself)
104
112
    {
105
113
      Users * self = static_cast<Users*>(gself);
106
114
 
107
 
      self->event_keys.push_back (key);
 
115
      self->event_keys.push_back (uid);
108
116
 
109
117
      if (self->event_keys.size() == self->expected_event_count)
110
118
        g_main_loop_quit (self->loop);
112
120
 
113
121
  protected:
114
122
 
115
 
    std::vector<std::string> event_keys;
 
123
    std::vector<guint> event_keys;
116
124
    size_t expected_event_count;
117
125
 
118
126
    void wait_for_signals (gpointer o, const gchar * name, size_t n)
150
158
 */
151
159
TEST_F (Users, InitialUsers)
152
160
{
153
 
  GStrv keys = indicator_session_users_get_keys (users);
154
 
 
155
 
  ASSERT_EQ (12, g_strv_length (keys));
156
 
 
157
 
  for (int i=0; keys && keys[i]; ++i)
 
161
  GList * l;
 
162
  GList * uids = indicator_session_users_get_uids (users);
 
163
 
 
164
  ASSERT_EQ (12, g_list_length (uids));
 
165
 
 
166
  for (l=uids; l!=NULL; l=l->next)
158
167
    {
159
 
      IndicatorSessionUser * isu = indicator_session_users_get_user (users, keys[i]);
160
 
      MockUser * mu = accounts->find_by_uid (isu->uid);
161
 
      compare_user (mu, isu, login1_seat->user_state (isu->uid));
162
 
      indicator_session_user_free (isu);
 
168
      const guint uid = GPOINTER_TO_UINT (l->data);
 
169
      compare_user (uid, login1_seat->user_state (uid));
163
170
    }
164
171
 
165
 
  g_strfreev (keys);
 
172
  g_list_free (uids);
166
173
}
167
174
 
168
175
/**
188
195
  MockUser * mu = accounts->find_by_username ("pdavison");
189
196
 
190
197
  /* confirm that users knows about pdavison */
191
 
  bool found = false;
192
 
  GStrv keys = indicator_session_users_get_keys (users);
193
 
  ASSERT_EQ (12, g_strv_length (keys));
194
 
  for (int i=0; !found && keys && keys[i]; i++)
195
 
    {
196
 
      IndicatorSessionUser * isu = indicator_session_users_get_user (users, keys[i]);
197
 
      found = isu->uid == mu->uid();
198
 
      indicator_session_user_free (isu);
199
 
    }
200
 
  g_strfreev (keys);
201
 
  ASSERT_TRUE (found);
 
198
  IndicatorSessionUser * isu = indicator_session_users_get_user (users, mu->uid());
 
199
  ASSERT_TRUE (isu != NULL);
 
200
  compare_user (mu, isu, "offline");
 
201
  g_clear_pointer (&isu, indicator_session_user_free);
202
202
 
203
203
  /* on the bus, remove pdavison. */
204
204
  accounts->remove_user (mu);
208
208
  wait_for_signals (users, INDICATOR_SESSION_USERS_SIGNAL_USER_REMOVED, 1);
209
209
  ASSERT_EQ (1, event_keys.size());
210
210
 
211
 
  /* confirm that users doesn't know about pdavison */
212
 
  keys = indicator_session_users_get_keys (users);
213
 
  ASSERT_EQ (11, g_strv_length (keys));
214
 
  for (int i=0; keys && keys[i]; i++)
215
 
    {
216
 
      IndicatorSessionUser * isu = indicator_session_users_get_user (users, keys[i]);
217
 
      ASSERT_NE (event_keys[0], keys[i]);
218
 
      ASSERT_NE (mu->uid(), isu->uid);
219
 
      indicator_session_user_free (isu);
220
 
    }
221
 
  g_strfreev (keys);
 
211
  /* confirm that users won't give us pdavison's info */
 
212
  isu = indicator_session_users_get_user (users, mu->uid());
 
213
  ASSERT_TRUE (isu == NULL);
 
214
 
 
215
  /* confirm that users won't give us pdavison's uid */
 
216
  GList * uids = indicator_session_users_get_uids (users);
 
217
  ASSERT_TRUE (g_list_find (uids, GUINT_TO_POINTER(mu->uid())) == NULL);
 
218
  g_list_free (uids);
222
219
 
223
220
  delete mu;
224
221
}
296
293
  compare_user (msmith, event_keys[1], "active");
297
294
}
298
295
 
299
 
#if 0
300
296
/**
301
297
 * Confirm that we can change the active session via users' API.
302
298
 * This is nearly the same as ActivateSession but uses users' API
303
299
 */
304
300
TEST_F (Users, ActivateUser)
305
301
{
306
 
  // The fist doctor logs in.
307
 
  // Confirm that 'users' notices.
308
 
  MockUser * mu = accounts->find_by_username ("whartnell");
309
 
  compare_user (mu->path(), mu, false, false);
310
 
  MockConsoleKitSession * session = ck_seat->add_session_by_user (mu);
 
302
  // confirm preconditions: msmith is active, msmith is offline
 
303
  MockUser * const whartnell = accounts->find_by_username ("whartnell");
 
304
  ASSERT_EQ (login1_seat->user_state (whartnell->uid()), "offline");
 
305
  MockUser * const msmith = accounts->find_by_username ("msmith");
 
306
  ASSERT_EQ (login1_seat->user_state (msmith->uid()), "active");
 
307
 
 
308
  // whartnell logs in... confirm that 'users' notices
 
309
  login1_manager->add_session (login1_seat, whartnell);
311
310
  wait_for_signals (users, INDICATOR_SESSION_USERS_SIGNAL_USER_CHANGED, 1);
312
 
  ASSERT_STREQ (mu->path(), event_keys[0].c_str());
313
 
  compare_user (mu->path(), mu, true, false);
314
 
 
315
 
  // activate the first doctor's session.
316
 
  // confirm that 'users' sees he's active and that ck_session isn't.
317
 
  // this should come in the form of two 'user-changed' events
318
 
  indicator_session_users_activate_user (users, mu->path());
319
 
  ck_seat->activate_session (session);
320
 
  wait_for_signals (users, INDICATOR_SESSION_USERS_SIGNAL_USER_CHANGED, 2);
321
 
  ASSERT_EQ (2, event_keys.size());
322
 
  compare_user (event_keys[0], ck_session->user(), true, false);
323
 
  compare_user (event_keys[1], mu, true, true);
324
 
 
325
 
  // switch back to the previous
326
 
  // confirm that 'users' sees it's active and the first doctor's session isn't
327
 
  // this should come in the form of two 'user-changed' events
328
 
  indicator_session_users_activate_user (users, ck_session->user()->path());
329
 
  ck_seat->activate_session (ck_session);
330
 
  wait_for_signals (users, INDICATOR_SESSION_USERS_SIGNAL_USER_CHANGED, 2);
331
 
  ASSERT_EQ (2, event_keys.size());
332
 
  compare_user (event_keys[0], mu, true, false);
333
 
  compare_user (event_keys[1], ck_session->user(), true, true);
 
311
  ASSERT_EQ (1, event_keys.size());
 
312
  compare_user (whartnell, event_keys[0], "online");
 
313
 
 
314
  // activate whartnell's session... confirm that 'users' sees:
 
315
  //  1. msmith changes from 'active' to 'online'
 
316
  //  2. whartnell changes from 'online' to 'active'
 
317
  indicator_session_users_activate_user (users, whartnell->uid());
 
318
  wait_for_signals (users, INDICATOR_SESSION_USERS_SIGNAL_USER_CHANGED, 2);
 
319
  ASSERT_EQ (2, event_keys.size());
 
320
  compare_user (msmith, event_keys[0], "online");
 
321
  compare_user (whartnell, event_keys[1], "active");
 
322
 
 
323
  // reverse the test
 
324
  indicator_session_users_activate_user (users, msmith->uid());
 
325
  wait_for_signals (users, INDICATOR_SESSION_USERS_SIGNAL_USER_CHANGED, 2);
 
326
  ASSERT_EQ (2, event_keys.size());
 
327
  compare_user (whartnell, event_keys[0], "online");
 
328
  compare_user (msmith, event_keys[1], "active");
334
329
}
335
330
 
 
331
#if 0
336
332
/**
337
333
 * Confirm that adding a Guest doesn't show up in the users list
338
334
 */