/*
|
* 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 2016 ForgeRock AS.
|
*/
|
package com.forgerock.opendj.ldap.tools;
|
|
import static com.forgerock.opendj.cli.CliMessages.ERR_FILEARG_NO_SUCH_FILE;
|
import static com.forgerock.opendj.cli.CliMessages.ERR_SUBCMDPARSER_NO_ARGUMENT_FOR_SHORT_ID;
|
import static com.forgerock.opendj.cli.CliMessages.ERR_SUBCMDPARSER_NO_GLOBAL_ARGUMENT_FOR_LONG_ID;
|
import static com.forgerock.opendj.cli.CliMessages.ERR_SUBCMDPARSER_NO_VALUE_FOR_ARGUMENT_WITH_LONG_ID;
|
import static com.forgerock.opendj.ldap.CoreMessages.ERR_BASE64_DECODE_INVALID_LENGTH;
|
import static com.forgerock.opendj.ldap.tools.ToolsMessages.ERR_BASE64_ERROR_DECODING_RAW_DATA;
|
import static com.forgerock.opendj.ldap.tools.ToolsTestUtils.addValueNeededShortArgs;
|
import static com.forgerock.opendj.ldap.tools.ToolsTestUtils.args;
|
import static com.forgerock.opendj.ldap.tools.ToolsTestUtils.toDataProviderArray;
|
import static org.assertj.core.api.Assertions.assertThat;
|
|
import java.io.BufferedReader;
|
import java.io.File;
|
import java.io.FileReader;
|
import java.io.IOException;
|
import java.nio.file.Files;
|
import java.util.ArrayList;
|
import java.util.Arrays;
|
import java.util.List;
|
|
import org.forgerock.i18n.LocalizableMessage;
|
import org.forgerock.opendj.ldap.ResultCode;
|
import org.testng.annotations.AfterMethod;
|
import org.testng.annotations.BeforeMethod;
|
import org.testng.annotations.DataProvider;
|
import org.testng.annotations.Test;
|
|
/** This class defines a set of tests for the {@link com.forgerock.opendj.ldap.tools.Base64} class. */
|
@Test
|
public final class Base64TestCase extends ToolsTestCase {
|
|
private static final boolean ENCODE = true;
|
private static final boolean DECODE = false;
|
|
@BeforeMethod
|
private void testSetup() {
|
refreshStream();
|
}
|
|
@AfterMethod
|
private void testTearDown() {
|
closeStream();
|
}
|
|
@Test
|
public void testNoSubcommandProvided() throws Exception {
|
final int res = runTool();
|
assertThat(res).isEqualTo(ResultCode.CLIENT_SIDE_PARAM_ERROR.intValue());
|
assertThat(err.toString()).contains(ToolsMessages.ERR_BASE64_NO_SUBCOMMAND_SPECIFIED.get().toString());
|
assertThat(out.toString()).isEmpty();
|
}
|
|
@DataProvider
|
public Object[][] invalidArgumentsEncode() throws Exception {
|
final List<List<String>> argLists = new ArrayList<>();
|
final List<LocalizableMessage> reasonList = new ArrayList<>();
|
|
addValueNeededShortArgs(argLists, reasonList, "d", "f", "o");
|
|
argLists.add(args("-I"));
|
reasonList.add(ERR_SUBCMDPARSER_NO_ARGUMENT_FOR_SHORT_ID.get("I"));
|
|
argLists.add(args("--invalidLongArgument"));
|
reasonList.add(ERR_SUBCMDPARSER_NO_GLOBAL_ARGUMENT_FOR_LONG_ID.get("invalidLongArgument"));
|
|
argLists.add(args("--rawData"));
|
reasonList.add(ERR_SUBCMDPARSER_NO_VALUE_FOR_ARGUMENT_WITH_LONG_ID.get("rawdata"));
|
|
argLists.add(args("--rawDataFile"));
|
reasonList.add(ERR_SUBCMDPARSER_NO_VALUE_FOR_ARGUMENT_WITH_LONG_ID.get("rawdatafile"));
|
|
argLists.add(args("--toEncodedFile"));
|
reasonList.add(ERR_SUBCMDPARSER_NO_VALUE_FOR_ARGUMENT_WITH_LONG_ID.get("toencodedfile"));
|
|
argLists.add(args("-f", "no.such.file"));
|
reasonList.add(ERR_FILEARG_NO_SUCH_FILE.get("no.such.file", "rawDataFile"));
|
|
argLists.add(args("--rawDataFile", "no.such.file"));
|
reasonList.add(ERR_FILEARG_NO_SUCH_FILE.get("no.such.file", "rawDataFile"));
|
return toDataProviderArray(argLists, reasonList);
|
}
|
|
@Override
|
@Test(dataProvider = "invalidArgumentsEncode")
|
public void testInvalidArguments(final String[] args, String invalidReason) throws LDAPToolException {
|
assertThat(testBase64(ENCODE, args)).isEqualTo(ResultCode.CLIENT_SIDE_PARAM_ERROR.intValue());
|
assertThat(errOnSingleLine()).contains(invalidReason);
|
assertThat(out.toString()).isEmpty();
|
}
|
|
@DataProvider
|
public Object[][] invalidArgumentsDecode() throws Exception {
|
final List<List<String>> argLists = new ArrayList<>();
|
final List<LocalizableMessage> reasonList = new ArrayList<>();
|
|
addValueNeededShortArgs(argLists, reasonList, "d", "f", "o");
|
|
argLists.add(args("-I"));
|
reasonList.add(ERR_SUBCMDPARSER_NO_ARGUMENT_FOR_SHORT_ID.get("I"));
|
|
argLists.add(args("--invalidLongArgument"));
|
reasonList.add(ERR_SUBCMDPARSER_NO_GLOBAL_ARGUMENT_FOR_LONG_ID.get("invalidLongArgument"));
|
|
argLists.add(args("--encodedData"));
|
reasonList.add(ERR_SUBCMDPARSER_NO_VALUE_FOR_ARGUMENT_WITH_LONG_ID.get("encodeddata"));
|
|
argLists.add(args("--encodedDataFile"));
|
reasonList.add(ERR_SUBCMDPARSER_NO_VALUE_FOR_ARGUMENT_WITH_LONG_ID.get("encodeddatafile"));
|
|
argLists.add(args("--toRawFile"));
|
reasonList.add(ERR_SUBCMDPARSER_NO_VALUE_FOR_ARGUMENT_WITH_LONG_ID.get("torawfile"));
|
|
argLists.add(args("-f", "no.such.file"));
|
reasonList.add(ERR_FILEARG_NO_SUCH_FILE.get("no.such.file", "encodedDataFile"));
|
|
argLists.add(args("--encodedDataFile", "no.such.file"));
|
reasonList.add(ERR_FILEARG_NO_SUCH_FILE.get("no.such.file", "encodedDataFile"));
|
return toDataProviderArray(argLists, reasonList);
|
}
|
|
@DataProvider
|
public Object[][] invalidEncodedDataLength() {
|
// FIXME: fix cases ==== and ==x=
|
return new Object[][] { { "=" }, { "==" }, { "===" }, { "A" }, { "AA" }, { "AAA" } };
|
}
|
|
@Test(dataProvider = "invalidEncodedDataLength")
|
public void testDecodeInvalidDataLength(final String encodedData) throws Exception {
|
final int res = testBase64(DECODE, "-d", encodedData);
|
assertThat(res).isEqualTo(ResultCode.CLIENT_SIDE_PARAM_ERROR.intValue());
|
assertThat(errOnSingleLine()).contains(ERR_BASE64_DECODE_INVALID_LENGTH.get(encodedData));
|
assertThat(out.toString()).isEmpty();
|
}
|
|
@DataProvider
|
public Object[][] invalidEncodedData() {
|
return new Object[][] {
|
{ "AA`=" }, { "AA~=" }, { "AA!=" }, { "AA@=" },
|
{ "AA#=" }, { "AA$=" }, { "AA%=" }, { "AA^=" },
|
{ "AA*=" }, { "AA(=" }, { "AA)=" }, { "AA_=" },
|
{ "AA-=" }, { "AA{=" }, { "AA}=" }, { "AA|=" },
|
{ "AA[=" }, { "AA]=" }, { "AA\\=" }, { "AA;=" },
|
{ "AA'=" }, { "AA\"=" }, { "AA:=" }, { "AA,=" },
|
{ "AA.=" }, { "AA<=" }, { "AA>=" }, { "AA?=" },
|
{ "AA;=" }
|
};
|
}
|
|
@Test(dataProvider = "invalidEncodedData")
|
public void testDecodeInvalidData(final String encodedData) throws Exception {
|
final int res = testBase64(DECODE, "-d", encodedData);
|
assertThat(res).isEqualTo(ResultCode.CLIENT_SIDE_PARAM_ERROR.intValue());
|
assertThat(errOnSingleLine()).contains(ERR_BASE64_ERROR_DECODING_RAW_DATA.get(encodedData));
|
assertThat(out.toString()).isEmpty();
|
}
|
|
/**
|
* Base 64 valid test data provider.
|
*
|
* @return Returns an array of decoded and valid encoded base64 data.
|
*/
|
@DataProvider
|
public Object[][] validData() {
|
return new Object[][] {
|
{ "dont panic", "ZG9udCBwYW5pYw==" },
|
|
{ "Time is an illusion. Lunchtime doubly so.",
|
"VGltZSBpcyBhbiBpbGx1c2lvbi4gTHVuY2h0aW1lIGRvdWJseSBzby4=" },
|
|
{ "I would far rather be happy than right any day.",
|
"SSB3b3VsZCBmYXIgcmF0aGVyIGJlIGhhcHB5IHRoYW4gcmlnaHQgYW55IGRheS4=" },
|
|
{ "This must be Thursday, said Arthur to himself, sinking low over his beer. "
|
+ "I never could get the hang of Thursdays",
|
"VGhpcyBtdXN0IGJlIFRodXJzZGF5LCBzYWlkIEFydGh1ciB0byBoaW1zZWxmLCBzaW5raW5nIGxvdyBvdmVyIGhpcyBiZWVy"
|
+ "LiBJIG5ldmVyIGNvdWxkIGdldCB0aGUgaGFuZyBvZiBUaHVyc2RheXM=" },
|
};
|
}
|
|
@Test(dataProvider = "validData")
|
public void testEncodeRawData(final String clearData, final String encodedData) throws Exception {
|
testValidData(ENCODE, clearData, encodedData);
|
}
|
|
@Test(dataProvider = "validData")
|
public void testDecodeRawData(final String encodedData, final String clearData) throws Exception {
|
testValidData(DECODE, clearData, encodedData);
|
}
|
|
@Test(dataProvider = "validData")
|
public void testEncodeDataWithFiles(final String clearData, final String encodedData) throws Exception {
|
testValidDataWithFiles(ENCODE, clearData, encodedData);
|
}
|
|
@Test(dataProvider = "validData")
|
public void testDecodeDataWithFiles(final String encodedData, final String clearData) throws Exception {
|
testValidDataWithFiles(DECODE, clearData, encodedData);
|
}
|
|
private void testValidData(final boolean mode, final String dataIn, final String dataOut) throws LDAPToolException {
|
final int res = testBase64(mode, "-d", dataIn);
|
assertThat(res).isEqualTo(ResultCode.SUCCESS.intValue());
|
assertThat(out.toString()).contains(dataOut);
|
}
|
|
private void testValidDataWithFiles(final boolean mode, final String dataIn, final String dataOut)
|
throws Exception {
|
final File dataInFile = File.createTempFile("Base64TestCase", ".data");
|
Files.write(dataInFile.toPath(), dataIn.getBytes());
|
final String dataOutFilePath = ToolsTestUtils.createTempFile();
|
final int res = testBase64(mode, "-f", dataInFile.getAbsolutePath(), "-o", dataOutFilePath);
|
assertThat(res).isEqualTo(ResultCode.SUCCESS.intValue());
|
assertThat(out.toString()).isEmpty();
|
assertThat(err.toString()).isEmpty();
|
assertThat(readFirstLine(dataOutFilePath)).isEqualTo(dataOut);
|
}
|
|
private String readFirstLine(final String resultFilePath) throws IOException {
|
try (final BufferedReader reader = new BufferedReader(new FileReader(resultFilePath))) {
|
return reader.readLine();
|
}
|
}
|
|
private Integer testBase64(final boolean encode, final String... args) throws LDAPToolException {
|
final List<String> arguments = new ArrayList<>();
|
arguments.add(encode ? "encode" : "decode");
|
arguments.addAll(Arrays.asList(args));
|
return runTool(arguments.toArray(new String[arguments.size()]));
|
}
|
|
@Override
|
ToolConsoleApplication createInstance() {
|
return new Base64(outStream, errStream);
|
}
|
}
|
