snapshot of https://github.com/twentyhq/twenty.git (main, 2026-09-17; blobs > 131072B omitted)

packages/twenty-server/test/integration/graphql/suites/view/view-field-group/__snapshots__/failing-create-many-view-field-groups.integration-spec.ts.snap

@@ -0,0 +1,13 @@
+// Jest Snapshot v1, https://jestjs.io/docs/snapshot-testing
+
+exports[`View Field Group Resolver - Failing Create Many Operations should fail when some inputs reference non-existent views 1`] = `
+{
+  "extensions": {
+    "code": "NOT_FOUND",
+    "subCode": "RELATION_UNIVERSAL_IDENTIFIER_NOT_FOUND",
+    "userFriendlyMessage": "An error occurred.",
+  },
+  "message": "Could not find view for given viewId",
+  "name": "NotFoundError",
+}
+`;

packages/twenty-server/test/integration/graphql/suites/view/view-field-group/__snapshots__/failing-create-view-field-group.integration-spec.ts.snap

@@ -0,0 +1,13 @@
+// Jest Snapshot v1, https://jestjs.io/docs/snapshot-testing
+
+exports[`View Field Group Resolver - Failing Create Operation should fail to create view field group when non-existent view 1`] = `
+{
+  "extensions": {
+    "code": "NOT_FOUND",
+    "subCode": "RELATION_UNIVERSAL_IDENTIFIER_NOT_FOUND",
+    "userFriendlyMessage": "An error occurred.",
+  },
+  "message": "Could not find view for given viewId",
+  "name": "NotFoundError",
+}
+`;

packages/twenty-server/test/integration/graphql/suites/view/view-field-group/__snapshots__/failing-delete-view-field-group.integration-spec.ts.snap

@@ -0,0 +1,12 @@
+// Jest Snapshot v1, https://jestjs.io/docs/snapshot-testing
+
+exports[`View Field Group Resolver - Failing Delete Operation should fail to delete view field group when non-existent view field group 1`] = `
+{
+  "extensions": {
+    "code": "INTERNAL_SERVER_ERROR",
+    "exceptionEventId": Any<String>,
+    "userFriendlyMessage": "A view field group error occurred.",
+  },
+  "message": "View field group to delete not found",
+}
+`;

packages/twenty-server/test/integration/graphql/suites/view/view-field-group/__snapshots__/failing-destroy-view-field-group.integration-spec.ts.snap

@@ -0,0 +1,12 @@
+// Jest Snapshot v1, https://jestjs.io/docs/snapshot-testing
+
+exports[`View Field Group Resolver - Failing Destroy Operation should fail to destroy view field group when non-existent view field group 1`] = `
+{
+  "extensions": {
+    "code": "INTERNAL_SERVER_ERROR",
+    "exceptionEventId": Any<String>,
+    "userFriendlyMessage": "A view field group error occurred.",
+  },
+  "message": "View field group to destroy not found",
+}
+`;

packages/twenty-server/test/integration/graphql/suites/view/view-field-group/__snapshots__/failing-update-view-field-group.integration-spec.ts.snap

@@ -0,0 +1,12 @@
+// Jest Snapshot v1, https://jestjs.io/docs/snapshot-testing
+
+exports[`View Field Group Resolver - Failing Update Operation should fail to update view field group when non-existent view field group 1`] = `
+{
+  "extensions": {
+    "code": "INTERNAL_SERVER_ERROR",
+    "exceptionEventId": Any<String>,
+    "userFriendlyMessage": "A view field group error occurred.",
+  },
+  "message": "View field group to update not found",
+}
+`;

packages/twenty-server/test/integration/graphql/suites/view/view-field-group/failing-create-many-view-field-groups.integration-spec.ts

