/*
    * Copyright 2008-2012 smartics, Kronseder & Reiner GmbH
    *
    * Licensed 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 de.smartics.util.test.matcher.io;
  
  import java.io.IOException;
  import java.io.InputStream;
  
  import org.apache.commons.io.IOUtils;
  import org.hamcrest.Factory;
  import org.hamcrest.Matcher;
  
  /**
   * A matcher to check that the contents of two stream contain the identical
   * information.
   *
   * <pre>
   * {@markupSource "Add Import"
   * import static de.smartics.util.test.matcher.io.StreamsEqualContentAs.streamsEqualContentAs;
   * }
   * </pre>
   * <p>
   * In the following examples <code>expected</code> and <code>actual</code> are
   * {@link InputStream}s:
   * </p>
   *
   * <pre>
   * {@markupExample "Assert Example"
   * import static org.hamcrest.MatcherAssert.assertThat;
   *
   * assertThat(actual, streamsEqualContentAs(expected));
   * }
   * </pre>
   * <p>
   * The following example shows a test spy and the verification of the expected
   * stream argument:
   * </p>
   *
   * <pre>
   * {@markupExample "Verify Example"
   * import static org.mockito.Matchers.argThat;
   * import static org.mockito.Mockito.verify;
   *
   * spy.pass(actual); // Test spy that expects a stream
   *
   * verify(spy).pass(
   *     (InputStream) argThat(streamsEqualContentAs(expected)));
   * }
   * </pre>
   */
  public class StreamsEqualContentAs extends AbstractEqualContentAs<InputStream>
  {
    // ********************************* Fields *********************************
  
    // --- constants ------------------------------------------------------------
  
    // --- members --------------------------------------------------------------
  
    /**
     * The encoding of both streams.
     */
    private final String encoding;
  
    // ****************************** Initializer *******************************
  
    // ****************************** Constructors ******************************
  
    /**
     * Default constructor.
     *
     * @param expected the expected stream to compare to.
     * @param encoding the encoding expected on both streams.
     * @throws IllegalArgumentException on any problem reading from the stream.
     */
    public StreamsEqualContentAs(final InputStream expected, final String encoding)
      throws IllegalArgumentException
    {
      this(toStringInternal(expected, encoding), encoding);
    }
  
    /**
     * Convenience constructor if the content is served as a String.
     *
     * @param expected the expected content.
     * @param encoding the encoding expected on both streams.
     */
    public StreamsEqualContentAs(final String expected, final String encoding)
   {
     super(expected);
     this.encoding = encoding;
   }
 
   // ****************************** Inner Classes *****************************
 
   // ********************************* Methods ********************************
 
   // --- init -----------------------------------------------------------------
 
   private static String toStringInternal(final InputStream input,
       final String encoding)
   {
     try
     {
       return IOUtils.toString(input, encoding);
     }
     catch (final IOException e)
     {
       throw new IllegalArgumentException(
           "Stream cannot be read with encoding '" + encoding + "'.", e);
     }
   }
 
   // --- get&set --------------------------------------------------------------
 
   // --- business -------------------------------------------------------------
 
   /**
    * {@inheritDoc}
    *
    * @see de.smartics.util.test.matcher.io.AbstractEqualContentAs#toString(java.lang.Object)
    */
   @Override
   protected final String toString(final InputStream actual)
     throws IllegalArgumentException
   {
     return toStringInternal(actual, encoding);
   }
 
   /**
    * Factory method to create the matcher.
    *
    * @param expected the expected stream content.
    * @param encoding the encoding expected on both streams.
    * @return the created matcher.
    * @throws IllegalArgumentException on any problem reading from the stream.
    */
   @Factory
   public static Matcher<? super InputStream> streamsEqualContentAs(
       final InputStream expected, final String encoding)
     throws IllegalArgumentException
   {
     try
     {
       return new StreamsEqualContentAs(expected, encoding);
     }
     catch (final Exception e)
     {
       throw new IllegalArgumentException("Cannot parse stream with encoding '"
                                          + encoding + "'.", e);
     }
   }
 
   /**
    * Factory method to create the matcher defaulting to UTF-8.
    *
    * @param expected the expected stream content.
    * @return the created matcher.
    * @throws IllegalArgumentException on any problem reading from the stream.
    */
   @Factory
   public static Matcher<? super InputStream> streamsEqualContentAs(
       final InputStream expected) throws IllegalArgumentException
   {
     return streamsEqualContentAs(expected, "UTF-8");
   }
 
   /**
    * Factory method to create the matcher for a preconfigured {@link String}.
    *
    * @param expected the expected stream content.
    * @param encoding the encoding expected on the stream.
    * @return the created matcher.
    */
   @Factory
   public static Matcher<? super InputStream> streamsEqualContentAs(
       final String expected, final String encoding)
   {
     return new StreamsEqualContentAs(expected, encoding);
   }
 
   /**
    * Factory method to create the matcher for a preconfigured {@link String}
    * with UTF-8 encoding.
    *
    * @param expected the expected stream content.
    * @return the created matcher.
    */
   @Factory
   public static Matcher<? super InputStream> streamsEqualContentAs(
       final String expected)
   {
     return streamsEqualContentAs(expected, "UTF-8");
   }
 
   // --- object basics --------------------------------------------------------
 
 }