/* * Copyright (c) 2015-present, Facebook, Inc. * All rights reserved. * * This source code is licensed under the BSD-style license found in the * LICENSE file in the root directory of this source tree. An additional grant * of patent rights can be found in the PATENTS file in the same directory. */ package com.facebook.datasource; import javax.annotation.Nullable; import java.util.Arrays; import java.util.List; import java.util.concurrent.Executor; import com.facebook.common.executors.CallerThreadExecutor; import com.facebook.common.internal.Supplier; import org.mockito.ArgumentCaptor; import org.mockito.InOrder; import org.mockito.invocation.InvocationOnMock; import org.mockito.stubbing.Answer; import org.mockito.verification.VerificationMode; import static org.junit.Assert.*; import static org.mockito.Mockito.*; public class DataSourceTestUtils { public static final boolean CLOSED = true; public static final boolean NOT_CLOSED = false; public static final boolean FINISHED = true; public static final boolean NOT_FINISHED = false; public static final boolean WITH_RESULT = true; public static final boolean WITHOUT_RESULT = false; public static final boolean FAILED = true; public static final boolean NOT_FAILED = false; public static final boolean LAST = true; public static final boolean INTERMEDIATE = false; public static final int NO_INTERACTIONS = 0; public static final int ON_NEW_RESULT = 1; public static final int ON_FAILURE = 2; public static final int ON_CANCELLATION = 3; public static VerificationMode optional() { return atLeast(0); } public static void setState( DataSource<Object> dataSource, boolean isClosed, boolean isFinished, boolean hasResult, Object value, boolean hasFailed, Throwable failureCause) { when(dataSource.isClosed()).thenReturn(isClosed); when(dataSource.isFinished()).thenReturn(isFinished); when(dataSource.hasResult()).thenReturn(hasResult); when(dataSource.getResult()).thenReturn(value); when(dataSource.hasFailed()).thenReturn(hasFailed); when(dataSource.getFailureCause()).thenReturn(failureCause); } public static <T> void verifyState( DataSource<T> dataSource, boolean isClosed, boolean isFinished, boolean hasResult, T result, boolean hasFailed, Throwable failureCause) { assertEquals("isClosed", isClosed, dataSource.isClosed()); assertEquals("isFinished", isFinished, dataSource.isFinished()); assertEquals("hasResult", hasResult, dataSource.hasResult()); assertSame("getResult", result, dataSource.getResult()); assertEquals("hasFailed", hasFailed, dataSource.hasFailed()); assertSame("failureCause", failureCause, dataSource.getFailureCause()); } public static class AbstractDataSourceSupplier { protected DataSource<Object> mSrc1; protected DataSource<Object> mSrc2; protected DataSource<Object> mSrc3; protected Supplier<DataSource<Object>> mDataSourceSupplier1; protected Supplier<DataSource<Object>> mDataSourceSupplier2; protected Supplier<DataSource<Object>> mDataSourceSupplier3; protected DataSubscriber<Object> mDataSubscriber; protected Executor mExecutor; protected InOrder mInOrder; protected List<Supplier<DataSource<Object>>> mSuppliers; protected Supplier<DataSource<Object>> mDataSourceSupplier; public void setUp() { mSrc1 = mock(DataSource.class); mSrc2 = mock(DataSource.class); mSrc3 = mock(DataSource.class); mDataSourceSupplier1 = mock(Supplier.class); mDataSourceSupplier2 = mock(Supplier.class); mDataSourceSupplier3 = mock(Supplier.class); when(mDataSourceSupplier1.get()).thenReturn(mSrc1); when(mDataSourceSupplier2.get()).thenReturn(mSrc2); when(mDataSourceSupplier3.get()).thenReturn(mSrc3); mDataSubscriber = mock(DataSubscriber.class); mExecutor = CallerThreadExecutor.getInstance(); mInOrder = inOrder( mSrc1, mSrc2, mSrc3, mDataSourceSupplier1, mDataSourceSupplier2, mDataSourceSupplier3, mDataSubscriber); mSuppliers = Arrays.asList( mDataSourceSupplier1, mDataSourceSupplier2, mDataSourceSupplier3); } protected void verifyNoMoreInteractionsAll() { verifyOptionals(mSrc1); verifyOptionals(mSrc2); verifyOptionals(mSrc3); mInOrder.verifyNoMoreInteractions(); verifyNoMoreInteractions( mSrc1, mSrc2, mSrc3, mDataSourceSupplier1, mDataSourceSupplier2, mDataSourceSupplier3, mDataSubscriber); } protected void verifyOptionals(DataSource<Object> underlyingDataSource) { mInOrder.verify(underlyingDataSource, optional()).isFinished(); mInOrder.verify(underlyingDataSource, optional()).hasResult(); mInOrder.verify(underlyingDataSource, optional()).hasFailed(); verify(underlyingDataSource, optional()).isFinished(); verify(underlyingDataSource, optional()).hasResult(); verify(underlyingDataSource, optional()).hasFailed(); } /** * Verifies that our mDataSourceSupplier got underlying data source and subscribed to it. * Subscriber is returned. */ protected DataSubscriber<Object> verifyGetAndSubscribe( Supplier<DataSource<Object>> dataSourceSupplier, DataSource<Object> underlyingDataSource, boolean expectMoreInteractions) { mInOrder.verify(dataSourceSupplier).get(); ArgumentCaptor<DataSubscriber> captor = ArgumentCaptor.forClass(DataSubscriber.class); mInOrder.verify(underlyingDataSource).subscribe(captor.capture(), any(Executor.class)); if (!expectMoreInteractions) { verifyNoMoreInteractionsAll(); } return captor.getValue(); } protected DataSubscriber<Object> verifyGetAndSubscribe( Supplier<DataSource<Object>> dataSourceSupplier, DataSource<Object> underlyingDataSource) { return verifyGetAndSubscribe(dataSourceSupplier, underlyingDataSource, false); } protected DataSubscriber<Object> verifyGetAndSubscribeM( Supplier<DataSource<Object>> dataSourceSupplier, DataSource<Object> underlyingDataSource) { return verifyGetAndSubscribe(dataSourceSupplier, underlyingDataSource, true); } /** * Verifies that data source provided by our mDataSourceSupplier notified mDataSubscriber. */ protected void verifySubscriber( DataSource<Object> dataSource, DataSource<Object> underlyingDataSource, int expected) { switch (expected) { case NO_INTERACTIONS: verifyNoMoreInteractionsAll(); break; case ON_NEW_RESULT: mInOrder.verify(mDataSubscriber).onNewResult(dataSource); verifyNoMoreInteractionsAll(); break; case ON_FAILURE: mInOrder.verify(underlyingDataSource).getFailureCause(); mInOrder.verify(mDataSubscriber).onFailure(dataSource); verifyNoMoreInteractionsAll(); break; case ON_CANCELLATION: verify(mDataSubscriber).onCancellation(dataSource); verifyNoMoreInteractionsAll(); break; } } /** * Verifies the state of the data source provided by our mDataSourceSupplier. */ protected void verifyState( DataSource<Object> dataSource, @Nullable DataSource<Object> dataSourceWithResult, boolean isClosed, boolean isFinished, boolean hasResult, Object result, boolean hasFailed, Throwable failureCause) { DataSourceTestUtils.verifyState( dataSource, isClosed, isFinished, hasResult, result, hasFailed, failureCause); // DataSourceTestUtils.verifyState will call dataSource.getResult() which should forward to // underlyingDataSource.getResult() if (dataSourceWithResult != null) { mInOrder.verify(dataSourceWithResult).getResult(); } verifyNoMoreInteractionsAll(); } /** * Verifies that the underlying data sources get closed when data source provided by * our mDataSourceSupplier gets closed. */ protected void testClose( DataSource<Object> dataSource, DataSource<Object>... underlyingDataSources) { dataSource.close(); if (underlyingDataSources != null) { for (DataSource<Object> underlyingDataSource : underlyingDataSources) { mInOrder.verify(underlyingDataSource, atLeastOnce()).close(); } } } /** * Gets data source from our mDataSourceSupplier and subscribes mDataSubscriber to it. * Obtained data source is returned. */ protected DataSource<Object> getAndSubscribe() { DataSource<Object> dataSource = mDataSourceSupplier.get(); dataSource.subscribe(mDataSubscriber, mExecutor); return dataSource; } /** Respond to subscriber with given data source and response. */ protected static <T> void respond( DataSubscriber<T> subscriber, DataSource<T> dataSource, int response) { switch (response) { case NO_INTERACTIONS: break; case ON_NEW_RESULT: subscriber.onNewResult(dataSource); break; case ON_FAILURE: subscriber.onFailure(dataSource); break; case ON_CANCELLATION: subscriber.onCancellation(dataSource); break; } } /** Schedule response on subscribe. */ protected static <T> void respondOnSubscribe( final DataSource<T> dataSource, final int response) { doAnswer( new Answer() { @Override public Object answer(InvocationOnMock invocation) throws Throwable { DataSubscriber<T> subscriber = (DataSubscriber<T>) invocation.getArguments()[0]; respond(subscriber, dataSource, response); return subscriber; } }).when(dataSource).subscribe(any(DataSubscriber.class), any(Executor.class)); } } }