@@ -0,0 +1,94 @@
+import { expectOneNotInternalServerErrorSnapshot } from 'test/integration/graphql/utils/expect-one-not-internal-server-error-snapshot.util';
+import { createOneObjectMetadata } from 'test/integration/metadata/suites/object-metadata/utils/create-one-object-metadata.util';
+import { deleteOneObjectMetadata } from 'test/integration/metadata/suites/object-metadata/utils/delete-one-object-metadata.util';
+import { updateOneObjectMetadata } from 'test/integration/metadata/suites/object-metadata/utils/update-one-object-metadata.util';
+import { createManyViewFieldGroups } from 'test/integration/metadata/suites/view-field-group/utils/create-many-view-field-groups.util';
+import { createOneView } from 'test/integration/metadata/suites/view/utils/create-one-view.util';
+import { v4 as uuidv4 } from 'uuid';
+
+import { type CreateViewFieldGroupInput } from 'src/engine/metadata-modules/view-field-group/dtos/inputs/create-view-field-group.input';
+
+describe('View Field Group Resolver - Failing Create Many Operations', () => {
+  let testSetup: {
+    testViewId: string;
+    testObjectMetadataId: string;
+  };
+
+  beforeAll(async () => {
+    const {
+      data: {
+        createOneObject: { id: objectMetadataId },
+      },
+    } = await createOneObjectMetadata({
+      expectToFail: false,
+      input: {
+        nameSingular: 'myFieldGroupTestObject',
+        namePlural: 'myFieldGroupTestObjects',
+        labelSingular: 'My Field Group Test Object',
+        labelPlural: 'My Field Group Test Objects',
+        icon: 'Icon123',
+      },
+    });
+
+    const {
+      data: {
+        createView: { id: testViewId },
+      },
+    } = await createOneView({
+      input: {
+        icon: 'icon123',
+        objectMetadataId,
+        name: 'TestViewForFieldGroups',
+      },
+      expectToFail: false,
+    });
+
+    testSetup = {
+      testViewId,
+      testObjectMetadataId: objectMetadataId,
+    };
+  });
+
+  afterAll(async () => {
+    await updateOneObjectMetadata({
+      input: {
+        idToUpdate: testSetup.testObjectMetadataId,
+        updatePayload: {
+          isActive: false,
+        },
+      },
+    });
+    await deleteOneObjectMetadata({
+      expectToFail: false,
+      input: { idToDelete: testSetup.testObjectMetadataId },
+    });
+  });
+
+  it('should fail when some inputs reference non-existent views', async () => {
+    const invalidViewId = uuidv4();
+
+    const inputs: CreateViewFieldGroupInput[] = [
+      {
+        name: 'Valid Group',
+        viewId: testSetup.testViewId,
+        position: 0,
+        isVisible: true,
+      },
+      {
+        name: 'Invalid Group',
+        viewId: invalidViewId,
+        position: 1,
+        isVisible: true,
+      },
+    ];
+
+    const { errors } = await createManyViewFieldGroups({
+      inputs,
+      expectToFail: true,
+    });
+
+    expectOneNotInternalServerErrorSnapshot({
+      errors,
+    });
+  });
+});

packages/twenty-server/test/integration/graphql/suites/view/view-field-group/failing-create-view-field-group.integration-spec.ts

