@auth0/auth0-checkmate 1.4.0

package/tests/databases/checkPasswordComplexity.test.js

@@ -0,0 +1,127 @@
+const { expect } = require("chai");
+const checkPasswordComplexity = require("../../analyzer/lib/databases/checkPasswordComplexity");
+const CONSTANTS = require("../../analyzer/lib/constants");
+
+describe("checkPasswordComplexity", function () {
+  it("should return failure if no databases are provided", function () {
+    const options = {
+      databases: [], // Empty databases array
+    };
+
+    checkPasswordComplexity(options, (report) => {
+      expect(report).to.have.lengthOf(1);
+      expect(report[0].field).to.equal("no_database_connections_found");
+      expect(report[0].status).to.equal(CONSTANTS.FAIL);
+    });
+  });
+
+  it("should return failure if password complexity is not configured", function () {
+    const options = {
+      databases: [
+        {
+          name: "Default DB",
+          options: {
+            password_complexity_options: {}, // Empty password_complexity_options
+          },
+        },
+      ],
+    };
+
+    checkPasswordComplexity(options, (report) => {
+      expect(report).to.have.lengthOf(1);
+      expect(report[0].field).to.equal("password_complexity_not_configured");
+      expect(report[0].status).to.equal(CONSTANTS.FAIL);
+    });
+  });
+
+  it("should return failure if password minimum length is less than 12", function () {
+    const options = {
+      databases: [
+        {
+          name: "Default DB",
+          options: {
+            password_complexity_options: {
+              min_length: 8, // Password min length is 8 (which is less than 12)
+            },
+          },
+        },
+      ],
+    };
+
+    checkPasswordComplexity(options, (report) => {
+      expect(report).to.have.lengthOf(1);
+      expect(report[0].field).to.equal("password_min_length_fail");
+      expect(report[0].status).to.equal(CONSTANTS.FAIL);
+      expect(report[0].value).to.equal(8);
+    });
+  });
+
+  it("should return success if password minimum length is 12 or greater", function () {
+    const options = {
+      databases: [
+        {
+          name: "Default DB",
+          options: {
+            password_complexity_options: {
+              min_length: 12, // Password min length is 12 (which meets the minimum requirement)
+            },
+          },
+        },
+      ],
+    };
+
+    checkPasswordComplexity(options, (report) => {
+      expect(report).to.have.lengthOf(1);
+      expect(report[0].field).to.equal("password_min_length_success");
+      expect(report[0].status).to.equal(CONSTANTS.SUCCESS);
+      expect(report[0].value).to.equal(12);
+    });
+  });
+
+  it("should handle multiple databases with different password complexity configurations", function () {
+    const options = {
+      databases: [
+        {
+          name: "DB 1",
+          options: {
+            password_complexity_options: {
+              min_length: 8, // Password min length is 8 (failure case)
+            },
+          },
+        },
+        {
+          name: "DB 2",
+          options: {
+            password_complexity_options: {
+              min_length: 14, // Password min length is 14 (success case)
+            },
+          },
+        },
+        {
+          name: "DB 3",
+          options: {
+            password_complexity_options: {}, // No password complexity configured (failure case)
+          },
+        },
+      ],
+    };
+
+    checkPasswordComplexity(options, (report) => {
+      expect(report).to.have.lengthOf(3);
+
+      // DB 1: Password min length is less than 12, should fail
+      expect(report[0].field).to.equal("password_min_length_fail");
+      expect(report[0].status).to.equal(CONSTANTS.FAIL);
+      expect(report[0].value).to.equal(8);
+
+      // DB 2: Password min length is 14, should succeed
+      expect(report[1].field).to.equal("password_min_length_success");
+      expect(report[1].status).to.equal(CONSTANTS.SUCCESS);
+      expect(report[1].value).to.equal(14);
+
+      // DB 3: Password complexity not configured, should fail
+      expect(report[2].field).to.equal("password_complexity_not_configured");
+      expect(report[2].status).to.equal(CONSTANTS.FAIL);
+    });
+  });
+});

package/tests/databases/checkPasswordHistory.test.js

