Example #1
0
    def setUpTestData(self):
        # Summary: 2 clusters, 4 users
        # Users #1 and #2 are in cluster #1
        # User #1 is admin of cluster #1
        # User #3 is Sigma admin

        super().setUpTestData()

        # Clusters
        self.clusters = ClusterFactory.create_batch(2)

        # Users
        self.users = UserFactory.create_batch(4)
        self.users[2].is_staff = True  # Sigma admin
        self.users[2].save()

        # Memberships
        self.member1 = GroupMemberFactory(
            user=self.users[0], group=self.clusters[0], perm_rank=Group.ADMINISTRATOR_RANK
        )
        self.member2 = GroupMemberFactory(user=self.users[1], group=self.clusters[0], perm_rank=1)

        serializer = BasicClusterSerializer(self.clusters[0])
        self.cluster_data = serializer.data
        self.clusters_url = "/cluster/"
        self.cluster_url = self.clusters_url + "%d/"

        self.new_cluster_data = {"name": "Ecole polytechnique", "design": "default"}
Example #2
0
    def setUpTestData(self):
        super(APITestCase, self).setUpTestData()

        # Routes
        self.members_url = "/group-member/"
        self.accept_join_requests_url = self.members_url + "%d/accept_join_request/"

        # Group with membership request
        self.group = GroupFactory(default_member_rank=0, req_rank_accept_join_requests=5)

        # Users already in group
        self.users = UserFactory.create_batch(3)
        # Associated GroupMember
        self.group_member1 = GroupMemberFactory(
            user=self.users[0], group=self.group, perm_rank=Group.ADMINISTRATOR_RANK
        )  # can validate requests
        self.group_member2 = GroupMemberFactory(
            user=self.users[1], group=self.group, perm_rank=1
        )  # cannot validate requests
        self.group_member3 = GroupMemberFactory(
            user=self.users[2], group=self.group, perm_rank=0
        )  # request to be validated

        # Testing user
        self.user = UserFactory()

        # Misc
        self.new_membership_data = {"group_id": self.group.id, "user_id": self.user.id}
Example #3
0
    def setUp(self):
        # Summary: 6 users + 1 admin, 2 chats
        # User #7 is Sigma admin
        # User #1 is creator of chat #1, User #3 is member of chat #1, User #4 is admin of chat #1, User #5 has been banned from chat #1, User#6 has left chat #1
        # User #2 is creator of chat #2

        super(ChatMemberTests, self).setUpTestData()
        self.users = UserFactory.create_batch(7) + [AdminUserFactory()]
        self.chats = ChatFactory.create_batch(2)
        self.chatmembers = [
            ChatMemberFactory(is_creator=True, is_admin=True, chat=self.chats[0], user=self.users[0]),
            ChatMemberFactory(is_creator=True, is_admin=True, chat=self.chats[1], user=self.users[1]),
            ChatMemberFactory(is_creator=False, is_admin=False, chat=self.chats[0], user=self.users[2]),
            ChatMemberFactory(is_creator=False, is_admin=True, chat=self.chats[0], user=self.users[3]),
            ChatMemberFactory(is_creator=False, is_admin=False, is_member=False, is_banned=True, chat=self.chats[0], user=self.users[4]),
            ChatMemberFactory(is_creator=False, is_admin=False, is_member=False, chat=self.chats[0], user=self.users[5])
        ]

        self.chatmembers_url = "/chatmember/"
        self.chatmember_url = self.chatmembers_url + "%d/"
        self.create_chatmember_url = "/chat/{0}/add_member/"
        self.change_role_chatmember_url = "/chat/{0}/change_role/"

        self.new_chatmember_data = {"user": self.users[0].id, "chat": self.chats[1].id, "is_creator": False, "is_admin": False}
        self.new_chatmember_data_right_way = {"user_id": self.users[0].id}

        self.new_chatmember_data = {"user": self.users[0].id, "chat": self.chats[1].id, "is_creator": False, "is_admin": False}
        self.new_chatmember_data_right_way = {"user_id": self.users[0].id}