@@ -0,0 +1,97 @@
+import { faker } from '@faker-js/faker';
+import {
+  cleanupViewFieldGroupTest,
+  setupViewFieldGroupTest,
+  type ViewFieldGroupTestSetup,
+} from 'test/integration/graphql/suites/view/utils/setup-view-field-group-test.util';
+import { createOneViewFieldGroup } from 'test/integration/metadata/suites/view-field-group/utils/create-one-view-field-group.util';
+import { deleteOneViewFieldGroup } from 'test/integration/metadata/suites/view-field-group/utils/delete-one-view-field-group.util';
+import { destroyOneViewFieldGroup } from 'test/integration/metadata/suites/view-field-group/utils/destroy-one-view-field-group.util';
+import { extractRecordIdsAndDatesAsExpectAny } from 'test/utils/extract-record-ids-and-dates-as-expect-any';
+import {
+  eachTestingContextFilter,
+  type EachTestingContext,
+} from 'twenty-shared/testing';
+
+import { type CreateViewFieldGroupInput } from 'src/engine/metadata-modules/view-field-group/dtos/inputs/create-view-field-group.input';
+
+const normalizeErrorMessage = (error: any) => {
+  const UUID_REGEX =
+    /[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}/gi;
+
+  return {
+    ...error,
+    message: error.message?.replace(UUID_REGEX, '{{UUID}}') || error.message,
+  };
+};
+
+describe('View Field Group Resolver - Failing Create Operation', () => {
+  let testSetup: ViewFieldGroupTestSetup;
+  let createdViewFieldGroupIds: string[] = [];
+
+  beforeAll(async () => {
+    testSetup = await setupViewFieldGroupTest();
+  });
+
+  afterEach(async () => {
+    for (const viewFieldGroupId of createdViewFieldGroupIds) {
+      await deleteOneViewFieldGroup({
+        input: {
+          id: viewFieldGroupId,
+        },
+        expectToFail: false,
+      });
+
+      await destroyOneViewFieldGroup({
+        input: {
+          id: viewFieldGroupId,
+        },
+        expectToFail: false,
+      });
+    }
+  });
+
+  afterAll(async () => {
+    await cleanupViewFieldGroupTest(testSetup.testObjectMetadataId);
+  });
+
+  type CreateViewFieldGroupTestCase = (testSetup: ViewFieldGroupTestSetup) => {
+    input: CreateViewFieldGroupInput;
+  };
+
+  const createViewFieldGroupTestCases: EachTestingContext<CreateViewFieldGroupTestCase>[] =
+    [
+      {
+        title: 'non-existent view',
+        context: () => ({
+          input: {
+            name: 'Test Group',
+            viewId: faker.string.uuid(),
+          },
+        }),
+      },
+    ];
+
+  it.each(eachTestingContextFilter(createViewFieldGroupTestCases))(
+    'should fail to create view field group when $title',
+    async ({ context }) => {
+      const { input } = context(testSetup);
+      const response = await createOneViewFieldGroup({
+        input,
+        expectToFail: true,
+      });
+
+      expect(response.errors).toBeDefined();
+      expect(response.errors.length).toBe(1);
+      const [firstError] = response.errors;
+
+      expect(firstError.extensions.code).not.toBe('INTERNAL_SERVER_ERROR');
+
+      const normalizedError = normalizeErrorMessage(firstError);
+
+      expect(normalizedError).toMatchSnapshot(
+        extractRecordIdsAndDatesAsExpectAny(normalizedError),
+      );
+    },
+  );
+});

packages/twenty-server/test/integration/graphql/suites/view/view-field-group/failing-delete-view-field-group.integration-spec.ts

@@ -0,0 +1,62 @@
+import {
+  cleanupViewFieldGroupTest,
+  setupViewFieldGroupTest,
+  type ViewFieldGroupTestSetup,
+} from 'test/integration/graphql/suites/view/utils/setup-view-field-group-test.util';
+import { deleteOneViewFieldGroup } from 'test/integration/metadata/suites/view-field-group/utils/delete-one-view-field-group.util';
+import { extractRecordIdsAndDatesAsExpectAny } from 'test/utils/extract-record-ids-and-dates-as-expect-any';
+import {
+  eachTestingContextFilter,
+  type EachTestingContext,
+} from 'twenty-shared/testing';
+
+import { type DeleteViewFieldGroupInput } from 'src/engine/metadata-modules/view-field-group/dtos/inputs/delete-view-field-group.input';
+
+const TEST_NOT_EXISTING_VIEW_FIELD_GROUP_ID =
+  '20202020-0000-4000-8000-000000000002';
+
+describe('View Field Group Resolver - Failing Delete Operation', () => {
+  let testSetup: ViewFieldGroupTestSetup;
+
+  beforeAll(async () => {
+    testSetup = await setupViewFieldGroupTest();
+  });
+
+  afterAll(async () => {
+    await cleanupViewFieldGroupTest(testSetup.testObjectMetadataId);
+  });
+
+  type DeleteViewFieldGroupTestCase = {
+    input: DeleteViewFieldGroupInput;
+  };
+
+  const deleteViewFieldGroupTestCases: EachTestingContext<DeleteViewFieldGroupTestCase>[] =
+    [
+      {
+        title: 'non-existent view field group',
+        context: {
+          input: {
+            id: TEST_NOT_EXISTING_VIEW_FIELD_GROUP_ID,
+          },
+        },
+      },
+    ];
+
+  it.each(eachTestingContextFilter(deleteViewFieldGroupTestCases))(
+    'should fail to delete view field group when $title',
+    async ({ context }) => {
+      const response = await deleteOneViewFieldGroup({
+        input: context.input,
+        expectToFail: true,
+      });
+
+      expect(response.errors).toBeDefined();
+      expect(response.errors.length).toBe(1);
+      const [firstError] = response.errors;
+
+      expect(firstError).toMatchSnapshot(
+        extractRecordIdsAndDatesAsExpectAny(firstError),
+      );
+    },
+  );
+});

