src/test/java/org/apache/commons/net/ftp/FTPSClientTest.java

/*
 * Licensed to the Apache Software Foundation (ASF) under one or more
 * contributor license agreements.  See the NOTICE file distributed with
 * this work for additional information regarding copyright ownership.
 * The ASF licenses this file to You under the Apache License, Version 2.0
 * (the "License"); you may not use this file except in compliance with
 * the License.  You may obtain a copy of the License at
 *
 *      https://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

package org.apache.commons.net.ftp;

import static org.junit.jupiter.api.Assertions.assertEquals;
import static org.junit.jupiter.api.Assertions.assertNotNull;
import static org.junit.jupiter.api.Assertions.assertTrue;

import java.io.IOException;
import java.net.SocketException;
import java.time.Instant;
import java.util.Calendar;
import java.util.stream.Stream;

import org.junit.jupiter.api.BeforeAll;
import org.junit.jupiter.api.Timeout;
import org.junit.jupiter.params.ParameterizedTest;
import org.junit.jupiter.params.provider.MethodSource;

/**
 * Tests {@link FTPSClient}.
 * <p>
 * To get our test cert to work on Java 11, this test must be run with:
 * </p>
 *
 * <pre>
 * -Djdk.tls.client.protocols="TLSv1.1"
 * </pre>
 * <p>
 * This test does the above programmatically.
 * </p>
 */
class FTPSClientTest extends AbstractFtpsTest {

    private static final String USER_PROPS_RES = "org/apache/commons/net/ftpsserver/users.properties";

    private static final String SERVER_JKS_RES = "org/apache/commons/net/ftpsserver/ftpserver.jks";

    private static Stream<Boolean> endpointCheckingEnabledSource() {
        return Stream.of(Boolean.FALSE, Boolean.TRUE);
    }

    @BeforeAll
    public static void setupServer() throws Exception {
        setupServer(IMPLICIT, USER_PROPS_RES, SERVER_JKS_RES, "target/test-classes/org/apache/commons/net/test-data");
    }

    @ParameterizedTest(name = "endpointCheckingEnabled={0}")
    @MethodSource("endpointCheckingEnabledSource")
    @Timeout(TEST_TIMEOUT)
    void testHasFeature(final boolean endpointCheckingEnabled) throws SocketException, IOException {
        setEndpointCheckingEnabled(endpointCheckingEnabled);
        trace(">>testHasFeature");
        loginClient().disconnect();
        trace("<<testHasFeature");
    }

    private void testListFiles(final String pathname) throws SocketException, IOException {
        final FTPSClient client = loginClient();
        try {
            // do it twice
            assertNotNull(client.listFiles(pathname));
            assertNotNull(client.listFiles(pathname));
        } finally {
            client.disconnect();
        }
    }

    @ParameterizedTest(name = "endpointCheckingEnabled={0}")
    @MethodSource("endpointCheckingEnabledSource")
    @Timeout(TEST_TIMEOUT)
    void testListFilesPathNameEmpty(final boolean endpointCheckingEnabled) throws SocketException, IOException {
        setEndpointCheckingEnabled(endpointCheckingEnabled);
        trace(">>testListFilesPathNameEmpty");
        testListFiles("");
        trace("<<testListFilesPathNameEmpty");
    }

    @ParameterizedTest(name = "endpointCheckingEnabled={0}")
    @MethodSource("endpointCheckingEnabledSource")
    @Timeout(TEST_TIMEOUT)
    void testListFilesPathNameJunk(final boolean endpointCheckingEnabled) throws SocketException, IOException {
        setEndpointCheckingEnabled(endpointCheckingEnabled);
        trace(">>testListFilesPathNameJunk");
        testListFiles("   Junk   ");
        trace("<<testListFilesPathNameJunk");
    }

    @ParameterizedTest(name = "endpointCheckingEnabled={0}")
    @MethodSource("endpointCheckingEnabledSource")
    @Timeout(TEST_TIMEOUT)
    void testListFilesPathNameNull(final boolean endpointCheckingEnabled) throws SocketException, IOException {
        setEndpointCheckingEnabled(endpointCheckingEnabled);
        trace(">>testListFilesPathNameNull");
        testListFiles(null);
        trace("<<testListFilesPathNameNull");
    }

