Revise Memberships API wrapper tests

Revise method for generating test accounts; the test accounts need to
be ‘Messaging’ licensed users (to enable the moderator functionality).

Author: cmlccie

tests/api/test_memberships.py

@@ -3,45 +3,226 @@
 """pytest Memberships functions, fixtures and tests."""
 
 
+import itertools
+
 import pytest
 
 import ciscosparkapi
 
 
 # Helper Functions
 
-def add_people_to_room(api, room, emails):
-    for email in emails:
-        api.memberships.create(room.id, personEmail=email)
+def add_person_to_room_by_email(api, room, person, isModerator=False):
+    return api.memberships.create(room.id,
+                                  personEmail=person.emails[0],
+                                  isModerator=isModerator)
+
+
+def add_person_to_room_by_id(api, room, person, isModerator=False):
+    return api.memberships.create(room.id,
+                                  personId=person.id,
+                                  isModerator=isModerator)
+
+
+def add_people_to_room_by_email(api, room, people):
+    return [add_person_to_room_by_email(api, room, person)
+            for person in people]
+
+
+def add_people_to_room_by_id(api, room, people):
+    return [add_person_to_room_by_id(api, room, person)
+            for person in people]
+
+
+def get_room_membership_list(api, room, **kwargs):
+    return list(api.memberships.list(roomId=room.id, **kwargs))
+
+
+def get_membership_by_id(api, id):
+    return api.memberships.get(id)
+
+
+def make_moderator(api, membership):
+    return api.memberships.update(membership.id, isModerator=True)
+
+
+def delete_membership(api, membership):
+    api.memberships.delete(membership.id)
 
 
 def empty_room(api, me, room):
     """Remove all memberships from a room (except the caller's membership)."""
     memberships = api.memberships.list(room.id)
     for membership in memberships:
         if membership.personId != me.id:
-            api.memberships.delete(membership.id)
+            delete_membership(api, membership)
+
+
+def is_valid_membership(membership):
+    return isinstance(membership, ciscosparkapi.Membership) \
+           and membership.id is not None
+
+
+def are_valid_memberships(iterable):
+    are_valid = (is_valid_membership(item) for item in iterable)
+    return all(are_valid)
+
+
+def membership_exists(api, membership):
+    try:
+        get_membership_by_id(api, membership.id)
+    except ciscosparkapi.SparkApiError:
+        return False
+    else:
+        return True
 
 
 # pytest Fixtures
 
 @pytest.fixture(scope="session")
-def group_room_with_members(api, me, group_room, email_addresses):
-    add_people_to_room(api, group_room, email_addresses)
-    yield group_room
-    empty_room(api, me, group_room)
+def authenticated_users_memberships(api):
+    return list(api.memberships.list())
+
+
+@pytest.fixture(scope="session")
+def my_group_room_membership(api, me, group_room):
+    memberships = get_room_membership_list(api, group_room, personId=me.id)
+    assert len(memberships) == 1
+    membership = memberships[0]
+    return membership
+
+
+@pytest.fixture(scope="session")
+def make_me_group_room_moderator(api, my_group_room_membership):
+    return make_moderator(api, my_group_room_membership)
 
 
 @pytest.fixture(scope="session")
-def team_room_with_members(api, me, team_room, email_addresses):
-    add_people_to_room(api, team_room, email_addresses)
-    yield team_room
-    empty_room(api, me, team_room)
+def person_1_group_room_membership(api, make_me_group_room_moderator,
+                                   group_room, person_1):
+    # Used by test_create_membership_by_email()
+    membership = add_person_to_room_by_email(api, group_room, person_1)
+    yield membership
+    delete_membership(api, membership)
 
 
-@pytest.fixture
-def temp_group_room_with_members(api, me, temp_group_room, email_addresses):
-    add_people_to_room(api, temp_group_room, email_addresses)
-    yield temp_group_room
-    empty_room(api, me, temp_group_room)
+@pytest.fixture(scope="session")
+def person_2_group_room_membership(api, make_me_group_room_moderator,
+                                   group_room, person_2):
+    # Used by test_create_membership_by_person_id()
+    membership = add_person_to_room_by_id(api, group_room, person_2)
+    yield membership
+    delete_membership(api, membership)
 