packages/twenty-server/test/integration/graphql/suites/view/view-field-group/failing-destroy-view-field-group.integration-spec.ts

@@ -0,0 +1,62 @@
+import {
+  cleanupViewFieldGroupTest,
+  setupViewFieldGroupTest,
+  type ViewFieldGroupTestSetup,
+} from 'test/integration/graphql/suites/view/utils/setup-view-field-group-test.util';
+import { destroyOneViewFieldGroup } from 'test/integration/metadata/suites/view-field-group/utils/destroy-one-view-field-group.util';
+import { extractRecordIdsAndDatesAsExpectAny } from 'test/utils/extract-record-ids-and-dates-as-expect-any';
+import {
+  eachTestingContextFilter,
+  type EachTestingContext,
+} from 'twenty-shared/testing';
+
+import { type DestroyViewFieldGroupInput } from 'src/engine/metadata-modules/view-field-group/dtos/inputs/destroy-view-field-group.input';
+
+const TEST_NOT_EXISTING_VIEW_FIELD_GROUP_ID =
+  '20202020-0000-4000-8000-000000000002';
+
+describe('View Field Group Resolver - Failing Destroy Operation', () => {
+  let testSetup: ViewFieldGroupTestSetup;
+
+  beforeAll(async () => {
+    testSetup = await setupViewFieldGroupTest();
+  });
+
+  afterAll(async () => {
+    await cleanupViewFieldGroupTest(testSetup.testObjectMetadataId);
+  });
+
+  type DestroyViewFieldGroupTestCase = {
+    input: DestroyViewFieldGroupInput;
+  };
+
+  const destroyViewFieldGroupTestCases: EachTestingContext<DestroyViewFieldGroupTestCase>[] =
+    [
+      {
+        title: 'non-existent view field group',
+        context: {
+          input: {
+            id: TEST_NOT_EXISTING_VIEW_FIELD_GROUP_ID,
+          },
+        },
+      },
+    ];
+
+  it.each(eachTestingContextFilter(destroyViewFieldGroupTestCases))(
+    'should fail to destroy view field group when $title',
+    async ({ context }) => {
+      const response = await destroyOneViewFieldGroup({
+        input: context.input,
+        expectToFail: true,
+      });
+
+      expect(response.errors).toBeDefined();
+      expect(response.errors.length).toBe(1);
+      const [firstError] = response.errors;
+
+      expect(firstError).toMatchSnapshot(
+        extractRecordIdsAndDatesAsExpectAny(firstError),
+      );
+    },
+  );
+});

packages/twenty-server/test/integration/graphql/suites/view/view-field-group/failing-update-view-field-group.integration-spec.ts

