feat: coverage control in pipeline (#1303)

Signed-off-by: mamoralesiob <miguelangel@io.builders>

Author: mamoralesiob

packages/ats/contracts/test/contracts/integration/accessControl/accessControl.test.ts

@@ -26,52 +26,52 @@ export function accessControlTests(getCtx: () => AssetMockCtx): void {
       await executeRbac(asset, [{ role: ATS_ROLES.ROLE_PAUSER, members: [ctx.user1.address] }]);
     });
 
-    it("GIVEN a deactivated asset WHEN grantRole THEN transaction fails with Deactivated", async () => {
+    it.only("GIVEN a deactivated asset WHEN grantRole THEN transaction fails with Deactivated", async () => {
       await asset.forceDeactivate();
       await expect(
         asset.connect(deployer).grantRole(ATS_ROLES.ROLE_PAUSER, unknownSigner.address),
       ).to.be.revertedWithCustomError(asset, "Deactivated");
     });
 
-    it("GIVEN an account without administrative role WHEN grantRole THEN transaction fails with AccountHasNoRole", async () => {
+    it.only("GIVEN an account without administrative role WHEN grantRole THEN transaction fails with AccountHasNoRole", async () => {
       await expect(asset.connect(signer_C).grantRole(ATS_ROLES.ROLE_PAUSER, unknownSigner.address))
         .to.be.revertedWithCustomError(asset, "AccountHasNoRole")
         .withArgs(signer_C.address, ATS_ROLES.DEFAULT_ADMIN_ROLE);
     });
 
-    it("GIVEN a deactivated asset WHEN revokeRole THEN transaction fails with Deactivated", async () => {
+    it.only("GIVEN a deactivated asset WHEN revokeRole THEN transaction fails with Deactivated", async () => {
       await asset.forceDeactivate();
       await expect(
         asset.connect(deployer).revokeRole(ATS_ROLES.DEFAULT_ADMIN_ROLE, unknownSigner.address),
       ).to.be.revertedWithCustomError(asset, "Deactivated");
     });
 
-    it("GIVEN an account without administrative role WHEN revokeRole THEN transaction fails with AccountHasNoRole", async () => {
+    it.only("GIVEN an account without administrative role WHEN revokeRole THEN transaction fails with AccountHasNoRole", async () => {
       await expect(asset.connect(signer_C).revokeRole(ATS_ROLES.DEFAULT_ADMIN_ROLE, unknownSigner.address))
         .to.be.revertedWithCustomError(asset, "AccountHasNoRole")
         .withArgs(signer_C.address, ATS_ROLES.DEFAULT_ADMIN_ROLE);
     });
 
-    it("GIVEN a deactivated asset WHEN applyRoles THEN transaction fails with Deactivated", async () => {
+    it.only("GIVEN a deactivated asset WHEN applyRoles THEN transaction fails with Deactivated", async () => {
       await asset.forceDeactivate();
       await expect(
         asset.connect(signer_C).applyRoles([ATS_ROLES.DEFAULT_ADMIN_ROLE], [true], unknownSigner.address),
       ).to.be.revertedWithCustomError(asset, "Deactivated");
     });
 
-    it("GIVEN an account without administrative role WHEN applyRoles THEN transaction fails with AccountHasNoRole", async () => {
+    it.only("GIVEN an account without administrative role WHEN applyRoles THEN transaction fails with AccountHasNoRole", async () => {
       await expect(asset.connect(signer_C).applyRoles([ATS_ROLES.DEFAULT_ADMIN_ROLE], [true], unknownSigner.address))
         .to.be.revertedWithCustomError(asset, "AccountHasNoRole")
         .withArgs(signer_C.address, ATS_ROLES.DEFAULT_ADMIN_ROLE);
     });
 
-    it("GIVEN a list of roles and actives that is not equally long WHEN applyRoles THEN transaction fails with RolesAndActivesLengthMismatch", async () => {
+    it.only("GIVEN a list of roles and actives that is not equally long WHEN applyRoles THEN transaction fails with RolesAndActivesLengthMismatch", async () => {
       await expect(asset.connect(signer_C).applyRoles([ATS_ROLES.DEFAULT_ADMIN_ROLE], [], unknownSigner.address))
         .to.be.revertedWithCustomError(asset, "RolesAndActivesLengthMismatch")
         .withArgs(1, 0);
     });
 
-    it("GIVEN a list of contradictory roles (enable and disable) role WHEN applyRoles THEN transaction fails with ApplyRoleContradiction", async () => {
+    it.only("GIVEN a list of contradictory roles (enable and disable) role WHEN applyRoles THEN transaction fails with ApplyRoleContradiction", async () => {
       const Roles_1 = [
         ATS_ROLES.DEFAULT_ADMIN_ROLE,
         ATS_ROLES.ROLE_PAUSER,
@@ -96,31 +96,31 @@ export function accessControlTests(getCtx: () => AssetMockCtx): void {
         .withArgs(3, 6);
     });
 
-    it("GIVEN a paused Token WHEN grantRole THEN transaction fails with IsPaused", async () => {
+    it.only("GIVEN a paused Token WHEN grantRole THEN transaction fails with IsPaused", async () => {
       await asset.connect(signer_B).pause();
 
       await expect(
         asset.connect(deployer).grantRole(ATS_ROLES.ROLE_PAUSER, unknownSigner.address),
       ).to.be.revertedWithCustomError(asset, "IsPaused");
     });
 
-    it("GIVEN a paused Token WHEN revokeRole THEN transaction fails with IsPaused", async () => {
+    it.only("GIVEN a paused Token WHEN revokeRole THEN transaction fails with IsPaused", async () => {
       await asset.connect(signer_B).pause();
 
       await expect(
         asset.connect(deployer).revokeRole(ATS_ROLES.ROLE_PAUSER, unknownSigner.address),
       ).to.be.revertedWithCustomError(asset, "IsPaused");
     });
 
-    it("GIVEN a deactivated asset WHEN renounceRole THEN transaction fails with Deactivated", async () => {
+    it.only("GIVEN a deactivated asset WHEN renounceRole THEN transaction fails with Deactivated", async () => {
       await asset.forceDeactivate();
       await expect(asset.connect(signer_C).renounceRole(ATS_ROLES.ROLE_PAUSER)).to.be.revertedWithCustomError(
         asset,
         "Deactivated",
       );
     });
 
-    it("GIVEN a paused Token WHEN renounce THEN transaction fails with IsPaused", async () => {
+    it.only("GIVEN a paused Token WHEN renounce THEN transaction fails with IsPaused", async () => {
       // Pausing the token
       await asset.connect(signer_B).pause();
 
@@ -131,7 +131,7 @@ export function accessControlTests(getCtx: () => AssetMockCtx): void {
       );
     });
 
-    it("GIVEN an paused Token WHEN applyRoles THEN transaction fails with IsPaused", async () => {
+    it.only("GIVEN an paused Token WHEN applyRoles THEN transaction fails with IsPaused", async () => {
       // Pausing the token
       await asset.connect(signer_B).pause();
 
@@ -141,7 +141,7 @@ export function accessControlTests(getCtx: () => AssetMockCtx): void {
       ).to.be.revertedWithCustomError(asset, "IsPaused");
     });
 
-    it("GIVEN an account with administrative role WHEN grantRole THEN transaction succeeds", async () => {
+    it.only("GIVEN an account with administrative role WHEN grantRole THEN transaction succeeds", async () => {
       // check that C does not have the role
       let check_C = await asset.hasRole(ATS_ROLES.ROLE_PAUSER, unknownSigner.address);
       expect(check_C).to.equal(false);
@@ -168,7 +168,7 @@ export function accessControlTests(getCtx: () => AssetMockCtx): void {
       expect(membersFor_Pause[1].toUpperCase()).to.equal(unknownSigner.address.toUpperCase());
     });
 
-    it("GIVEN an account with administrative role WHEN revokeRole THEN transaction succeeds", async () => {
+    it.only("GIVEN an account with administrative role WHEN revokeRole THEN transaction succeeds", async () => {
       // check that B has the role
       let check_B = await asset.hasRole(ATS_ROLES.ROLE_PAUSER, signer_B.address);
       expect(check_B).to.equal(true);
@@ -192,7 +192,7 @@ export function accessControlTests(getCtx: () => AssetMockCtx): void {
       expect(membersFor_Pause.length).to.equal(memberCountFor_Pause);
     });
 
-    it("GIVEN an account with pauser role WHEN renouncing the pauser role THEN transaction succeeds", async () => {
+    it.only("GIVEN an account with pauser role WHEN renouncing the pauser role THEN transaction succeeds", async () => {
       // check that B has the role
       let check_B = await asset.hasRole(ATS_ROLES.ROLE_PAUSER, signer_B.address);
       expect(check_B).to.equal(true);
@@ -216,7 +216,7 @@ export function accessControlTests(getCtx: () => AssetMockCtx): void {
       expect(membersFor_Pause.length).to.equal(memberCountFor_Pause);
     });
 
-    it("GIVEN an account with administrative role WHEN applyRoles THEN transaction succeeds", async () => {
+    it.only("GIVEN an account with administrative role WHEN applyRoles THEN transaction succeeds", async () => {
       // check that C does not have the role
       await asset.connect(deployer).grantRole(ATS_ROLES.ROLE_PAUSER, signer_C.address);
 
@@ -256,7 +256,7 @@ export function accessControlTests(getCtx: () => AssetMockCtx): void {
       expect(membersFor_Default[1].toUpperCase()).to.equal(signer_C.address.toUpperCase());
     });
 
-    it("GIVEN an account with administrative role, if roles are duplicated but not contradictory WHEN applyRoles THEN transaction succeeds", async () => {
+    it.only("GIVEN an account with administrative role, if roles are duplicated but not contradictory WHEN applyRoles THEN transaction succeeds", async () => {
       // check that C does not have the role
       await asset.connect(deployer).grantRole(ATS_ROLES.ROLE_PAUSER, signer_C.address);
 
@@ -291,7 +291,7 @@ export function accessControlTests(getCtx: () => AssetMockCtx): void {
       expect(rolesFor_C[0].toUpperCase()).to.equal(ATS_ROLES.ROLE_PAUSER.toUpperCase());
     });
 
-    it("GIVEN a mixed batch of effective and no-op entries WHEN applyRoles THEN RolesApplied carries only the effectively changed entries in input order", async () => {
+    it.only("GIVEN a mixed batch of effective and no-op entries WHEN applyRoles THEN RolesApplied carries only the effectively changed entries in input order", async () => {
       // Pre-state: signer_C holds ROLE_PAUSER and ROLE_AGENT, nothing else.
       await asset.connect(deployer).grantRole(ATS_ROLES.ROLE_PAUSER, signer_C.address);
       await asset.connect(deployer).grantRole(ATS_ROLES.ROLE_AGENT, signer_C.address);
@@ -325,7 +325,7 @@ export function accessControlTests(getCtx: () => AssetMockCtx): void {
       expect(await asset.hasRole(ATS_ROLES.ROLE_MATURITY_MANAGER, signer_C.address)).to.equal(false);
     });
 
-    it("GIVEN an account that already has a role WHEN grantRole is called again THEN transaction fails with AccountAssignedToRole", async () => {
+    it.only("GIVEN an account that already has a role WHEN grantRole is called again THEN transaction fails with AccountAssignedToRole", async () => {
       // Grant the role first time
       await asset.connect(deployer).grantRole(ATS_ROLES.ROLE_PAUSER, unknownSigner.address);
 
@@ -338,7 +338,7 @@ export function accessControlTests(getCtx: () => AssetMockCtx): void {
         .withArgs(ATS_ROLES.ROLE_PAUSER, unknownSigner.address);
     });
 
-    it("GIVEN an account without a specific role WHEN revokeRole is called THEN transaction fails with AccountNotAssignedToRole", async () => {
+    it.only("GIVEN an account without a specific role WHEN revokeRole is called THEN transaction fails with AccountNotAssignedToRole", async () => {
       // Verify that the account does not have the role
       expect(await asset.hasRole(ATS_ROLES.ROLE_PAUSER, unknownSigner.address)).to.equal(false);
 
@@ -348,7 +348,7 @@ export function accessControlTests(getCtx: () => AssetMockCtx): void {
         .withArgs(ATS_ROLES.ROLE_PAUSER, unknownSigner.address);
     });
 
-    it("GIVEN an account without a specific role WHEN renounceRole is called THEN transaction fails with AccountNotAssignedToRole", async () => {
+    it.only("GIVEN an account without a specific role WHEN renounceRole is called THEN transaction fails with AccountNotAssignedToRole", async () => {
       // Verify that the account does not have the role
       expect(await asset.hasRole(ATS_ROLES.ROLE_PAUSER, unknownSigner.address)).to.equal(false);
 
@@ -358,7 +358,7 @@ export function accessControlTests(getCtx: () => AssetMockCtx): void {
         .withArgs(ATS_ROLES.ROLE_PAUSER, unknownSigner.address);
     });
 
-    it("GIVEN the sole DEFAULT_ADMIN_ROLE holder WHEN renounceRole is called THEN transaction fails with CannotRenounceSoleAdmin", async () => {
+    it.only("GIVEN the sole DEFAULT_ADMIN_ROLE holder WHEN renounceRole is called THEN transaction fails with CannotRenounceSoleAdmin", async () => {
       // Verify deployer is the only admin
       const memberCount = await asset.getRoleMemberCount(ATS_ROLES.DEFAULT_ADMIN_ROLE);
       expect(memberCount).to.equal(1);
@@ -370,7 +370,7 @@ export function accessControlTests(getCtx: () => AssetMockCtx): void {
       );
     });
 
-    it("GIVEN two DEFAULT_ADMIN_ROLE holders WHEN one renounces THEN transaction succeeds and one admin remains", async () => {
+    it.only("GIVEN two DEFAULT_ADMIN_ROLE holders WHEN one renounces THEN transaction succeeds and one admin remains", async () => {
       // Grant DEFAULT_ADMIN_ROLE to signer_C so there are 2 admins
       await asset.connect(deployer).applyRoles([ATS_ROLES.DEFAULT_ADMIN_ROLE], [true], signer_C.address);
       expect(await asset.getRoleMemberCount(ATS_ROLES.DEFAULT_ADMIN_ROLE)).to.equal(2);
@@ -387,21 +387,21 @@ export function accessControlTests(getCtx: () => AssetMockCtx): void {
     });
 
     describe("initializeAccessControl", () => {
-      it("GIVEN a caller without DEFAULT_ADMIN_ROLE WHEN initializeAccessControl is called THEN it reverts with AccountHasNoRole", async () => {
+      it.only("GIVEN a caller without DEFAULT_ADMIN_ROLE WHEN initializeAccessControl is called THEN it reverts with AccountHasNoRole", async () => {
         await expect(asset.connect(unknownSigner).initializeAccessControl())
           .to.be.revertedWithCustomError(asset, "AccountHasNoRole")
           .withArgs(unknownSigner.address, ATS_ROLES.DEFAULT_ADMIN_ROLE);
       });
 
-      it("GIVEN an already-initialised facet WHEN initializeAccessControl is called again THEN it reverts with FacetAlreadyRegistered", async () => {
+      it.only("GIVEN an already-initialised facet WHEN initializeAccessControl is called again THEN it reverts with FacetAlreadyRegistered", async () => {
         await expect(asset.initializeAccessControl())
           .to.be.revertedWithCustomError(asset, "FacetAlreadyRegistered")
           .withArgs(RESOLVER_KEY_ACCESS_CONTROL, 1);
       });
     });
 
     describe("initializeAccessControl event", () => {
-      it("GIVEN a fresh deployment WHEN initializeAccessControl is called THEN it emits AccessControlInitialized", async () => {
+      it.only("GIVEN a fresh deployment WHEN initializeAccessControl is called THEN it emits AccessControlInitialized", async () => {
         await asset.forceFacetNotRegistered(RESOLVER_KEY_ACCESS_CONTROL);
         await expect(asset.initializeAccessControl()).to.emit(asset, "AccessControlInitialized");
       });
@@ -412,25 +412,25 @@ export function accessControlTests(getCtx: () => AssetMockCtx): void {
         await asset.forceNonOperational();
       });
 
-      it("GIVEN non-operational WHEN grantRole is called THEN AssetNotOperational", async () => {
+      it.only("GIVEN non-operational WHEN grantRole is called THEN AssetNotOperational", async () => {
         await expect(asset.grantRole(ATS_ROLES.DEFAULT_ADMIN_ROLE, unknownSigner.address))
           .to.be.revertedWithCustomError(asset, "AssetNotOperational")
           .withArgs(ASSET_MOCK_CONFIG_ID, 1);
       });
 
-      it("GIVEN non-operational WHEN revokeRole is called THEN AssetNotOperational", async () => {
+      it.only("GIVEN non-operational WHEN revokeRole is called THEN AssetNotOperational", async () => {
         await expect(asset.revokeRole(ATS_ROLES.DEFAULT_ADMIN_ROLE, unknownSigner.address))
           .to.be.revertedWithCustomError(asset, "AssetNotOperational")
           .withArgs(ASSET_MOCK_CONFIG_ID, 1);
       });
 
-      it("GIVEN non-operational WHEN renounceRole is called THEN AssetNotOperational", async () => {
+      it.only("GIVEN non-operational WHEN renounceRole is called THEN AssetNotOperational", async () => {
         await expect(asset.renounceRole(ATS_ROLES.DEFAULT_ADMIN_ROLE))
           .to.be.revertedWithCustomError(asset, "AssetNotOperational")
           .withArgs(ASSET_MOCK_CONFIG_ID, 1);
       });
 
-      it("GIVEN non-operational WHEN applyRoles is called THEN AssetNotOperational", async () => {
+      it.only("GIVEN non-operational WHEN applyRoles is called THEN AssetNotOperational", async () => {
         await expect(asset.applyRoles([], [], unknownSigner.address))
           .to.be.revertedWithCustomError(asset, "AssetNotOperational")
           .withArgs(ASSET_MOCK_CONFIG_ID, 1);