@@ -0,0 +1,100 @@
+const { expect } = require("chai");
+const checkPasswordHistory = require("../../analyzer/lib/databases/checkPasswordHistory");
+const CONSTANTS = require("../../analyzer/lib/constants");
+
+describe("checkPasswordHistory", function () {
+  it("should return failure if no databases are provided", function () {
+    const options = {
+      databases: [], // Empty databases array
+    };
+
+    checkPasswordHistory(options, (report) => {
+      expect(report).to.have.lengthOf(1);
+      expect(report[0].field).to.equal("no_database_connections_found");
+      expect(report[0].status).to.equal(CONSTANTS.FAIL);
+    });
+  });
+
+  it("should return failure if password history is disabled", function () {
+    const options = {
+      databases: [
+        {
+          name: "Default DB",
+          options: {
+            password_history: {
+              enable: false, // Password history is disabled
+              size: 5,
+            },
+          },
+        },
+      ],
+    };
+
+    checkPasswordHistory(options, (report) => {
+      expect(report).to.have.lengthOf(1);
+      expect(report[0].field).to.equal("password_history_disabled");
+      expect(report[0].status).to.equal(CONSTANTS.FAIL);
+    });
+  });
+
+  it("should return success if password history is enabled", function () {
+    const options = {
+      databases: [
+        {
+          name: "Default DB",
+          options: {
+            password_history: {
+              enable: true, // Password history is enabled
+              size: 5,
+            },
+          },
+        },
+      ],
+    };
+
+    checkPasswordHistory(options, (report) => {
+      expect(report).to.have.lengthOf(1);
+      expect(report[0].field).to.equal("password_history_enabled");
+      expect(report[0].status).to.equal(CONSTANTS.SUCCESS);
+      expect(report[0].value).to.equal(5);
+    });
+  });
+
+  it("should handle multiple databases with different password history configurations", function () {
+    const options = {
+      databases: [
+        {
+          name: "DB 1",
+          options: {
+            password_history: {
+              enable: false, // Password history is disabled (failure case)
+              size: 5,
+            },
+          },
+        },
+        {
+          name: "DB 2",
+          options: {
+            password_history: {
+              enable: true, // Password history is enabled (success case)
+              size: 10,
+            },
+          },
+        },
+      ],
+    };
+
+    checkPasswordHistory(options, (report) => {
+      expect(report).to.have.lengthOf(2);
+
+      // DB 1: Password history disabled, should fail
+      expect(report[0].field).to.equal("password_history_disabled");
+      expect(report[0].status).to.equal(CONSTANTS.FAIL);
+
+      // DB 2: Password history enabled, should succeed
+      expect(report[1].field).to.equal("password_history_enabled");
+      expect(report[1].status).to.equal(CONSTANTS.SUCCESS);
+      expect(report[1].value).to.equal(10);
+    });
+  });
+});

package/tests/databases/checkPasswordNoPersonalInfo.test.js

@@ -0,0 +1,94 @@
+const { expect } = require("chai");
+const checkPasswordNoPersonalInfo = require("../../analyzer/lib/databases/checkPasswordNoPersonalInfo");
+const CONSTANTS = require("../../analyzer/lib/constants");
+
+describe("checkPasswordNoPersonalInfo", function () {
+  it("should return failure if no databases are provided", function () {
+    const options = {
+      databases: [], // Empty databases array
+    };
+
+    checkPasswordNoPersonalInfo(options, (report) => {
+      expect(report).to.have.lengthOf(1);
+      expect(report[0].field).to.equal("no_database_connections_found");
+      expect(report[0].status).to.equal(CONSTANTS.FAIL);
+    });
+  });
+
+  it("should return failure if password_no_personal_info is disabled", function () {
+    const options = {
+      databases: [
+        {
+          name: "Default DB",
+          options: {
+            password_no_personal_info: {
+              enable: false, // Personal info disallowed is disabled
+            },
+          },
+        },
+      ],
+    };
+
+    checkPasswordNoPersonalInfo(options, (report) => {
+      expect(report).to.have.lengthOf(1);
+      expect(report[0].field).to.equal("password_no_personal_info_disabled");
+      expect(report[0].status).to.equal(CONSTANTS.FAIL);
+    });
+  });
+
+  it("should return success if password_no_personal_info is enabled", function () {
+    const options = {
+      databases: [
+        {
+          name: "Default DB",
+          options: {
+            password_no_personal_info: {
+              enable: true, // Personal info disallowed is enabled
+            },
+          },
+        },
+      ],
+    };
+
+    checkPasswordNoPersonalInfo(options, (report) => {
+      expect(report).to.have.lengthOf(1);
+      expect(report[0].field).to.equal("password_no_personal_info_enable");
+      expect(report[0].status).to.equal(CONSTANTS.SUCCESS);
+    });
+  });
+
+  it("should handle multiple databases with different personal info configurations", function () {
+    const options = {
+      databases: [
+        {
+          name: "DB 1",
+          options: {
+            password_no_personal_info: {
+              enable: false, // Personal info disallowed is disabled (failure case)
+            },
+          },
+        },
+        {
+          name: "DB 2",
+          options: {
+            password_no_personal_info: {
+              enable: true, // Personal info disallowed is enabled (success case)
+            },
+          },
+        },
+      ],
+    };
+
+    checkPasswordNoPersonalInfo(options, (report) => {
+      expect(report).to.have.lengthOf(2);
+
+      // DB 1: Personal info disallowed is disabled, should fail
+      expect(report[0].field).to.equal("password_no_personal_info_disabled");
+      expect(report[0].status).to.equal(CONSTANTS.FAIL);
+
+      // DB 2: Personal info disallowed is enabled, should succeed
+      expect(report[1].field).to.equal("password_no_personal_info_enable");
+      expect(report[1].status).to.equal(CONSTANTS.SUCCESS);
+    });
+  });
+});

