Add TestPeople class to Manage Test Accounts

Add a TestPeople class to create, manage and delete (when tests are
complete) test (person) accounts.

Author: cmlccie

tests/api/test_memberships.py

@@ -79,71 +79,71 @@ def membership_exists(api, membership):
 
 # pytest Fixtures
 
-@pytest.fixture(scope="session")
-def authenticated_users_memberships(api):
-    return list(api.memberships.list())
-
-
-@pytest.fixture(scope="session")
+@pytest.fixture()
 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 authenticated_user_memberships(api):
+    return list(api.memberships.list())
+
+
 @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 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)
+def group_room_member_added_by_email(api, make_me_group_room_moderator,
+                                     group_room, test_people):
+    person = test_people["group_room_member_added_by_email"]
+    membership = add_person_to_room_by_email(api, group_room, person)
     yield membership
     delete_membership(api, membership)
 
 
 @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)
+def group_room_member_added_by_id(api, make_me_group_room_moderator,
+                                  group_room, test_people):
+    person = test_people["group_room_member_added_by_id"]
+    membership = add_person_to_room_by_id(api, group_room, person)
     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,
+def group_room_moderator_added_by_email(api, make_me_group_room_moderator,
+                                        group_room, test_people):
+    person = test_people["group_room_moderator_added_by_email"]
+    membership = add_person_to_room_by_email(api, group_room, person,
                                              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,
+def group_room_moderator_added_by_id(api, make_me_group_room_moderator,
+                                     group_room, test_people):
+    person = test_people["group_room_moderator_added_by_id"]
+    membership = add_person_to_room_by_id(api, group_room, person,
                                           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]
+def additional_group_room_memberships(group_room_member_added_by_email,
+                                      group_room_member_added_by_id,
+                                      group_room_moderator_added_by_email,
+                                      group_room_moderator_added_by_id):
+    return [group_room_member_added_by_email,
+            group_room_member_added_by_id,
+            group_room_moderator_added_by_email,
+            group_room_moderator_added_by_id]
 
 
 @pytest.fixture(scope="session")
@@ -156,73 +156,77 @@ def group_room_with_members(group_room, additional_group_room_memberships):
 class TestMembershipsAPI(object):
     """Test MembershipsAPI methods."""
 
+    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_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)
+                                   authenticated_user_memberships):
+        assert len(authenticated_user_memberships) >= 3
+        assert are_valid_memberships(authenticated_user_memberships)
 
     def test_list_user_memberships_with_paging(self, api, add_rooms,
-                                               authenticated_users_memberships,
+                                               authenticated_user_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))
+        if len(authenticated_user_memberships) < num_memberships:
+            add_rooms(num_memberships - len(authenticated_user_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_create_membership_by_email(self,
+                                        group_room_member_added_by_email):
+        assert is_valid_membership(group_room_member_added_by_email)
+
+    def test_create_membership_by_person_id(self,
+                                            group_room_member_added_by_id):
+        assert is_valid_membership(group_room_member_added_by_id)
+
+    def test_create_moderator_by_email(self,
+                                       group_room_moderator_added_by_email):
+        assert is_valid_membership(group_room_moderator_added_by_email)
+
+    def test_create_moderator_by_person_id(self,
+                                           group_room_moderator_added_by_id):
+        assert is_valid_membership(group_room_moderator_added_by_id)
+
+    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)
+
     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,
+    def test_filter_room_memberships_by_personEmail(self, api, test_people,
                                                     group_room_with_members):
+        email = test_people["group_room_member_added_by_email"].emails[0]
         memberships = get_room_membership_list(api, group_room_with_members,
-                                               personEmail=person_1.emails[0])
+                                               personEmail=email)
         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,
+    def test_filter_room_memberships_by_personId(self, api, test_people,
                                                  group_room_with_members):
+        id = test_people["group_room_member_added_by_id"].id
         memberships = get_room_membership_list(api, group_room_with_members,
-                                               personId=person_1.id)
+                                               personId=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