    @ParameterizedTest(name = "endpointCheckingEnabled={0}")
    @MethodSource("endpointCheckingEnabledSource")
    @Timeout(TEST_TIMEOUT)
    void testListFilesPathNameRoot(final boolean endpointCheckingEnabled) throws SocketException, IOException {
        setEndpointCheckingEnabled(endpointCheckingEnabled);
        trace(">>testListFilesPathNameRoot");
        testListFiles("/");
        trace("<<testListFilesPathNameRoot");
    }

    @ParameterizedTest(name = "endpointCheckingEnabled={0}")
    @MethodSource("endpointCheckingEnabledSource")
    @Timeout(TEST_TIMEOUT)
    void testMdtmCalendar(final boolean endpointCheckingEnabled) throws SocketException, IOException {
        setEndpointCheckingEnabled(endpointCheckingEnabled);
        trace(">>testMdtmCalendar");
        testMdtmCalendar("/file.txt");
        trace("<<testMdtmCalendar");
    }

    private void testMdtmCalendar(final String pathname) throws SocketException, IOException {
        final FTPSClient client = loginClient();
        try {
            // do it twice
            final Calendar mdtmCalendar1 = client.mdtmCalendar(pathname);
            final Calendar mdtmCalendar2 = client.mdtmCalendar(pathname);
            assertNotNull(mdtmCalendar1);
            assertNotNull(mdtmCalendar2);
            assertEquals(mdtmCalendar1, mdtmCalendar2);
        } finally {
            client.disconnect();
        }
    }

    @ParameterizedTest(name = "endpointCheckingEnabled={0}")
    @MethodSource("endpointCheckingEnabledSource")
    @Timeout(TEST_TIMEOUT)
    void testMdtmFile(final boolean endpointCheckingEnabled) throws SocketException, IOException {
        setEndpointCheckingEnabled(endpointCheckingEnabled);
        trace(">>testMdtmFile");
        testMdtmFile("/file.txt");
        trace("<<testMdtmFile");
    }

    private void testMdtmFile(final String pathname) throws SocketException, IOException {
        final FTPSClient client = loginClient();
        try {
            // do it twice
            final FTPFile mdtmFile1 = client.mdtmFile(pathname);
            final FTPFile mdtmFile2 = client.mdtmFile(pathname);
            assertNotNull(mdtmFile1);
            assertNotNull(mdtmFile2);
            assertEquals(mdtmFile1.toString(), mdtmFile2.toString());
        } finally {
            client.disconnect();
        }
    }

    @ParameterizedTest(name = "endpointCheckingEnabled={0}")
    @MethodSource("endpointCheckingEnabledSource")
    @Timeout(TEST_TIMEOUT)
    void testMdtmInstant(final boolean endpointCheckingEnabled) throws SocketException, IOException {
        setEndpointCheckingEnabled(endpointCheckingEnabled);
        trace(">>testMdtmInstant");
        testMdtmInstant("/file.txt");
        trace("<<testMdtmInstant");
    }

    private void testMdtmInstant(final String pathname) throws SocketException, IOException {
        final FTPSClient client = loginClient();
        try {
            // do it twice
            final Instant mdtmInstant1 = client.mdtmInstant(pathname);
            final Instant mdtmInstant2 = client.mdtmInstant(pathname);
            assertNotNull(mdtmInstant1);
            assertNotNull(mdtmInstant2);
            assertEquals(mdtmInstant1, mdtmInstant2);
        } finally {
            client.disconnect();
        }
    }

    @ParameterizedTest(name = "endpointCheckingEnabled={0}")
    @MethodSource("endpointCheckingEnabledSource")
    @Timeout(TEST_TIMEOUT)
    void testOpenClose(final boolean endpointCheckingEnabled) throws SocketException, IOException {
        setEndpointCheckingEnabled(endpointCheckingEnabled);
        trace(">>testOpenClose");
        final FTPSClient ftpsClient = loginClient();
        try {
            assertTrue(ftpsClient.hasFeature("MODE"));
            assertTrue(ftpsClient.hasFeature(FTPCmd.MODE));
        } finally {
            ftpsClient.disconnect();
        }
        trace("<<testOpenClose");
    }

    @ParameterizedTest(name = "endpointCheckingEnabled={0}")
    @MethodSource("endpointCheckingEnabledSource")
    @Timeout(TEST_TIMEOUT)
    void testRetrieveFilePathNameRoot(final boolean endpointCheckingEnabled) throws SocketException, IOException {
        setEndpointCheckingEnabled(endpointCheckingEnabled);
        trace(">>testRetrieveFilePathNameRoot");
        retrieveFile("/file.txt");
        trace("<<testRetrieveFilePathNameRoot");
    }

}