Example #4
0
    def setUpTestData(self):
        # Summary: 2 clusters, 4 users
        # Users #1 and #2 are in cluster #1
        # User #1 is admin of cluster #1
        # User #3 is Sigma admin

        super().setUpTestData()

        # Clusters
        self.clusters = ClusterFactory.create_batch(2)

        # Users
        self.users = UserFactory.create_batch(4)
        self.users[2].is_staff = True # Sigma admin
        self.users[2].save()

        # Memberships
        self.member1 = GroupMemberFactory(user=self.users[0], group=self.clusters[0], perm_rank=Group.ADMINISTRATOR_RANK)
        self.member2 = GroupMemberFactory(user=self.users[1], group=self.clusters[0], perm_rank=1)

        serializer = BasicClusterSerializer(self.clusters[0])
        self.cluster_data = serializer.data
        self.clusters_url = "/cluster/"
        self.cluster_url = self.clusters_url + "%d/"

        self.new_cluster_data = {"name": "Ecole polytechnique", "design": "default"}
Example #5
0
    def setUp(self):
        # Summary: 4 users + 1 admin, 2 chats
        # User #5 is Sigma admin
        # User #1 is creator of and sent 1 message to chat #1, User #3 is member of, and sent 1 message to chat#1
        # User #2 is creator of, and sent 1 message to chat #2, User #1 is member of, and sent 1 message to chat #2

        super(MessageTests, self).setUp()
        self.users = UserFactory.create_batch(4) + [AdminUserFactory()]
        self.chats = ChatFactory.create_batch(2)
        self.chatmembers = [
            ChatMemberFactory(is_creator=True, is_admin=True, chat=self.chats[0], user=self.users[0]),
            ChatMemberFactory(is_creator=False, is_admin=False, chat=self.chats[1], user=self.users[0]),
            ChatMemberFactory(is_creator=True, is_admin=True, chat=self.chats[1], user=self.users[1]),
            ChatMemberFactory(is_creator=False, is_admin=False, chat=self.chats[0], user=self.users[2]),
        ]
        self.messages = [
            MessageFactory(chat_id=self.chats[0], chatmember_id=self.chatmembers[0]),
            MessageFactory(chat_id=self.chats[1], chatmember_id=self.chatmembers[1]),
            MessageFactory(chat_id=self.chats[1], chatmember_id=self.chatmembers[2]),
            MessageFactory(chat_id=self.chats[0], chatmember_id=self.chatmembers[3]),
        ]

        self.messages_url = "/message/"
        self.message_url = self.messages_url + "%d/"
        self.create_message_url = "/chatmember/{0}/send_message/"

        f = SimpleUploadedFile("file.txt", b"file_content")
        self.new_message_data = {
            "chatmember_id": self.chatmembers[0].id,
            "chat_id": self.chats[0].id,
            "text": "text",
            "attachment": f,
        }
        self.new_message_data_right_way = {"text": "text", "attachment": f}
    def setUpTestData(self):
        super(APITestCase, self).setUpTestData()

        # Routes
        self.group_field_url = "/group-member-value/"

        # Create the base Group
        self.group = GroupFactory()

        # Users already in group
        # User[0]: Not in Group
        # User[1]: Requested join, not accepted
        # User[2]: Group member
        # User[3]: Group admin
        self.users = UserFactory.create_batch(5) + [AdminUserFactory()]

        # Associated GroupMember
        self.group_member = [
            None,
            GroupMemberFactory(user=self.users[1], group=self.group, perm_rank=0),
            GroupMemberFactory(user=self.users[2], group=self.group, perm_rank=1),
            GroupMemberFactory(user=self.users[3], group=self.group, perm_rank=Group.ADMINISTRATOR_RANK),
            GroupMemberFactory(user=self.users[4], group=self.group, perm_rank=0)
        ]
        # Let's add some custom fields to this Group
        self.validator_none = Validator.objects.all().get(html_name=Validator.VALIDATOR_NONE)
        self.validator_text = Validator.objects.all().get(html_name=Validator.VALIDATOR_TEXT)
        self.group_fields = [
            # First field does not require any validation
            GroupFieldFactory(group=self.group, validator=self.validator_none, validator_values={}),
            # Second field must be in the email format
            GroupFieldFactory(group=self.group,
                validator=self.validator_text,
                validator_values={"regex": "[^@]+@[^@]+\.[^@]+", "message": "Invalid email"}),
            GroupFieldFactory(group=self.group, validator=self.validator_none, validator_values={}),
        ]

        # And we need a second group
        self.group2 = GroupFactory()
        self.group2_user2 = GroupMemberFactory(user=self.users[4], group=self.group2, perm_rank=1)
        self.group2_fields = [
            # First field does not require any validation
            GroupFieldFactory(group=self.group2, validator=self.validator_none, validator_values={}),
            # Second field must be in the email format
            GroupFieldFactory(group=self.group2,
                validator=self.validator_text,
                validator_values={"regex": "[^@]+@[^@]+\.[^@]+", "message": "Invalid email"}),
            GroupFieldFactory(group=self.group2, validator=self.validator_none, validator_values={}),
        ]

        # Create some values
        GroupMemberValueFactory(field=self.group2_fields[0], membership=self.group2_user2, value="TextFieldValue1")
        GroupMemberValueFactory(field=self.group2_fields[1], membership=self.group2_user2, value="*****@*****.**")
        GroupMemberValueFactory(field=self.group_fields[2], membership=self.group_member[2], value="Field3Value__user2")
        GroupMemberValueFactory(field=self.group_fields[2], membership=self.group_member[3], value="Field3Value__user3")
