Add uuid flag validation (#180)

* Added custom flag type: uuid

* CustomFlags is now uppercase.

* Changed flag type from Flags.string to CustomFlags.uuid where appropriate. Added integration tests.

* Updated documentation.

* Updated test name.

* Updated a test.

Author: Nadegamra

docs/access-control/member/group/add.md

@@ -12,7 +12,7 @@ Groups and their roles can be provided to this command in multiple ways:
   The ID of the iTwin to which the groups will be added.  
   **Type:** `string` **Required:** Yes
 
-- **`--group-id`**  
+- **`-g, --group-id`**  
   Specify id of the group to add roles to. This flag can be provided multiple times.  
   **Type:** `string` **Required:** No **Multiple:** Yes
 

integration-tests/access-control/group.test.ts

@@ -128,6 +128,30 @@ const tests = () => {
     expect(updateError).to.not.be.undefined;
     expect(updateError?.message).to.be.equal("A maximum of 50 ims groups can be provided.");
   });
+
+  it("Should return an error when invalid uuid is provided as --itwin-id", async () => {
+    const { error: infoError } = await runCommand<Group>(`access-control group info -i an-invalid-uuid -g ${crypto.randomUUID()}`);
+    expect(infoError?.message).to.contain("'an-invalid-uuid' is not a valid UUID.");
+
+    const { error: updateError } = await runCommand<Group>(`access-control group update -i an-invalid-uuid -g ${crypto.randomUUID()}`);
+    expect(updateError?.message).to.contain("'an-invalid-uuid' is not a valid UUID.");
+
+    const { error: deleteError } = await runCommand<ResultResponse>(`access-control group delete --itwin-id an-invalid-uuid --group-id ${crypto.randomUUID()}`);
+    expect(deleteError?.message).to.contain("'an-invalid-uuid' is not a valid UUID.");
+  });
+
+  it("Should return an error when invalid uuid is provided as --group-id", async () => {
+    const { error: infoError } = await runCommand<Group>(`access-control group info -i ${crypto.randomUUID()} -g another-invalid-uuid`);
+    expect(infoError?.message).to.contain("'another-invalid-uuid' is not a valid UUID.");
+
+    const { error: updateError } = await runCommand<Group>(`access-control group update -i ${crypto.randomUUID()} -g another-invalid-uuid`);
+    expect(updateError?.message).to.contain("'another-invalid-uuid' is not a valid UUID.");
+
+    const { error: deleteError } = await runCommand<ResultResponse>(
+      `access-control group delete --itwin-id ${crypto.randomUUID()} --group-id another-invalid-uuid`,
+    );
+    expect(deleteError?.message).to.contain("'another-invalid-uuid' is not a valid UUID.");
+  });
 };
 
 export default tests;

integration-tests/access-control/member/group.test.ts

@@ -314,12 +314,54 @@ const tests = () => {
   it("Should return an error when there are too many roles assigned", async () => {
     let command = `access-control member group update --itwin-id ${iTwinId} --group-id ${groupId1}`;
 
-    for (let i = 0; i < 51; i++) command += ` --role-id role${i}`;
+    for (let i = 0; i < 51; i++) command += ` --role-id ${crypto.randomUUID()}`;
 
     const { error: createError } = await runCommand<GroupMemberInfo[]>(command);
     expect(createError).to.not.be.undefined;
     expect(createError?.message).to.be.equal("A maximum of 50 roles can be assigned.");
   });
+
+  it("Should return an error when invalid uuid is provided as --itwin-id", async () => {
+    const { error: addError } = await runCommand<Group>(`access-control member group add -i an-invalid-uuid -g ${crypto.randomUUID()}`);
+    expect(addError?.message).to.contain("'an-invalid-uuid' is not a valid UUID.");
+
+    const { error: infoError } = await runCommand<Group>(`access-control member group info -i an-invalid-uuid -g ${crypto.randomUUID()}`);
+    expect(infoError?.message).to.contain("'an-invalid-uuid' is not a valid UUID.");
+
+    const { error: listError } = await runCommand<Group>(`access-control member group list -i an-invalid-uuid -g ${crypto.randomUUID()}`);
+    expect(listError?.message).to.contain("'an-invalid-uuid' is not a valid UUID.");
+
+    const { error: updateError } = await runCommand<Group>(`access-control member group update -i an-invalid-uuid -g ${crypto.randomUUID()}`);
+    expect(updateError?.message).to.contain("'an-invalid-uuid' is not a valid UUID.");
+
+    const { error: deleteError } = await runCommand<ResultResponse>(
+      `access-control member group delete --itwin-id an-invalid-uuid --group-id ${crypto.randomUUID()}`,
+    );
+    expect(deleteError?.message).to.contain("'an-invalid-uuid' is not a valid UUID.");
+  });
+
+  it("Should return an error when invalid uuid is provided as --group-id", async () => {
+    const { error: addError } = await runCommand<Group>(`access-control member group add -i ${crypto.randomUUID()} -g another-invalid-uuid`);
+    expect(addError?.message).to.contain("'another-invalid-uuid' is not a valid UUID.");
+
+    const { error: infoError } = await runCommand<Group>(`access-control member group info -i ${crypto.randomUUID()} -g another-invalid-uuid`);
+    expect(infoError?.message).to.contain("'another-invalid-uuid' is not a valid UUID.");
+
+    const { error: updateError } = await runCommand<Group>(`access-control member group update -i ${crypto.randomUUID()} -g another-invalid-uuid`);
+    expect(updateError?.message).to.contain("'another-invalid-uuid' is not a valid UUID.");
+
+    const { error: deleteError } = await runCommand<ResultResponse>(
+      `access-control member group delete --itwin-id ${crypto.randomUUID()} --group-id another-invalid-uuid`,
+    );
+    expect(deleteError?.message).to.contain("'another-invalid-uuid' is not a valid UUID.");
+  });
+
+  it("Should return an error when invalid uuid is provided as --role-id", async () => {
+    const { error: updateError } = await runCommand<Group>(
+      `access-control member group update -i ${crypto.randomUUID()} -g ${crypto.randomUUID()} --role-id ${crypto.randomUUID()} --role-id an-invalid-uuid`,
+    );
+    expect(updateError?.message).to.contain("'an-invalid-uuid' is not a valid UUID.");
+  });
 };
 
 export default tests;

