/**

* Copyright 2014 Netflix, Inc.

*

* 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 rx.exceptions;

import org.junit.Test;

import rx.Observable;

import rx.Observer;

import rx.functions.Func1;

import java.io.PrintWriter;

import java.io.StringWriter;

import static org.junit.Assert.assertTrue;

import static org.junit.Assert.fail;

/**

* ```java

* public OnNextValue(Object value) {

* super("OnError while emitting onNext value: " + value);

* this.value = value;

* }

* ```

* I know this is probably a helpful error message in some cases but this can be a really costly operation when an objects toString is an expensive call or contains alot of output. I don't think we should be printing this in any case but if so it should be on demand (overload of getMessage()) rather than eagerly.

* <p/>

* In my case it is causing a toString of a large context object that is normally only used for debugging purposes which makes the exception logs hard to use and they are rolling over the log files very quickly.

* <p/>

* There is an added danger that if there is a bug in the toString method it will cause inconsistent exception creation. If the object throws an exception while rendering a string it will actually end up not seeing the real exception.

*/

public final class OnNextValueTest {

private static final class BadToString {

private final boolean throwDuringToString;

private BadToString(boolean throwDuringToString) {

this.throwDuringToString = throwDuringToString;

}

@Override

public String toString() {

if (throwDuringToString) {

throw new IllegalArgumentException("Error Making toString");

} else {

return "BadToString";

}

}

}

private static class BadToStringObserver implements Observer<BadToString> {

@Override

public void onCompleted() {

System.out.println("On Complete");

fail("OnComplete shouldn't be reached");

}

@Override

public void onError(Throwable e) {

String trace = stackTraceAsString(e);

System.out.println("On Error: " + trace);

assertTrue(trace, trace.contains("OnNextValue"));

assertTrue("No Cause on throwable" + e, e.getCause() != null);

assertTrue(e.getCause().getClass().getSimpleName() + " no OnNextValue",

e.getCause() instanceof OnErrorThrowable.OnNextValue);

}

@Override

public void onNext(BadToString badToString) {

System.out.println("On Next");

fail("OnNext shouldn't be reached");

}

}

public static String stackTraceAsString(Throwable e) {

StringWriter sw = new StringWriter();

e.printStackTrace(new PrintWriter(sw));

return sw.toString();

}

@Test

public void addOnNextValueExceptionAdded() throws Exception {

Observer<BadToString> observer = new BadToStringObserver();

Observable.just(new BadToString(false))

.map(new Func1<BadToString, BadToString>() {

@Override

public BadToString call(BadToString badToString) {

throw new IllegalArgumentException("Failure while handling");

}

}).subscribe(observer);

}

@Test

public void addOnNextValueExceptionNotAddedWithBadString() throws Exception {

Observer<BadToString> observer = new BadToStringObserver();

Observable.just(new BadToString(true))

.map(new Func1<BadToString, BadToString>() {

@Override

public BadToString call(BadToString badToString) {

throw new IllegalArgumentException("Failure while handling");

}

}).subscribe(observer);

}

}