package/tests/databases/checkPasswordPolicy.test.js

@@ -0,0 +1,161 @@
+const { expect } = require("chai");
+const checkPasswordPolicy = require("../../analyzer/lib/databases/checkPasswordPolicy");
+const CONSTANTS = require("../../analyzer/lib/constants");
+
+describe("checkPasswordPolicy", function () {
+  it("should return failure if no databases are provided", function () {
+    const options = {
+      databases: [], // Empty databases array
+    };
+
+    checkPasswordPolicy(options, (report) => {
+      expect(report).to.have.lengthOf(1);
+      expect(report[0].field).to.equal("no_database_connections_found");
+      expect(report[0].status).to.equal(CONSTANTS.FAIL);
+    });
+  });
+
+  it('should return failure if passwordPolicy is "none"', function () {
+    const options = {
+      databases: [
+        {
+          name: "DB 1",
+          options: {
+            passwordPolicy: "none", // Password policy is "none"
+          },
+        },
+      ],
+    };
+
+    checkPasswordPolicy(options, (report) => {
+      expect(report).to.have.lengthOf(1);
+      expect(report[0].field).to.equal("password_policy");
+      expect(report[0].status).to.equal(CONSTANTS.FAIL);
+      expect(report[0].value).to.equal("none");
+    });
+  });
+
+  it('should return failure if passwordPolicy is "low"', function () {
+    const options = {
+      databases: [
+        {
+          name: "DB 2",
+          options: {
+            passwordPolicy: "low", // Password policy is "low"
+          },
+        },
+      ],
+    };
+
+    checkPasswordPolicy(options, (report) => {
+      expect(report).to.have.lengthOf(1);
+      expect(report[0].field).to.equal("password_policy");
+      expect(report[0].status).to.equal(CONSTANTS.FAIL);
+      expect(report[0].value).to.equal("low");
+    });
+  });
+
+  it('should return failure if passwordPolicy is "fair"', function () {
+    const options = {
+      databases: [
+        {
+          name: "DB 3",
+          options: {
+            passwordPolicy: "fair", // Password policy is "fair"
+          },
+        },
+      ],
+    };
+
+    checkPasswordPolicy(options, (report) => {
+      expect(report).to.have.lengthOf(1);
+      expect(report[0].field).to.equal("password_policy");
+      expect(report[0].status).to.equal(CONSTANTS.FAIL);
+      expect(report[0].value).to.equal("fair");
+    });
+  });
+
+  it('should return success if passwordPolicy is "good"', function () {
+    const options = {
+      databases: [
+        {
+          name: "DB 4",
+          options: {
+            passwordPolicy: "good", // Password policy is "good"
+          },
+        },
+      ],
+    };
+
+    checkPasswordPolicy(options, (report) => {
+      expect(report).to.have.lengthOf(1);
+      expect(report[0].field).to.equal("password_policy");
+      expect(report[0].status).to.equal(CONSTANTS.SUCCESS);
+      expect(report[0].value).to.equal("good");
+    });
+  });
+
+  it('should return success if passwordPolicy is "excellent"', function () {
+    const options = {
+      databases: [
+        {
+          name: "DB 5",
+          options: {
+            passwordPolicy: "excellent", // Password policy is "excellent"
+          },
+        },
+      ],
+    };
+
+    checkPasswordPolicy(options, (report) => {
+      expect(report).to.have.lengthOf(1);
+      expect(report[0].field).to.equal("password_policy");
+      expect(report[0].status).to.equal(CONSTANTS.SUCCESS);
+      expect(report[0].value).to.equal("excellent");
+    });
+  });
+
+  it("should handle multiple databases with different password policies", function () {
+    const options = {
+      databases: [
+        {
+          name: "DB 1",
+          options: {
+            passwordPolicy: "none", // Password policy is "none"
+          },
+        },
+        {
+          name: "DB 2",
+          options: {
+            passwordPolicy: "low", // Password policy is "low"
+          },
+        },
+        {
+          name: "DB 3",
+          options: {
+            passwordPolicy: "good", // Password policy is "good"
+          },
+        },
+      ],
+    };
+
+    checkPasswordPolicy(options, (report) => {
+      expect(report).to.have.lengthOf(3);
+
+      // DB 1: Password policy "none", should fail
+      expect(report[0].field).to.equal("password_policy");
+      expect(report[0].status).to.equal(CONSTANTS.FAIL);
+      expect(report[0].value).to.equal("none");
+
+      // DB 2: Password policy "low", should fail
+      expect(report[1].field).to.equal("password_policy");
+      expect(report[1].status).to.equal(CONSTANTS.FAIL);
+      expect(report[1].value).to.equal("low");
+
+      // DB 3: Password policy "good", should succeed
+      expect(report[2].field).to.equal("password_policy");
+      expect(report[2].status).to.equal(CONSTANTS.SUCCESS);
+      expect(report[2].value).to.equal("good");
+    });
+  });
+});