integration-tests/access-control/member/owner.test.ts

@@ -73,6 +73,26 @@ const tests = () => {
     expect(userInfo!.id).to.not.be.undefined;
     expect(owners!.some((owner) => owner.id === userInfo!.id)).to.be.true;
   });
+
+  it("Should return an error when invalid uuid is provided as --itwin-id", async () => {
+    const { error: addError } = await runCommand<GroupMember>(`access-control member owner add -i an-invalid-uuid --email [email protected]`);
+    expect(addError?.message).to.contain("'an-invalid-uuid' is not a valid UUID.");
+
+    const { error: listError } = await runCommand<GroupMember>(`access-control member owner list -i an-invalid-uuid`);
+    expect(listError?.message).to.contain("'an-invalid-uuid' is not a valid UUID.");
+
+    const { error: deleteError } = await runCommand<ResultResponse>(
+      `access-control member owner delete --itwin-id an-invalid-uuid --member-id ${crypto.randomUUID()}`,
+    );
+    expect(deleteError?.message).to.contain("'an-invalid-uuid' is not a valid UUID.");
+  });
+
+  it("Should return an error when invalid uuid is provided as --member-id", async () => {
+    const { error: deleteError } = await runCommand<ResultResponse>(
+      `access-control member owner delete --itwin-id ${crypto.randomUUID()} --member-id an-invalid-uuid`,
+    );
+    expect(deleteError?.message).to.contain("'an-invalid-uuid' is not a valid UUID.");
+  });
 };
 
 export default tests;

integration-tests/access-control/member/user.test.ts

@@ -314,12 +314,57 @@ const tests = () => {
     expect(usersInfo!).to.have.lengthOf(1);
 
     let command = `access-control member user update --itwin-id ${iTwinId} --member-id ${usersInfo![0].id}`;
-    for (let i = 0; i < 51; i++) command += ` --role-id role${i}`;
+    for (let i = 0; i < 51; i++) command += ` --role-id ${crypto.randomUUID()}`;
 
     const result = await runCommand<MembersResponse>(command);
     expect(result.error).to.not.be.undefined;
     expect(result.error?.message).to.be.equal("A maximum of 50 roles can be assigned.");
   });
