From da66aa4852b036fb1e88382f6f66fcf54555fe20 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Wolfgang=20Hu=C3=9F?= <wolle.huss@pjannto.com>
Date: Thu, 1 Sep 2022 15:33:28 +0200
Subject: [PATCH] Test 'UpdateGroup' resolver, a start

---
 backend/src/schema/resolvers/groups.spec.js | 130 ++++++++++++++++++++
 1 file changed, 130 insertions(+)

diff --git a/backend/src/schema/resolvers/groups.spec.js b/backend/src/schema/resolvers/groups.spec.js
index 1d272de2b..ddf003659 100644
--- a/backend/src/schema/resolvers/groups.spec.js
+++ b/backend/src/schema/resolvers/groups.spec.js
@@ -2,6 +2,7 @@ import { createTestClient } from 'apollo-server-testing'
 import Factory, { cleanDatabase } from '../../db/factories'
 import {
   createGroupMutation,
+  updateGroupMutation,
   joinGroupMutation,
   changeGroupMemberRoleMutation,
   groupMembersQuery,
@@ -2043,5 +2044,134 @@ describe('in mode', () => {
         })
       })
     })
+
+    describe('UpdateGroup', () => {
+      beforeAll(async () => {
+        await seedBasicsAndClearAuthentication()
+      })
+
+      afterAll(async () => {
+        await cleanDatabase()
+      })
+
+      describe('unauthenticated', () => {
+        it.only('throws authorization error', async () => {
+          const { errors } = await mutate({
+            query: updateGroupMutation,
+            variables: {
+              id: 'my-group',
+              slug: 'my-best-group',
+            },
+          })
+          expect(errors[0]).toHaveProperty('message', 'Not Authorized!')
+        })
+      })
+
+      describe('authenticated', () => {
+        let otherUser
+
+        beforeAll(async () => {
+          otherUser = await Factory.build(
+            'user',
+            {
+              id: 'other-user',
+              name: 'Other TestUser',
+            },
+            {
+              email: 'test2@example.org',
+              password: '1234',
+            },
+          )
+          authenticatedUser = await otherUser.toJson()
+          await mutate({
+            mutation: createGroupMutation,
+            variables: {
+              id: 'others-group',
+              name: 'Uninteresting Group',
+              about: 'We will change nothing!',
+              description: 'We love it like it is!?' + descriptionAdditional100,
+              groupType: 'closed',
+              actionRadius: 'global',
+              categoryIds,
+            },
+          })
+          authenticatedUser = await user.toJson()
+          await mutate({
+            mutation: createGroupMutation,
+            variables: {
+              id: 'my-group',
+              name: 'The Best Group',
+              about: 'We will change the world!',
+              description: 'Some description' + descriptionAdditional100,
+              groupType: 'public',
+              actionRadius: 'regional',
+              categoryIds,
+            },
+          })
+        })
+
+        describe('query groups', () => {
+          describe('without any filters', () => {
+            it('finds all groups', async () => {
+              await expect(query({ query: groupQuery, variables: {} })).resolves.toMatchObject({
+                data: {
+                  Group: expect.arrayContaining([
+                    expect.objectContaining({
+                      id: 'my-group',
+                      slug: 'the-best-group',
+                      myRole: 'owner',
+                    }),
+                    expect.objectContaining({
+                      id: 'others-group',
+                      slug: 'uninteresting-group',
+                      myRole: null,
+                    }),
+                  ]),
+                },
+                errors: undefined,
+              })
+            })
+          })
+
+          describe('isMember = true', () => {
+            it('finds only groups where user is member', async () => {
+              await expect(
+                query({ query: groupQuery, variables: { isMember: true } }),
+              ).resolves.toMatchObject({
+                data: {
+                  Group: [
+                    {
+                      id: 'my-group',
+                      slug: 'the-best-group',
+                      myRole: 'owner',
+                    },
+                  ],
+                },
+                errors: undefined,
+              })
+            })
+          })
+
+          describe('isMember = false', () => {
+            it('finds only groups where user is not(!) member', async () => {
+              await expect(
+                query({ query: groupQuery, variables: { isMember: false } }),
+              ).resolves.toMatchObject({
+                data: {
+                  Group: expect.arrayContaining([
+                    expect.objectContaining({
+                      id: 'others-group',
+                      slug: 'uninteresting-group',
+                      myRole: null,
+                    }),
+                  ]),
+                },
+                errors: undefined,
+              })
+            })
+          })
+        })
+      })
+    })
   })
 })