Example #7
0
    def setUpTestData(self):
        # Summary: 1 cluster, 4 users + 1 admin, 5 groups (+1 group for the cluster)
        # Users #1 and #2 are in cluster #1
        # User #5 is Sigma admin
        # Group #1 is public, others are private
        # Users #1 and #2 are members of group #3; user #1 is group admin
        # Users #3 and #4 are members of group #2; user #3 has invitation clearance, not user #4
        # User #4 is member of group #5
        # User #1 is invited to group #5
        # Group #4 is acknowledged by cluster #1

        super(GroupTests, self).setUpTestData()
        self.clusters = ClusterFactory.create_batch(1)
        self.groups = GroupFactory.create_batch(5, is_private=True)
        self.users = UserFactory.create_batch(3) + [AdminUserFactory()]

        # Group #1 is public
        self.groups[0].is_private = False
        self.groups[0].default_member_rank = 1
        self.groups[0].name = "Public group without invitation"
        self.groups[0].save()

        # Group #2 clearance parameters
        self.groups[1].req_rank_invite = 5
        self.groups[1].save()

        # Users in cluster
        self.users[0].clusters.add(self.clusters[0])
        self.users[1].clusters.add(self.clusters[0])
        GroupMemberFactory(user=self.users[0], group=self.clusters[0].group_ptr)
        GroupMemberFactory(user=self.users[1], group=self.clusters[0].group_ptr)
        # Users in group #2
        GroupMemberFactory(user=self.users[2], group=self.groups[1], perm_rank=self.groups[1].req_rank_invite)
        GroupMemberFactory(user=self.users[3], group=self.groups[1])
        # Users in group #3
        GroupMemberFactory(user=self.users[0], group=self.groups[2], perm_rank=Group.ADMINISTRATOR_RANK)
        GroupMemberFactory(user=self.users[1], group=self.groups[2])
        # Users in group #5
        GroupMemberFactory(user=self.users[3], group=self.groups[4])
        # User #1 is invited to group #5
        self.users[0].invited_to_groups.add(self.groups[4])

        # GroupAcknowledgment
        GroupAcknowledgmentFactory(subgroup=self.groups[3], parent_group=self.clusters[0].group_ptr, validated=True)

        self.groups_url = "/group/"
        self.group_url = self.groups_url + "%d/"

        self.new_private_group_data = {"name": "New private group", "is_private": True}
        self.new_public_group_data = {"name": "New public group", "is_private": False}
        self.invite_data = {"user_id": self.users[0].id}
Example #8
0
    def setUpTestData(self):
        # Summary: 4 users + 1 admin, 1 chat
        # User #5 is Sigma admin
        # User #1 is in chat

        super(ChatTests, self).setUpTestData()
        self.users = UserFactory.create_batch(3) + [AdminUserFactory()]
        self.chats = ChatFactory.create_batch(1)
        self.chatmember = ChatMemberFactory(is_creator=True, is_admin=True, chat=self.chats[0], user=self.users[0])

        self.chats_url = "/chat/"
        self.chat_url = self.chats_url + "%d/"

        self.new_chat_data = {"name": "New chat"}
        self.add_member_data = {"user_id": self.users[0].id}
