enforcer-rules/src/test/java/org/apache/maven/enforcer/rules/version/TestRequireJavaVersion.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
 *
 *   http://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.maven.enforcer.rules.version;

import java.util.stream.Stream;

import org.apache.commons.lang3.SystemUtils;
import org.apache.maven.enforcer.rule.api.EnforcerLogger;
import org.apache.maven.enforcer.rule.api.EnforcerRuleException;
import org.junit.jupiter.api.BeforeEach;
import org.junit.jupiter.api.Test;
import org.junit.jupiter.params.ParameterizedTest;
import org.junit.jupiter.params.provider.Arguments;
import org.junit.jupiter.params.provider.MethodSource;

import static org.assertj.core.api.Assertions.assertThat;
import static org.assertj.core.api.Assertions.assertThatThrownBy;
import static org.mockito.Mockito.mock;

/**
 * The Class TestRequireJavaVersion.
 *
 * @author <a href="mailto:brianf@apache.org">Brian Fox</a>
 */
class TestRequireJavaVersion {

    private RequireJavaVersion rule;

    @BeforeEach
    void setup() {
        rule = new RequireJavaVersion();
        rule.setLog(mock(EnforcerLogger.class));
    }
    /**
     * Test fix jdk version.
     */
    @Test
    void testFixJDKVersion() {
        // test that we only take the first 3 versions for
        // comparison
        assertThat(RequireJavaVersion.normalizeJDKVersion("1.5.0_11")).isEqualTo("1.5.0-11");
        assertThat(RequireJavaVersion.normalizeJDKVersion("1.5.1")).isEqualTo("1.5.1");
        assertThat(RequireJavaVersion.normalizeJDKVersion("1.5.2-1.b11")).isEqualTo("1.5.2-1");
        assertThat(RequireJavaVersion.normalizeJDKVersion("1.5.3_11")).isEqualTo("1.5.3-11");
        assertThat(RequireJavaVersion.normalizeJDKVersion("1.5.4.5_11")).isEqualTo("1.5.4-5");
        assertThat(RequireJavaVersion.normalizeJDKVersion("1.5.5.6_11.2")).isEqualTo("1.5.5-6");

        // test for non-standard versions
        assertThat(RequireJavaVersion.normalizeJDKVersion("1-5-0-11")).isEqualTo("1.5.0-11");
        assertThat(RequireJavaVersion.normalizeJDKVersion("1-_5-_0-_11")).isEqualTo("1.5.0-11");
        assertThat(RequireJavaVersion.normalizeJDKVersion("1_5_0_11")).isEqualTo("1.5.0-11");
        assertThat(RequireJavaVersion.normalizeJDKVersion("1.5.0-07")).isEqualTo("1.5.0-7");
        assertThat(RequireJavaVersion.normalizeJDKVersion("1.5.0-b7")).isEqualTo("1.5.0-7");
        assertThat(RequireJavaVersion.normalizeJDKVersion("1.5.0-;7")).isEqualTo("1.5.0-7");
        assertThat(RequireJavaVersion.normalizeJDKVersion("1.6.0-dp")).isEqualTo("1.6.0");
        assertThat(RequireJavaVersion.normalizeJDKVersion("1.6.0-dp2")).isEqualTo("1.6.0-2");
        assertThat(RequireJavaVersion.normalizeJDKVersion("1.8.0_73")).isEqualTo("1.8.0-73");
        assertThat(RequireJavaVersion.normalizeJDKVersion("9")).isEqualTo("9");

        assertThat(RequireJavaVersion.normalizeJDKVersion("17")).isEqualTo("17");
    }

    /**
     * Test rule.
     *
     * @throws EnforcerRuleException the enforcer rule exception
     */
    @Test
    void settingsTheJavaVersionAsNormalizedVersionShouldNotFail() throws EnforcerRuleException {
        String normalizedJDKVersion = RequireJavaVersion.normalizeJDKVersion(SystemUtils.JAVA_VERSION);

        rule.setVersion(normalizedJDKVersion);

        // test the singular version
        rule.execute();
        // intentionally no assertThat(...) because we don't expect and exception.
    }

    @Test
    void excludingTheCurrentJavaVersionViaRangeThisShouldFailWithException() {
        String thisVersion = RequireJavaVersion.normalizeJDKVersion(SystemUtils.JAVA_VERSION);
        String requiredVersion = "(" + thisVersion;
        rule.setVersion(requiredVersion);

        assertThatThrownBy(() -> rule.execute())
                .isInstanceOf(EnforcerRuleException.class)
                .hasMessage("The requested JDK version %s is invalid.", requiredVersion);
    }

    @Test
    void shouldIncludeJavaHomeLocationInTheErrorMessage() {
        String thisVersion = RequireJavaVersion.normalizeJDKVersion(SystemUtils.JAVA_VERSION);
        String requiredVersion = "10000";
        rule.setVersion(requiredVersion);

        assertThatThrownBy(() -> rule.execute())
                .isInstanceOf(EnforcerRuleException.class)
                .hasMessage(
                        "Detected JDK version %s (JAVA_HOME=%s) is not in the allowed range %s.",
                        thisVersion, SystemUtils.JAVA_HOME, "[" + requiredVersion + ",)");
    }

    @Test
    void shouldUseCustomErrorMessage() {
        String requiredVersion = "10000";
        String message = "My custom error message";
        rule.setVersion(requiredVersion);
        rule.setMessage(message);

        assertThatThrownBy(() -> rule.execute())
                .isInstanceOf(EnforcerRuleException.class)
                .hasMessage(message);
    }

    /**
     * Test id.
     */
    @Test
    void testId() {
        assertThat(rule.getCacheId()).isEqualTo("0");
    }

    static Stream<Arguments> fixJava8ShortVersion() {
        return Stream.of(
                Arguments.of("1.8", "1.8"),
                Arguments.of("8", "1.8"),
                Arguments.of(".8", ".8"),
                Arguments.of("8.", "8."),
                Arguments.of("8,)", "1.8,)"),
                Arguments.of("[8,)", "[1.8,)"),
                Arguments.of("(1.7,8]", "(1.7,1.8]"),
                Arguments.of("[1.8,)", "[1.8,)"),
                Arguments.of("(1.8,8]", "(1.8,1.8]"),
                Arguments.of("(8,8]", "(1.8,1.8]"),
                Arguments.of("(8,)", "(1.8,)"),
                Arguments.of("[8]", "[1.8]"),
                Arguments.of("(9,11],[8]", "(9,11],[1.8]"),
                Arguments.of("(11.0.18", "(11.0.18"),
                Arguments.of("(15.1.8", "(15.1.8"),
                Arguments.of("(15.1.2", "(15.1.2"),
                Arguments.of("18", "18"),
                Arguments.of("18.", "18."),
                Arguments.of(".18", ".18"),
                Arguments.of("38", "38"));
    }

    @ParameterizedTest
    @MethodSource
    void fixJava8ShortVersion(String input, String expected) {
        rule.setVersion(input);
        assertThat(rule.getVersion()).isEqualTo(expected);
    }
}