+
+@pytest.fixture(scope="session")
+def person_3_group_room_membership(api, make_me_group_room_moderator,
+                                   group_room, person_3):
+    # Used by test_create_moderator_by_email()
+    membership = add_person_to_room_by_email(api, group_room, person_3,
+                                             isModerator=True)
+    yield membership
+    delete_membership(api, membership)
+
+
+@pytest.fixture(scope="session")
+def person_4_group_room_membership(api, make_me_group_room_moderator,
+                                   group_room, person_4):
+    # Used by test_create_moderator_by_person_id()
+    membership = add_person_to_room_by_id(api, group_room, person_4,
+                                          isModerator=True)
+    yield membership
+    delete_membership(api, membership)
+
+
+@pytest.fixture(scope="session")
+def additional_group_room_memberships(person_1_group_room_membership,
+                                      person_2_group_room_membership,
+                                      person_3_group_room_membership,
+                                      person_4_group_room_membership):
+    return [person_1_group_room_membership,
+            person_2_group_room_membership,
+            person_3_group_room_membership,
+            person_4_group_room_membership]
+
+
+@pytest.fixture(scope="session")
+def group_room_with_members(group_room, additional_group_room_memberships):
+    return group_room
+
+
+# Room Tests
+
+class TestMembershipsAPI(object):
+    """Test MembershipsAPI methods."""
+
+    def test_list_user_memberships(self, group_room, team_room, direct_rooms,
+                                   authenticated_users_memberships):
+        assert len(authenticated_users_memberships) >= 3
+        assert are_valid_memberships(authenticated_users_memberships)
+
+    def test_list_user_memberships_with_paging(self, api, add_rooms,
+                                               authenticated_users_memberships,
+                                               group_room, team_room,
+                                               direct_rooms):
+        page_size = 2
+        pages = 3
+        num_memberships = pages * page_size
+        if len(authenticated_users_memberships) < num_memberships:
+            add_rooms(num_memberships - len(authenticated_users_memberships))
+        memberships = api.memberships.list(max=page_size)
+        memberships_list = list(itertools.islice(memberships, num_memberships))
+        assert len(memberships_list) == num_memberships
+        assert are_valid_memberships(memberships_list)
+
+    def test_list_room_memberships(self, api, group_room_with_members):
+        memberships = get_room_membership_list(api, group_room_with_members)
+        assert len(memberships) > 1
+        assert are_valid_memberships(memberships)
+
+    def test_filter_room_memberships_by_personEmail(self, api, person_1,
+                                                    group_room_with_members):
+        memberships = get_room_membership_list(api, group_room_with_members,
+                                               personEmail=person_1.emails[0])
+        assert len(memberships) == 1
+        membership = memberships[0]
+        assert is_valid_membership(membership)
+        assert membership.roomId == group_room_with_members.id
+
+    def test_filter_room_memberships_by_personId(self, api, person_1,
+                                                 group_room_with_members):
+        memberships = get_room_membership_list(api, group_room_with_members,
+                                               personId=person_1.id)
+        assert len(memberships) == 1
+        membership = memberships[0]
+        assert is_valid_membership(membership)
+        assert membership.roomId == group_room_with_members.id
+
+    def test_create_membership_by_email(self, person_1_group_room_membership):
+        assert is_valid_membership(person_1_group_room_membership)
+
+    def test_create_membership_by_person_id(self,
+                                            person_2_group_room_membership):
+        assert is_valid_membership(person_2_group_room_membership)
+
+    def test_create_moderator_by_email(self, person_3_group_room_membership):
+        assert is_valid_membership(person_3_group_room_membership)
+
+    def test_create_moderator_by_person_id(self,
+                                           person_4_group_room_membership):
+        assert is_valid_membership(person_4_group_room_membership)
+
+    def test_get_membership_details(self, api, my_group_room_membership):
+        membership = get_membership_by_id(api, my_group_room_membership.id)
+        assert is_valid_membership(membership)
+
+    def test_update_membership_make_moderator(self,
+                                              make_me_group_room_moderator):
+        assert is_valid_membership(make_me_group_room_moderator)
+        assert make_me_group_room_moderator.isModerator
+
+    def test_delete_membership(self, api, group_room, temp_person):
+        membership = add_person_to_room_by_id(api, group_room, temp_person)
+        assert is_valid_membership(membership)
+        delete_membership(api, membership)
+        assert not membership_exists(api, membership)

tests/api/test_messages.py

@@ -11,22 +11,58 @@
 
 # Helper Functions
 
+def send_direct_message_to_email(api, email, message=None):
+    msg_text = message if message else create_string("Message")
+    return api.messages.create(toPersonEmail=email, text=msg_text)
 
 
+def delete_message(api, message):
+    api.messages.delete(message.id)
+
+
+def delete_messages(api, messages):
+    for message in messages:
+        delete_message(api, message)
+
 
 # pytest Fixtures
 
 @pytest.fixture(scope="session")
-def direct_messages(api, email_addresses):
-    msg_text = create_string("Message")
-    messages = []
-    for email in email_addresses:
-        messages.append(api.messages.create(toPersonEmail=email,
-                                            text=msg_text))
-    yield messages
-    delete_messages(api, messages)
+def direct_message_person_1(api, get_new_email_address):
+    message = send_direct_message_to_email(api, get_new_email_address())
+    yield message
+    delete_message(api, message)
 
 
-def delete_messages(api, messages):
-    for message in messages:
-        api.messages.delete(message.id)
+@pytest.fixture(scope="session")
+def direct_message_person_2(api, get_new_email_address):
+    message = send_direct_message_to_email(api, get_new_email_address())
+    yield message
+    delete_message(api, message)
+
+
+@pytest.fixture(scope="session")
+def direct_message_person_3(api, get_new_email_address):
+    message = send_direct_message_to_email(api, get_new_email_address())
+    yield message
+    delete_message(api, message)
+
+
+@pytest.fixture(scope="session")
+def direct_message_person_4(api, get_new_email_address):
+    message = send_direct_message_to_email(api, get_new_email_address())
+    yield message
+    delete_message(api, message)
+
+
+@pytest.fixture(scope="session")
+def direct_messages(direct_message_person_1, direct_message_person_2,
+                    direct_message_person_3, direct_message_person_4):
+    return [direct_message_person_1, direct_message_person_2,
+            direct_message_person_3, direct_message_person_4]
+
+@pytest.fixture(scope="session")
+def send_direct_message(api):
+    def inner_function(email_address, message=None):
+        send_direct_message_to_email(api, email_address, message=message)
+    return inner_function