Example #9
0
    def setUpTestData(self):
        super(ImageTests, self).setUpTestData()

        self.user = UserFactory()
        self.other_user = UserFactory()
        file = SimpleUploadedFile(name='test.jpg', content=PIL_Image.new('RGB', (15, 15)).tobytes(), content_type='image/jpeg')
        self.profile_image = Image.objects.create(file=file, owner=self.user)

        self.user.photo = self.profile_image
        self.user.save()

        serializer = ImageSerializer(self.profile_image)
        self.profile_data = serializer.data
        self.profiles_url = '/image/'
        self.profile_url = self.profiles_url + '%d/' % self.profile_image.id
Example #10
0
    def setUpTestData(self):
        # Summary: 2 clusters, 2 groups, 10 users
        # Cluster #1: users #1 to #5
        # Cluster #2: users #5 to #9
        # Group #1: users #1, #2 and #6 (pending request)
        # Group #2: users #3, #7 and #8 (invitation not accepted yet)
        # User #1 is admin in cluster #1
        # User #6 is admin in cluster #2
        # User #10 is Sigma admin

        super(UserTests, self).setUpTestData()
        self.clusters = ClusterFactory.create_batch(2)
        self.users = UserFactory.create_batch(9)
        self.groups = GroupFactory.create_batch(2)

        # User #10 is Sigma admin
        self.users.append(AdminUserFactory())

        # Add users in clusters (user #1 is admin in cluster #1 and user #6 is admin in cluster #2)
        for i in range(5):
            self.clusters[0].cluster_users.add(self.users[i])
            GroupMemberFactory(
                group=self.clusters[0], user=self.users[i], perm_rank=(Group.ADMINISTRATOR_RANK if i == 0 else 1)
            )

            self.clusters[1].cluster_users.add(self.users[4 + i])
            GroupMemberFactory(
                group=self.clusters[1], user=self.users[4 + i], perm_rank=(Group.ADMINISTRATOR_RANK if i == 1 else 1)
            )

        # Add users in group #1
        GroupMemberFactory(group=self.groups[0], user=self.users[0], perm_rank=Group.ADMINISTRATOR_RANK)
        GroupMemberFactory(group=self.groups[0], user=self.users[1], perm_rank=1)
        GroupMemberFactory(group=self.groups[0], user=self.users[5], perm_rank=0)  # pending request

        # Add users in group #2
        GroupMemberFactory(group=self.groups[1], user=self.users[2], perm_rank=1)
        GroupMemberFactory(group=self.groups[1], user=self.users[6], perm_rank=1)
        self.users[7].invited_to_groups.add(self.groups[1])  # User #8 is invited to group #2

        self.user_url = "/user/"
        self.new_user_data = {
            "lastname": "Doe",
            "firstname": "John",
            "email": "*****@*****.**",
            "password": "******",
            "clusters_ids": {self.clusters[0].id},
        }
Example #11
0
    def setUpTestData(self):
        super(APITestCase, self).setUpTestData()

        # Routes
        self.members_url = "/group-member/"
        self.group_invite_url = "/group/%d/invite/"
        self.group_invite_accept_url = "/group/%d/invite_accept/"

        # Group with invitation only
        self.group = GroupFactory(req_rank_invite=5, default_member_rank=-1)

        # Testing user
        self.users = UserFactory.create_batch(2)
        self.memberships = [
            None,
            GroupMemberFactory(user=self.users[1], group=self.group, perm_rank=self.group.req_rank_invite),
        ]
Example #12
0
    def setUpTestData(self):
        # Summary: 6 users, 1 group, 5 mships

        super().setUpTestData()

        self.member_rank_url = "/group-member/%d/rank/"
        self.member_url = "/group-member/%d/"
        self.users = UserFactory.create_batch(6)
        self.group = GroupFactory(req_rank_promote=3, req_rank_demote=4, req_rank_kick=5)
        self.mships = [
            None,
            GroupMemberFactory(user=self.users[1], group=self.group, perm_rank=1),
            GroupMemberFactory(user=self.users[2], group=self.group, perm_rank=2),
            GroupMemberFactory(user=self.users[3], group=self.group, perm_rank=3),
            GroupMemberFactory(user=self.users[4], group=self.group, perm_rank=4),
            GroupMemberFactory(user=self.users[5], group=self.group, perm_rank=5),
        ]
