SdkAsserts.java

/*
 * Copyright (c) 2016. Amazon.com, Inc. or its affiliates. All Rights Reserved.
 *
 * Licensed under the Apache License, Version 2.0 (the "License").
 * You may not use this file except in compliance with the License.
 * A copy of the License is located at
 *
 * http://aws.amazon.com/apache2.0
 *
 * or in the "license" file accompanying this file. This file 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 com.amazonaws.test.util;

import static org.junit.Assert.assertNotNull;
import static org.junit.Assert.assertTrue;
import static org.junit.Assert.fail;

import java.io.ByteArrayInputStream;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.IOException;
import java.io.InputStream;
import java.security.NoSuchAlgorithmException;
import java.util.Arrays;

import org.junit.Assert;

import com.amazonaws.AmazonClientException;
import com.amazonaws.AmazonServiceException;
import com.amazonaws.util.IOUtils;

public class SdkAsserts {

    /**
     * Asserts that the specified String is not null and not empty.
     *
     * @param str
     *            The String to test.
     * @deprecated Use Hamcrest Matchers instead
     */
    @Deprecated
    public static void assertNotEmpty(String str) {
        assertNotNull(str);
        assertTrue(str.length() > 0);
    }

    /**
     * Asserts that the contents in the specified file are exactly equal to the contents read from
     * the specified input stream. The input stream will be closed at the end of this method. If any
     * problems are encountered, or the stream's contents don't match up exactly with the file's
     * contents, then this method will fail the current test.
     *
     * @param expected
     *            The file containing the expected contents.
     * @param actual
     *            The stream that will be read, compared to the expected file contents, and finally
     *            closed.
     */
    public static void assertFileEqualsStream(File expected, InputStream actual) {
        assertFileEqualsStream(null, expected, actual);
    }

    /**
     * Asserts that the contents in the specified file are exactly equal to the contents read from
     * the specified input stream. The input stream will be closed at the end of this method. If any
     * problems are encountered, or the stream's contents don't match up exactly with the file's
     * contents, then this method will fail the current test.
     *
     * @param errmsg
     *            error message to be thrown when the assertion fails.
     * @param expected
     *            The file containing the expected contents.
     * @param actual
     *            The stream that will be read, compared to the expected file contents, and finally
     *            closed.
     */
    public static void assertFileEqualsStream(String errmsg, File expected, InputStream actual) {
        try {
            InputStream expectedInputStream = new FileInputStream(expected);
            assertStreamEqualsStream(errmsg, expectedInputStream, actual);
        } catch (FileNotFoundException e) {
            fail("Expected file " + expected.getAbsolutePath() + " doesn't exist: " + e.getMessage());
        }
    }

    /**
     * Asserts that the contents in the specified input streams are same. The input streams will be
     * closed at the end of this method. If any problems are encountered, or the stream's contents
     * don't match up exactly with the file's contents, then this method will fail the current test.
     *
     * @param expected
     *            expected input stream. The stream will be closed at the end.
     * @param actual
     *            The stream that will be read, compared to the expected file contents, and finally
     *            closed.
     */
    public static void assertStreamEqualsStream(InputStream expected, InputStream actual) {
        assertStreamEqualsStream(null, expected, actual);
    }

    /**
     * Asserts that the contents in the specified input streams are same. The input streams will be
     * closed at the end of this method. If any problems are encountered, or the stream's contents
     * don't match up exactly with the file's contents, then this method will fail the current test.
     *
     * @param errmsg
     *            error message to be thrown when the assertion fails.
     * @param expected
     *            expected input stream. The stream will be closed at the end.
     * @param actual
     *            The stream that will be read, compared to the expected file contents, and finally
     *            closed.
     */
    public static void assertStreamEqualsStream(String errmsg,
                                                InputStream expectedInputStream,
                                                InputStream inputStream) {
        try {
            assertTrue(errmsg, doesStreamEqualStream(expectedInputStream, inputStream));
        } catch (IOException e) {
            fail("Error reading from stream: " + e.getMessage());
        }
    }

    /**
     * Asserts that the contents of the two files are same.
     *
     * @param expected
     *            expected file.
     * @param actual
     *            actual file.
     */
    public static void assertFileEqualsFile(File expected, File actual) {
        if (expected == null || !expected.exists())
            fail("Expected file doesn't exist");
        if (actual == null || !actual.exists())
            fail("Actual file doesn't exist");

        final long expectedFileLen = expected.length();
        final long fileLen = actual.length();
        Assert.assertTrue("expectedFileLen=" + expectedFileLen + ", fileLen=" + fileLen + ", expectedFile=" + expected
                + ", file=" + actual, expectedFileLen == fileLen);
        try {
            assertStreamEqualsStream("expected file: " + expected + " vs. actual file: " + actual,
                    new FileInputStream(expected), new FileInputStream(actual));
        } catch (Exception e) {
            fail("Unable to compare files: " + e.getMessage());
        }
    }

    /**
     * Asserts that the contents in the specified string are exactly equal to the contents read from
     * the specified input stream. The input stream will be closed at the end of this method. If any
     * problems are encountered, or the stream's contents don't match up exactly with the string's
     * contents, then this method will fail the current test.
     *
     * @param expected
     *            The string containing the expected data.
     * @param actual
     *            The stream that will be read, compared to the expected string data, and finally
     *            closed.
     */
    public static void assertStringEqualsStream(String expected, InputStream actual) {
        try {
            InputStream expectedInputStream = new ByteArrayInputStream(expected.getBytes());
            assertTrue(doesStreamEqualStream(expectedInputStream, actual));
        } catch (IOException e) {
            fail("Error reading from stream: " + e.getMessage());
        }
    }

    /**
     * Returns true if, and only if, the contents read from the specified input streams are exactly
     * equal. Both input streams will be closed at the end of this method.
     *
     * @param expected
     *            The input stream containing the expected contents.
     * @param inputStream
     *            The stream that will be read, compared to the expected file contents, and finally
     *            closed.
     * @return True if the two input streams contain the same data.
     * @throws IOException
     *             If any problems are encountered comparing the file and stream.
     */
    public static boolean doesStreamEqualStream(InputStream expected, InputStream actual) throws IOException {

        try {
            final byte[] expectedDigest = InputStreamUtils.calculateMD5Digest(expected);
            final byte[] actualDigest = InputStreamUtils.calculateMD5Digest(actual);

            return Arrays.equals(expectedDigest, actualDigest);
        } catch (NoSuchAlgorithmException nse) {
            throw new AmazonClientException(nse.getMessage(), nse);
        } finally {
            IOUtils.closeQuietly(expected, null);
            IOUtils.closeQuietly(actual, null);
        }
    }

    /**
     * Returns true if, and only if, the contents in the specified file are exactly equal to the
     * contents read from the specified input stream. The input stream will be closed at the end of
     * this method.
     *
     * @param expectedFile
     *            The file containing the expected contents.
     * @param inputStream
     *            The stream that will be read, compared to the expected file contents, and finally
     *            closed.
     * @throws IOException
     *             If any problems are encountered comparing the file and stream.
     */
    public static boolean doesFileEqualStream(File expectedFile, InputStream inputStream) throws IOException {
        InputStream expectedInputStream = new FileInputStream(expectedFile);
        return doesStreamEqualStream(expectedInputStream, inputStream);
    }

    /**
     * Asserts that the specified AmazonServiceException is valid, meaning it has a non-empty,
     * non-null value for its message, requestId, etc.
     *
     * @param e
     *            The exception to validate.
     */
    public static void assertValidException(AmazonServiceException e) {
        assertNotNull(e.getRequestId());
        assertTrue(e.getRequestId().trim().length() > 0);

        assertNotNull(e.getMessage());
        assertTrue(e.getMessage().trim().length() > 0);

        assertNotNull(e.getErrorCode());
        assertTrue(e.getErrorCode().trim().length() > 0);

        assertNotNull(e.getServiceName());
        assertTrue(e.getServiceName().startsWith("Amazon") || e.getServiceName().startsWith("AWS"));
    }

}