@@ -0,0 +1,65 @@
+import {
+  cleanupViewFieldGroupTest,
+  setupViewFieldGroupTest,
+  type ViewFieldGroupTestSetup,
+} from 'test/integration/graphql/suites/view/utils/setup-view-field-group-test.util';
+import { updateOneViewFieldGroup } from 'test/integration/metadata/suites/view-field-group/utils/update-one-view-field-group.util';
+import { extractRecordIdsAndDatesAsExpectAny } from 'test/utils/extract-record-ids-and-dates-as-expect-any';
+import {
+  eachTestingContextFilter,
+  type EachTestingContext,
+} from 'twenty-shared/testing';
+
+import { type UpdateViewFieldGroupInput } from 'src/engine/metadata-modules/view-field-group/dtos/inputs/update-view-field-group.input';
+
+const TEST_NOT_EXISTING_VIEW_FIELD_GROUP_ID =
+  '20202020-0000-4000-8000-000000000002';
+
+describe('View Field Group Resolver - Failing Update Operation', () => {
+  let testSetup: ViewFieldGroupTestSetup;
+
+  beforeAll(async () => {
+    testSetup = await setupViewFieldGroupTest();
+  });
+
+  afterAll(async () => {
+    await cleanupViewFieldGroupTest(testSetup.testObjectMetadataId);
+  });
+
+  type UpdateViewFieldGroupTestCase = {
+    input: UpdateViewFieldGroupInput;
+  };
+
+  const updateViewFieldGroupTestCases: EachTestingContext<UpdateViewFieldGroupTestCase>[] =
+    [
+      {
+        title: 'non-existent view field group',
+        context: {
+          input: {
+            id: TEST_NOT_EXISTING_VIEW_FIELD_GROUP_ID,
+            update: {
+              name: 'Updated Name',
+            },
+          },
+        },
+      },
+    ];
+
+  it.each(eachTestingContextFilter(updateViewFieldGroupTestCases))(
+    'should fail to update view field group when $title',
+    async ({ context }) => {
+      const response = await updateOneViewFieldGroup({
+        input: context.input,
+        expectToFail: true,
+      });
+
+      expect(response.errors).toBeDefined();
+      expect(response.errors.length).toBe(1);
+      const [firstError] = response.errors;
+
+      expect(firstError).toMatchSnapshot(
+        extractRecordIdsAndDatesAsExpectAny(firstError),
+      );
+    },
+  );
+});

packages/twenty-server/test/integration/graphql/suites/view/view-field-group/successful-create-many-view-field-groups.integration-spec.ts