Example #13
0
    def setUpTestData(self):
        super(APITestCase, self).setUpTestData()

        # Routes
        self.members_url = "/group-member/"

        # Group with invitation only
        self.group = GroupFactory(req_rank_invite=5, default_member_rank=-1, is_private=True)

        # Testing user
        self.users = UserFactory.create_batch(2)
        self.memberships = [
            None,
            GroupMemberFactory(user=self.users[1], group=self.group, perm_rank=self.group.req_rank_invite),
        ]

        # Misc
        self.new_membership_data = {"group_id": self.group.id, "user_id": self.users[0].id}
Example #14
0
    def setUpTestData(self):
        # Summary: 1 Sigma admin + 10 users, 4 groups, 2 clusters
        super().setUpTestData()

        self.users = [AdminUserFactory()] + UserFactory.create_batch(10)
        self.clusters = ClusterFactory.create_batch(2)
        self.groups = [None] + GroupFactory.create_batch(4, is_private=True)

        # Group #2 is public
        self.groups[2].is_private = False
        self.groups[2].save()

        # Add users in clusters (user #1 is admin in cluster #1 and user #6 is admin in cluster #2)
        for i in range(5):
            self.clusters[0].cluster_users.add(self.users[1 + i])
            GroupMemberFactory(
                group=self.clusters[0], user=self.users[1 + i], perm_rank=(Group.ADMINISTRATOR_RANK if i == 0 else 1)
            )

            self.clusters[1].cluster_users.add(self.users[6 + i])
            GroupMemberFactory(
                group=self.clusters[1], user=self.users[6 + i], perm_rank=(Group.ADMINISTRATOR_RANK if i == 0 else 1)
            )

        # Add users to group
        self.mships = [
            GroupMemberFactory(user=self.users[2], group=self.groups[1], perm_rank=1),
            GroupMemberFactory(user=self.users[3], group=self.groups[2], perm_rank=1),
            GroupMemberFactory(user=self.users[6], group=self.groups[2], perm_rank=1),
            GroupMemberFactory(user=self.users[6], group=self.groups[3], perm_rank=1),
            GroupMemberFactory(user=self.users[8], group=self.groups[3], perm_rank=1),
            GroupMemberFactory(user=self.users[4], group=self.groups[4], perm_rank=1),
            GroupMemberFactory(user=self.users[7], group=self.groups[4], perm_rank=1),
            GroupMemberFactory(user=self.users[9], group=self.groups[4], perm_rank=0),  # pending request
        ]

        # User #5 is invited to group #2
        self.users[5].invited_to_groups.add(self.groups[2])

        # GroupAcknowledgments
        GroupAcknowledgmentFactory(parent_group=self.clusters[0].group_ptr, subgroup=self.groups[1], validated=True)

        # Misc
        self.mship_url = "/group-member/?"