package/tests/databases/checkPromotedDBConnection.test.js

@@ -0,0 +1,62 @@
+const { expect } = require("chai");
+const checkPromotedDBConnection = require("../../analyzer/lib/databases/checkPromotedDBConnection");
+const CONSTANTS = require("../../analyzer/lib/constants");
+
+describe("checkPromotedDBConnection", function () {
+  it("should return failure if no databases are provided", function () {
+    const options = {
+      databases: [], // Empty databases array
+    };
+
+    checkPromotedDBConnection(options, (report) => {
+      expect(report).to.have.lengthOf(1);
+      expect(report[0].field).to.equal("no_database_connections_found");
+      expect(report[0].status).to.equal(CONSTANTS.FAIL);
+    });
+  });
+
+  it('should return no_connection if no any prmoted domain connection', function () {
+    const options = {
+      databases: [
+        {
+          name: "DB 1",
+          is_domain_connection: false,
+        },
+        {
+          name: "DB 2",
+          is_domain_connection: false,
+        }
+      ],
+    };
+
+    checkPromotedDBConnection(options, (report) => {
+      expect(report).to.have.lengthOf(1);
+      expect(report[0].field).to.equal("NO_PRMOTED_DOMAIN_CONNECTION");
+      expect(report[0].status).to.equal(CONSTANTS.FAIL);
+      expect(report[0].value).to.equal("no_database_connections_found");
+    });
+  });
+
+  it('should return promoted_domain_connection name if is_domain_connection is true', function () {
+    const options = {
+      databases: [
+        {
+          name: "DB 1",
+          is_domain_connection: false,
+        },
+        {
+          name: "DB 2",
+          is_domain_connection: true,
+        }
+      ],
+    };
+
+    checkPromotedDBConnection(options, (report) => {
+      expect(report).to.have.lengthOf(1);
+      expect(report[0].field).to.equal("DB 2");
+      expect(report[0].status).to.equal(CONSTANTS.FAIL);
+      expect(report[0].value).to.equal("with_promoted_database_connections");
+    });
+  });
+
+});

package/tests/email_provider/checkEmailProvider.test.js

@@ -0,0 +1,58 @@
+const chai = require("chai");
+const expect = chai.expect;
+
+const checkEmailProvider = require("../../analyzer/lib/email_provider/checkEmailProvider");
+const CONSTANTS = require("../../analyzer/lib/constants");
+
+describe("checkEmailProvider", function () {
+  it("should return fail when no email provider is provided", function () {
+    const options = {};
+
+    checkEmailProvider(options, (report) => {
+      expect(report).to.deep.equal([
+        {
+          field: "email_provider_not_configured",
+          status: CONSTANTS.FAIL,
+        },
+      ]);
+    });
+  });
+
+  it("should return success for an enabled email provider", function () {
+    const options = {
+      emailProvider: {
+        name: "sendgrid",
+        enabled: true,
+      },
+    };
+
+    checkEmailProvider(options, (report) => {
+      expect(report).to.deep.equal([
+        {
+          field: "email_provider_enabled",
+          status: CONSTANTS.SUCCESS,
+          value: "sendgrid",
+        },
+      ]);
+    });
+  });
+
+  it("should return fail for a disabled email provider", function () {
+    const options = {
+      emailProvider: {
+        name: "sendgrid",
+        enabled: false,
+      },
+    };
+
+    checkEmailProvider(options, (report) => {
+      expect(report).to.deep.equal([
+        {
+          field: "email_provider_disabled",
+          status: CONSTANTS.FAIL,
+          value: "sendgrid",
+        },
+      ]);
+    });
+  });
+});