@@ -0,0 +1,188 @@
+import { createOneObjectMetadata } from 'test/integration/metadata/suites/object-metadata/utils/create-one-object-metadata.util';
+import { deleteOneObjectMetadata } from 'test/integration/metadata/suites/object-metadata/utils/delete-one-object-metadata.util';
+import { updateOneObjectMetadata } from 'test/integration/metadata/suites/object-metadata/utils/update-one-object-metadata.util';
+import { createManyViewFieldGroups } from 'test/integration/metadata/suites/view-field-group/utils/create-many-view-field-groups.util';
+import { deleteOneViewFieldGroup } from 'test/integration/metadata/suites/view-field-group/utils/delete-one-view-field-group.util';
+import { destroyOneViewFieldGroup } from 'test/integration/metadata/suites/view-field-group/utils/destroy-one-view-field-group.util';
+import { createOneView } from 'test/integration/metadata/suites/view/utils/create-one-view.util';
+import { isDefined } from 'twenty-shared/utils';
+
+import { type CreateViewFieldGroupInput } from 'src/engine/metadata-modules/view-field-group/dtos/inputs/create-view-field-group.input';
+
+describe('View Field Group Resolver - Successful Create Many Operations', () => {
+  let testSetup: {
+    testViewId: string;
+    testObjectMetadataId: string;
+  };
+  let createdViewFieldGroupIds: string[] = [];
+
+  beforeAll(async () => {
+    const {
+      data: {
+        createOneObject: { id: objectMetadataId },
+      },
+    } = await createOneObjectMetadata({
+      expectToFail: false,
+      input: {
+        nameSingular: 'myFieldGroupTestObject',
+        namePlural: 'myFieldGroupTestObjects',
+        labelSingular: 'My Field Group Test Object',
+        labelPlural: 'My Field Group Test Objects',
+        icon: 'Icon123',
+      },
+    });
+
+    const {
+      data: {
+        createView: { id: testViewId },
+      },
+    } = await createOneView({
+      input: {
+        icon: 'icon123',
+        objectMetadataId,
+        name: 'TestViewForFieldGroups',
+      },
+      expectToFail: false,
+    });
+
+    testSetup = {
+      testViewId,
+      testObjectMetadataId: objectMetadataId,
+    };
+  });
+
+  afterAll(async () => {
+    await updateOneObjectMetadata({
+      input: {
+        idToUpdate: testSetup.testObjectMetadataId,
+        updatePayload: {
+          isActive: false,
+        },
+      },
+    });
+    await deleteOneObjectMetadata({
+      expectToFail: false,
+      input: { idToDelete: testSetup.testObjectMetadataId },
+    });
+  });
+
+  afterEach(async () => {
+    for (const viewFieldGroupId of createdViewFieldGroupIds) {
+      if (isDefined(viewFieldGroupId)) {
+        const {
+          data: { deleteViewFieldGroup },
+        } = await deleteOneViewFieldGroup({
+          expectToFail: false,
+          input: {
+            id: viewFieldGroupId,
+          },
+        });
+
+        expect(deleteViewFieldGroup.deletedAt).not.toBeNull();
+        await destroyOneViewFieldGroup({
+          expectToFail: false,
+          input: {
+            id: viewFieldGroupId,
+          },
+        });
+      }
+    }
+    createdViewFieldGroupIds = [];
+  });
+
+  it('should successfully create multiple view field groups in batch', async () => {
+    const inputs: CreateViewFieldGroupInput[] = [
+      {
+        name: 'First Group',
+        viewId: testSetup.testViewId,
+        position: 0,
+        isVisible: true,
+      },
+      {
+        name: 'Second Group',
+        viewId: testSetup.testViewId,
+        position: 1,
+        isVisible: false,
+      },
+      {
+        name: 'Third Group',
+        viewId: testSetup.testViewId,
+        position: 2,
+        isVisible: true,
+      },
+    ];
+
+    const {
+      data: { createManyViewFieldGroups: createdViewFieldGroups },
+      errors,
+    } = await createManyViewFieldGroups({
+      inputs,
+      expectToFail: false,
+    });
+
+    expect(errors).toBeUndefined();
+    expect(createdViewFieldGroups).toBeDefined();
+    expect(createdViewFieldGroups).toHaveLength(3);
+
+    createdViewFieldGroups.forEach((viewFieldGroup, index) => {
+      expect(viewFieldGroup).toMatchObject({
+        name: inputs[index].name,
+        viewId: testSetup.testViewId,
+        position: inputs[index].position,
+        isVisible: inputs[index].isVisible,
+      });
+
+      createdViewFieldGroupIds.push(viewFieldGroup.id);
+    });
+  });
+
+  it('should successfully create single view field group using batch endpoint', async () => {
+    const inputs: CreateViewFieldGroupInput[] = [
+      {
+        name: 'Single Batch Group',
+        viewId: testSetup.testViewId,
+        position: 5,
+        isVisible: true,
+      },
+    ];
+
+    const {
+      data: { createManyViewFieldGroups: createdViewFieldGroups },
+      errors,
+    } = await createManyViewFieldGroups({
+      inputs,
+      expectToFail: false,
+    });
+
+    expect(errors).toBeUndefined();
+    expect(createdViewFieldGroups).toBeDefined();
+    expect(createdViewFieldGroups).toHaveLength(1);
+
+    const viewFieldGroup = createdViewFieldGroups[0];
+
+    expect(viewFieldGroup).toMatchObject({
+      name: 'Single Batch Group',
+      viewId: testSetup.testViewId,
+      position: 5,
+      isVisible: true,
+    });
+
+    createdViewFieldGroupIds.push(viewFieldGroup.id);
+  });
+
+  it('should return empty array when creating zero view field groups', async () => {
+    const inputs: CreateViewFieldGroupInput[] = [];
+
+    const {
+      data: { createManyViewFieldGroups: createdViewFieldGroups },
+      errors,
+    } = await createManyViewFieldGroups({
+      inputs,
+      expectToFail: false,
+    });
+
+    expect(errors).toBeUndefined();
+    expect(createdViewFieldGroups).toBeDefined();
+    expect(createdViewFieldGroups).toHaveLength(0);
+  });
+});

packages/twenty-server/test/integration/graphql/suites/view/view-field-group/successful-create-view-field-group.integration-spec.ts