+
+  it("Should return an error when invalid uuid is provided as --itwin-id", async () => {
+    const { error: addError } = await runCommand<Member>(
+      `access-control member user add -i an-invalid-uuid --email [email protected] --role-ids ${crypto.randomUUID()},${crypto.randomUUID()}`,
+    );
+    expect(addError?.message).to.contain("'an-invalid-uuid' is not a valid UUID.");
+
+    const { error: infoError } = await runCommand<Member>(`access-control member user info -i an-invalid-uuid --member-id ${crypto.randomUUID()}`);
+    expect(infoError?.message).to.contain("'an-invalid-uuid' is not a valid UUID.");
+
+    const { error: listError } = await runCommand<Member>(`access-control member user list -i an-invalid-uuid`);
+    expect(listError?.message).to.contain("'an-invalid-uuid' is not a valid UUID.");
+
+    const { error: updateError } = await runCommand<Member>(
+      `access-control member user update -i an-invalid-uuid --member-id ${crypto.randomUUID()} --role-id ${crypto.randomUUID()}`,
+    );
+    expect(updateError?.message).to.contain("'an-invalid-uuid' is not a valid UUID.");
+
+    const { error: deleteError } = await runCommand<ResultResponse>(
+      `access-control member user delete --itwin-id an-invalid-uuid --member-id ${crypto.randomUUID()}`,
+    );
+    expect(deleteError?.message).to.contain("'an-invalid-uuid' is not a valid UUID.");
+  });
+
+  it("Should return an error when invalid uuid is provided as --member-id", async () => {
+    const { error: infoError } = await runCommand<Member>(`access-control member user info -i ${crypto.randomUUID()} --member-id an-invalid-uuid`);
+    expect(infoError?.message).to.contain("'an-invalid-uuid' is not a valid UUID.");
+
+    const { error: updateError } = await runCommand<Member>(
+      `access-control member user update -i ${crypto.randomUUID()} --member-id an-invalid-uuid --role-id ${crypto.randomUUID()}`,
+    );
+    expect(updateError?.message).to.contain("'an-invalid-uuid' is not a valid UUID.");
+
+    const { error: deleteError } = await runCommand<ResultResponse>(
+      `access-control member user delete --itwin-id ${crypto.randomUUID()} --member-id an-invalid-uuid`,
+    );
+    expect(deleteError?.message).to.contain("'an-invalid-uuid' is not a valid UUID.");
+  });
+
+  it("Should return an error when invalid uuid is provided as --role-id", async () => {
+    const { error: updateError } = await runCommand<Member>(
+      `access-control member user update -i ${crypto.randomUUID()} --member-id ${crypto.randomUUID()} --role-id an-invalid-uuid`,
+    );
+    expect(updateError?.message).to.contain("'an-invalid-uuid' is not a valid UUID.");
+  });
 };
 
 export default tests;

integration-tests/access-control/role.test.ts

@@ -85,6 +85,34 @@ const tests = () => {
     const { result: deleteResult } = await runCommand<ResultResponse>(`access-control role delete --itwin-id ${iTwinId} --role-id ${newRole!.id}`);
     expect(deleteResult).to.have.property("result", "deleted");
   });
+
+  it("Should return an error when invalid uuid is provided as --itwin-id", async () => {
+    const { error: addError } = await runCommand<Role>(`access-control role create -i an-invalid-uuid -n Name -d Description`);
+    expect(addError?.message).to.contain("'an-invalid-uuid' is not a valid UUID.");
+
+    const { error: infoError } = await runCommand<Role>(`access-control role info -i an-invalid-uuid --role-id ${crypto.randomUUID()}`);
+    expect(infoError?.message).to.contain("'an-invalid-uuid' is not a valid UUID.");
+
+    const { error: listError } = await runCommand<Role>(`access-control role list -i an-invalid-uuid`);
+    expect(listError?.message).to.contain("'an-invalid-uuid' is not a valid UUID.");
+
+    const { error: updateError } = await runCommand<Role>(`access-control role update -i an-invalid-uuid  --role-id ${crypto.randomUUID()} --name NewName`);
+    expect(updateError?.message).to.contain("'an-invalid-uuid' is not a valid UUID.");
+
+    const { error: deleteError } = await runCommand<ResultResponse>(`access-control role delete --itwin-id an-invalid-uuid --role-id ${crypto.randomUUID()}`);
+    expect(deleteError?.message).to.contain("'an-invalid-uuid' is not a valid UUID.");
+  });
+
+  it("Should return an error when invalid uuid is provided as --role-id", async () => {
+    const { error: infoError } = await runCommand<Role>(`access-control role info -i ${crypto.randomUUID()} --role-id an-invalid-uuid`);
+    expect(infoError?.message).to.contain("'an-invalid-uuid' is not a valid UUID.");
+
+    const { error: updateError } = await runCommand<Role>(`access-control role update -i ${crypto.randomUUID()} --role-id an-invalid-uuid --name NewName`);
+    expect(updateError?.message).to.contain("'an-invalid-uuid' is not a valid UUID.");
+
+    const { error: deleteError } = await runCommand<ResultResponse>(`access-control role delete --itwin-id ${crypto.randomUUID()} --role-id an-invalid-uuid`);
+    expect(deleteError?.message).to.contain("'an-invalid-uuid' is not a valid UUID.");
+  });
 };
 
 export default tests;

