xref: /OpenGrok/plugins/src/test/java/opengrok/auth/plugin/LdapServerTest.java (revision cb97e8782f9c60c94308b0e334f4e3b4930f04a6)

/*
 * CDDL HEADER START
 *
 * The contents of this file are subject to the terms of the
 * Common Development and Distribution License (the "License").
 * You may not use this file except in compliance with the License.
 *
 * See LICENSE.txt included in this distribution for the specific
 * language governing permissions and limitations under the License.
 *
 * When distributing Covered Code, include this CDDL HEADER in each
 * file and include the License file at LICENSE.txt.
 * If applicable, add the following below this CDDL HEADER, with the
 * fields enclosed by brackets "[]" replaced with your own identifying
 * information: Portions Copyright [yyyy] [name of copyright owner]
 *
 * CDDL HEADER END
 */

/*
 * Copyright (c) 2020, 2021, Oracle and/or its affiliates. All rights reserved.
 */
package opengrok.auth.plugin;

import opengrok.auth.plugin.ldap.LdapServer;
import org.junit.jupiter.api.Test;
import org.mockito.Mockito;
import org.opengrok.web.api.v1.controller.PortChecker;

import java.io.IOException;
import java.net.InetAddress;
import java.net.ServerSocket;
import java.net.Socket;
import java.net.URISyntaxException;
import java.net.UnknownHostException;
import java.util.Random;

import static org.junit.jupiter.api.Assertions.assertEquals;
import static org.junit.jupiter.api.Assertions.assertFalse;
import static org.junit.jupiter.api.Assertions.assertNotNull;
import static org.junit.jupiter.api.Assertions.assertNull;
import static org.junit.jupiter.api.Assertions.assertTrue;
import static org.mockito.ArgumentMatchers.any;
import static org.mockito.Mockito.doReturn;

public class LdapServerTest {

    @Test
    public void testInvalidURI() {
        LdapServer server = new LdapServer("foo:/\\/\\foo.bar");
        assertFalse(server.isReachable());
    }

    @Test
    public void testGetPort() throws URISyntaxException {
        LdapServer server = new LdapServer("ldaps://foo.bar");
        assertEquals(636, server.getPort());

        server = new LdapServer("ldap://foo.bar");
        assertEquals(389, server.getPort());

        server = new LdapServer("crumble://foo.bar");
        assertEquals(-1, server.getPort());
    }

    @Test
    public void testSetGetUsername() {
        LdapServer server = new LdapServer();

        assertNull(server.getUsername());
        assertNull(server.getPassword());

        final String testUsername = "foo";
        server.setUsername(testUsername);
        assertEquals(testUsername, server.getUsername());

        final String testPassword = "bar";
        server.setPassword(testPassword);
        assertEquals(testPassword, server.getPassword());
    }

    @Test
    public void testIsReachable() throws IOException, InterruptedException, URISyntaxException {
        final int testPortBase = 6336;    // It has to be > 1024 to avoid BindException due to permission denied.
        final int randomRange = 49152;
        int triesCount = 0;
        final int MAX_PORT_TRIES = 20;
        Random rand = new Random();
        int testPort;
        while (true) {
            testPort = testPortBase + rand.nextInt(randomRange);
            if (PortChecker.available(testPort)) {
                break;
            }
            if (++triesCount > MAX_PORT_TRIES) {
                throw new RuntimeException("Could not find an available port after " +
                        MAX_PORT_TRIES + " tries");
            }
        }

        // Start simple TCP server on test port.
        InetAddress localhostAddr = InetAddress.getLocalHost();
        ServerSocket serverSocket = new ServerSocket(testPort, 1, localhostAddr);
        Thread thread = new Thread(() -> {
            try {
                while (true) {
                    Socket client = serverSocket.accept();
                    client.close();
                }
            } catch (IOException e) {
                e.printStackTrace();
            }
        });

        thread.start();
        Socket socket = null;
        for (int i = 0; i < 3; i++) {
            try {
                socket = new Socket(localhostAddr, testPort);
            } catch (IOException e) {
                Thread.sleep(1000);
            }
        }

        assertNotNull(socket);
        assertTrue(socket.isConnected());

        // Mock getAddresses() to return single localhost IP address and getPort() to return the test port.
        LdapServer server = new LdapServer("ldaps://foo.bar.com");
        LdapServer serverSpy = Mockito.spy(server);
        Mockito.when(serverSpy.getAddresses(any())).thenReturn(new InetAddress[]{localhostAddr});
        doReturn(testPort).when(serverSpy).getPort();

        // Test reachability.
        boolean reachable = serverSpy.isReachable();
        serverSocket.close();
        thread.join(5000);
        thread.interrupt();
        assertTrue(reachable);

        // Test non-reachability.
        reachable = serverSpy.isReachable();
        assertFalse(reachable);
    }

    @Test
    public void testEmptyAddressArray() throws UnknownHostException {
        LdapServer server = new LdapServer("ldaps://foo.bar.com");
        LdapServer serverSpy = Mockito.spy(server);
        Mockito.when(serverSpy.getAddresses(any())).thenReturn(new InetAddress[]{});
        assertFalse(serverSpy.isReachable());
    }

    @Test
    public void testToString() {
        LdapServer server = new LdapServer("ldaps://foo.bar.com", "foo", "bar");
        server.setConnectTimeout(2000);
        server.setReadTimeout(1000);
        assertEquals("ldaps://foo.bar.com, connect timeout: 2000, read timeout: 1000, username: foo",
                server.toString());
    }
}