@@ -0,0 +1,127 @@
+import {
+  type ViewFieldGroupTestSetup,
+  cleanupViewFieldGroupTest,
+  setupViewFieldGroupTest,
+} from 'test/integration/graphql/suites/view/utils/setup-view-field-group-test.util';
+import { createOneViewFieldGroup } from 'test/integration/metadata/suites/view-field-group/utils/create-one-view-field-group.util';
+import { deleteOneViewFieldGroup } from 'test/integration/metadata/suites/view-field-group/utils/delete-one-view-field-group.util';
+import { destroyOneViewFieldGroup } from 'test/integration/metadata/suites/view-field-group/utils/destroy-one-view-field-group.util';
+import { assertViewFieldGroupStructure } from 'test/integration/utils/view-test.util';
+import {
+  type EachTestingContext,
+  eachTestingContextFilter,
+} from 'twenty-shared/testing';
+import { isDefined } from 'twenty-shared/utils';
+
+import { type CreateViewFieldGroupInput } from 'src/engine/metadata-modules/view-field-group/dtos/inputs/create-view-field-group.input';
+import { type ViewFieldGroupDTO } from 'src/engine/metadata-modules/view-field-group/dtos/view-field-group.dto';
+
+type TestContext = {
+  viewFieldGroupInput: (
+    testSetup: ViewFieldGroupTestSetup,
+  ) => CreateViewFieldGroupInput;
+  expected: Partial<ViewFieldGroupDTO>;
+};
+
+describe('View Field Group Resolver - Successful Create Operations', () => {
+  let testSetup: ViewFieldGroupTestSetup;
+  let createdViewFieldGroupId: string | undefined;
+
+  beforeAll(async () => {
+    testSetup = await setupViewFieldGroupTest();
+  });
+
+  afterAll(async () => {
+    await cleanupViewFieldGroupTest(testSetup.testObjectMetadataId);
+  });
+
+  afterEach(async () => {
+    if (isDefined(createdViewFieldGroupId)) {
+      const {
+        data: { deleteViewFieldGroup },
+      } = await deleteOneViewFieldGroup({
+        expectToFail: false,
+        input: {
+          id: createdViewFieldGroupId,
+        },
+      });
+
+      expect(deleteViewFieldGroup.deletedAt).not.toBeNull();
+      await destroyOneViewFieldGroup({
+        expectToFail: false,
+        input: {
+          id: createdViewFieldGroupId,
+        },
+      });
+      createdViewFieldGroupId = undefined;
+    }
+  });
+
+  const successfulTestCases: EachTestingContext<TestContext>[] = [
+    {
+      title: 'visible group with position',
+      context: {
+        viewFieldGroupInput: (testSetup) => ({
+          name: 'Test Group',
+          viewId: testSetup.testViewId,
+          position: 1,
+          isVisible: true,
+        }),
+        expected: {
+          name: 'Test Group',
+          position: 1,
+          isVisible: true,
+        },
+      },
+    },
+    {
+      title: 'hidden group with position',
+      context: {
+        viewFieldGroupInput: (testSetup) => ({
+          name: 'Hidden Group',
+          viewId: testSetup.testViewId,
+          position: 2,
+          isVisible: false,
+        }),
+        expected: {
+          name: 'Hidden Group',
+          position: 2,
+          isVisible: false,
+        },
+      },
+    },
+    {
+      title: 'group with minimum required properties',
+      context: {
+        viewFieldGroupInput: (testSetup) => ({
+          name: 'Minimal Group',
+          viewId: testSetup.testViewId,
+        }),
+        expected: {
+          name: 'Minimal Group',
+          position: 0,
+          isVisible: true,
+        },
+      },
+    },
+  ];
+
+  test.each(eachTestingContextFilter(successfulTestCases))(
+    'Create $title',
+    async ({ context: { viewFieldGroupInput, expected } }) => {
+      const response = await createOneViewFieldGroup({
+        input: viewFieldGroupInput(testSetup),
+        expectToFail: false,
+      });
+
+      expect(response.errors).toBeUndefined();
+      expect(response.data.createViewFieldGroup).toBeDefined();
+      createdViewFieldGroupId = response.data.createViewFieldGroup.id;
+
+      assertViewFieldGroupStructure(response.data.createViewFieldGroup, {
+        viewId: testSetup.testViewId,
+        ...expected,
+      });
+    },
+  );
+});