@@ -28,41 +28,24 @@ def delete_messages(api, messages):
 # pytest Fixtures
 
 @pytest.fixture(scope="session")
-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 direct_messages(api, additional_group_room_memberships, test_people):
+    # Using additional_group_room_memberships to ensure some test_people
+    # have been created
+    direct_messages = []
+    for person in test_people:
+        message = send_direct_message_to_email(api, person.emails[0])
+        direct_messages.append(message)
 
+    yield direct_messages
 
-@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)
-
+    for message in direct_messages:
+        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

tests/api/test_people.py

@@ -37,14 +37,18 @@ def create_person(api, emails, **person_attributes):
     return api.people.create(emails, **person_attributes)
 
 
+def delete_person(api, person):
+    api.people.delete(person.id)
+
+
 def get_new_test_person(api, get_new_email_address, licenses_dict):
     person_email = get_new_email_address()
     person = get_person_by_email(api, person_email)
     if person:
         return person
     else:
         emails = [person_email]
-        display_name = person_email
+        display_name = "ciscosparkapi"
         first_name = "ciscosparkapi"
         last_name = "ciscosparkapi"
         licenses = [licenses_dict["Messaging"].id]
@@ -57,38 +61,62 @@ def get_new_test_person(api, get_new_email_address, licenses_dict):
         return person
 
 
-# pytest Fixtures
+# Helper Classes
 
-@pytest.fixture(scope="session")
-def me(api):
-    return api.people.me()
+class TestPeople(object):
+    """Creates, tracks and manages test accounts 'people' used by the tests."""
 
-@pytest.fixture(scope="session")
-def person_1(api, get_new_email_address, licenses_dict):
-    return get_new_test_person(api, get_new_email_address, licenses_dict)
+    def __init__(self, api, get_new_email_address, licenses_dict):
+        super(object, TestPeople).__init__()
+        self._api = api
+        self._get_new_email_address = get_new_email_address
+        self._licenses_dict = licenses_dict
+        self.test_people = {}
 
+    def __getitem__(self, item):
+        if self.test_people.get(item):
+            return self.test_people[item]
+        else:
+            new_test_person = get_new_test_person(self._api,
+                                                  self._get_new_email_address,
+                                                  self._licenses_dict)
+            self.test_people[item] = new_test_person
+            return new_test_person
 
-@pytest.fixture(scope="session")
-def person_2(api, get_new_email_address, licenses_dict):
-    return get_new_test_person(api, get_new_email_address, licenses_dict)
+    def list(self):
+        return self.test_people.values()
 
+    def __iter__(self):
+        return iter(self.list())
+
+    def __del__(self):
+        for person in self.test_people.values():
+            delete_person(self._api, person)
+        super(object, TestPeople).__del__()
+
+
+# pytest Fixtures
 
 @pytest.fixture(scope="session")
-def person_3(api, get_new_email_address, licenses_dict):
-    return get_new_test_person(api, get_new_email_address, licenses_dict)
+def me(api):
+    return api.people.me()
 
 
 @pytest.fixture(scope="session")
-def person_4(api, get_new_email_address, licenses_dict):
-    return get_new_test_person(api, get_new_email_address, licenses_dict)
+def test_people(api, get_new_email_address, licenses_dict):
+    test_people = TestPeople()
+    yield test_people
+    del(test_people)
 
 
 @pytest.fixture()
 def temp_person(api, get_new_email_address, licenses_dict):
-    return get_new_test_person(api, get_new_email_address, licenses_dict)
+    person =  get_new_test_person(api, get_new_email_address, licenses_dict)
+    yield person
+    delete_person(api, person)
 
 
-@pytest.fixture(scope="session")
+@pytest.fixture()
 def people_in_group_room(api, group_room_memberships):
     return [get_person_by_id(api, membership.personId)
             for membership in group_room_memberships]