Fix some tests

packages/modules/openldap/src/import.sh

@@ -1,4 +1,5 @@
 #!/usr/bin/env bash
 set -e
-ldapadd $([[ -n "$1" ]] && echo "-a $1") < "/tmp/import.ldif"
+# shellcheck disable=SC2046
+ldapadd -x $([[ -n "$1" ]] && echo "-D $1") $([[ -n "$2" ]] && echo "-w $2") -f /tmp/import.ldif
 echo "Imported"

packages/modules/openldap/src/initData.ldif

@@ -1,7 +1,27 @@
-dn: uid=test.user,ou=users,dc=example,dc=org
+# LDIF file to create two users
+
+# Entry for User 1
+dn: uid=testuser1,ou=users,dc=example,dc=com
 changetype: add
-objectclass: iNetOrgPerson
-cn: Test User
-sn: Test
-mail: test.user@example.org
-userPassword: Password1
+objectClass: inetOrgPerson
+objectClass: posixAccount
+cn: User 1
+uid: user1
+sn: Lastname1
+userPassword: Password123
+uidNumber: 1001
+gidNumber: 1001
+homeDirectory: /home/user1
+
+# Entry for User 2
+dn: uid=testuser2,ou=users,dc=example,dc=com
+changetype: add
+objectClass: inetOrgPerson
+objectClass: posixAccount
+cn: User 2
+uid: user2
+sn: Lastname2
+userPassword: Password456
+uidNumber: 1002
+gidNumber: 1002
+homeDirectory: /home/user2

packages/modules/openldap/src/openldap-container.test.ts