integration-tests/context/context.test.ts

@@ -71,9 +71,8 @@ const tests = () =>
       expect(output2.result).to.deep.equal({ iModelId: undefined, iTwinId: anotherITwin.id });
     });
 
-    it("should fail to set context with invalid iTwin ID", async () => {
-      const invalidITwinId = "invalid-id";
-      const output = await runCommand(`context set --itwin-id ${invalidITwinId}`);
+    it("should fail to set context with not found iTwin ID", async () => {
+      const output = await runCommand(`context set --itwin-id ${crypto.randomUUID()}`);
       expect(output.error).to.not.be.undefined;
       expect(output.error?.message).to.contain("Requested iTwin is not available.");
     });
@@ -124,11 +123,21 @@ const tests = () =>
     });
 
     it("should fail to set context with only an iModel ID if the iModel does not exist", async () => {
-      const invalidIModelId = "invalid-id";
+      const invalidIModelId = crypto.randomUUID();
       const output = await runCommand(`context set --imodel-id ${invalidIModelId}`);
       expect(output.error).to.not.be.undefined;
       expect(output.error?.message).to.contain("Requested iModel is not available.");
     });
+
+    it("should fail to set context when --itwin-id or --imodel-id in not a valid uuid", async () => {
+      const { error: iModelIdError } = await runCommand(`context set --imodel-id an-invalid-uuid`);
+      expect(iModelIdError).to.not.be.undefined;
+      expect(iModelIdError?.message).to.contain("'an-invalid-uuid' is not a valid UUID.");
+
+      const { error: iTwinIdError } = await runCommand(`context set --itwin-id an-invalid-uuid`);
+      expect(iTwinIdError).to.not.be.undefined;
+      expect(iTwinIdError?.message).to.contain("'an-invalid-uuid' is not a valid UUID.");
+    });
   });
 
 export default tests;

integration-tests/imodel/connection/create.test.ts

@@ -91,6 +91,14 @@ const tests = () =>
         "When multiple connector-type options are provided, their amount must match file-id option amount. Alternatively, you can provide a single connector-type option, which will then be applied to all file-id options.",
       );
     });
+
+    it(`should return an error when invalid uuid is provided as --imodel-id`, async () => {
+      const { error: createError } = await runCommand<StorageConnection>(
+        `imodel connection create -m an-invalid-uuid -f ${testFileId1} --connector-type MSTN -n TestConnection`,
+      );
+      expect(createError).to.not.be.undefined;
+      expect(createError!.message).to.contain("'an-invalid-uuid' is not a valid UUID.");
+    });
   });
 
 export default tests;

integration-tests/imodel/connection/list.test.ts

@@ -80,6 +80,11 @@ const tests = () =>
       expect(filteredConnections!.connections).to.have.lengthOf(1);
       expect(filteredConnections!.connections[0].id).to.be.equal(allConnections!.connections[1].id);
     });
+
+    it("should return an error when invalid uuid is provided as --imodel-id", async () => {
+      const { error } = await runCommand<StorageConnectionListResponse>(`imodel connection list -m an-invalid-uuid`);
+      expect(error?.message).to.contain("'an-invalid-uuid' is not a valid UUID.");
+    });
   });
 
 export default tests;

integration-tests/imodel/connection/sourcefile.test.ts

@@ -136,6 +136,21 @@ const tests = () =>
       );
       expect(deleteResult2).to.have.property("result", "deleted");
     });
+
+    it("Should return an error when invalid uuid is provided as --source-file-id", async () => {
+      const { error: infoError } = await runCommand<SourceFile>(`imodel connection sourcefile info -c some-connection-id --source-file-id an-invalid-uuid`);
+      expect(infoError?.message).to.contain("'an-invalid-uuid' is not a valid UUID.");
+
+      const { error: updateError } = await runCommand<SourceFile>(
+        `imodel connection sourcefile update -c some-connection-id --connector-type MSTN --storage-file-id some-id --source-file-id an-invalid-uuid`,
+      );
+      expect(updateError?.message).to.contain("'an-invalid-uuid' is not a valid UUID.");
+
+      const { error: deleteError } = await runCommand<ResultResponse>(
+        `imodel connection sourcefile delete -c some-connection-id --source-file-id an-invalid-uuid`,
+      );
+      expect(deleteError?.message).to.contain("'an-invalid-uuid' is not a valid UUID.");
+    });
   });
 
 export default tests;