/*
 * Copyright 2002-2015 the original author or authors.
 *
 * 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 org.springframework.security.web.util;

import java.io.IOException;
import java.io.PrintWriter;
import java.util.Locale;

import org.junit.Before;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.mockito.Mock;
import org.mockito.runners.MockitoJUnitRunner;

import org.springframework.security.web.util.OnCommittedResponseWrapper;

import javax.servlet.ServletOutputStream;
import javax.servlet.http.HttpServletResponse;

import static org.assertj.core.api.Assertions.assertThat;
import static org.mockito.Mockito.verify;
import static org.mockito.Mockito.when;

@RunWith(MockitoJUnitRunner.class)
public class OnCommittedResponseWrapperTests {
	private static final String NL = "\r\n";

	@Mock
	HttpServletResponse delegate;
	@Mock
	PrintWriter writer;
	@Mock
	ServletOutputStream out;

	OnCommittedResponseWrapper response;

	boolean committed;

	@Before
	public void setup() throws Exception {
		response = new OnCommittedResponseWrapper(delegate) {
			@Override
			protected void onResponseCommitted() {
				committed = true;
			}
		};
		when(delegate.getWriter()).thenReturn(writer);
		when(delegate.getOutputStream()).thenReturn(out);
	}


	// --- printwriter

	@Test
	public void printWriterHashCode() throws Exception {
		int expected = writer.hashCode();

		assertThat(response.getWriter().hashCode()).isEqualTo(expected);
	}

	@Test
	public void printWriterCheckError() throws Exception {
		boolean expected = true;
		when(writer.checkError()).thenReturn(expected);

		assertThat(response.getWriter().checkError()).isEqualTo(expected);
	}

	@Test
	public void printWriterWriteInt() throws Exception {
		int expected = 1;

		response.getWriter().write(expected);

		verify(writer).write(expected);
	}

	@Test
	public void printWriterWriteCharIntInt() throws Exception {
		char[] buff = new char[0];
		int off = 2;
		int len = 3;

		response.getWriter().write(buff,off,len);

		verify(writer).write(buff,off,len);
	}

	@Test
	public void printWriterWriteChar() throws Exception {
		char[] buff = new char[0];

		response.getWriter().write(buff);

		verify(writer).write(buff);
	}

	@Test
	public void printWriterWriteStringIntInt() throws Exception {
		String s = "";
		int off = 2;
		int len = 3;

		response.getWriter().write(s,off,len);

		verify(writer).write(s,off,len);
	}

	@Test
	public void printWriterWriteString() throws Exception {
		String s = "";

		response.getWriter().write(s);

		verify(writer).write(s);
	}

	@Test
	public void printWriterPrintBoolean() throws Exception {
		boolean b = true;

		response.getWriter().print(b);

		verify(writer).print(b);
	}

	@Test
	public void printWriterPrintChar() throws Exception {
		char c = 1;

		response.getWriter().print(c);

		verify(writer).print(c);
	}

	@Test
	public void printWriterPrintInt() throws Exception {
		int i = 1;

		response.getWriter().print(i);

		verify(writer).print(i);
	}

	@Test
	public void printWriterPrintLong() throws Exception {
		long l = 1;

		response.getWriter().print(l);

		verify(writer).print(l);
	}

	@Test
	public void printWriterPrintFloat() throws Exception {
		float f = 1;

		response.getWriter().print(f);

		verify(writer).print(f);
	}

	@Test
	public void printWriterPrintDouble() throws Exception {
		double x = 1;

		response.getWriter().print(x);

		verify(writer).print(x);
	}

	@Test
	public void printWriterPrintCharArray() throws Exception {
		char[] x = new char[0];

		response.getWriter().print(x);

		verify(writer).print(x);
	}

	@Test
	public void printWriterPrintString() throws Exception {
		String x = "1";

		response.getWriter().print(x);

		verify(writer).print(x);
	}

	@Test
	public void printWriterPrintObject() throws Exception {
		Object x = "1";

		response.getWriter().print(x);

		verify(writer).print(x);
	}

	@Test
	public void printWriterPrintln() throws Exception {
		response.getWriter().println();

		verify(writer).println();
	}

	@Test
	public void printWriterPrintlnBoolean() throws Exception {
		boolean b = true;

		response.getWriter().println(b);

		verify(writer).println(b);
	}

	@Test
	public void printWriterPrintlnChar() throws Exception {
		char c = 1;

		response.getWriter().println(c);

		verify(writer).println(c);
	}

	@Test
	public void printWriterPrintlnInt() throws Exception {
		int i = 1;

		response.getWriter().println(i);

		verify(writer).println(i);
	}

	@Test
	public void printWriterPrintlnLong() throws Exception {
		long l = 1;

		response.getWriter().println(l);

		verify(writer).println(l);
	}

	@Test
	public void printWriterPrintlnFloat() throws Exception {
		float f = 1;

		response.getWriter().println(f);

		verify(writer).println(f);
	}

	@Test
	public void printWriterPrintlnDouble() throws Exception {
		double x = 1;

		response.getWriter().println(x);

		verify(writer).println(x);
	}

	@Test
	public void printWriterPrintlnCharArray() throws Exception {
		char[] x = new char[0];

		response.getWriter().println(x);

		verify(writer).println(x);
	}

	@Test
	public void printWriterPrintlnString() throws Exception {
		String x = "1";

		response.getWriter().println(x);

		verify(writer).println(x);
	}

	@Test
	public void printWriterPrintlnObject() throws Exception {
		Object x = "1";

		response.getWriter().println(x);

		verify(writer).println(x);
	}

	@Test
	public void printWriterPrintfStringObjectVargs() throws Exception {
		String format = "format";
		Object[] args = new Object[] { "1" };

		response.getWriter().printf(format, args);

		verify(writer).printf(format, args);
	}

	@Test
	public void printWriterPrintfLocaleStringObjectVargs() throws Exception {
		Locale l = Locale.US;
		String format = "format";
		Object[] args = new Object[] { "1" };

		response.getWriter().printf(l, format, args);

		verify(writer).printf(l, format, args);
	}

	@Test
	public void printWriterFormatStringObjectVargs() throws Exception {
		String format = "format";
		Object[] args = new Object[] { "1" };

		response.getWriter().format(format, args);

		verify(writer).format(format, args);
	}

	@Test
	public void printWriterFormatLocaleStringObjectVargs() throws Exception {
		Locale l = Locale.US;
		String format = "format";
		Object[] args = new Object[] { "1" };

		response.getWriter().format(l, format, args);

		verify(writer).format(l, format, args);
	}


	@Test
	public void printWriterAppendCharSequence() throws Exception {
		String x = "a";

		response.getWriter().append(x);

		verify(writer).append(x);
	}

	@Test
	public void printWriterAppendCharSequenceIntInt() throws Exception {
		String x = "abcdef";
		int start = 1;
		int end = 3;

		response.getWriter().append(x, start, end);

		verify(writer).append(x, start, end);
	}


	@Test
	public void printWriterAppendChar() throws Exception {
		char x = 1;

		response.getWriter().append(x);

		verify(writer).append(x);
	}

	// servletoutputstream


	@Test
	public void outputStreamHashCode() throws Exception {
		int expected = out.hashCode();

		assertThat(response.getOutputStream().hashCode()).isEqualTo(expected);
	}

	@Test
	public void outputStreamWriteInt() throws Exception {
		int expected = 1;

		response.getOutputStream().write(expected);

		verify(out).write(expected);
	}

	@Test
	public void outputStreamWriteByte() throws Exception {
		byte[] expected = new byte[0];

		response.getOutputStream().write(expected);

		verify(out).write(expected);
	}

	@Test
	public void outputStreamWriteByteIntInt() throws Exception {
		int start = 1;
		int end = 2;
		byte[] expected = new byte[0];

		response.getOutputStream().write(expected, start, end);

		verify(out).write(expected, start, end);
	}

	@Test
	public void outputStreamPrintBoolean() throws Exception {
		boolean b = true;

		response.getOutputStream().print(b);

		verify(out).print(b);
	}

	@Test
	public void outputStreamPrintChar() throws Exception {
		char c = 1;

		response.getOutputStream().print(c);

		verify(out).print(c);
	}

	@Test
	public void outputStreamPrintInt() throws Exception {
		int i = 1;

		response.getOutputStream().print(i);

		verify(out).print(i);
	}

	@Test
	public void outputStreamPrintLong() throws Exception {
		long l = 1;

		response.getOutputStream().print(l);

		verify(out).print(l);
	}

	@Test
	public void outputStreamPrintFloat() throws Exception {
		float f = 1;

		response.getOutputStream().print(f);

		verify(out).print(f);
	}

	@Test
	public void outputStreamPrintDouble() throws Exception {
		double x = 1;

		response.getOutputStream().print(x);

		verify(out).print(x);
	}

	@Test
	public void outputStreamPrintString() throws Exception {
		String x = "1";

		response.getOutputStream().print(x);

		verify(out).print(x);
	}

	@Test
	public void outputStreamPrintln() throws Exception {
		response.getOutputStream().println();

		verify(out).println();
	}

	@Test
	public void outputStreamPrintlnBoolean() throws Exception {
		boolean b = true;

		response.getOutputStream().println(b);

		verify(out).println(b);
	}

	@Test
	public void outputStreamPrintlnChar() throws Exception {
		char c = 1;

		response.getOutputStream().println(c);

		verify(out).println(c);
	}

	@Test
	public void outputStreamPrintlnInt() throws Exception {
		int i = 1;

		response.getOutputStream().println(i);

		verify(out).println(i);
	}

	@Test
	public void outputStreamPrintlnLong() throws Exception {
		long l = 1;

		response.getOutputStream().println(l);

		verify(out).println(l);
	}

	@Test
	public void outputStreamPrintlnFloat() throws Exception {
		float f = 1;

		response.getOutputStream().println(f);

		verify(out).println(f);
	}

	@Test
	public void outputStreamPrintlnDouble() throws Exception {
		double x = 1;

		response.getOutputStream().println(x);

		verify(out).println(x);
	}

	@Test
	public void outputStreamPrintlnString() throws Exception {
		String x = "1";

		response.getOutputStream().println(x);

		verify(out).println(x);
	}

	// The amount of content specified in the setContentLength method of the response
	// has been greater than zero and has been written to the response.

	// gh-3823
	@Test
	public void contentLengthPrintWriterWriteNullCommits() throws Exception {
		String expected = null;
		this.response.setContentLength(String.valueOf(expected).length() + 1);

		this.response.getWriter().write(expected);

		assertThat(this.committed).isFalse();

		this.response.getWriter().write("a");

		assertThat(this.committed).isTrue();
	}

	@Test
	public void contentLengthPrintWriterWriteIntCommits() throws Exception {
		int expected = 1;
		response.setContentLength(String.valueOf(expected).length());

		response.getWriter().write(expected);

		assertThat(committed).isTrue();
	}

	@Test
	public void contentLengthPrintWriterWriteIntMultiDigitCommits() throws Exception {
		int expected = 10000;
		response.setContentLength(String.valueOf(expected).length());

		response.getWriter().write(expected);

		assertThat(committed).isTrue();
	}

	@Test
	public void contentLengthPlus1PrintWriterWriteIntMultiDigitCommits() throws Exception {
		int expected = 10000;
		response.setContentLength(String.valueOf(expected).length() + 1);

		response.getWriter().write(expected);

		assertThat(committed).isFalse();

		response.getWriter().write(1);

		assertThat(committed).isTrue();
	}


	@Test
	public void contentLengthPrintWriterWriteCharIntIntCommits() throws Exception {
		char[] buff = new char[0];
		int off = 2;
		int len = 3;
		response.setContentLength(3);

		response.getWriter().write(buff,off,len);

		assertThat(committed).isTrue();
	}

	@Test
	public void contentLengthPrintWriterWriteCharCommits() throws Exception {
		char[] buff = new char[4];
		response.setContentLength(buff.length);

		response.getWriter().write(buff);

		assertThat(committed).isTrue();
	}

	@Test
	public void contentLengthPrintWriterWriteStringIntIntCommits() throws Exception {
		String s = "";
		int off = 2;
		int len = 3;
		response.setContentLength(3);

		response.getWriter().write(s,off,len);

		assertThat(committed).isTrue();
	}


	@Test
	public void contentLengthPrintWriterWriteStringCommits() throws IOException {
		String body = "something";
		response.setContentLength(body.length());

		response.getWriter().write(body);

		assertThat(committed).isTrue();
	}

	@Test
	public void printWriterWriteStringContentLengthCommits() throws IOException {
		String body = "something";
		response.getWriter().write(body);

		response.setContentLength(body.length());

		assertThat(committed).isTrue();
	}

	@Test
	public void printWriterWriteStringDoesNotCommit() throws IOException {
		String body = "something";

		response.getWriter().write(body);

		assertThat(committed).isFalse();
	}

	@Test
	public void contentLengthPrintWriterPrintBooleanCommits() throws Exception {
		boolean b = true;
		response.setContentLength(1);

		response.getWriter().print(b);

		assertThat(committed).isTrue();
	}

	@Test
	public void contentLengthPrintWriterPrintCharCommits() throws Exception {
		char c = 1;
		response.setContentLength(1);

		response.getWriter().print(c);

		assertThat(committed).isTrue();
	}

	@Test
	public void contentLengthPrintWriterPrintIntCommits() throws Exception {
		int i = 1234;
		response.setContentLength(String.valueOf(i).length());

		response.getWriter().print(i);

		assertThat(committed).isTrue();
	}

	@Test
	public void contentLengthPrintWriterPrintLongCommits() throws Exception {
		long l = 12345;
		response.setContentLength(String.valueOf(l).length());

		response.getWriter().print(l);

		assertThat(committed).isTrue();
	}

	@Test
	public void contentLengthPrintWriterPrintFloatCommits() throws Exception {
		float f = 12345;
		response.setContentLength(String.valueOf(f).length());

		response.getWriter().print(f);

		assertThat(committed).isTrue();
	}

	@Test
	public void contentLengthPrintWriterPrintDoubleCommits() throws Exception {
		double x = 1.2345;
		response.setContentLength(String.valueOf(x).length());

		response.getWriter().print(x);

		assertThat(committed).isTrue();
	}

	@Test
	public void contentLengthPrintWriterPrintCharArrayCommits() throws Exception {
		char[] x = new char[10];
		response.setContentLength(x.length);

		response.getWriter().print(x);

		assertThat(committed).isTrue();
	}

	@Test
	public void contentLengthPrintWriterPrintStringCommits() throws Exception {
		String x = "12345";
		response.setContentLength(x.length());

		response.getWriter().print(x);

		assertThat(committed).isTrue();
	}

	@Test
	public void contentLengthPrintWriterPrintObjectCommits() throws Exception {
		Object x = "12345";
		response.setContentLength(String.valueOf(x).length());

		response.getWriter().print(x);

		assertThat(committed).isTrue();
	}

	@Test
	public void contentLengthPrintWriterPrintlnCommits() throws Exception {
		response.setContentLength(NL.length());

		response.getWriter().println();

		assertThat(committed).isTrue();
	}

	@Test
	public void contentLengthPrintWriterPrintlnBooleanCommits() throws Exception {
		boolean b = true;
		response.setContentLength(1);

		response.getWriter().println(b);

		assertThat(committed).isTrue();
	}

	@Test
	public void contentLengthPrintWriterPrintlnCharCommits() throws Exception {
		char c = 1;
		response.setContentLength(1);

		response.getWriter().println(c);

		assertThat(committed).isTrue();
	}

	@Test
	public void contentLengthPrintWriterPrintlnIntCommits() throws Exception {
		int i = 12345;
		response.setContentLength(String.valueOf(i).length());

		response.getWriter().println(i);

		assertThat(committed).isTrue();
	}

	@Test
	public void contentLengthPrintWriterPrintlnLongCommits() throws Exception {
		long l = 12345678;
		response.setContentLength(String.valueOf(l).length());

		response.getWriter().println(l);

		assertThat(committed).isTrue();
	}

	@Test
	public void contentLengthPrintWriterPrintlnFloatCommits() throws Exception {
		float f = 1234;
		response.setContentLength(String.valueOf(f).length());

		response.getWriter().println(f);

		assertThat(committed).isTrue();
	}

	@Test
	public void contentLengthPrintWriterPrintlnDoubleCommits() throws Exception {
		double x = 1;
		response.setContentLength(String.valueOf(x).length());

		response.getWriter().println(x);

		assertThat(committed).isTrue();
	}

	@Test
	public void contentLengthPrintWriterPrintlnCharArrayCommits() throws Exception {
		char[] x = new char[20];
		response.setContentLength(x.length);

		response.getWriter().println(x);

		assertThat(committed).isTrue();
	}

	@Test
	public void contentLengthPrintWriterPrintlnStringCommits() throws Exception {
		String x = "1";
		response.setContentLength(String.valueOf(x).length());

		response.getWriter().println(x);

		assertThat(committed).isTrue();
	}

	@Test
	public void contentLengthPrintWriterPrintlnObjectCommits() throws Exception {
		Object x = "1";
		response.setContentLength(String.valueOf(x).length());

		response.getWriter().println(x);

		assertThat(committed).isTrue();
	}

	@Test
	public void contentLengthPrintWriterAppendCharSequenceCommits() throws Exception {
		String x = "a";
		response.setContentLength(String.valueOf(x).length());

		response.getWriter().append(x);

		assertThat(committed).isTrue();
	}

	@Test
	public void contentLengthPrintWriterAppendCharSequenceIntIntCommits() throws Exception {
		String x = "abcdef";
		int start = 1;
		int end = 3;
		response.setContentLength(end - start);

		response.getWriter().append(x, start, end);

		assertThat(committed).isTrue();
	}

	@Test
	public void contentLengthPrintWriterAppendCharCommits() throws Exception {
		char x = 1;
		response.setContentLength(1);

		response.getWriter().append(x);

		assertThat(committed).isTrue();
	}

	@Test
	public void contentLengthOutputStreamWriteIntCommits() throws Exception {
		int expected = 1;
		response.setContentLength(String.valueOf(expected).length());

		response.getOutputStream().write(expected);

		assertThat(committed).isTrue();
	}

	@Test
	public void contentLengthOutputStreamWriteIntMultiDigitCommits() throws Exception {
		int expected = 10000;
		response.setContentLength(String.valueOf(expected).length());

		response.getOutputStream().write(expected);

		assertThat(committed).isTrue();
	}

	@Test
	public void contentLengthPlus1OutputStreamWriteIntMultiDigitCommits() throws Exception {
		int expected = 10000;
		response.setContentLength(String.valueOf(expected).length() + 1);

		response.getOutputStream().write(expected);

		assertThat(committed).isFalse();

		response.getOutputStream().write(1);

		assertThat(committed).isTrue();
	}

	// gh-171
	@Test
	public void contentLengthPlus1OutputStreamWriteByteArrayMultiDigitCommits() throws Exception {
		String expected = "{\n" +
				"  \"parameterName\" : \"_csrf\",\n" +
				"  \"token\" : \"06300b65-c4aa-4c8f-8cda-39ee17f545a0\",\n" +
				"  \"headerName\" : \"X-CSRF-TOKEN\"\n" +
				"}";
		response.setContentLength(expected.length() + 1);

		response.getOutputStream().write(expected.getBytes());

		assertThat(committed).isFalse();

		response.getOutputStream().write("1".getBytes("UTF-8"));

		assertThat(committed).isTrue();
	}

	@Test
	public void contentLengthOutputStreamPrintBooleanCommits() throws Exception {
		boolean b = true;
		response.setContentLength(1);

		response.getOutputStream().print(b);

		assertThat(committed).isTrue();
	}

	@Test
	public void contentLengthOutputStreamPrintCharCommits() throws Exception {
		char c = 1;
		response.setContentLength(1);

		response.getOutputStream().print(c);

		assertThat(committed).isTrue();
	}

	@Test
	public void contentLengthOutputStreamPrintIntCommits() throws Exception {
		int i = 1234;
		response.setContentLength(String.valueOf(i).length());

		response.getOutputStream().print(i);

		assertThat(committed).isTrue();
	}

	@Test
	public void contentLengthOutputStreamPrintLongCommits() throws Exception {
		long l = 12345;
		response.setContentLength(String.valueOf(l).length());

		response.getOutputStream().print(l);

		assertThat(committed).isTrue();
	}

	@Test
	public void contentLengthOutputStreamPrintFloatCommits() throws Exception {
		float f = 12345;
		response.setContentLength(String.valueOf(f).length());

		response.getOutputStream().print(f);

		assertThat(committed).isTrue();
	}

	@Test
	public void contentLengthOutputStreamPrintDoubleCommits() throws Exception {
		double x = 1.2345;
		response.setContentLength(String.valueOf(x).length());

		response.getOutputStream().print(x);

		assertThat(committed).isTrue();
	}

	@Test
	public void contentLengthOutputStreamPrintStringCommits() throws Exception {
		String x = "12345";
		response.setContentLength(x.length());

		response.getOutputStream().print(x);

		assertThat(committed).isTrue();
	}

	@Test
	public void contentLengthOutputStreamPrintlnCommits() throws Exception {
		response.setContentLength(NL.length());

		response.getOutputStream().println();

		assertThat(committed).isTrue();
	}

	@Test
	public void contentLengthOutputStreamPrintlnBooleanCommits() throws Exception {
		boolean b = true;
		response.setContentLength(1);

		response.getOutputStream().println(b);

		assertThat(committed).isTrue();
	}

	@Test
	public void contentLengthOutputStreamPrintlnCharCommits() throws Exception {
		char c = 1;
		response.setContentLength(1);

		response.getOutputStream().println(c);

		assertThat(committed).isTrue();
	}

	@Test
	public void contentLengthOutputStreamPrintlnIntCommits() throws Exception {
		int i = 12345;
		response.setContentLength(String.valueOf(i).length());

		response.getOutputStream().println(i);

		assertThat(committed).isTrue();
	}

	@Test
	public void contentLengthOutputStreamPrintlnLongCommits() throws Exception {
		long l = 12345678;
		response.setContentLength(String.valueOf(l).length());

		response.getOutputStream().println(l);

		assertThat(committed).isTrue();
	}

	@Test
	public void contentLengthOutputStreamPrintlnFloatCommits() throws Exception {
		float f = 1234;
		response.setContentLength(String.valueOf(f).length());

		response.getOutputStream().println(f);

		assertThat(committed).isTrue();
	}

	@Test
	public void contentLengthOutputStreamPrintlnDoubleCommits() throws Exception {
		double x = 1;
		response.setContentLength(String.valueOf(x).length());

		response.getOutputStream().println(x);

		assertThat(committed).isTrue();
	}

	@Test
	public void contentLengthOutputStreamPrintlnStringCommits() throws Exception {
		String x = "1";
		response.setContentLength(String.valueOf(x).length());

		response.getOutputStream().println(x);

		assertThat(committed).isTrue();
	}

	@Test
	public void contentLengthDoesNotCommit() throws IOException {
		String body = "something";

		response.setContentLength(body.length());

		assertThat(committed).isFalse();
	}

	@Test
	public void contentLengthOutputStreamWriteStringCommits() throws IOException {
		String body = "something";
		response.setContentLength(body.length());

		response.getOutputStream().print(body);

		assertThat(committed).isTrue();
	}

	@Test
	public void addHeaderContentLengthPrintWriterWriteStringCommits() throws Exception {
		int expected = 1234;
		response.addHeader("Content-Length",String.valueOf(String.valueOf(expected).length()));

		response.getWriter().write(expected);

		assertThat(committed).isTrue();
	}

	@Test
	public void bufferSizePrintWriterWriteCommits() throws Exception {
		String expected = "1234567890";
		when(response.getBufferSize()).thenReturn(expected.length());

		response.getWriter().write(expected);

		assertThat(committed).isTrue();
	}

	@Test
	public void bufferSizeCommitsOnce() throws Exception {
		String expected = "1234567890";
		when(response.getBufferSize()).thenReturn(expected.length());

		response.getWriter().write(expected);

		assertThat(committed).isTrue();

		committed = false;

		response.getWriter().write(expected);

		assertThat(committed).isFalse();
	}
}