@@ -9,17 +9,23 @@ describe("OpenLdapContainer", () => {
 
   // startContainer {
   it("should connect and execute set-get", async () => {
-    const container = await new OpenldapContainer().start();
+    const container = await new OpenldapContainer().withRootDn("dc=example,dc=org").start();
 
     const client = await connectTo(container);
 
-    await client.add("cn=foo, o=example", {
-      cn: "foo",
-      sn: "bar",
-      email: ["foo@bar.com", "foo1@bar.com"],
-      objectclass: "fooPerson",
+    const newUserName = "foo";
+    const dn = `cn=${newUserName}, ${container.getRootDn()}`;
+    await client.add(dn, {
+      cn: newUserName,
+      uidNumber: "1000",
+      gidNumber: "1000",
+      homeDirectory: `/home/${newUserName}`,
+      uid: newUserName,
+      sn: "LastName",
+      objectclass: ["inetOrgPerson", "posixAccount"],
     });
-    expect(await client.search("key")).toBe("val");
+    const user = await client.search(dn);
+    expect(user.searchEntries[0].object).not.toBeNull();
 
     await client.unbind();
     await container.stop();
@@ -68,12 +74,8 @@ describe("OpenLdapContainer", () => {
       .withInitialLdif(path.join(__dirname, "initData.ldif"))
       .start();
     const client = await connectTo(container);
-    const user = {
-      first_name: "David",
-      last_name: "Bloom",
-      dob: "03-MAR-1981",
-    };
-    expect(client.search("user:002")).toBe(JSON.stringify(user));
+    const user1 = await client.search("uid=testuser1,ou=users,dc=example,dc=com");
+    expect(user1.searchEntries.length).toBe(1);
 
     client.unbind();
     await container.stop();
@@ -87,15 +89,11 @@ describe("OpenLdapContainer", () => {
 
     // Test authentication
     const container = await new OpenldapContainer().withUsername(username).withPassword(password).start();
-    expect(container.getConnectionUrl()).toEqual(
-      `ldap://${username}:${password}@${container.getHost()}:${container.getPort()}`
-    );
-
+    expect(container.getConnectionUrl()).toEqual(`ldap://${container.getHost()}:${container.getPort()}`);
+    expect(container.getUsername()).toEqual(username);
+    expect(container.getPassword()).toEqual(password);
     const client = await connectTo(container);
 
-    //await client.set("key", "val");
-    //expect(await client.get("key")).toBe("val");
-
     await client.unbind();
     await container.stop();
   });
@@ -116,11 +114,8 @@ describe("OpenLdapContainer", () => {
   async function connectTo(container: StartedOpenldapContainer) {
     const client = new Client({
       url: container.getConnectionUrl(),
-      tlsOptions: {
-        rejectUnauthorized: true,
-      },
     });
-    await client.bind(container.getUsername(), container.getPassword());
+    await client.bind(`cn=${container.getUsername()},${container.getRootDn()}`, container.getPassword());
     expect(client.isConnected).toBeTruthy();
     return client;
   }

packages/modules/openldap/src/openldap-container.ts

@@ -4,19 +4,25 @@ import path from "path";
 const OPENLDAP_PORT = 1389;
 
 export class OpenldapContainer extends GenericContainer {
-  private readonly importFilePath = "/tmp/import.ldif";
+  private readonly importFilePath = "/home/import.ldif";
   private username? = "admin";
-  private password? = "";
+  private password? = "adminpassword";
   private rootDn? = "dc=example,dc=org";
   private baseDn? = "cn=admin,dc=example,dc=org";
   private persistenceVolume? = "";
   private initialImportScriptFile? = "";
 
   constructor(image = "bitnami/openldap:latest") {
     super(image);
+    this.withEnvironment({
+      LDAP_ADMIN_USERNAME: this.username ?? "",
+      LDAP_ADMIN_PASSWORD: this.password ?? "",
+      LDAP_ROOT: this.rootDn ?? "",
+      LDAP_BASE: this.baseDn ?? "",
+    });
     this.withExposedPorts(OPENLDAP_PORT)
       .withStartupTimeout(120_000)
-      .withWaitStrategy(Wait.forAll([Wait.forLogMessage("** Starting slapd **"), Wait.forListeningPorts()]));
+      .withWaitStrategy(Wait.forAll([Wait.forLogMessage("slapd starting"), Wait.forListeningPorts()]));
   }
 
   public withUsername(username: string): this {
@@ -62,7 +68,7 @@ export class OpenldapContainer extends GenericContainer {
     if (this.initialImportScriptFile) {
       this.withCopyFilesToContainer([
         {
-          mode: 666,
+          mode: 777,
           source: this.initialImportScriptFile,
           target: this.importFilePath,
         },
@@ -73,13 +79,18 @@ export class OpenldapContainer extends GenericContainer {
         },
       ]);
     }
-    const startedRedisContainer = new StartedOpenldapContainer(await super.start(), this.username, this.password);
+    const startedRedisContainer = new StartedOpenldapContainer(
+      await super.start(),
+      this.username,
+      this.password,
+      this.rootDn
+    );
     if (this.initialImportScriptFile) await this.importInitialData(startedRedisContainer);
     return startedRedisContainer;
   }
 
   private async importInitialData(container: StartedOpenldapContainer) {
-    const re = await container.exec(`/tmp/import.sh ${this.password}`);
+    const re = await container.exec(`/tmp/import.sh "${this.username},${this.rootDn}" ${this.password}`);
     if (re.exitCode != 0 || re.output.includes("ERR"))
       throw Error(`Could not import initial data from ${this.initialImportScriptFile}: ${re.output}`);
   }
@@ -89,7 +100,8 @@ export class StartedOpenldapContainer extends AbstractStartedContainer {
   constructor(
     startedTestContainer: StartedTestContainer,
     private readonly username?: string,
-    private readonly password?: string
+    private readonly password?: string,
+    private readonly rootDn?: string
   ) {
     super(startedTestContainer);
   }
@@ -106,17 +118,20 @@ export class StartedOpenldapContainer extends AbstractStartedContainer {
     return this.password ?? "";
   }
 
+  public getRootDn(): string {
+    return this.rootDn ?? "";
+  }
+
   public getConnectionUrl(): string {
     const url = new URL("", "ldap://");
     url.hostname = this.getHost();
     url.port = this.getPort().toString();
-    url.password = this.getPassword();
     return url.toString();
   }
 
   public async executeCliCmd(cmd: string, additionalFlags: string[] = []): Promise<string> {
     const result = await this.startedTestContainer.exec([
-      "redis-cli",
+      "ldap-cli",
       ...(this.password != "" ? [`-a ${this.password}`] : []),
       `${cmd}`,
       ...additionalFlags,