下面列出了java.nio.channels.AsynchronousByteChannel#org.mockito.invocation.InvocationOnMock 实例代码,或者点击链接到github查看源代码,也可以在右侧发表评论。
@Before
public void setUpPlugin() throws IOException {
dataFolder = temporaryFolder.newFolder();
// Wire various Bukkit components
setField(Bukkit.class, "server", null, server);
given(server.getLogger()).willReturn(mock(Logger.class));
given(server.getScheduler()).willReturn(mock(BukkitScheduler.class));
given(server.getPluginManager()).willReturn(pluginManager);
given(server.getVersion()).willReturn("1.9.4-RC1");
// SettingsManager always returns the default
given(settings.getProperty(any(Property.class))).willAnswer(new Answer<Object>() {
@Override
public Object answer(InvocationOnMock invocation) throws Throwable {
return ((Property<?>) invocation.getArguments()[0]).getDefaultValue();
}
});
// PluginDescriptionFile is final and so cannot be mocked
PluginDescriptionFile descriptionFile = new PluginDescriptionFile(
"PerWorldInventory", "N/A", PerWorldInventory.class.getCanonicalName());
JavaPluginLoader pluginLoader = new JavaPluginLoader(server);
plugin = new PerWorldInventory(pluginLoader, descriptionFile, dataFolder, null);
setField(JavaPlugin.class, "logger", plugin, mock(PluginLogger.class));
}
@Test
public void testPullMessage_Success() throws Exception {
doAnswer(new Answer() {
@Override public Object answer(InvocationOnMock mock) throws Throwable {
PullMessageRequestHeader requestHeader = mock.getArgument(1);
return createPullResult(requestHeader, PullStatus.FOUND, Collections.singletonList(new MessageExt()));
}
}).when(mQClientAPIImpl).pullMessage(anyString(), any(PullMessageRequestHeader.class), anyLong(), any(CommunicationMode.class), nullable(PullCallback.class));
MessageQueue messageQueue = new MessageQueue(topic, brokerName, 0);
PullResult pullResult = pullConsumer.pull(messageQueue, "*", 1024, 3);
assertThat(pullResult).isNotNull();
assertThat(pullResult.getPullStatus()).isEqualTo(PullStatus.FOUND);
assertThat(pullResult.getNextBeginOffset()).isEqualTo(1024 + 1);
assertThat(pullResult.getMinOffset()).isEqualTo(123);
assertThat(pullResult.getMaxOffset()).isEqualTo(2048);
assertThat(pullResult.getMsgFoundList()).isEqualTo(new ArrayList<>());
}
@Test
public void tMasterLaunchRestartsTMasterOnFailure() throws Exception {
HeronMasterDriver.TMaster tMaster =
spy(spyDriver.buildTMaster(Executors.newSingleThreadExecutor()));
HeronExecutorTask mockTask = mock(HeronExecutorTask.class);
final CountDownLatch testLatch = new CountDownLatch(1);
doAnswer(new Answer<Object>() {
@Override
public Object answer(InvocationOnMock invocation) throws Throwable {
testLatch.await();
return null;
}
}).when(mockTask).startExecutor();
doReturn(mockTask).when(tMaster).getTMasterExecutorTask();
tMaster.launch();
verify(mockTask, timeout(1000).times(1)).startExecutor();
testLatch.countDown();
//retries if tmaster ends for some reason
verify(mockTask, timeout(1000).times(3)).startExecutor();
}
void createBytesMessage() throws Exception {
BytesMessage message = mock(BytesMessage.class);
when(message.getBodyLength()).thenReturn((long)BYTES.length);
when(message.readBytes(any(byte[].class))).then(new Answer<Integer>() {
@Override
public Integer answer(InvocationOnMock invocation) throws Throwable {
byte[] buffer = (byte[])invocation.getArguments()[0];
if(buffer != null) {
assertEquals(buffer.length, BYTES.length);
System.arraycopy(BYTES, 0, buffer, 0, BYTES.length);
}
return BYTES.length;
}
});
this.message = message;
}
@Test
public void run_ok() {
// Given
Database database = spy(Database.class);
final DataSnapshot dataSnapshot = Mockito.mock(DataSnapshot.class);
Mockito.doAnswer(new Answer() {
@Override
public Object answer(InvocationOnMock invocation) {
((ValueEventListener) invocation.getArgument(0)).onDataChange(dataSnapshot);
return null;
}
}).when(databaseReference).addListenerForSingleValueEvent(Mockito.any(ValueEventListener.class));
database.inReference("test");
QueryReadValue query = new QueryReadValue(database, "/test");
ConverterPromise promise = spy(ConverterPromise.class);
promise.with(Mockito.mock(FirebaseMapConverter.class), String.class);
// When
query.with(promise).withArgs(String.class).execute();
// Then
}
@Test
public void testNack() throws InterruptedException {
holder.onMessage(makeMessages(0, false, "a", 1));
final CountDownLatch latch = new CountDownLatch(1);
final AtomicReference<AckMessageCommandV5> cmd = new AtomicReference<>();
when(ackManager.writeAckToBroker(any(AckMessageCommandV5.class))).thenAnswer(new Answer<Boolean>() {
@Override
public Boolean answer(InvocationOnMock invocation) throws Throwable {
cmd.set(invocation.getArgumentAt(0, AckMessageCommandV5.class));
latch.countDown();
return true;
}
});
PulledBatch<String> batch = holder.poll(1, 100);
List<ConsumerMessage<String>> msgs = batch.getMessages();
assertEquals(1, msgs.size());
msgs.get(0).nack();
batch.commitSync();
assertTrue(latch.await(config.getManualCommitInterval() * 3, TimeUnit.MILLISECONDS));
assertEquals(1, cmd.get().getNackedMsgs().size());
}
/**
* Creates {@link org.apache.streams.core.StreamsProcessor} that passes any StreamsDatum it gets as an
* input and counts the number of items it processes.
* @param counter
* @return
*/
private StreamsProcessor createPassThroughProcessor(final AtomicInteger counter) {
StreamsProcessor processor = mock(StreamsProcessor.class);
when(processor.process(any(StreamsDatum.class))).thenAnswer(new Answer<List<StreamsDatum>>() {
@Override
public List<StreamsDatum> answer(InvocationOnMock invocationOnMock) throws Throwable {
List<StreamsDatum> datum = new LinkedList<>();
if(counter != null) {
counter.incrementAndGet();
}
datum.add((StreamsDatum) invocationOnMock.getArguments()[0] );
return datum;
}
});
return processor;
}
@Test
public void test_getContentProvider()
{
try
{
PowerMockito.doAnswer(new Answer<Void>() {
public Void answer(InvocationOnMock invocation) {
DefaultContentService contentService = (DefaultContentService)invocation.getMock();
WPBContentProvider mockProvider = EasyMock.createMock(WPBContentProvider.class);
Whitebox.setInternalState(contentService, "contentProvider", mockProvider);
return null;
} }).when(contentService, "initializeContentProvider");
WPBContentProvider result = contentService.getContentProvider();
assertTrue (result != null);
} catch (Exception e)
{
assertTrue(false);
}
}
/**
* Help function: mock kylin projects, to match projectUuid and projectName
*/
private static void mockKylinProjects() {
KylinConfig kylinConfig = KylinConfig.getInstanceFromEnv();
ProjectManager projectManager = mock(ProjectManager.class);
@SuppressWarnings({ "rawtypes", "unchecked" })
Map<Class, Object> managersCache = (Map<Class, Object>) ReflectionTestUtils.getField(kylinConfig,
"managersCache");
managersCache.put(ProjectManager.class, projectManager);
Answer<ProjectInstance> answer = new Answer<ProjectInstance>() {
@Override
public ProjectInstance answer(InvocationOnMock invocation) throws Throwable {
Object[] args = invocation.getArguments();
if (args == null || args.length == 0) {
return null;
}
String uuid = (String) args[0];
return uuid2Projects.get(uuid);
}
};
when(projectManager.getPrjByUuid(anyString())).thenAnswer(answer);
}
@Before
public void setUp() throws Exception {
super.setUp();
Map<String, String> map = new HashMap<>();
map.put(WXConfig.scale, Float.toString(TEST_DENSITY));
PowerMockito.mockStatic(WXEnvironment.class);
PowerMockito.when(WXEnvironment.class, "getConfig").thenReturn(map);
PowerMockito.mockStatic(WXViewUtils.class);
PowerMockito.when(WXViewUtils.class, "getScreenWidth").thenReturn(TEST_SCREEN_WIDTH);
PowerMockito.mockStatic(WXSDKInstance.class);
PowerMockito.when(WXSDKInstance.class, "getViewPortWidth").thenReturn(TEST_VIEW_PORT);
PowerMockito.mockStatic(TextUtils.class);
PowerMockito.when(TextUtils.isEmpty(any(CharSequence.class))).thenAnswer(new Answer<Boolean>() {
@Override
public Boolean answer(InvocationOnMock invocation) throws Throwable {
CharSequence a = (CharSequence) invocation.getArguments()[0];
return !(a != null && a.length() > 0);
}
});
// also look at @PrepareForTest if add mock of new class
}
@Before
public void setupTest() throws Exception {
this.queryDNS = new QueryDNS();
this.queryDNSTestRunner = TestRunners.newTestRunner(queryDNS);
Hashtable env = new Hashtable<String, String>();
env.put(Context.INITIAL_CONTEXT_FACTORY, FakeDNSInitialDirContextFactory.class.getName());
this.queryDNS.initializeContext(env);
final DirContext mockContext = FakeDNSInitialDirContextFactory.getLatestMockContext();
// Capture JNDI's getAttibutes method containing the (String) queryValue and (String[]) queryType
Mockito.when( mockContext.getAttributes(Mockito.anyString(), Mockito.any(String[].class)))
.thenAnswer(new Answer() {
public Object answer(InvocationOnMock invocation) throws Throwable {
// Craft a false DNS response
// Note the DNS response will not make use of any of the mocked
// query contents (all input is discarded and replies synthetically
// generated
return craftResponse(invocation);
}
});
}
@Test
public void test_no_connect_idle_handler_default() throws Exception {
final IdleStateHandler[] idleStateHandler = new IdleStateHandler[1];
when(pipeline.addAfter(anyString(), anyString(), any(ChannelHandler.class))).thenAnswer(
new Answer<ChannelPipeline>() {
@Override
public ChannelPipeline answer(final InvocationOnMock invocation) throws Throwable {
if (invocation.getArguments()[1].equals(NEW_CONNECTION_IDLE_HANDLER)) {
idleStateHandler[0] = (IdleStateHandler) (invocation.getArguments()[2]);
}
return pipeline;
}
});
abstractChannelInitializer.initChannel(socketChannel);
assertEquals(500, idleStateHandler[0].getReaderIdleTimeInMillis());
}
@Before
public final void setUpEventManager()
throws Exception
{
eventManagerEvents = new ArrayList<Object>();
doAnswer(new Answer<Object>()
{
@Override
public Object answer(final InvocationOnMock invocation)
throws Throwable
{
eventManagerEvents.add(invocation.getArguments()[0]);
return null;
}
}).when(eventManager).post(any());
}
private OngoingStubbing<Call> mockReturnDocument(OngoingStubbing<Call> stub,
final String document, int statusCode, String statusMessage) {
return stub.thenAnswer(new Answer<Call>() {
@Override
public Call answer(InvocationOnMock invocationOnMock) throws Throwable {
Request realRequest = (Request) invocationOnMock.getArguments()[0];
Response mockResponse = new Response.Builder()
.request(realRequest)
.protocol(Protocol.HTTP_1_1)
.code(statusCode)
.message(statusMessage)
.body(ResponseBody.create(MediaType.parse("application/json"), document))
.build();
final Call call = mock(Call.class);
if (exceptionToThrow != null) {
when(call.execute()).thenThrow(exceptionToThrow);
} else {
when(call.execute()).thenReturn(mockResponse);
}
return call;
}
});
}
@Override
public InputReader answer(final InvocationOnMock invocationOnMock) throws Throwable {
final List<CompletableFuture<DataUtil.IteratorWithNumBytes>> inputFutures = new ArrayList<>(SOURCE_PARALLELISM);
final int elementsPerSource = DATA_SIZE / SOURCE_PARALLELISM;
for (int i = 0; i < SOURCE_PARALLELISM; i++) {
inputFutures.add(CompletableFuture.completedFuture(
DataUtil.IteratorWithNumBytes.of(elements.subList(i * elementsPerSource, (i + 1) * elementsPerSource)
.iterator())));
}
final InputReader inputReader = mock(InputReader.class);
final IRVertex srcVertex = (IRVertex) invocationOnMock.getArgument(1);
srcVertex.setProperty(ParallelismProperty.of(SOURCE_PARALLELISM));
when(inputReader.getSrcIrVertex()).thenReturn(srcVertex);
when(inputReader.read()).thenReturn(inputFutures);
when(inputReader.getProperties()).thenReturn(new ExecutionPropertyMap<>(""));
return inputReader;
}
@Test
@SuppressWarnings("rawtypes")
public void invalidCorsFilterTest() throws IOException, ServletException {
CorsFilter filter = new CorsFilter();
HttpServletResponse mockResponse = mock(HttpServletResponse.class);
FilterChain mockedFilterChain = mock(FilterChain.class);
HttpServletRequest mockRequest = mock(HttpServletRequest.class);
when(mockRequest.getHeader("Origin")).thenReturn("http://evillocalhost:8080");
when(mockRequest.getMethod()).thenReturn("Empty");
when(mockRequest.getServerName()).thenReturn("evillocalhost");
doAnswer(new Answer() {
@Override
public Object answer(InvocationOnMock invocationOnMock) throws Throwable {
headers[count] = invocationOnMock.getArguments()[1].toString();
count++;
return null;
}
}).when(mockResponse).setHeader(anyString(), anyString());
filter.doFilter(mockRequest, mockResponse, mockedFilterChain);
Assert.assertTrue(headers[0].equals(""));
}
/**
* Creates a result partition manager that ignores all IDs, and simply returns the given
* subpartitions in sequence.
*/
public static ResultPartitionManager createResultPartitionManager(final ResultSubpartition[] sources) throws Exception {
final Answer<ResultSubpartitionView> viewCreator = new Answer<ResultSubpartitionView>() {
private int num = 0;
@Override
public ResultSubpartitionView answer(InvocationOnMock invocation) throws Throwable {
BufferAvailabilityListener channel = (BufferAvailabilityListener) invocation.getArguments()[2];
return sources[num++].createReadView(channel);
}
};
ResultPartitionManager manager = mock(ResultPartitionManager.class);
when(manager.createSubpartitionView(
any(ResultPartitionID.class), anyInt(), any(BufferAvailabilityListener.class)))
.thenAnswer(viewCreator);
return manager;
}
@Test
public void testPullMessage_Success() throws Exception {
doAnswer(new Answer() {
@Override
public Object answer(InvocationOnMock mock) throws Throwable {
PullMessageRequestHeader requestHeader = mock.getArgument(1);
return createPullResult(requestHeader, PullStatus.FOUND, Collections.singletonList(new MessageExt()));
}
}).when(mQClientAPIImpl).pullMessage(anyString(), any(PullMessageRequestHeader.class), anyLong(), any(CommunicationMode.class), nullable(PullCallback.class));
MessageQueue messageQueue = new MessageQueue(topic, brokerName, 0);
PullResult pullResult = pullConsumer.pull(messageQueue, "*", 1024, 3);
assertThat(pullResult).isNotNull();
assertThat(pullResult.getPullStatus()).isEqualTo(PullStatus.FOUND);
assertThat(pullResult.getNextBeginOffset()).isEqualTo(1024 + 1);
assertThat(pullResult.getMinOffset()).isEqualTo(123);
assertThat(pullResult.getMaxOffset()).isEqualTo(2048);
assertThat(pullResult.getMsgFoundList()).isEqualTo(new ArrayList<Object>());
}
@Test
public void requestOneTimePayment_doesNotCallCancelListenerWhenSuccessful() {
final BraintreeFragment fragment = mMockFragmentBuilder
.successResponse(stringFromFixture("paypal_hermes_response.json"))
.build();
doAnswer(new Answer() {
@Override
public Object answer(InvocationOnMock invocation) {
Intent intent = new Intent()
.setData(Uri.parse("com.braintreepayments.api.test.braintree://onetouch/v1/success?PayerID=HERMES-SANDBOX-PAYER-ID&paymentId=HERMES-SANDBOX-PAYMENT-ID&token=EC-HERMES-SANDBOX-EC-TOKEN"));
PayPal.onActivityResult(fragment, RESULT_OK, intent);
return null;
}
}).when(fragment).startActivity(any(Intent.class));
MockStaticTokenizationClient.mockTokenizeSuccess(new PayPalAccountNonce());
PayPal.requestOneTimePayment(fragment, new PayPalRequest("1"));
verify(fragment, never()).postCancelCallback(anyInt());
}
@Test
public void signInAnonymously() {
// Given
Mockito.doAnswer(new Answer() {
@Override
public Object answer(InvocationOnMock invocation) {
((FIRAuth.Block_signInAnonymouslyWithCompletion) invocation.getArgument(0)).call_signInAnonymouslyWithCompletion(null, null);
return null;
}
}).when(firAuth).signInAnonymouslyWithCompletion(Mockito.any());
Auth auth = new Auth();
// When
auth.signInAnonymously().subscribe(consumer);
// Then
Mockito.verify(firAuth, VerificationModeFactory.times(1)).signInAnonymouslyWithCompletion(Mockito.any());
Mockito.verify(consumer, VerificationModeFactory.times(1)).accept(Mockito.nullable(GdxFirebaseUser.class));
}
@Before
public void init() throws CoreException {
IProjectDescription description = mock(IProjectDescription.class);
when(description.getBuildSpec()).thenReturn(new ICommand[0]);
when(description.newCommand()).thenReturn(mock(ICommand.class));
when(description.getNatureIds()).thenReturn(natureIds.toArray(new String[natureIds.size()]));
doAnswer(new Answer<Void>() {
@Override
public Void answer(InvocationOnMock invocation) throws Throwable {
natureIds.clear();
natureIds.addAll(Arrays.asList((String[])invocation.getArguments()[0]));
return null;
}
}).when(description).setNatureIds(any(String[].class));
when(project.getDescription()).thenReturn(description);
when(folder.getProject()).thenReturn(project);
when(folder.exists()).thenReturn(true);
when(folder.getFile(anyString())).thenReturn(file);
when(root.getFolder(new Path(folderName))).thenReturn(folder);
}
@Before
public void setUp() {
doReturn(mock(ChannelLogger.class)).when(helper).getChannelLogger();
doReturn(syncContext).when(helper).getSynchronizationContext();
doReturn(fakeClock.getScheduledExecutorService()).when(helper).getScheduledExecutorService();
when(orcaOobUtil.newOrcaReportingHelperWrapper(any(Helper.class),
any(OrcaOobReportListener.class)))
.thenAnswer(new Answer<OrcaReportingHelperWrapper>() {
@Override
public OrcaReportingHelperWrapper answer(InvocationOnMock invocation) {
Helper h = invocation.getArgument(0);
FakeOrcaReportingHelperWrapper res =
new FakeOrcaReportingHelperWrapper(h);
childHelperWrappers.put(h.getAuthority(), res);
return res;
}
});
lbRegistry.register(lbProvider);
localityStore =
new LocalityStoreImpl(logId, helper, lbRegistry, random, loadStatsStore,
orcaPerRequestUtil, orcaOobUtil);
}
@Before
public void setUp() throws Exception {
MockInjector.setInstance(ConfigUtil.class, new MockConfigUtil());
propertiesFactory = mock(PropertiesFactory.class);
when(propertiesFactory.getPropertiesInstance()).thenAnswer(new Answer<Properties>() {
@Override
public Properties answer(InvocationOnMock invocation) {
return new Properties();
}
});
MockInjector.setInstance(PropertiesFactory.class, propertiesFactory);
someResourceDir = new File(ClassLoaderUtil.getClassPath() + "/META-INF/config");
someResourceDir.mkdirs();
someNamespace = "someName";
configRepository = mock(ConfigRepository.class);
}
@Test
public void authorizeAccount_whenSuccessfulBrowserSwitch_sendsAnalyticsEvents() throws Exception {
final BraintreeFragment fragment = mMockFragmentBuilder
.successResponse(stringFromFixture("paypal_hermes_billing_agreement_response.json"))
.build();
doAnswer(new Answer() {
@Override
public Object answer(InvocationOnMock invocation) {
Intent intent = new Intent()
.setData(Uri.parse("com.braintreepayments.api.test.braintree://onetouch/v1/success?PayerID=HERMES-SANDBOX-PAYER-ID&paymentId=HERMES-SANDBOX-PAYMENT-ID&ba_token=EC-HERMES-SANDBOX-EC-TOKEN"));
PayPal.onActivityResult(fragment, RESULT_OK, intent);
return null;
}
}).when(fragment).browserSwitch(eq(BraintreeRequestCodes.PAYPAL), any(Intent.class));
MockStaticTokenizationClient.mockTokenizeSuccess(new PayPalAccountNonce());
PayPal.requestBillingAgreement(fragment, new PayPalRequest());
verify(fragment).sendAnalyticsEvent("paypal.billing-agreement.selected");
verify(fragment).sendAnalyticsEvent("paypal.billing-agreement.browser-switch.started");
verify(fragment).sendAnalyticsEvent("paypal.billing-agreement.browser-switch.succeeded");
}
@Test
public void testDoSomethingAsynchronouslyUsingDoAnswer() {
final List<String> results = Arrays.asList("One", "Two", "Three");
// Let's do a synchronous answer for the callback
doAnswer(new Answer() {
@Override
public Object answer(InvocationOnMock invocation) throws Throwable {
((DummyCallback)invocation.getArguments()[0]).onSuccess(results);
return null;
}
}).when(mockDummyCollaborator).doSomethingAsynchronously(any(DummyCallback.class));
// Let's call the method under test
dummyCaller.doSomethingAsynchronously();
// Verify state and interaction
verify(mockDummyCollaborator, times(1)).doSomethingAsynchronously(any(DummyCallback.class));
assertThat(dummyCaller.getResult(), is(equalTo(results)));
}
@Test
public void testConfigMessage() throws Exception {
hBaseShim = mock( HBaseShim.class );
HBaseConnection hBaseConnection = mock( HBaseConnectionTestImpls.HBaseConnectionWithResultField.class );
when( hBaseShim.getHBaseConnection() ).thenReturn( hBaseConnection );
hBaseConnectionPool = new HBaseConnectionPool( hBaseShim, props, logChannelInterface, namedCluster );
final String message = "message";
doAnswer( new Answer<Void>() {
@Override public Void answer( InvocationOnMock invocation ) throws Throwable {
( (List<String>) invocation.getArguments()[ 2 ] ).add( message );
return null;
}
} ).when( hBaseConnection ).configureConnection( eq( props ), eq( namedCluster ), anyList() );
hBaseConnectionPool.getConnectionHandle();
verify( logChannelInterface ).logBasic( message );
hBaseConnectionPool = new HBaseConnectionPool( hBaseShim, props, null, namedCluster );
hBaseConnectionPool.getConnectionHandle();
}
@Test
public void testGetSystemProperties() throws Exception {
Socket socket = mock(Socket.class);
OutputStream outputStream = mock(OutputStream.class);
when(socket.getOutputStream()).thenReturn(outputStream);
InputStream inputStream = mock(InputStream.class);
when(socket.getInputStream()).thenReturn(inputStream);
when(inputStream.read(any(byte[].class))).then(new Answer<Integer>() {
public Integer answer(InvocationOnMock invocation) throws Throwable {
byte[] result = (FOO + "=" + BAR).getBytes("ISO_8859_1");
byte[] buffer = invocation.getArgument(0);
System.arraycopy(result, 0, buffer, 0, result.length);
buffer[result.length] = 0;
return result.length + 1;
}
});
Properties properties = new VirtualMachine.ForOpenJ9(socket).getSystemProperties();
assertThat(properties.size(), is(1));
assertThat(properties.getProperty(FOO), is(BAR));
verify(outputStream).write("ATTACH_GETSYSTEMPROPERTIES".getBytes("UTF-8"));
}
@Test
public void testSetLatestRevision() {
// our experiment will always be at revision Long.MIN_VALUE + 1
doAnswer(new Answer() {
@Override
public Object answer(InvocationOnMock invocation) throws Throwable {
final ExperimentEntity entity = mock(ExperimentEntity.class);
entity.revision = Long.MIN_VALUE + 1;
return entity;
}
}).when(ds).get(eq(ExperimentEntity.class), anyString());
final RevisionManager revisionManager = new RevisionManager(ds);
revision = Long.MIN_VALUE; // our databases' revision
revisionManager.setLatestRevision(Long.MIN_VALUE); // revision manager's internal revision
assertFalse(revisionManager.checkIfAnyStale());
assertTrue(revisionManager.checkIfStale("foo"));
revision = Long.MIN_VALUE + 1; // our databases' revision
revisionManager.setLatestRevision(Long.MIN_VALUE); // revision manager's internal revision
assertTrue(revisionManager.checkIfAnyStale());
revisionManager.setLatestRevision(Long.MIN_VALUE + 1); // revision manager's internal revision
assertFalse(revisionManager.checkIfStale("foo"));
}
public static DockerAPI createMockedDockerAPI(List<Container> containerList) {
DockerAPI result = Mockito.mock(DockerAPI.class);
DockerClient client = Mockito.mock(DockerClient.class);
Mockito.when(result.getClient()).thenReturn(client);
DockerServerEndpoint dockerServerEndpoint = Mockito.mock(DockerServerEndpoint.class);
Mockito.when(dockerServerEndpoint.getUri()).thenReturn("tcp://mocked-docker-host:2375");
Mockito.when(result.getDockerHost()).thenReturn(dockerServerEndpoint);
ListContainersCmd listContainerCmd = Mockito.mock(ListContainersCmd.class);
Mockito.when(client.listContainersCmd()).thenReturn(listContainerCmd);
Mockito.when(listContainerCmd.withShowAll(true)).thenReturn(listContainerCmd);
Mockito.when(listContainerCmd.withLabelFilter(Matchers.anyMap())).thenAnswer( new Answer<ListContainersCmd>() {
@Override
public ListContainersCmd answer(InvocationOnMock invocation) throws Throwable {
Map<String, String> arg = invocation.getArgumentAt(0, Map.class);
String jenkinsInstanceIdInFilter = arg.get(DockerContainerLabelKeys.JENKINS_INSTANCE_ID);
Assert.assertEquals(UNITTEST_JENKINS_ID, jenkinsInstanceIdInFilter);
return listContainerCmd;
}
});
Mockito.when(listContainerCmd.exec()).thenReturn(containerList);
return result;
}
@BeforeClass
public static void prepareClass() throws Exception {
AppConfig config = appConfig();
app = mock(App.class);
when(app.config()).thenReturn(config);
when(app.cuid()).thenReturn(S.random());
when(app.file(anyString())).thenAnswer(new Answer<File>() {
@Override
public File answer(InvocationOnMock invocation) throws Throwable {
String path = (String) invocation.getArguments()[0];
return new File(BASE, path);
}
});
Field f = App.class.getDeclaredField("INST");
f.setAccessible(true);
f.set(null, app);
}