@northern.tech/testing 0.1.0

package/dist/requestHandlers/requestHandlers.cjs

@@ -0,0 +1,1712 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/requestHandlers/requestHandlers.ts
+var requestHandlers_exports = {};
+__export(requestHandlers_exports, {
+  default: () => requestHandlers_default
+});
+module.exports = __toCommonJS(requestHandlers_exports);
+var import_msw7 = require("msw");
+
+// src/requestHandlers/deploymentHandlers.ts
+var import_constants2 = require("@northern.tech/utils/constants");
+var import_msw = require("msw");
+
+// src/mockData.ts
+var import_constants = require("@northern.tech/utils/constants");
+var TEST_SESSION_DATETIME = "2019-01-13T13:00:00.000Z";
+var testDate = new Date(TEST_SESSION_DATETIME);
+var mockDate = new Date(testDate.setMilliseconds(testDate.getMilliseconds() + import_constants.maxSessionAge));
+var defaultPassword = "mysecretpassword!123";
+var defaultCreationDate = "2019-01-13T06:25:00.000Z";
+var defaultMacAddress = "dc:a6:32:12:ad:bf";
+var testSsoId = "sso_id";
+var permissionSetObjectTypes = {
+  any: "Any",
+  artifacts: "Artifacts",
+  empty: "",
+  groups: "Device groups",
+  releases: "Releases",
+  tenantManagement: "Tenant management",
+  userManagement: "User management"
+};
+var commonEndpoints = {
+  artifacts: "^/api/management/v1/deployments/artifacts",
+  artifactDetails: "^/api/management/v1/deployments/artifacts/[^/]+",
+  deviceManagement: "^/api/management/(v[1-9])/(devauth|inventory)/"
+};
+var token = "eyJhbGciOiJSUzI1NiIsInR5cCI6IkpXVCJ9.eyJqdGkiOiJjZTNkMGY4Yy1hZWRlLTQwMzAtYjM5MS03ZDUwMjBlYjg3M2UiLCJzdWIiOiJhMzBhNzgwYi1iODQzLTUzNDQtODBlMy0wZmQ5NWE0ZjZmYzMiLCJleHAiOjE2MDY4MTUzNjksImlhdCI6MTYwNjIxMDU2OSwibWVuZGVyLnRlbmFudCI6IjVmODVjMTdiY2U2MmI3ZmE3ZjVmNzA0MCIsIm1lbmRlci51c2VyIjp0cnVlLCJpc3MiOiJNZW5kZXIgVXNlcnMiLCJzY3AiOiJtZW5kZXIuKiIsIm1lbmRlci5wbGFuIjoicHJvZmVzc2lvbmFsIiwibmJmIjoxNjA2MjEwNTY5fQ.qVgYdCzLTf8OdK9uUctqqaY_HWkIiwpekuGvuGQAXCEgOv4bRNDlZRN_ZRSbxQoARG3pquhScbQrjBV9tcF4irTUPlTn3yrsXNO17DpcbTVeKRkb88RDtIKiRw3orVZ_GlIb-ckTQ5dS-Nqlyyf3Fmrhca-gwt6m_xv2UrmJK6eYYTMfggdRRWb-4u7mEkBI_pHPMTQrT8kJ2BeX-vHgazH9AoH0k85LHtFZQXD7pXHlDZRnLxJXukncwMGDmF17374gavYAIyDIzcC8sEBMDnVXgpikeA1sauzirqix6mAVs6XmxdQO7aF0wfXO1_PTYUA3Nk1oQfMYNlEI3U9uLRJRZIq2L8fmrrBryhstKd4y0KlBbGAQrx8NtRkgajjd1ljMfPBUEZrb7uSerVjneiO-aIBO76CuH0zdklphIjpGJeogkBhe8pAYNggp1XsZHgpZfl7IE5faKaDkMGnutaea--Czor6bhqUNCuY4tR0cpQJbNwy6LS9o1CFy4Log";
+var accessTokens = [
+  { id: "some-id-1", expiration_date: "2022-06-02T11:11:21.725Z", name: "some-name-1" },
+  { id: "some-id-2", expiration_date: "2022-06-02T11:11:21.725Z", last_used: "2022-06-02T11:05:21.725Z", name: "some-name-2" }
+];
+var webhookEvents = [
+  {
+    id: "1",
+    type: "device-status-changed",
+    data: { id: "1", status: "accepted" },
+    time: "2020-09-01T12:00:00.000Z",
+    delivery_statuses: [{ integration_id: "1", success: true, status_code: 200 }]
+  },
+  {
+    id: "2",
+    type: "device-status-changed",
+    data: { id: "3", status: "accepted" },
+    time: "2020-09-01T12:00:05.000Z",
+    delivery_statuses: [{ integration_id: "1", success: true, status_code: 200 }]
+  }
+];
+var userId = "a30a780b-b843-5344-80e3-0fd95a4f6fc3";
+var defaultUser = {
+  created_ts: "2019-01-01T10:30:00.000Z",
+  email: "a@b.com",
+  id: "a1",
+  roles: ["RBAC_ROLE_PERMIT_ALL"],
+  tfa_status: "enabled",
+  verified: true
+};
+var deviceTypes = { qemu: "qemux86-64" };
+var checkInTimeRounded = "2019-01-01T00:00:00.000Z";
+var checkInTimeExact = "2019-01-01T10:25:00.000Z";
+var mockApiResponses = {
+  deployments: {
+    byId: {
+      d1: {
+        id: "d1",
+        name: "test deployment",
+        created: "2019-01-01T12:30:00.000Z",
+        devices: {
+          a1: {
+            id: "a1",
+            status: "installing",
+            attributes: {},
+            image: { size: 123 }
+          }
+        },
+        statistics: {
+          status: {
+            "already-installed": 0,
+            decommissioned: 0,
+            downloading: 0,
+            failure: 0,
+            installing: 1,
+            noartifact: 0,
+            pending: 0,
+            rebooting: 0,
+            success: 0
+          },
+          total_size: 1234
+        }
+      },
+      d2: {
+        id: "d2",
+        name: "test deployment 2",
+        artifact_name: "r1",
+        artifacts: ["123"],
+        created: "2019-01-01T12:25:00.000Z",
+        device_count: 1,
+        devices: {
+          b1: {
+            attributes: {},
+            id: "b1",
+            status: "pending"
+          }
+        },
+        filter: void 0,
+        group: void 0,
+        statistics: {
+          status: {
+            downloading: 0,
+            decommissioned: 0,
+            failure: 0,
+            installing: 0,
+            noartifact: 0,
+            pending: 1,
+            rebooting: 0,
+            success: 0,
+            "already-installed": 0
+          }
+        }
+      },
+      d3: {
+        id: "d3",
+        name: "Test",
+        phases: [
+          { id: "0", batch_size: 2, device_count: 2 },
+          { id: "1", start_ts: "2019-02-04T11:45:10.002Z", batch_size: 3, device_count: 3 },
+          { id: "2", start_ts: "2019-02-05T11:45:10.002Z", batch_size: 5, device_count: 5 },
+          { id: "3", start_ts: "2019-02-06T11:45:10.002Z", batch_size: 5, device_count: 5 },
+          { id: "4", start_ts: "2019-02-21T11:45:10.002Z", batch_size: 5, device_count: 0 }
+        ],
+        max_devices: 0,
+        created: "2019-01-31T12:59:30.020Z",
+        devices: {},
+        filter: void 0,
+        group: void 0,
+        stats: {
+          pending: 3,
+          decommissioned: 0,
+          failure: 23,
+          pause_before_committing: 0,
+          pause_before_rebooting: 0,
+          installing: 0,
+          rebooting: 0,
+          "already-installed": 0,
+          pause_before_installing: 0,
+          downloading: 0,
+          success: 6,
+          aborted: 0,
+          noartifact: 0
+        },
+        statistics: { total_size: "1234" },
+        status: "inprogress",
+        active: true,
+        device_count: 100,
+        retries: "0",
+        type: "software"
+      }
+    },
+    byStatus: {
+      pending: { deploymentIds: ["d2"] },
+      inprogress: { deploymentIds: ["d3"] }
+    }
+  },
+  devices: {
+    byId: {
+      a1: {
+        id: "a1",
+        auth_sets: [
+          {
+            id: "auth1",
+            identity_data: { mac: defaultMacAddress },
+            pubkey: "-----BEGIN PUBLIC KEY-----\nMIIBojWELzgJ62hcXIhAfqfoNiaB1326XZByZwcnHr5BuSPAgMBAAE=\n-----END PUBLIC KEY-----\n",
+            status: "accepted",
+            ts: defaultCreationDate
+          }
+        ],
+        updated_ts: "2019-01-01T09:25:00.000Z"
+      },
+      b1: {
+        id: "b1",
+        attributes: {
+          ipv4_wlan0: "192.168.10.141/24",
+          device_type: [deviceTypes.qemu]
+        },
+        system: {
+          check_in_time: checkInTimeRounded
+        },
+        check_in_time: checkInTimeExact,
+        check_in_time_exact: checkInTimeExact,
+        check_in_time_rounded: checkInTimeRounded,
+        identity_data: { mac: defaultMacAddress },
+        status: "accepted",
+        decommissioning: false,
+        created_ts: defaultCreationDate,
+        updated_ts: "2019-01-01T09:25:00.000Z",
+        auth_sets: [
+          {
+            id: "auth1",
+            identity_data: { mac: defaultMacAddress },
+            pubkey: "-----BEGIN PUBLIC KEY-----\nMIIBojWELzgJ62hcXIhAfqfoNiaB1326XZByZwcnHr5BuSPAgMBAAE=\n-----END PUBLIC KEY-----\n",
+            ts: defaultCreationDate,
+            status: "accepted"
+          }
+        ]
+      }
+    },
+    groups: {
+      byId: {
+        testGroup: {
+          deviceIds: ["a1", "b1"],
+          filters: [],
+          total: 2
+        },
+        testGroupDynamic: {
+          id: "filter1",
+          name: "filter1",
+          filters: [{ scope: "system", key: "group", operator: "$eq", value: "things" }]
+        }
+      }
+    },
+    limit: 500,
+    byStatus: {
+      accepted: { deviceIds: ["a1", "b1"], total: 2 },
+      active: { deviceIds: [], total: 0 },
+      inactive: { deviceIds: [], total: 0 },
+      pending: { deviceIds: ["c1"], total: 1 },
+      preauthorized: { deviceIds: [], total: 0 },
+      rejected: { deviceIds: [], total: 0 }
+    }
+  },
+  organization: {
+    organization: {
+      id: "1",
+      addons: [],
+      name: "test",
+      plan: "os",
+      trial: false
+    },
+    intentId: "testIntent",
+    auditlog: {
+      events: [
+        {
+          actor: {
+            id: "string",
+            type: "user",
+            email: "string@example.com"
+          },
+          time: "2019-01-01T12:10:22.667Z",
+          action: "create",
+          object: {
+            id: "string",
+            type: "user",
+            user: {
+              email: "user@acme.com"
+            }
+          },
+          change: "change1"
+        },
+        {
+          actor: {
+            id: "string",
+            type: "user",
+            email: "string",
+            identity_data: "string"
+          },
+          time: "2019-01-01T12:16:22.667Z",
+          action: "create",
+          object: {
+            id: "string",
+            type: "deployment",
+            deployment: {
+              name: "production",
+              artifact_name: "Application 0.0.1"
+            }
+          },
+          change: "change2"
+        },
+        {
+          actor: {
+            id: "string",
+            type: "user",
+            email: "string@example.com"
+          },
+          time: "2019-01-01T12:10:22.669Z",
+          action: "open_terminal",
+          meta: {
+            session_id: ["abd313a8-ee88-48ab-9c99-fbcd80048e6e"]
+          },
+          object: {
+            id: "a1",
+            type: "device"
+          },
+          change: "change3"
+        }
+      ]
+    }
+  },
+  releases: {
+    byId: {
+      r1: {
+        name: "r1",
+        artifacts: [
+          {
+            id: "art1",
+            description: "test description",
+            device_types_compatible: [deviceTypes.qemu],
+            modified: "2020-09-10T12:16:22.667Z",
+            updates: [{ type_info: "testtype" }],
+            artifact_depends: {
+              device_type: [deviceTypes.qemu]
+            },
+            artifact_provides: {
+              artifact_name: "myapp",
+              "data-partition.myapp.version": "v2020.10",
+              list_of_fancy: [deviceTypes.qemu, "x172"]
+            },
+            clears_artifact_provides: ["data-partition.myapp.*"]
+          }
+        ],
+        device_types_compatible: [deviceTypes.qemu],
+        modified: "2020-09-10T12:16:22.667Z",
+        metaData: {}
+      }
+    }
+  },
+  users: {
+    byId: {
+      a1: defaultUser,
+      [userId]: { ...defaultUser, id: userId, email: "a2@b.com", created_ts: "2019-01-01T12:30:00.000Z" }
+    },
+    rolesById: {
+      admin: {
+        name: "admin",
+        description: "Administrator role",
+        permissions: []
+      },
+      test: { name: "test", description: "test description", permissions: [] }
+    },
+    globalSettings: {
+      "2fa": "enabled",
+      id_attribute: void 0,
+      previousFilters: []
+    },
+    userSettings: {
+      "2fa": "disabled",
+      columnSelection: [],
+      onboarding: { something: "here" },
+      tooltips: {},
+      previousFilters: []
+    }
+  }
+};
+var releasesList = Array.from({ length: 5e3 }, (x, i) => ({
+  artifacts: [
+    {
+      id: "art1",
+      description: "test description",
+      device_types_compatible: [deviceTypes.qemu],
+      modified: "2020-09-10T12:16:22.667Z",
+      updates: [{ type_info: "testtype" }],
+      artifact_depends: {
+        device_type: [deviceTypes.qemu]
+      },
+      artifact_provides: {
+        artifact_name: "myapp",
+        "data-partition.myapp.version": "v2020.10",
+        list_of_fancy: [deviceTypes.qemu, "x172"]
+      },
+      clears_artifact_provides: ["data-partition.myapp.*"]
+    }
+  ],
+  device_types_compatible: [deviceTypes.qemu],
+  metaData: {},
+  name: `release-${i + 1}`,
+  modified: i
+}));
+var permissionSets = [
+  {
+    ...import_constants.defaultPermissionSets.Basic,
+    object: permissionSetObjectTypes.empty,
+    description: "Set containing basic permissions.",
+    permissions: [
+      { action: "http", object: { type: "any", value: "^/api/management/v1/useradm/settings$" } },
+      { action: "http", object: { type: "any", value: "^/api/management/v1/useradm/users/me$" } },
+      { action: "http", object: { type: "any", value: "^/api/management/1.0/auth/verify$" } },
+      { action: "http", object: { type: "PUT", value: "^/api/management/v1/useradm/2faverify$" } },
+      { action: "http", object: { type: "POST", value: "^/api/management/v1/useradm/users/me/2fa/(enable|disable)$" } },
+      { action: "http", object: { type: "GET", value: "^/api/management/(v[1-9])/useradm/roles" } },
+      { action: "http", object: { type: "GET", value: "^/api/management/(v[1-9])/tenantadm/user/tenant" } }
+    ]
+  },
+  {
+    ...import_constants.defaultPermissionSets.ManageReleases,
+    action: import_constants.uiPermissionsById.manage.title,
+    object: permissionSetObjectTypes.releases,
+    description: "Set of permissions which allows user to manage releases",
+    permissions: [
+      { action: "http", object: { type: "GET", value: commonEndpoints.artifacts } },
+      { action: "http", object: { type: "GET", value: commonEndpoints.artifactDetails } },
+      { action: "http", object: { type: "PUT", value: commonEndpoints.artifactDetails } },
+      { action: "http", object: { type: "DELETE", value: commonEndpoints.artifactDetails } },
+      { action: "http", object: { type: "GET", value: "^/api/management/v1/deployments/artifacts/[^/]+/download" } }
+    ]
+  },
+  {
+    ...import_constants.defaultPermissionSets.ReadUsers,
+    action: import_constants.uiPermissionsById.read.title,
+    object: permissionSetObjectTypes.userManagement,
+    description: "Set of permissions which allows user to view other users",
+    permissions: [{ action: "http", object: { type: "GET", value: "^/api/management/(v[1-9])/useradm/" } }]
+  },
+  {
+    ...import_constants.defaultPermissionSets.ManageUsers,
+    action: import_constants.uiPermissionsById.manage.title,
+    object: permissionSetObjectTypes.userManagement,
+    description: "Set of permissions which allows user manage other user accounts",
+    permissions: [{ action: "http", object: { type: "any", value: "^/api/management/(v[1-9])/useradm/" } }]
+  },
+  {
+    ...import_constants.defaultPermissionSets.ReadTenants,
+    action: import_constants.uiPermissionsById.read.title,
+    object: permissionSetObjectTypes.tenantManagement,
+    description: "Set of permissions which allows user to list other tenants and their config",
+    permissions: [
+      { action: "http", object: { type: "GET", value: "^/api/management/(v[1-9])/tenantadm/" } },
+      { action: "http", object: { type: "POST", value: "^/api/management/(v[1-9])/tenantadm/" } }
+    ]
+  },
+  {
+    ...import_constants.defaultPermissionSets.ManageTenants,
+    action: import_constants.uiPermissionsById.manage.title,
+    object: permissionSetObjectTypes.tenantManagement,
+    description: "Set of permissions which allows user to manage other tenants and their config",
+    permissions: [
+      { action: "http", object: { type: "GET", value: "^/api/management/(v[1-9])/tenantadm/" } },
+      { action: "http", object: { type: "POST", value: "^/api/management/(v[1-9])/tenantadm/" } },
+      { action: "http", object: { type: "PUT", value: "^/api/management/(v[1-9])/tenantadm/" } }
+    ]
+  },
+  {
+    ...import_constants.defaultPermissionSets.ReadAuditLogs,
+    action: import_constants.uiPermissionsById.read.title,
+    object: "System Audit Log",
+    description: "Set of permissions which allows user to view system audit log",
+    permissions: [{ action: "http", object: { type: "GET", value: "^/api/management/(v[1-9]|0.1.0)/auditlogs/logs" } }]
+  },
+  {
+    ...import_constants.defaultPermissionSets.DeployToDevices,
+    action: "Deploy",
+    object: permissionSetObjectTypes.groups,
+    description: "Set of permissions which allows user to deploy to devices",
+    permissions: [{ action: "http", object: { type: "any", value: "^/api/management/(v[1-9])/(deployments|deviceconfig)/" } }],
+    supported_scope_types: [import_constants.scopedPermissionAreas.groups.scopeType]
+  },
+  {
+    ...import_constants.defaultPermissionSets.ConfigureDevices,
+    action: "Configure",
+    object: permissionSetObjectTypes.groups,
+    description: "Set of permissions which allows user to manage configuration of the devices",
+    permissions: [{ action: "http", object: { type: "any", value: "^/api/management/(v[1-9])/deviceconfig/" } }],
+    supported_scope_types: [import_constants.scopedPermissionAreas.groups.scopeType]
+  },
+  {
+    ...import_constants.defaultPermissionSets.ConnectToDevices,
+    action: "Connect",
+    object: permissionSetObjectTypes.groups,
+    description: "Set of permissions which allows user to use remote terminal and file transfer",
+    permissions: [
+      { action: "http", object: { type: "GET", value: "^/api/management/(v[1-9]|0.1.0)/deviceconnect/devices/[^/]+/connect$" } },
+      { action: "http", object: { type: "GET", value: "^/api/management/(v[1-9]|0.1.0)/deviceconnect/devices/[^/]+/download\\?path=[^&]+$" } },
+      { action: "http", object: { type: "PUT", value: "^/api/management/(v[1-9]|0.1.0)/deviceconnect/devices/[^/]+/upload$" } }
+    ],
+    supported_scope_types: [import_constants.scopedPermissionAreas.groups.scopeType]
+  },
+  {
+    ...import_constants.defaultPermissionSets.SuperUser,
+    action: "Any",
+    object: permissionSetObjectTypes.any,
+    description: "Set of permissions which allows user to do anything",
+    permissions: [{ action: "any", object: { type: "any", value: "any" } }]
+  },
+  {
+    ...import_constants.defaultPermissionSets.UploadArtifacts,
+    action: "Upload",
+    object: permissionSetObjectTypes.artifacts,
+    description: "Set of permissions which allows user to upload artifacts",
+    permissions: [
+      { action: "http", object: { type: "POST", value: commonEndpoints.artifacts } },
+      { action: "http", object: { type: "POST", value: "^/api/management/v1/deployments/artifacts/generate" } }
+    ]
+  },
+  {
+    ...import_constants.defaultPermissionSets.ReadDevices,
+    action: import_constants.uiPermissionsById.read.title,
+    object: permissionSetObjectTypes.groups,
+    description: "Set of permissions which allows user to view devices",
+    permissions: [
+      { action: "http", object: { type: "POST", value: "^/api/management/v2/inventory/filters/search" } },
+      { action: "http", object: { type: "POST", value: "^/api/management/v1/reporting/devices/search" } },
+      { action: "http", object: { type: "GET", value: "^/api/management/(v[1-9])/(deployments|devauth|inventory|deviceconfig|devicemonitor)/" } },
+      { action: "http", object: { type: "GET", value: "^/api/management/(v[1-9]|0.1.0)/deviceconnect/devices/[^/]+$" } }
+    ],
+    supported_scope_types: [import_constants.scopedPermissionAreas.groups.scopeType]
+  },
+  {
+    ...import_constants.defaultPermissionSets.ManageDevices,
+    action: import_constants.uiPermissionsById.manage.title,
+    object: permissionSetObjectTypes.groups,
+    description: "Set of permissions which allows user to manage devices",
+    permissions: [
+      { action: "http", object: { type: "POST", value: commonEndpoints.deviceManagement } },
+      { action: "http", object: { type: "PUT", value: commonEndpoints.deviceManagement } },
+      { action: "http", object: { type: "DELETE", value: commonEndpoints.deviceManagement } }
+    ],
+    supported_scope_types: [import_constants.scopedPermissionAreas.groups.scopeType]
+  },
+  {
+    ...import_constants.defaultPermissionSets.ReadReleases,
+    action: import_constants.uiPermissionsById.read.title,
+    object: permissionSetObjectTypes.releases,
+    description: "Set of permissions which allows user to view releases",
+    permissions: [
+      { action: "http", object: { type: "GET", value: commonEndpoints.artifacts } },
+      { action: "http", object: { type: "GET", value: commonEndpoints.artifactDetails } },
+      { action: "http", object: { type: "GET", value: "^/api/management/v1/deployments/artifacts/[^/]+/download" } }
+    ]
+  },
+  {
+    name: "almostAdmin",
+    object: permissionSetObjectTypes.empty,
+    description: "Set containing all the permissions.",
+    permissions: [
+      { action: "http", object: { type: "any", value: "^/api/management/(v[1-9])/auditlogs/.*" } },
+      { action: "http", object: { type: "any", value: "^/api/management/(v[1-9])/deployments/.*" } },
+      { action: "http", object: { type: "any", value: "^/api/management/(v[1-9])/deployments/config/.*" } },
+      { action: "http", object: { type: "any", value: "^/api/management/(v[1-9])/deployments/deployments/.*" } },
+      { action: "http", object: { type: "any", value: "^/api/management/(v[1-9])/deployments/deployments/releases/.*" } },
+      { action: "http", object: { type: "any", value: "^/api/management/(v[1-9])/devauth/.*" } },
+      { action: "http", object: { type: "any", value: "^/api/management/(v[1-9])/deviceconfig/.*" } },
+      { action: "http", object: { type: "any", value: "^/api/management/(v[1-9])/deviceconnect/.*" } },
+      { action: "http", object: { type: "any", value: "^/api/management/(v[1-9])/deviceconnect/devices" } },
+      { action: "http", object: { type: "any", value: "^/api/management/(v[1-9])/inventory/.*" } },
+      { action: "http", object: { type: "any", value: "^/api/management/(v[1-9])/iot-manager/.*" } },
+      { action: "http", object: { type: "any", value: "^/api/management/(v[1-9])/monitor/.*" } },
+      { action: "http", object: { type: "any", value: "^/api/management/(v[1-9])/useradm/.*" } }
+    ]
+  }
+];
+var rbacRoles = [
+  {
+    name: "dyn",
+    description: "",
+    permissions: [
+      { action: "CREATE_DEPLOYMENT", object: { type: "DEVICE_GROUP", value: "dyn" } },
+      { action: "VIEW_DEVICE", object: { type: "DEVICE_GROUP", value: "dyn" } }
+    ]
+  },
+  { name: "asdasd", description: "123", permissions: [{ action: "http", object: { type: "any", value: "/api/management/v1/useradm/.*" } }] },
+  {
+    name: "141sasd",
+    description: "1313adg",
+    permission_sets_with_scope: [
+      { ...import_constants.defaultPermissionSets.ReadDevices, scope: { type: import_constants.scopedPermissionAreas.groups.scopeType, value: ["bestgroup"] } },
+      { ...import_constants.defaultPermissionSets.ConnectToDevices, scope: { type: import_constants.scopedPermissionAreas.groups.scopeType, value: ["bestgroup"] } },
+      { ...import_constants.defaultPermissionSets.ManageUsers }
+    ]
+  },
+  {
+    name: "kljlkk",
+    description: "lkl",
+    permission_sets_with_scope: [{ ...import_constants.defaultPermissionSets.ConnectToDevices, scope: { type: import_constants.scopedPermissionAreas.groups.scopeType, value: ["bestgroup"] } }]
+  },
+  {
+    name: "yyyyy",
+    description: "asd",
+    permission_sets_with_scope: [
+      { ...import_constants.defaultPermissionSets.ManageDevices, scope: { type: import_constants.scopedPermissionAreas.groups.scopeType, value: ["dockerclient"] } },
+      { ...import_constants.defaultPermissionSets.ManageReleases }
+    ]
+  },
+  {
+    name: "RBAC_ROLE_DEPLOYMENTS_MANAGER",
+    description: "Intended for users responsible for managing deployments, this role can create and abort deployments",
+    permission_sets_with_scope: [{ ...import_constants.defaultPermissionSets.DeployToDevices }]
+  },
+  {
+    name: "RBAC_ROLE_REMOTE_TERMINAL",
+    description: `Intended for tech support accounts, this role can access the devices' Remote Terminal.`,
+    permission_sets_with_scope: [{ ...import_constants.defaultPermissionSets.ConnectToDevices }]
+  },
+  { name: "RBAC_ROLE_PERMIT_ALL", description: "", permission_sets_with_scope: [{ ...import_constants.defaultPermissionSets.SuperUser }] },
+  {
+    name: "RBAC_ROLE_OBSERVER",
+    description: "Intended for team leaders or limited tech support accounts, this role can see all Devices, Artifacts and Deployment reports but not make any changes.",
+    permission_sets_with_scope: [{ ...import_constants.defaultPermissionSets.ReadReleases }, { ...import_constants.defaultPermissionSets.ReadDevices }]
+  },
+  {
+    name: "RBAC_ROLE_CI",
+    description: "Intended for automation accounts building software (e.g. CI/CD systems), this role can only manage Artifacts, including upload new Artifacts and delete Artifacts. It does not have access to Devices or Deployments.",
+    permission_sets_with_scope: [
+      { ...import_constants.defaultPermissionSets.ReadReleases },
+      { ...import_constants.defaultPermissionSets.ManageReleases },
+      { ...import_constants.defaultPermissionSets.UploadArtifacts }
+    ]
+  },
+  {
+    name: "almostAdmin",
+    description: "almost admin rights",
+    permissions: permissionSets.find((item) => item.name === "almostAdmin")?.permissions
+  },
+  {
+    name: "almostAdminNew",
+    description: "almost admin rights",
+    permission_sets_with_scope: Object.values(import_constants.defaultPermissionSets)
+  }
+];
+var expectedParsedRoles = {
+  "141sasd": {
+    editable: true,
+    isCustom: void 0,
+    uiPermissions: {
+      ...import_constants.emptyUiPermissions,
+      groups: { bestgroup: [import_constants.uiPermissionsById.read.value, import_constants.uiPermissionsById.connect.value] },
+      userManagement: [import_constants.uiPermissionsById.manage.value]
+    }
+  },
+  asdasd: {
+    editable: false,
+    isCustom: true,
+    uiPermissions: { ...import_constants.emptyUiPermissions, userManagement: [import_constants.uiPermissionsById.read.value, import_constants.uiPermissionsById.manage.value] }
+  },
+  dyn: {
+    editable: false,
+    isCustom: true,
+    uiPermissions: {
+      ...import_constants.emptyUiPermissions,
+      deployments: [import_constants.uiPermissionsById.deploy.value],
+      groups: { dyn: [import_constants.uiPermissionsById.read.value, import_constants.uiPermissionsById.deploy.value] }
+    }
+  },
+  kljlkk: {
+    editable: true,
+    isCustom: false,
+    uiPermissions: { ...import_constants.emptyUiPermissions, groups: { bestgroup: [import_constants.uiPermissionsById.read.value, import_constants.uiPermissionsById.connect.value] } }
+  },
+  yyyyy: {
+    editable: true,
+    isCustom: void 0,
+    uiPermissions: {
+      ...import_constants.emptyUiPermissions,
+      groups: { dockerclient: [import_constants.uiPermissionsById.read.value, import_constants.uiPermissionsById.manage.value] },
+      releases: { [import_constants.ALL_RELEASES]: [import_constants.uiPermissionsById.manage.value] }
+    }
+  },
+  almostAdmin: {
+    editable: false,
+    isCustom: true,
+    uiPermissions: {
+      ...import_constants.emptyUiPermissions,
+      auditlog: [import_constants.uiPermissionsById.read.value],
+      deployments: [import_constants.uiPermissionsById.manage.value, import_constants.uiPermissionsById.deploy.value, import_constants.uiPermissionsById.read.value],
+      groups: {
+        [import_constants.ALL_DEVICES]: [
+          import_constants.uiPermissionsById.read.value,
+          // we can't assign deployment permissions to devices here, since the old path based rbac controls don't allow the scoped permissions
+          // uiPermissionsById.deploy.value,
+          import_constants.uiPermissionsById.manage.value,
+          import_constants.uiPermissionsById.connect.value,
+          import_constants.uiPermissionsById.configure.value
+        ]
+      },
+      releases: {
+        [import_constants.ALL_RELEASES]: [import_constants.uiPermissionsById.read.value, import_constants.uiPermissionsById.upload.value, import_constants.uiPermissionsById.manage.value]
+      },
+      userManagement: [import_constants.uiPermissionsById.read.value, import_constants.uiPermissionsById.manage.value]
+    }
+  },
+  almostAdminNew: {
+    editable: true,
+    isCustom: void 0,
+    uiPermissions: {
+      ...import_constants.emptyUiPermissions,
+      auditlog: [import_constants.uiPermissionsById.read.value],
+      deployments: [import_constants.uiPermissionsById.read.value, import_constants.uiPermissionsById.deploy.value, import_constants.uiPermissionsById.manage.value],
+      groups: {
+        [import_constants.ALL_DEVICES]: [
+          import_constants.uiPermissionsById.read.value,
+          import_constants.uiPermissionsById.manage.value,
+          import_constants.uiPermissionsById.deploy.value,
+          import_constants.uiPermissionsById.connect.value,
+          import_constants.uiPermissionsById.configure.value
+        ]
+      },
+      releases: {
+        [import_constants.ALL_RELEASES]: [import_constants.uiPermissionsById.manage.value, import_constants.uiPermissionsById.upload.value, import_constants.uiPermissionsById.read.value]
+      },
+      tenantManagement: [import_constants.uiPermissionsById.read.value, import_constants.uiPermissionsById.manage.value],
+      userManagement: [import_constants.uiPermissionsById.read.value, import_constants.uiPermissionsById.manage.value]
+    }
+  }
+};
+var defaultRolesById = {
+  ...import_constants.rolesById,
+  test: {
+    ...import_constants.emptyRole,
+    name: "test",
+    description: "test description",
+    editable: true,
+    uiPermissions: {
+      ...import_constants.emptyUiPermissions,
+      groups: { testGroup: [import_constants.uiPermissionsById.read.value] },
+      releases: { bar: [import_constants.uiPermissionsById.read.value] }
+    }
+  }
+};
+var receivedRoles = rbacRoles.reduce(
+  (accu, role) => {
+    const { name, description, ...roleRemainder } = role;
+    if (name.startsWith("RBAC")) {
+      accu[name] = {
+        ...defaultRolesById[name],
+        ...roleRemainder,
+        editable: false,
+        isCustom: false,
+        description: defaultRolesById[name].description ? defaultRolesById[name].description : description
+      };
+    } else {
+      const result = expectedParsedRoles[name] ?? {};
+      accu[name] = {
+        ...import_constants.emptyRole,
+        ...role,
+        ...result,
+        name
+      };
+    }
+    return accu;
+  },
+  { ...defaultRolesById }
+);
+var receivedPermissionSets = permissionSets.reduce((accu, set) => {
+  const result = import_constants.defaultPermissionSets[set.name]?.result ?? {};
+  accu[set.name] = {
+    ...set,
+    result: {
+      ...import_constants.emptyUiPermissions,
+      ...result
+    }
+  };
+  return accu;
+}, {});
+
+// src/requestHandlers/deploymentHandlers.ts
+var createdDeployment = {
+  id: "created-123",
+  name: "test deployment",
+  artifact_name: "r1",
+  artifacts: ["123"],
+  created: "2019-01-01T12:30:00.000Z",
+  device_count: 1,
+  devices: {
+    a1: {
+      attributes: {},
+      id: "a1",
+      image: { size: 123 },
+      status: "installing"
+    }
+  },
+  filter: void 0,
+  group: void 0,
+  statistics: {
+    status: {
+      downloading: 0,
+      decommissioned: 0,
+      failure: 0,
+      installing: 1,
+      noartifact: 0,
+      pending: 0,
+      rebooting: 0,
+      success: 0,
+      "already-installed": 0
+    },
+    total_size: 1234
+  }
+};
+var defaultDeploymentConfig = {
+  delta: {
+    enabled: true,
+    binary_delta: {
+      xdelta_args: {
+        disable_checksum: false,
+        disable_external_decompression: false,
+        compression_level: 6,
+        source_window_size: 0,
+        input_window_size: 0,
+        compression_duplicates_window: 0,
+        instruction_buffer_size: 0
+      },
+      timeout: 0
+    },
+    binary_delta_limits: {
+      xdelta_args_limits: {
+        source_window_size: import_constants2.limitDefault,
+        input_window_size: import_constants2.limitDefault,
+        compression_duplicates_window: import_constants2.limitDefault,
+        instruction_buffer_size: import_constants2.limitDefault
+      },
+      timeout: { min: 60, max: 3600, default: 60 },
+      jobs_in_parallel: import_constants2.limitDefault,
+      queue_length: import_constants2.limitDefault
+    }
+  }
+};
+var deploymentHandlers = [
+  import_msw.http.get(
+    `${import_constants2.deploymentsApiUrl}/deployments`,
+    () => new import_msw.HttpResponse(JSON.stringify(Object.values(mockApiResponses.deployments.byId).reverse()), {
+      headers: { [import_constants2.headerNames.total]: Object.keys(mockApiResponses.deployments.byId).length }
+    })
+  ),
+  import_msw.http.get(`${import_constants2.deploymentsApiUrl}/deployments/releases`, ({ request }) => {
+    const { searchParams } = new URL(request.url);
+    const releaseName = searchParams.get("name");
+    const release = mockApiResponses.releases.byId[releaseName] || {};
+    if (releaseName) {
+      const { device_types_compatible, ...remainder } = release;
+      return Object.keys(remainder).length || releaseName === "createdRelease" ? import_msw.HttpResponse.json([remainder]) : new import_msw.HttpResponse(null, { status: 520 });
+    }
+    const releases = Object.values(mockApiResponses.releases.byId).map((stateRelease) => {
+      const { device_types_compatible, ...remainder } = stateRelease;
+      return remainder;
+    });
+    return import_msw.HttpResponse.json(releases);
+  }),
+  import_msw.http.get(`${import_constants2.deploymentsApiUrl}/deployments/:deploymentId`, ({ params: { deploymentId } }) => {
+    if (deploymentId === createdDeployment.id) {
+      return import_msw.HttpResponse.json(createdDeployment);
+    } else if (deploymentId === "config1") {
+      return import_msw.HttpResponse.json({
+        ...createdDeployment,
+        id: "config1",
+        created: "2019-01-01T09:25:01.000Z",
+        finished: "2019-01-01T09:25:03.000Z",
+        status: "finished"
+      });
+    }
+    return import_msw.HttpResponse.json(mockApiResponses.deployments.byId[deploymentId]);
+  }),
+  import_msw.http.get(`${import_constants2.deploymentsApiUrl}/deployments/:deploymentId/devices`, ({ params: { deploymentId } }) => {
+    if (deploymentId === createdDeployment.id) {
+      return import_msw.HttpResponse.json(Object.values(createdDeployment.devices));
+    } else if (mockApiResponses.deployments.byId[deploymentId]) {
+      return import_msw.HttpResponse.json(Object.values(mockApiResponses.deployments.byId[deploymentId].devices));
+    }
+    return new import_msw.HttpResponse(null, { status: 521 });
+  }),
+  import_msw.http.post(`${import_constants2.deploymentsApiUrl}/deployments/statistics/list`, async ({ request }) => {
+    const { deployment_ids = [] } = await request.json();
+    if (deployment_ids.includes(createdDeployment.id)) {
+      return import_msw.HttpResponse.json([]);
+    } else if (deployment_ids.every((id) => mockApiResponses.deployments.byId[id])) {
+      const stats = deployment_ids.map((id) => ({ id, stats: mockApiResponses.deployments.byId[id].statistics.status }));
+      return import_msw.HttpResponse.json(stats);
+    }
+    return new import_msw.HttpResponse(null, { status: 522 });
+  }),
+  import_msw.http.get(`${import_constants2.deploymentsApiUrl}/deployments/:deploymentId/devices/:deviceId/log`, ({ params: { deploymentId, deviceId } }) => {
+    if (mockApiResponses.deployments.byId[deploymentId] && mockApiResponses.deployments.byId[deploymentId].devices[deviceId]) {
+      return import_msw.HttpResponse.text("test");
+    }
+    return new import_msw.HttpResponse(null, { status: 523 });
+  }),
+  import_msw.http.post(`${import_constants2.deploymentsApiUrl}/deployments`, async ({ request }) => {
+    const body = await request.json();
+    if (!Object.keys(body).length) {
+      return new import_msw.HttpResponse(JSON.stringify({}), { status: 524 });
+    }
+    return new import_msw.HttpResponse(JSON.stringify({}), { headers: { location: `find/me/here/${createdDeployment.id}` } });
+  }),
+  import_msw.http.post(`${import_constants2.deploymentsApiUrlV2}/deployments`, async ({ request }) => {
+    const { filter_id, devices = [] } = await request.json();
+    if (!filter_id || !!devices.length) {
+      return new import_msw.HttpResponse(JSON.stringify({}), { status: 525 });
+    }
+    return new import_msw.HttpResponse(JSON.stringify({}), { headers: { location: `find/me/here/${createdDeployment.id}` } });
+  }),
+  import_msw.http.post(`${import_constants2.deploymentsApiUrl}/deployments/group/:deploymentGroup`, async ({ params: { deploymentGroup }, request }) => {
+    const { filter_id, devices = [] } = await request.json();
+    if (filter_id || !!devices.length || deploymentGroup !== Object.keys(mockApiResponses.devices.groups.byId)[0]) {
+      return new import_msw.HttpResponse(JSON.stringify({}), { status: 526 });
+    }
+    return new import_msw.HttpResponse(JSON.stringify({}), { headers: { location: `find/me/here/${createdDeployment.id}` } });
+  }),
+  import_msw.http.patch(`${import_constants2.deploymentsApiUrl}/deployments/:deploymentId`, async ({ params: { deploymentId }, request }) => {
+    const { update_control_map } = await request.json();
+    if (deploymentId === createdDeployment.id && Object.keys(update_control_map).length) {
+      return new import_msw.HttpResponse(null, { status: 204 });
+    }
+    return new import_msw.HttpResponse(null, { status: 581 });
+  }),
+  import_msw.http.put(`${import_constants2.deploymentsApiUrl}/deployments/:deploymentId/status`, async ({ params: { deploymentId }, request }) => {
+    const { status } = await request.json();
+    return new import_msw.HttpResponse(JSON.stringify({}), {
+      status: status === "aborted" && [...mockApiResponses.deployments.byStatus.pending.deploymentIds, ...mockApiResponses.deployments.byStatus.inprogress.deploymentIds].includes(
+        deploymentId
+      ) ? 200 : 528
+    });
+  }),
+  import_msw.http.get(`${import_constants2.deploymentsApiUrl}/deployments/:deploymentId/devices/list`, ({ params: { deploymentId } }) => {
+    if (deploymentId === createdDeployment.id) {
+      return new import_msw.HttpResponse(JSON.stringify(Object.values(createdDeployment.devices)), {
+        headers: { [import_constants2.headerNames.total]: Object.keys(createdDeployment.devices).length }
+      });
+    } else if (mockApiResponses.deployments.byId[deploymentId]) {
+      return new import_msw.HttpResponse(JSON.stringify(Object.values(mockApiResponses.deployments.byId[deploymentId].devices)), {
+        headers: { [import_constants2.headerNames.total]: Object.keys(mockApiResponses.deployments.byId[deploymentId].devices).length }
+      });
+    }
+    return new import_msw.HttpResponse(null, { status: 529 });
+  }),
+  import_msw.http.get(`${import_constants2.deploymentsApiUrl}/config`, () => import_msw.HttpResponse.json(defaultDeploymentConfig)),
+  import_msw.http.put(`${import_constants2.deploymentsApiUrl}/config/binary_delta`, () => new import_msw.HttpResponse(null, { status: 200 })),
+  import_msw.http.get(`${import_constants2.deploymentsApiUrl}/deployments/devices/:deviceId`, ({ params: { deviceId } }) => {
+    if (deviceId === mockApiResponses.devices.byId.a1.id) {
+      return new import_msw.HttpResponse(
+        JSON.stringify([
+          {
+            id: createdDeployment.id + "something",
+            deployment: { ...createdDeployment, id: mockApiResponses.deployments.byId.d1.id, status: "inprogress" },
+            device: {
+              created: "2019-01-01T12:35:00.000Z",
+              finished: "2019-01-01T12:40:00.000Z",
+              status: "noartifact",
+              id: "something",
+              image: { ...mockApiResponses.releases.byId.r1 }
+            },
+            log: true,
+            attempts: 1,
+            delta_job_id: ""
+          }
+        ]),
+        {
+          headers: { [import_constants2.headerNames.total]: 34 }
+        }
+      );
+    }
+    return new import_msw.HttpResponse(null, { status: 529 });
+  }),
+  import_msw.http.delete(`${import_constants2.deploymentsApiUrl}/deployments/devices/:deviceId/history`, () => new import_msw.HttpResponse(null, { status: 204 }))
+];
+
+// src/requestHandlers/deviceHandlers.ts
+var import_constants3 = require("@northern.tech/utils/constants");
+var import_msw2 = require("msw");
+var defaultDeviceId = "a1";
+var deviceAuthDevice = {
+  id: defaultDeviceId,
+  identity_data: { mac: defaultMacAddress },
+  status: "accepted",
+  decommissioning: false,
+  created_ts: defaultCreationDate,
+  updated_ts: "2019-01-01T09:25:00.000Z",
+  auth_sets: [
+    {
+      id: "auth1",
+      identity_data: { mac: defaultMacAddress },
+      pubkey: "-----BEGIN PUBLIC KEY-----\nMIIBojWELzgJ62hcXIhAfqfoNiaB1326XZByZwcnHr5BuSPAgMBAAE=\n-----END PUBLIC KEY-----\n",
+      ts: defaultCreationDate,
+      status: "accepted"
+    }
+  ]
+};
+var checkInTimeExact2 = "2019-01-01T10:25:00.000Z";
+var updatedTime = "2019-01-01T09:25:00.000Z";
+var inventoryDevice = {
+  id: defaultDeviceId,
+  attributes: [
+    { name: "network_interfaces", value: ["eth0", "wlan0"], scope: "inventory" },
+    { name: "kernel", value: "Linux version 4.19.75-v7l+", scope: "inventory" },
+    { name: "artifact_name", value: "raspotifyInstaller", scope: "inventory" },
+    { name: "ipv6_wlan0", value: "fe80::68d9:8453:3e9c:7c80/64", scope: "inventory" },
+    { name: "mac_eth0", value: defaultMacAddress, scope: "inventory" },
+    { name: "rootfs_type", value: "ext4", scope: "inventory" },
+    { name: "mender_bootloader_integration", value: "unknown", scope: "inventory" },
+    { name: "cpu_model", value: "ARMv7 Processor rev 3 (v7l)", scope: "inventory" },
+    { name: "hostname", value: "raspberrypi", scope: "inventory" },
+    { name: "mender_client_version", value: "2.1.0", scope: "inventory" },
+    { name: "ipv4_wlan0", value: "192.168.10.141/24", scope: "inventory" },
+    { name: "device_type", value: "raspberrypi4", scope: "inventory" },
+    { name: "mem_total_kB", value: "1986024", scope: "inventory" },
+    { name: "mac_wlan0", value: "dc:a6:32:12:ad:c0", scope: "inventory" },
+    { name: "os", value: "Raspbian GNU/Linux 10 (buster)", scope: "inventory" },
+    { name: "created_ts", value: defaultCreationDate, scope: "system" },
+    { name: "updated_ts", value: updatedTime, scope: "system" },
+    { name: "status", value: "accepted", scope: "identity" },
+    { name: "mac", value: defaultMacAddress, scope: "identity" },
+    { name: "group", value: "test", scope: "system" }
+  ],
+  check_in_time: checkInTimeExact2,
+  updated_ts: updatedTime
+};
+var deviceAttributes = [
+  { name: "status", scope: "identity", count: 5 },
+  { name: "created_ts", scope: "system", count: 5 },
+  { name: "updated_ts", scope: "system", count: 5 },
+  { name: "mac", scope: "identity", count: 1 },
+  { name: "artifact_name", scope: "inventory", count: 1 },
+  { name: "cpu_model", scope: "inventory", count: 1 },
+  { name: "device_type", scope: "inventory", count: 1 },
+  { name: "hostname", scope: "inventory", count: 1 },
+  { name: "ipv4_wlan0", scope: "inventory", count: 1 },
+  { name: "ipv6_wlan0", scope: "inventory", count: 1 },
+  { name: "kernel", scope: "inventory", count: 1 },
+  { name: "mac_eth0", scope: "inventory", count: 1 },
+  { name: "mac_wlan0", scope: "inventory", count: 1 },
+  { name: "mem_total_kB", scope: "inventory", count: 1 },
+  { name: "mender_bootloader_integration", scope: "inventory", count: 1 },
+  { name: "mender_client_version", scope: "inventory", count: 1 },
+  { name: "network_interfaces", scope: "inventory", count: 1 },
+  { name: "os", scope: "inventory", count: 1 },
+  { name: "rootfs_type", scope: "inventory", count: 1 },
+  { name: "group", scope: "system", count: 1 }
+];
+var searchHandler = async ({ request }) => {
+  const { page, per_page, filters } = await request.json();
+  if ([page, per_page, filters].some((item) => !item)) {
+    return new import_msw2.HttpResponse(null, { status: 509 });
+  }
+  const filter = filters.find((filter2) => filter2.scope === "identity" && filter2.attribute === "status" && Object.values(import_constants3.DEVICE_STATES).includes(filter2.value));
+  const status = filter?.value || "";
+  if (!status || filters.length > 1) {
+    if (filters.find((filter2) => filter2.attribute === "group" && filter2.value.includes(Object.keys(mockApiResponses.devices.groups.byId)[0]))) {
+      return new import_msw2.HttpResponse(JSON.stringify([inventoryDevice, { ...inventoryDevice, id: "b1" }]), {
+        headers: { [import_constants3.headerNames.total]: 2 }
+      });
+    }
+    if (filters.find((filter2) => filter2.scope === "monitor" && ["failed_last_update", "alerts", "auth_request"].includes(filter2.attribute))) {
+      return new import_msw2.HttpResponse(JSON.stringify([inventoryDevice]), { headers: { [import_constants3.headerNames.total]: 4 } });
+    }
+    return new import_msw2.HttpResponse(JSON.stringify([]), { headers: { [import_constants3.headerNames.total]: 0 } });
+  }
+  let deviceList = Array.from({ length: mockApiResponses.devices.byStatus[status].total }, (_, index) => ({
+    ...inventoryDevice,
+    attributes: [...inventoryDevice.attributes, { name: "test-count", value: index, scope: "system" }],
+    id: `${String.fromCharCode("a".charCodeAt(0) + index)}1`
+  }));
+  deviceList = deviceList.slice((page - 1) * per_page, page * per_page);
+  return new import_msw2.HttpResponse(JSON.stringify(deviceList), { headers: { [import_constants3.headerNames.total]: mockApiResponses.devices.byStatus[status].total } });
+};
+var deviceHandlers = [
+  import_msw2.http.delete(`${import_constants3.deviceAuthV2}/devices/:deviceId/auth/:authId`, ({ params: { authId, deviceId } }) => {
+    if (mockApiResponses.devices.byId[deviceId].auth_sets.find((authSet) => authSet.id === authId)) {
+      return new import_msw2.HttpResponse(null, { status: 200 });
+    }
+    return new import_msw2.HttpResponse(null, { status: 501 });
+  }),
+  import_msw2.http.delete(`${import_constants3.deviceAuthV2}/devices/:deviceId`, ({ params: { deviceId } }) => {
+    if (mockApiResponses.devices.byId[deviceId]) {
+      return new import_msw2.HttpResponse(null, { status: 200 });
+    }
+    return new import_msw2.HttpResponse(null, { status: 502 });
+  }),
+  import_msw2.http.delete(`${import_constants3.inventoryApiUrl}/groups/:group`, ({ params: { group } }) => {
+    if (mockApiResponses.devices.groups.byId[group]) {
+      return new import_msw2.HttpResponse(null, { status: 200 });
+    }
+    return new import_msw2.HttpResponse(null, { status: 515 });
+  }),
+  import_msw2.http.delete(`${import_constants3.inventoryApiUrl}/groups/:group/devices`, async ({ params: { group }, request }) => {
+    const deviceIds = await request.json();
+    if (mockApiResponses.devices.groups.byId[group] && deviceIds.every((id) => !!mockApiResponses.devices.byId[id])) {
+      return new import_msw2.HttpResponse(null, { status: 200 });
+    }
+    return new import_msw2.HttpResponse(null, { status: 503 });
+  }),
+  import_msw2.http.delete(`${import_constants3.inventoryApiUrlV2}/filters/:filterId`, ({ params: { filterId } }) => {
+    if (Object.values(mockApiResponses.devices.groups.byId).find((group) => group.id === filterId)) {
+      return new import_msw2.HttpResponse(null, { status: 200 });
+    }
+    return new import_msw2.HttpResponse(null, { status: 504 });
+  }),
+  import_msw2.http.get(`${import_constants3.deviceAuthV2}/devices`, ({ request }) => {
+    const { searchParams } = new URL(request.url);
+    const deviceIds = searchParams.getAll("id");
+    if (deviceIds.every((id) => !!mockApiResponses.devices.byId[id])) {
+      return import_msw2.HttpResponse.json(deviceIds.map((id) => ({ ...deviceAuthDevice, id })));
+    }
+    return new import_msw2.HttpResponse(null, { status: 505 });
+  }),
+  import_msw2.http.get(`${import_constants3.deviceAuthV2}/limits/max_devices`, () => import_msw2.HttpResponse.json({ limit: mockApiResponses.devices.limit })),
+  import_msw2.http.get(`${import_constants3.inventoryApiUrl}/devices/:deviceId`, ({ params: { deviceId } }) => {
+    if (mockApiResponses.devices.byId[deviceId]) {
+      return import_msw2.HttpResponse.json(inventoryDevice);
+    }
+    return new import_msw2.HttpResponse(null, { status: 506 });
+  }),
+  import_msw2.http.put(`${import_constants3.inventoryApiUrl}/devices/:deviceId/tags`, async ({ params: { deviceId }, request }) => {
+    const tags = await request.json();
+    if (!mockApiResponses.devices.byId[deviceId] && !Array.isArray(tags) && !tags.every((item) => item.name && item.value)) {
+      return new import_msw2.HttpResponse(null, { status: 506 });
+    }
+    return import_msw2.HttpResponse.json(tags);
+  }),
+  import_msw2.http.get(`${import_constants3.inventoryApiUrl}/groups`, () => {
+    const groups = Object.entries(mockApiResponses.devices.groups.byId).reduce((accu, [groupName, group]) => {
+      if (!group.id) {
+        accu.push(groupName);
+      }
+      return accu;
+    }, []);
+    return import_msw2.HttpResponse.json(groups);
+  }),
+  import_msw2.http.get(`${import_constants3.inventoryApiUrlV2}/filters/attributes`, () => import_msw2.HttpResponse.json(deviceAttributes)),
+  import_msw2.http.get(`${import_constants3.reportingApiUrl}/devices/attributes`, () => import_msw2.HttpResponse.json({ attributes: deviceAttributes, count: deviceAttributes.length, limit: 100 })),
+  import_msw2.http.get(`${import_constants3.reportingApiUrl}/devices/search/attributes`, () => import_msw2.HttpResponse.json(deviceAttributes)),
+  import_msw2.http.post(
+    `${import_constants3.reportingApiUrl}/devices/aggregate`,
+    () => import_msw2.HttpResponse.json([
+      {
+        name: "*",
+        items: [
+          { key: "test", count: 6 },
+          { key: "original", count: 1 }
+        ],
+        other_count: 42
+      }
+    ])
+  ),
+  import_msw2.http.get(
+    `${import_constants3.inventoryApiUrlV2}/filters`,
+    () => import_msw2.HttpResponse.json([
+      {
+        id: "filter1",
+        name: "testGroupDynamic",
+        terms: [
+          { scope: "identity", attribute: "id", type: "$in", value: [defaultDeviceId] },
+          { scope: "identity", attribute: "mac", type: "$exists", value: false },
+          { scope: "identity", attribute: "kernel", type: "$exists", value: true }
+        ]
+      }
+    ])
+  ),
+  import_msw2.http.patch(`${import_constants3.inventoryApiUrl}/groups/:group/devices`, async ({ params: { group }, request }) => {
+    const deviceIds = await request.json();
+    if (!!group && deviceIds.every((id) => !!mockApiResponses.devices.byId[id])) {
+      return new import_msw2.HttpResponse(null, { status: 200 });
+    }
+    return new import_msw2.HttpResponse(null, { status: 508 });
+  }),
+  import_msw2.http.post(`${import_constants3.deviceAuthV2}/devices`, async ({ request }) => {
+    const authset = await request.json();
+    if (Object.values(mockApiResponses.devices.byId).some(
+      (device) => device.auth_sets.some((deviceAuthSet) => deviceAuthSet.pubkey == authset.pubkey || deviceAuthSet.identity_data == authset.identity_data)
+    )) {
+      return new import_msw2.HttpResponse(null, { status: 409 });
+    }
+    return new import_msw2.HttpResponse(null, { status: 200 });
+  }),
+  import_msw2.http.post(`${import_constants3.inventoryApiUrlV2}/filters/search`, searchHandler),
+  import_msw2.http.post(`${import_constants3.reportingApiUrl}/filters/search`, searchHandler),
+  import_msw2.http.post(`${import_constants3.inventoryApiUrlV2}/filters`, async ({ request }) => {
+    const { name, terms } = await request.json();
+    if ([name, terms].some((item) => !item) || mockApiResponses.devices.groups[name] || !terms.every((term) => import_constants3.DEVICE_FILTERING_OPTIONS[term.type] && ["identity", "inventory", "system"].includes(term.scope) && !!term.value && !!term.attribute)) {
+      return new import_msw2.HttpResponse(null, { status: 510 });
+    }
+    return new import_msw2.HttpResponse(JSON.stringify({}), { headers: { location: "find/me/here/createdFilterId" } });
+  }),
+  import_msw2.http.put(`${import_constants3.deviceAuthV2}/devices/:deviceId/auth/:authId/status`, async ({ params: { authId, deviceId }, request }) => {
+    const { status } = await request.json();
+    if (mockApiResponses.devices.byId[deviceId].auth_sets.find((authSet) => authSet.id === authId) && import_constants3.DEVICE_STATES[status]) {
+      return new import_msw2.HttpResponse(null, { status: 200 });
+    }
+    return new import_msw2.HttpResponse(null, { status: 511 });
+  }),
+  import_msw2.http.get(`${import_constants3.deviceConfig}/:deviceId`, ({ params: { deviceId } }) => {
+    if (deviceId === "testId") {
+      return new import_msw2.HttpResponse(JSON.stringify({ error: { status_code: 404 } }), { status: 404 });
+    }
+    if (mockApiResponses.devices.byId[deviceId]) {
+      return import_msw2.HttpResponse.json({
+        configured: { test: true, something: "else", aNumber: 42 },
+        deployment_id: "config1",
+        reported: { test: true, something: "else", aNumber: 42 },
+        updated_ts: updatedTime,
+        reported_ts: "2019-01-01T09:25:01.000Z"
+      });
+    }
+    return new import_msw2.HttpResponse(null, { status: 512 });
+  }),
+  import_msw2.http.put(`${import_constants3.deviceConfig}/:deviceId`, async ({ params: { deviceId }, request }) => {
+    const body = await request.text();
+    if (body.includes("evilValue")) {
+      return new import_msw2.HttpResponse(null, { status: 418 });
+    }
+    return new import_msw2.HttpResponse(null, { status: mockApiResponses.devices.byId[deviceId] ? 201 : 513 });
+  }),
+  import_msw2.http.post(`${import_constants3.deviceConfig}/:deviceId/deploy`, ({ params: { deviceId } }) => {
+    if (mockApiResponses.devices.byId[deviceId]) {
+      return import_msw2.HttpResponse.json({ deployment_id: "config1" });
+    }
+    return new import_msw2.HttpResponse(null, { status: 514 });
+  }),
+  import_msw2.http.get(`${import_constants3.deviceConnect}/devices/:deviceId`, ({ params: { deviceId } }) => {
+    if (deviceId === "testId") {
+      return new import_msw2.HttpResponse(JSON.stringify({ error: { status_code: 404 } }), { status: 404 });
+    }
+    if (mockApiResponses.devices.byId[deviceId]) {
+      return import_msw2.HttpResponse.json({ status: "connected", updated_ts: mockApiResponses.devices.byId[deviceId].updated_ts });
+    }
+    return new import_msw2.HttpResponse(null, { status: 512 });
+  }),
+  import_msw2.http.post(`${import_constants3.deviceConnect}/devices/:deviceId/:action`, ({ params: { deviceId, action } }) => {
+    if (["check-update", "send-inventory"].includes(action) && mockApiResponses.devices.byId[deviceId]) {
+      return new import_msw2.HttpResponse(null, { status: 202 });
+    }
+    return new import_msw2.HttpResponse(null, { status: 518 });
+  }),
+  import_msw2.http.get(`${import_constants3.iotManagerBaseURL}/devices/:deviceId/state`, ({ params: { deviceId } }) => {
+    if (mockApiResponses.devices.byId[deviceId]) {
+      return import_msw2.HttpResponse.json({ deployment_id: mockApiResponses.deployments.byId.d1.id });
+    }
+    return new import_msw2.HttpResponse(null, { status: 515 });
+  }),
+  import_msw2.http.put(`${import_constants3.iotManagerBaseURL}/devices/:deviceId/state/:integrationId`, async ({ params: { deviceId }, request }) => {
+    const body = await request.json();
+    if (mockApiResponses.devices.byId[deviceId] && body) {
+      return import_msw2.HttpResponse.json({ deployment_id: mockApiResponses.deployments.byId.d1.id });
+    }
+    return new import_msw2.HttpResponse(null, { status: 516 });
+  }),
+  import_msw2.http.put(
+    `${import_constants3.deviceConnect}/devices/:deviceId/upload`,
+    ({ params: { deviceId } }) => new import_msw2.HttpResponse(null, { status: mockApiResponses.devices.byId[deviceId] ? 200 : 517 })
+  ),
+  import_msw2.http.get(`${import_constants3.deviceAuthV2}/reports/devices`, () => import_msw2.HttpResponse.text("test,report"))
+];
+
+// src/requestHandlers/monitorHandlers.ts
+var import_constants4 = require("@northern.tech/utils/constants");
+var import_msw3 = require("msw");
+var monitorHandlers = [
+  import_msw3.http.get(`${import_constants4.monitorApiUrlv1}/devices/:id/alerts`, () => new import_msw3.HttpResponse(JSON.stringify([]), { headers: { [import_constants4.headerNames.total]: 1 } })),
+  import_msw3.http.get(`${import_constants4.monitorApiUrlv1}/devices/:id/alerts/latest`, () => import_msw3.HttpResponse.json([])),
+  import_msw3.http.get(`${import_constants4.monitorApiUrlv1}/devices/:id/config`, ({ params: { id } }) => {
+    if (id === mockApiResponses.devices.byId.a1.id) {
+      return import_msw3.HttpResponse.json([{ something: "here" }]);
+    }
+    return import_msw3.HttpResponse.json([]);
+  }),
+  import_msw3.http.put(`${import_constants4.monitorApiUrlv1}/settings/global/channel/alerts/:channel/status`, async ({ params: { channel }, request }) => {
+    const { enabled } = await request.json();
+    if (Object.keys(import_constants4.alertChannels).includes(channel) && enabled !== void 0) {
+      return new import_msw3.HttpResponse(null, { status: 200 });
+    }
+    return new import_msw3.HttpResponse(null, { status: 590 });
+  })
+];
+
+// src/requestHandlers/organizationHandlers.ts
+var import_constants5 = require("@northern.tech/utils/constants");
+var import_msw4 = require("msw");
+var PLANS = {
+  os: { id: "os", name: "Basic" },
+  professional: { id: "professional", name: "Professional" },
+  enterprise: { id: "enterprise", name: "Enterprise" }
+};
+var releasesSample = {
+  lts: ["3.3"],
+  releases: {
+    "3.2": {
+      "3.2.1": {
+        release_date: "2022-02-02",
+        release: "3.2.1",
+        repos: [
+          { name: "integration", version: "1.2.3" },
+          { name: "mender", version: "3.2.1" },
+          { name: "mender-artifact", version: "1.3.7" },
+          { name: "service", version: "3.0.0" },
+          { name: "other-service", version: "1.1.0" }
+        ]
+      },
+      "3.2.0": {
+        release_date: "2022-01-24",
+        release: "3.2.0",
+        repos: [
+          { name: "service", version: "3.0.0" },
+          { name: "another-service", version: "4.1.0" }
+        ]
+      }
+    },
+    "2.7": {
+      "2.7.2": {
+        release_date: "2021-11-04",
+        release: "2.7.2",
+        repos: [
+          { name: "service", version: "1.1.0" },
+          { name: "more-service", version: "1.0.2" }
+        ]
+      }
+    },
+    "1.0": {
+      supported_until: "2018-02",
+      "1.0.1": {
+        release_date: "2017-04-03",
+        release: "1.0.1",
+        repos: [{ name: "service", version: "1.0.1" }]
+      },
+      "1.0.0": {
+        release_date: "2017-02-16",
+        release: "1.0.0",
+        repos: [{ name: "mono-service", version: "1.0.0" }]
+      }
+    }
+  },
+  saas: [
+    { tag: "saas-v2022.03.10", date: "2022-03-09" },
+    { tag: "saas-v2020.09.25", date: "2020-09-24" },
+    { tag: "saas-v2020.07.09", date: "2020-07-09" }
+  ]
+};
+var tagsSample = [{ name: "saas-v2023.05.02", more: "here" }];
+var signupHandler = async ({ request }) => {
+  const signup = await request.json();
+  if (["email", "organization", "plan", "tos"].every((item) => !!signup[item])) {
+    return import_msw4.HttpResponse.text("test");
+  }
+  return new import_msw4.HttpResponse(null, { status: 400 });
+};
+var organizationHandlers = [
+  import_msw4.http.get("/tags.json", () => import_msw4.HttpResponse.json(tagsSample)),
+  import_msw4.http.get("/versions.json", () => import_msw4.HttpResponse.json(releasesSample)),
+  import_msw4.http.get(`${import_constants5.tenantadmApiUrlv1}/user/tenant`, () => import_msw4.HttpResponse.json(mockApiResponses.organization.organization)),
+  import_msw4.http.put(`${import_constants5.tenantadmApiUrlv2}/tenants/:tenantId/child`, () => new import_msw4.HttpResponse(null, { status: 200 })),
+  import_msw4.http.post(`${import_constants5.tenantadmApiUrlv2}/tenants/:tenantId/cancel`, () => new import_msw4.HttpResponse(null, { status: 200 })),
+  import_msw4.http.post(`${import_constants5.tenantadmApiUrlv2}/tenants/trial`, signupHandler),
+  import_msw4.http.post(`${import_constants5.tenantadmApiUrlv2}/tenants`, () => new import_msw4.HttpResponse(null, { status: 200 })),
+  import_msw4.http.post(`https://hosted.mender.io${import_constants5.tenantadmApiUrlv2}/tenants/trial`, signupHandler),
+  import_msw4.http.get(`${import_constants5.tenantadmApiUrlv2}/tenants`, () => new import_msw4.HttpResponse([])),
+  import_msw4.http.get(`${import_constants5.tenantadmApiUrlv2}/billing`, () => import_msw4.HttpResponse.json({ card: { last4: "7890", exp_month: 1, exp_year: 2024, brand: "testCorp" } })),
+  import_msw4.http.post(`${import_constants5.tenantadmApiUrlv2}/billing/card`, () => import_msw4.HttpResponse.json({ intent_id: mockApiResponses.organization.intentId, secret: "testSecret" })),
+  import_msw4.http.post(
+    `${import_constants5.tenantadmApiUrlv2}/billing/card/:intentId/confirm`,
+    ({ params: { intentId } }) => new import_msw4.HttpResponse(null, { status: intentId == mockApiResponses.organization.intentId ? 200 : 540 })
+  ),
+  import_msw4.http.post(`${import_constants5.tenantadmApiUrlv2}/tenants/:tenantId/upgrade/:status`, async ({ params: { status, tenantId }, request }) => {
+    if (tenantId != mockApiResponses.organization.organization.id || !["cancel", "complete", "start"].includes(status)) {
+      return new import_msw4.HttpResponse(null, { status: 541 });
+    }
+    if (status === "start") {
+      return import_msw4.HttpResponse.json({ secret: "testSecret" });
+    }
+    let plan;
+    try {
+      const body = await request.json();
+      plan = body.plan;
+    } catch {
+    }
+    if (plan && !Object.keys(PLANS).includes(plan)) {
+      return new import_msw4.HttpResponse(null, { status: 542 });
+    }
+    return new import_msw4.HttpResponse(null, { status: 200 });
+  }),
+  import_msw4.http.post(`${import_constants5.tenantadmApiUrlv2}/tenants/:tenantId/plan`, async ({ params: { tenantId }, request }) => {
+    const body = await request.json();
+    const expectedKeys = ["current_plan", "requested_plan", "current_addons", "requested_addons", "user_message"];
+    if (tenantId != mockApiResponses.organization.organization.id || !Object.keys(body).every((key) => expectedKeys.includes(key))) {
+      return new import_msw4.HttpResponse(null, { status: 544 });
+    }
+    if (body.requested_plan && !Object.values(PLANS).some((item) => item.name === body.requested_plan)) {
+      return new import_msw4.HttpResponse(null, { status: 545 });
+    }
+    return new import_msw4.HttpResponse(null, { status: 200 });
+  }),
+  import_msw4.http.post(`${import_constants5.tenantadmApiUrlv2}/contact/support`, async ({ request }) => {
+    const { subject, body } = await request.json();
+    if (!(subject && body)) {
+      return new import_msw4.HttpResponse(null, { status: 543 });
+    }
+    return new import_msw4.HttpResponse(null, { status: 200 });
+  }),
+  import_msw4.http.get(`${import_constants5.auditLogsApiUrl}/logs`, ({ request }) => {
+    const { searchParams } = new URL(request.url);
+    const perPage = Number(searchParams.get("per_page"));
+    if (perPage === 500) {
+      return import_msw4.HttpResponse.json([
+        { meta: mockApiResponses.organization.auditlog.events[2].meta, time: mockApiResponses.organization.auditlog.events[1].time, action: "close_terminal" }
+      ]);
+    }
+    return new import_msw4.HttpResponse(JSON.stringify(mockApiResponses.organization.auditlog.events), {
+      headers: { [import_constants5.headerNames.total]: mockApiResponses.organization.auditlog.events.length }
+    });
+  }),
+  import_msw4.http.get(
+    `${import_constants5.auditLogsApiUrl}/logs/export`,
+    () => import_msw4.HttpResponse.text(`action,actor.id,actor.type,actor.email,actor.identity_data,object.id,object.type,object.user.email,object.deployment.name,object.deployment.artifact_name,change
+    update,5c56c2ed-2a9a-5de9-bb86-cf38b3d4a5e1,user,test@example.coim,,067f23a9-76a5-5585-b119-32402a120978,user,test@example.com,,,"Update user 067f23a9-76a5-5585-b119-32402a120978 (test@example.com).
+    Diff:
+    --- Original
+    +++ Current
+    @@ -9 +9,2 @@
+    -    ""RBAC_ROLE_OBSERVER""
+    +    ""RBAC_ROLE_OBSERVER"",
+    +    ""RBAC_ROLE_PERMIT_ALL""
+    "
+    `)
+  ),
+  import_msw4.http.get(
+    `${import_constants5.iotManagerBaseURL}/integrations`,
+    () => import_msw4.HttpResponse.json([
+      { connection_string: "something_else", id: 1, provider: "iot-hub" },
+      { id: 2, provider: "iot-core", something: "new" }
+    ])
+  ),
+  import_msw4.http.post(`${import_constants5.iotManagerBaseURL}/integrations`, () => import_msw4.HttpResponse.json([{ connection_string: "something_else", provider: "iot-hub" }])),
+  import_msw4.http.put(`${import_constants5.iotManagerBaseURL}/integrations/:integrationId`, ({ params: { integrationId } }) => {
+    if (!integrationId) {
+      return new import_msw4.HttpResponse(null, { status: 547 });
+    }
+    return new import_msw4.HttpResponse(null, { status: 200 });
+  }),
+  import_msw4.http.put(`${import_constants5.iotManagerBaseURL}/integrations/:integrationId/credentials`, ({ params: { integrationId } }) => {
+    if (!integrationId) {
+      return new import_msw4.HttpResponse(null, { status: 548 });
+    }
+    return new import_msw4.HttpResponse(null, { status: 200 });
+  }),
+  import_msw4.http.delete(`${import_constants5.iotManagerBaseURL}/integrations/:integrationId`, ({ params: { integrationId } }) => {
+    if (!integrationId) {
+      return new import_msw4.HttpResponse(null, { status: 549 });
+    }
+    return new import_msw4.HttpResponse(null, { status: 200 });
+  }),
+  import_msw4.http.get(`${import_constants5.iotManagerBaseURL}/events`, ({ request }) => {
+    const { searchParams } = new URL(request.url);
+    const page = Number(searchParams.get("page"));
+    const perPage = Number(searchParams.get("per_page"));
+    return import_msw4.HttpResponse.json(webhookEvents.slice(page - 1, page * perPage));
+  }),
+  import_msw4.http.get(
+    import_constants5.ssoIdpApiUrlv1,
+    () => import_msw4.HttpResponse.json([
+      { id: "1", issuer: "https://samltest.id/saml/idp", valid_until: "2038-08-24T21:14:09Z" },
+      { id: "2", issuer: "https://samltest2.id/saml/idp", valid_until: "2030-10-24T21:14:09Z" }
+    ])
+  ),
+  import_msw4.http.post(import_constants5.ssoIdpApiUrlv1, () => new import_msw4.HttpResponse(null, { status: 200 })),
+  import_msw4.http.get(`${import_constants5.ssoIdpApiUrlv1}/:configId`, ({ params: { configId } }) => {
+    if (!configId) {
+      return new import_msw4.HttpResponse(null, { status: 550 });
+    }
+    return import_msw4.HttpResponse.json({ email: "user@acme.com", password: "mypass1234", login: { google: "bob@gmail.com" }, config: "<div>not quite right</div>" });
+  }),
+  import_msw4.http.put(`${import_constants5.ssoIdpApiUrlv1}/:configId`, ({ params: { configId } }) => new import_msw4.HttpResponse(null, { status: configId ? 200 : 551 })),
+  import_msw4.http.delete(`${import_constants5.ssoIdpApiUrlv1}/:configId`, ({ params: { configId } }) => new import_msw4.HttpResponse(null, { status: configId ? 200 : 552 }))
+];
+
+// src/requestHandlers/releaseHandlers.ts
+var import_constants6 = require("@northern.tech/utils/constants");
+var import_helpers = require("@northern.tech/utils/helpers");
+var import_msw5 = require("msw");
+var releaseHandlers = [
+  import_msw5.http.get(`${import_constants6.deploymentsApiUrl}/artifacts/:id/download`, () => import_msw5.HttpResponse.json({ uri: "https://testlocation.com/artifact.mender" })),
+  import_msw5.http.delete(
+    `${import_constants6.deploymentsApiUrl}/artifacts/:id`,
+    ({ params: { id } }) => new import_msw5.HttpResponse(null, { status: id === mockApiResponses.releases.byId.r1.artifacts[0].id ? 200 : 591 })
+  ),
+  import_msw5.http.put(`${import_constants6.deploymentsApiUrl}/artifacts/:id`, async ({ params: { id }, request }) => {
+    const { description } = await request.json();
+    return new import_msw5.HttpResponse(null, { status: id === mockApiResponses.releases.byId.r1.artifacts[0].id && description ? 200 : 592 });
+  }),
+  import_msw5.http.post(`${import_constants6.deploymentsApiUrl}/artifacts/generate`, () => new import_msw5.HttpResponse(null, { status: 200 })),
+  import_msw5.http.post(`${import_constants6.deploymentsApiUrl}/artifacts`, () => new import_msw5.HttpResponse(null, { status: 200 })),
+  import_msw5.http.get(`${import_constants6.deploymentsApiUrlV2}/deployments/releases`, async ({ request }) => {
+    const { searchParams } = new URL(request.url);
+    const page = Number(searchParams.get("page"));
+    const perPage = Number(searchParams.get("per_page"));
+    if (!page || ![1, 10, 20, 50, 100, 250, 500].includes(perPage)) {
+      return new import_msw5.HttpResponse(null, { status: 593 });
+    }
+    if (searchParams.get("device_type")) {
+      return import_msw5.HttpResponse.json([]);
+    }
+    if (page == 42) {
+      return new import_msw5.HttpResponse(JSON.stringify([mockApiResponses.releases.byId.r1]), { headers: { [import_constants6.headerNames.total]: 1 } });
+    }
+    const sort = searchParams.get("sort");
+    const releaseListSection = releasesList.sort((0, import_helpers.customSort)(sort.includes(import_constants6.SORTING_OPTIONS.desc), "name")).slice((page - 1) * perPage, page * perPage);
+    if (page === 1 && perPage === 1 && searchParams.get("name")) {
+      return import_msw5.HttpResponse.json([mockApiResponses.releases.byId.r1]);
+    }
+    if (searchParams.get("name")) {
+      return new import_msw5.HttpResponse(JSON.stringify(releaseListSection), { headers: { [import_constants6.headerNames.total]: 1234 } });
+    }
+    return new import_msw5.HttpResponse(JSON.stringify(releaseListSection), { headers: { [import_constants6.headerNames.total]: releasesList.length } });
+  }),
+  import_msw5.http.get(`${import_constants6.deploymentsApiUrlV2}/deployments/releases/:name`, () => import_msw5.HttpResponse.json(mockApiResponses.releases.byId.r1)),
+  import_msw5.http.get(`${import_constants6.deploymentsApiUrlV2}/releases/all/tags`, () => import_msw5.HttpResponse.json(["foo", "bar"])),
+  import_msw5.http.get(`${import_constants6.deploymentsApiUrlV2}/releases/all/types`, () => import_msw5.HttpResponse.json(["single-file", "not-this"])),
+  import_msw5.http.put(`${import_constants6.deploymentsApiUrlV2}/deployments/releases/:name/tags`, async ({ params: { name }, request }) => {
+    const tags = await request.json();
+    if (name && tags.every((i) => i && i.toString() === i)) {
+      return new import_msw5.HttpResponse(null, { status: 200 });
+    }
+    return new import_msw5.HttpResponse(null, { status: 593 });
+  }),
+  import_msw5.http.patch(`${import_constants6.deploymentsApiUrlV2}/deployments/releases/:name`, async ({ params: { name }, request }) => {
+    const { notes } = await request.json();
+    return new import_msw5.HttpResponse(null, { status: name && notes.length ? 200 : 594 });
+  })
+];
+
+// src/requestHandlers/userHandlers.ts
+var import_constants7 = require("@northern.tech/utils/constants");
+var import_msw6 = require("msw");
+var userHandlers = [
+  import_msw6.http.post(`${import_constants7.useradmApiUrl}/auth/login`, ({ request }) => {
+    const authHeader = request.headers.get("authorization");
+    const authInfo = atob(authHeader?.split(" ")[1]);
+    const [user, password] = authInfo.split(":");
+    if (!password) {
+      return import_msw6.HttpResponse.json({ id: testSsoId, kind: "sso/saml" });
+    } else if (password !== defaultPassword) {
+      return new import_msw6.HttpResponse(null, { status: 401 });
+    } else if (user.includes("limited")) {
+      return new import_msw6.HttpResponse("limitedToken", { headers: { "Content-Type": import_constants7.APPLICATION_JWT_CONTENT_TYPE } });
+    } else if (user.includes("2fa")) {
+      return new import_msw6.HttpResponse(JSON.stringify({ error: "2fa needed" }), { status: 401 });
+    }
+    return new import_msw6.HttpResponse(token, { headers: { "Content-Type": import_constants7.APPLICATION_JWT_CONTENT_TYPE } });
+  }),
+  import_msw6.http.get(`https://hosted.mender.io${import_constants7.useradmApiUrl}/auth/magic/:id`, ({ params: { id } }) => {
+    if (id) {
+      return new import_msw6.HttpResponse("test", { headers: { "Set-Cookie": "JWT=test" } });
+    }
+    return new import_msw6.HttpResponse(null, { status: 400 });
+  }),
+  import_msw6.http.post(`${import_constants7.useradmApiUrl}/auth/logout`, () => new import_msw6.HttpResponse(null, { status: 200 })),
+  import_msw6.http.post(`${import_constants7.useradmApiUrl}/auth/password-reset/:status`, async ({ params: { status }, request }) => {
+    const { email, secret_hash, password } = await request.json();
+    if (!["start", "complete"].includes(status) && ![email, secret_hash, password].some((item) => item)) {
+      return new import_msw6.HttpResponse(null, { status: 560 });
+    }
+    if (status === "start" && email) {
+      return new import_msw6.HttpResponse(null, { status: 200 });
+    }
+    if (status === "complete" && secret_hash && password) {
+      return new import_msw6.HttpResponse(null, { status: 200 });
+    }
+    return new import_msw6.HttpResponse(null, { status: 561 });
+  }),
+  import_msw6.http.put(`${import_constants7.useradmApiUrl}/2faverify`, async ({ request }) => {
+    const { token2fa } = await request.json();
+    if (!token2fa) {
+      return new import_msw6.HttpResponse(null, { status: 562 });
+    }
+    return new import_msw6.HttpResponse(null, { status: 200 });
+  }),
+  import_msw6.http.get(`${import_constants7.useradmApiUrl}/users`, () => import_msw6.HttpResponse.json(Object.values(mockApiResponses.users.byId))),
+  import_msw6.http.get(`${import_constants7.useradmApiUrl}/users/me`, ({ request }) => {
+    const authHeader = request.headers.get("authorization");
+    if (authHeader?.includes("limited")) {
+      return new import_msw6.HttpResponse(JSON.stringify({ error: "forbidden by role-based access control" }), { status: 403 });
+    }
+    return import_msw6.HttpResponse.json(mockApiResponses.users.byId[userId]);
+  }),
+  import_msw6.http.get(`${import_constants7.useradmApiUrl}/users/:userId`, ({ params: { userId: userId2 } }) => {
+    if (userId2 === "me" || mockApiResponses.users.byId[userId2]) {
+      const user = userId2 === "me" ? userId : userId2;
+      return import_msw6.HttpResponse.json(mockApiResponses.users.byId[user]);
+    }
+    return new import_msw6.HttpResponse(null, { status: 563 });
+  }),
+  import_msw6.http.post(`${import_constants7.useradmApiUrl}/users`, async ({ request }) => {
+    const { email, password } = await request.json();
+    if (email === "test@test.com" || [email, password].every((value) => value)) {
+      return import_msw6.HttpResponse.json(mockApiResponses.users.byId.a1);
+    }
+    return new import_msw6.HttpResponse(null, { status: 564 });
+  }),
+  import_msw6.http.put(`${import_constants7.useradmApiUrl}/users/:userId`, async ({ params: { userId: userId2 }, request }) => {
+    const { email, password, current_password } = await request.json();
+    if (current_password === "bad_password") {
+      return new import_msw6.HttpResponse(null, { status: 401 });
+    }
+    if (mockApiResponses.users.byId[userId2] && [email, password].some((value) => Object.values(mockApiResponses.users.byId[userId2]).includes(value)) || email === "test@test.com") {
+      return new import_msw6.HttpResponse(null, { status: 200 });
+    }
+    return new import_msw6.HttpResponse(null, { status: 565 });
+  }),
+  import_msw6.http.delete(
+    `${import_constants7.useradmApiUrl}/users/:userId`,
+    ({ params: { userId: userId2 } }) => new import_msw6.HttpResponse(null, { status: mockApiResponses.users.byId[userId2] ? 200 : 566 })
+  ),
+  import_msw6.http.get(`${import_constants7.useradmApiUrl}/roles`, () => import_msw6.HttpResponse.json(rbacRoles)),
+  import_msw6.http.post(`${import_constants7.useradmApiUrl}/roles`, async ({ request }) => {
+    const { name, permissions } = await request.json();
+    if ([name, permissions].every((value) => value) && permissions.every((permission) => permission.action && permission.object && permission.object.type && permission.object.value)) {
+      return new import_msw6.HttpResponse(null, { status: 200 });
+    }
+    return new import_msw6.HttpResponse(null, { status: 567 });
+  }),
+  import_msw6.http.put(`${import_constants7.useradmApiUrl}/roles/:roleId`, async ({ params: { roleId }, request }) => {
+    const { description, name, permissions } = await request.json();
+    if (mockApiResponses.users.rolesById[roleId] && [description, name, permissions].some((value) => value)) {
+      return new import_msw6.HttpResponse(null, { status: 200 });
+    }
+    return new import_msw6.HttpResponse(null, { status: 568 });
+  }),
+  import_msw6.http.delete(
+    `${import_constants7.useradmApiUrl}/roles/:roleId`,
+    ({ params: { roleId } }) => new import_msw6.HttpResponse(null, { status: mockApiResponses.users.rolesById[roleId] ? 200 : 569 })
+  ),
+  import_msw6.http.get(`${import_constants7.useradmApiUrlv2}/roles`, () => import_msw6.HttpResponse.json(rbacRoles)),
+  import_msw6.http.get(`${import_constants7.useradmApiUrlv2}/roles/:roleId`, async ({ params: { roleId } }) => {
+    if (mockApiResponses.users.rolesById[roleId]) {
+      return import_msw6.HttpResponse.json(mockApiResponses.users.rolesById[roleId]);
+    }
+    return new import_msw6.HttpResponse(null, { status: 571 });
+  }),
+  import_msw6.http.post(`${import_constants7.useradmApiUrlv2}/roles`, async ({ request }) => {
+    const { name, permission_sets_with_scope } = await request.json();
+    if (!!name && permission_sets_with_scope.every((permission) => permission.name && permissionSets.find((permissionSet) => permissionSet.name === permission.name))) {
+      return new import_msw6.HttpResponse(null, { status: 200 });
+    }
+    return new import_msw6.HttpResponse(null, { status: 572 });
+  }),
+  import_msw6.http.put(`${import_constants7.useradmApiUrlv2}/roles/:roleId`, async ({ params: { roleId }, request }) => {
+    const { description, name, permission_sets_with_scope } = await request.json();
+    if (mockApiResponses.users.rolesById[roleId] && [description, name, permission_sets_with_scope].some((value) => value)) {
+      return new import_msw6.HttpResponse(null, { status: 200 });
+    }
+    return new import_msw6.HttpResponse(null, { status: 573 });
+  }),
+  import_msw6.http.delete(`${import_constants7.useradmApiUrlv2}/roles/:roleId`, ({ params: { roleId } }) => {
+    if (mockApiResponses.users.rolesById[roleId]) {
+      return new import_msw6.HttpResponse(null, { status: 200 });
+    }
+    return new import_msw6.HttpResponse(null, { status: 574 });
+  }),
+  import_msw6.http.get(`${import_constants7.useradmApiUrl}/settings`, () => import_msw6.HttpResponse.json(mockApiResponses.users.globalSettings)),
+  import_msw6.http.post(`${import_constants7.useradmApiUrl}/settings`, () => new import_msw6.HttpResponse(null, { status: 200 })),
+  import_msw6.http.get(`${import_constants7.useradmApiUrl}/settings/me`, () => import_msw6.HttpResponse.json(mockApiResponses.users.userSettings)),
+  import_msw6.http.post(`${import_constants7.useradmApiUrl}/settings/me`, () => new import_msw6.HttpResponse(null, { status: 200 })),
+  import_msw6.http.get(`${import_constants7.useradmApiUrl}/settings/tokens`, () => import_msw6.HttpResponse.json(accessTokens)),
+  import_msw6.http.post(`${import_constants7.useradmApiUrl}/settings/tokens`, () => import_msw6.HttpResponse.json("aNewToken")),
+  import_msw6.http.delete(
+    `${import_constants7.useradmApiUrl}/settings/tokens/:tokenId`,
+    ({ params: { tokenId } }) => new import_msw6.HttpResponse(null, { status: tokenId === "some-id-1" ? 200 : 577 })
+  ),
+  import_msw6.http.get(`${import_constants7.useradmApiUrl}/2faqr`, () => import_msw6.HttpResponse.json({ qr: btoa("test") })),
+  import_msw6.http.post(`${import_constants7.useradmApiUrl}/users/:userId/2fa/enable`, ({ params: { userId: userId2 } }) => {
+    if (mockApiResponses.users.byId[userId2] || userId2 === "me") {
+      return new import_msw6.HttpResponse(null, { status: 200 });
+    }
+    return new import_msw6.HttpResponse(null, { status: 570 });
+  }),
+  import_msw6.http.post(`${import_constants7.useradmApiUrl}/users/:userId/2fa/disable`, ({ params: { userId: userId2 } }) => {
+    if (mockApiResponses.users.byId[userId2] || userId2 === "me") {
+      return new import_msw6.HttpResponse(null, { status: 200 });
+    }
+    return new import_msw6.HttpResponse(null, { status: 571 });
+  }),
+  import_msw6.http.post(`${import_constants7.useradmApiUrl}/auth/verify-email/start`, () => new import_msw6.HttpResponse(null, { status: 200 })),
+  import_msw6.http.post(`${import_constants7.useradmApiUrl}/auth/verify-email/complete`, async ({ request }) => {
+    const { secret_hash } = await request.json();
+    return new import_msw6.HttpResponse(null, { status: secret_hash === "superSecret" ? 200 : 576 });
+  }),
+  import_msw6.http.get(`${import_constants7.useradmApiUrlv2}/permission_sets`, () => import_msw6.HttpResponse.json(permissionSets)),
+  import_msw6.http.post(`${import_constants7.useradmApiUrl}/users/:userId/assign`, async ({ request }) => {
+    const { tenant_ids } = await request.json();
+    return new import_msw6.HttpResponse(null, { status: tenant_ids.length ? 200 : 577 });
+  }),
+  import_msw6.http.get(`${import_constants7.useradmApiUrl}/users/tenants/:tenantId/token`, () => import_msw6.HttpResponse.text("differentToken"))
+];
+
+// src/requestHandlers/requestHandlers.ts
+var testLocation = "/test";
+var baseHandlers = [
+  import_msw7.http.get(testLocation, () => new import_msw7.HttpResponse(null, { status: 200 })),
+  import_msw7.http.post(testLocation, () => import_msw7.HttpResponse.json({})),
+  import_msw7.http.put(testLocation, () => import_msw7.HttpResponse.json({})),
+  import_msw7.http.delete(testLocation, () => import_msw7.HttpResponse.json({}))
+];
+var handlers = [...baseHandlers, ...deploymentHandlers, ...deviceHandlers, ...monitorHandlers, ...organizationHandlers, ...releaseHandlers, ...userHandlers];
+var requestHandlers_default = handlers;
+//# sourceMappingURL=requestHandlers.cjs.map