Example #15
0
    def setUpTestData(self):
        # Summary: 2 clusters, 2 groups, 10 users
        # Cluster #1: users #1 to #5
        # Cluster #2: users #5 to #9
        # Group #1: users #1, #2 and #6 (pending request)
        # Group #2: users #3, #7 and #8 (invitation not accepted yet)
        # User #1 is admin in cluster #1
        # User #6 is admin in cluster #2
        # User #10 is Sigma admin

        super(UserTests, self).setUpTestData()
        self.clusters = ClusterFactory.create_batch(2)
        self.users = UserFactory.create_batch(9)
        self.groups = GroupFactory.create_batch(2)

        # User #10 is Sigma admin
        self.users.append(AdminUserFactory())

        # Add users in clusters (user #1 is admin in cluster #1 and user #6 is admin in cluster #2)
        for i in range(5):
            self.clusters[0].cluster_users.add(self.users[i])
            GroupMemberFactory(
                group=self.clusters[0],
                user=self.users[i],
                perm_rank=(Group.ADMINISTRATOR_RANK if i == 0 else 1))

            self.clusters[1].cluster_users.add(self.users[4 + i])
            GroupMemberFactory(
                group=self.clusters[1],
                user=self.users[4 + i],
                perm_rank=(Group.ADMINISTRATOR_RANK if i == 1 else 1))

        # Add users in group #1
        GroupMemberFactory(group=self.groups[0],
                           user=self.users[0],
                           perm_rank=Group.ADMINISTRATOR_RANK)
        GroupMemberFactory(group=self.groups[0],
                           user=self.users[1],
                           perm_rank=1)
        GroupMemberFactory(group=self.groups[0],
                           user=self.users[5],
                           perm_rank=0)  # pending request

        # Add users in group #2
        GroupMemberFactory(group=self.groups[1],
                           user=self.users[2],
                           perm_rank=1)
        GroupMemberFactory(group=self.groups[1],
                           user=self.users[6],
                           perm_rank=1)
        self.users[7].invited_to_groups.add(
            self.groups[1])  # User #8 is invited to group #2

        self.user_url = '/user/'
        self.new_user_data = {
            'lastname': 'Doe',
            'firstname': 'John',
            'email': '*****@*****.**',
            'password': '******',
            'clusters_ids': {self.clusters[0].id}
        }
Example #16
0
class ImageTests(APITestCase):
    @classmethod
    def setUpTestData(self):
        super(ImageTests, self).setUpTestData()

        self.user = UserFactory()
        self.other_user = UserFactory()
        file = SimpleUploadedFile(name='test.jpg', content=PIL_Image.new('RGB', (15, 15)).tobytes(), content_type='image/jpeg')
        self.profile_image = Image.objects.create(file=file, owner=self.user)

        self.user.photo = self.profile_image
        self.user.save()

        serializer = ImageSerializer(self.profile_image)
        self.profile_data = serializer.data
        self.profiles_url = '/image/'
        self.profile_url = self.profiles_url + '%d/' % self.profile_image.id

    def test_get_list_unauthed(self):
        # Client not authenticated
        response = self.client.get(self.profiles_url)
        self.assertEqual(response.status_code, status.HTTP_401_UNAUTHORIZED)

    def test_get_list_ok(self):
        self.client.force_authenticate(user=self.user)
        response = self.client.get(self.profiles_url)
        self.assertEqual(response.status_code, status.HTTP_200_OK)

    def test_get_one_ok(self):
        self.client.force_authenticate(user=self.user)
        response = self.client.get(self.profile_url)
        self.assertEqual(response.status_code, status.HTTP_200_OK)

    def test_create_unauthed(self):
        with open("sigma_files/test_img.png", "rb") as img:
             response = self.client.post(self.profiles_url, {'file': img}, format='multipart')
        self.assertEqual(response.status_code, status.HTTP_401_UNAUTHORIZED)

    def test_create_ok(self):
        self.client.force_authenticate(user=self.user)
        with open("sigma_files/test_img.png", "rb") as img:
             response = self.client.post(self.profiles_url, {'file': img}, format='multipart')
        self.assertEqual(response.status_code, status.HTTP_201_CREATED)

    def test_delete_forbidden(self):
        # Client wants to delete an image that he does not own
        self.client.force_authenticate(user=self.other_user)
        file = SimpleUploadedFile(name='test.jpg', content=PIL_Image.new('RGB', (15, 15)).tobytes(), content_type='image/jpeg')
        profile_image = Image.objects.create(file=file, owner=self.user)
        response = self.client.delete(self.profiles_url + "%d/" % profile_image.id)
        self.assertEqual(response.status_code, status.HTTP_403_FORBIDDEN)

    def test_delete_ok(self):
        # Client wants to delete an image that he owns
        self.client.force_authenticate(user=self.user)
        file = SimpleUploadedFile(name='test.jpg', content=PIL_Image.new('RGB', (15, 15)).tobytes(), content_type='image/jpeg')
        profile_image = Image.objects.create(file=file, owner=self.user)
        response = self.client.delete(self.profiles_url + "%d/" % profile_image.id)
        self.assertEqual(response.status_code, status.HTTP_204_NO_CONTENT)
        try:
            img = Image.objects.get(pk=profile_image.id)
        except Image.DoesNotExist:
            img = None # File has been deleted
        self.assertEqual(img, None)