/*
|
* 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.
|
*
|
* You can obtain a copy of the License at legal/CDDLv1.0.txt. See the License for the
|
* specific language governing permission and limitations under the License.
|
*
|
* When distributing Covered Software, include this CDDL Header Notice in each file and include
|
* the License file at legal/CDDLv1.0.txt. If applicable, add the following below the CDDL
|
* Header, with the fields enclosed by brackets [] replaced by your own identifying
|
* information: "Portions copyright [year] [name of copyright owner]".
|
*
|
* Copyright 2026 3A Systems, LLC.
|
*/
|
package org.opends.quicksetup.installer;
|
|
import static org.mockito.Mockito.mock;
|
import static org.mockito.Mockito.when;
|
import static org.opends.messages.QuickSetupMessages.*;
|
import static org.testng.Assert.assertEquals;
|
import static org.testng.Assert.assertFalse;
|
import static org.testng.Assert.assertNull;
|
import static org.testng.Assert.assertTrue;
|
|
import java.io.File;
|
import java.io.IOException;
|
import java.util.ArrayList;
|
import java.util.List;
|
|
import org.forgerock.i18n.LocalizableMessage;
|
import org.opends.quicksetup.TempLogFile;
|
import org.opends.quicksetup.UserData;
|
import org.opends.quicksetup.event.ProgressUpdateEvent;
|
import org.opends.quicksetup.event.ProgressUpdateListener;
|
import org.opends.quicksetup.util.PlainTextProgressMessageFormatter;
|
import org.opends.server.DirectoryServerTestCase;
|
import org.opends.server.TestCaseUtils;
|
import org.testng.annotations.AfterClass;
|
import org.testng.annotations.BeforeClass;
|
import org.testng.annotations.Test;
|
|
/**
|
* Tests what a failed installation tells its listeners about the log file.
|
* <p>
|
* This report is the one place the diagnosis of a failed setup lives, and it used to promise
|
* the file without looking at it - printing a {@code NoSuchFileException} stack when the file
|
* was gone (issue #1030). The roads below are the whole of that decision.
|
*/
|
@SuppressWarnings("javadoc")
|
@Test(groups = { "precommit", "quicksetup" }, sequential = true)
|
public class InstallerTest extends DirectoryServerTestCase
|
{
|
private static final String PREFIX = "opendj-setup-";
|
/** Marks a line the report sends out as a warning, see {@link MarkedArmsFormatter}. */
|
private static final String WARNING = "[W]";
|
/** Marks a line the report sends out as progress. */
|
private static final String PROGRESS = "[P]";
|
|
private File tempDir;
|
private final List<TempLogFile> created = new ArrayList<>();
|
|
@BeforeClass
|
public void setUp() throws IOException
|
{
|
tempDir = TestCaseUtils.createTemporaryDirectory("installerTest");
|
}
|
|
@AfterClass
|
public void tearDown() throws IOException
|
{
|
for (TempLogFile logFile : created)
|
{
|
logFile.deleteLogFileAfterSuccess();
|
}
|
TestCaseUtils.deleteDirectory(tempDir);
|
}
|
|
/** A log that is there is named, as before, and named as progress rather than as a warning. */
|
@Test
|
public void testAReadableLogIsHandedOver() throws Exception
|
{
|
final TempLogFile logFile = newLogFile();
|
|
final String report = reportOf(logFile);
|
|
assertContains(report, PROGRESS, INFO_GENERAL_PROVIDE_LOG_IN_ERROR.get(logFile.getPath()));
|
assertDoesNotContain(report, INFO_GENERAL_LOG_IN_ERROR_MISSING.get(logFile.getPath()));
|
}
|
|
/**
|
* The contents of the log reach the report: attaching the file is up to whoever reads it,
|
* so the report carries the log itself.
|
* <p>
|
* What the file holds is not the point here and is mocked away - with
|
* {@code OPENDJ_LOG_TO_STDOUT} set, a real log is empty and would pin nothing.
|
*/
|
@Test
|
public void testTheContentsOfTheLogReachTheReport() throws Exception
|
{
|
final String contents = "QuickSetup application launched\nthe last line before the failure\n";
|
final TempLogFile logFile = mock(TempLogFile.class);
|
when(logFile.isEnabled()).thenReturn(true);
|
when(logFile.isReadable()).thenReturn(true);
|
when(logFile.getPath()).thenReturn(new File(tempDir, "readable.log").getAbsolutePath());
|
when(logFile.readContents()).thenReturn(contents);
|
|
final String report = reportOf(logFile);
|
|
assertTrue(report.contains(contents), report);
|
}
|
|
/** A log something else removed is reported as gone, instead of being asked for. */
|
@Test
|
public void testAMissingLogIsReportedAsMissing() throws Exception
|
{
|
final TempLogFile logFile = newLogFile();
|
final String path = logFile.getPath();
|
logFile.deleteLogFileAfterSuccess();
|
assertFalse(logFile.isReadable());
|
|
final String report = reportOf(logFile);
|
|
assertContains(report, WARNING, INFO_GENERAL_LOG_IN_ERROR_MISSING.get(path));
|
// The line that asks for the file must not go out when there is no file to provide.
|
assertDoesNotContain(report, INFO_GENERAL_PROVIDE_LOG_IN_ERROR.get(path));
|
}
|
|
/** A log which is there but cannot be read costs the report its contents, not its diagnosis. */
|
@Test
|
public void testAnUnreadableLogIsReportedAsUnreadable() throws Exception
|
{
|
final String path = new File(tempDir, "unreadable.log").getAbsolutePath();
|
final IOException failure = new IOException("Input/output error");
|
final TempLogFile logFile = mock(TempLogFile.class);
|
when(logFile.isEnabled()).thenReturn(true);
|
when(logFile.isReadable()).thenReturn(true);
|
when(logFile.getPath()).thenReturn(path);
|
when(logFile.readContents()).thenThrow(failure);
|
|
final String report = reportOf(logFile);
|
|
assertContains(report, WARNING, INFO_GENERAL_LOG_IN_ERROR_UNREADABLE.get(path, failure));
|
assertDoesNotContain(report, INFO_GENERAL_LOG_IN_ERROR_MISSING.get(path));
|
}
|
|
/** Nothing is said about a log that was never created. */
|
@Test
|
public void testNoLogMeansNoReport() throws Exception
|
{
|
final TempLogFile logFile = mock(TempLogFile.class);
|
when(logFile.isEnabled()).thenReturn(false);
|
|
assertTrue(reportOf(logFile).isEmpty(), "a launcher without a log has nothing to report");
|
}
|
|
/**
|
* A cancelled install takes its log with it - and asks for it only when it begins.
|
* <p>
|
* Nothing names the log on that road - the report belongs to the failure road - and the
|
* cancel has just taken the installation back, so a log kept there is a report nobody is
|
* ever pointed at (issue #1030). The installer is handed the log the way the wizard and the
|
* command line hand it over, as a supplier: nothing asks for it before {@code run()}.
|
*/
|
@Test
|
public void testACancelledInstallTakesItsLogWithIt() throws Exception
|
{
|
final TempLogFile logFile = newLogFile();
|
final File instance = new File(tempDir, "cancelled");
|
// A locks directory the lock file can be taken in: without it the cancel road reads the
|
// server as running and goes off to stop it.
|
assertTrue(new File(instance, "locks").mkdirs());
|
|
final TestInstaller installer = new TestInstaller(instance);
|
installer.setProgressMessageFormatter(new MarkedArmsFormatter());
|
final int[] asked = { 0 };
|
installer.setTempLogFile(() -> {
|
asked[0]++;
|
return logFile;
|
});
|
installer.setUserData(new UserData());
|
installer.cancel();
|
assertEquals(asked[0], 0, "nothing is logged before the install begins");
|
|
installer.run();
|
|
assertEquals(asked[0], 1, "the install asks for its log once, as it begins");
|
assertEquals(installer.getCurrentProgressStep(), InstallProgressStep.FINISHED_CANCELED);
|
assertFalse(logFile.getLogFile().exists(), logFile.getPath());
|
}
|
|
/**
|
* An application nobody handed a log to has none, and asking for it is not a failure: the
|
* command line uninstaller is built that way, its launcher having created the log already.
|
*/
|
@Test
|
public void testAnApplicationGivenNoLogHasNone() throws Exception
|
{
|
assertNull(new TestInstaller(null).openTempLogFile());
|
}
|
|
private TempLogFile newLogFile()
|
{
|
final TempLogFile logFile = TempLogFile.newTempLogFile(PREFIX, new File(tempDir, "logs"));
|
created.add(logFile);
|
return logFile;
|
}
|
|
/** What the listeners of a failed installation are told about the log file. */
|
private static String reportOf(final TempLogFile logFile)
|
{
|
final TestInstaller installer = new TestInstaller(null);
|
installer.setProgressMessageFormatter(new MarkedArmsFormatter());
|
final StringBuilder report = new StringBuilder();
|
installer.addProgressUpdateListener(new ProgressUpdateListener()
|
{
|
@Override
|
public void progressUpdate(final ProgressUpdateEvent ev)
|
{
|
if (ev.getNewLogs() != null)
|
{
|
report.append(ev.getNewLogs());
|
}
|
}
|
});
|
installer.setTempLogFile(() -> logFile);
|
// The report is made by an install which has begun, and so has asked for its log.
|
installer.openTempLogFile();
|
installer.notifyListenersOfExistingLogFile();
|
return report.toString();
|
}
|
|
private static void assertContains(final String report, final String arm, final LocalizableMessage expected)
|
{
|
assertTrue(report.contains(arm + expected), "expected <" + arm + expected + "> in <" + report + ">");
|
}
|
|
private static void assertDoesNotContain(final String report, final LocalizableMessage unexpected)
|
{
|
assertFalse(report.contains(unexpected.toString()), "unexpected <" + unexpected + "> in <" + report + ">");
|
}
|
|
/** An installer which can be told where it lives, and whose log can be asked for. */
|
private static final class TestInstaller extends Installer
|
{
|
/** The installation, or {@code null} for the one the class path names. */
|
private final File instance;
|
|
TestInstaller(final File instance)
|
{
|
this.instance = instance;
|
}
|
|
/**
|
* An installation under the temporary directory rather than the one the class path names:
|
* the installer takes both paths from there, and in a test run there is none.
|
*/
|
@Override
|
public String getInstallationPath()
|
{
|
return instance != null ? instance.getAbsolutePath() : super.getInstallationPath();
|
}
|
|
@Override
|
public String getInstancePath()
|
{
|
return instance != null ? instance.getAbsolutePath() : super.getInstancePath();
|
}
|
|
@Override
|
protected TempLogFile openTempLogFile()
|
{
|
return super.openTempLogFile();
|
}
|
}
|
|
/**
|
* A formatter that marks the arm each line goes out on.
|
* <p>
|
* The plain text formatter returns warnings and progress messages unchanged - only the
|
* wizard's HTML formatter tells them apart - so without a mark a report which says "the log
|
* is gone" as an ordinary progress line reads exactly like one which warns about it.
|
*/
|
private static final class MarkedArmsFormatter extends PlainTextProgressMessageFormatter
|
{
|
@Override
|
public LocalizableMessage getFormattedWarning(final LocalizableMessage text, final boolean applyMargin)
|
{
|
return LocalizableMessage.raw(WARNING + super.getFormattedWarning(text, applyMargin));
|
}
|
|
@Override
|
public LocalizableMessage getFormattedProgress(final LocalizableMessage text)
|
{
|
return LocalizableMessage.raw(PROGRESS + super.getFormattedProgress(text));
|
}
|
}
|
}
|
