@Test
public void testExceptionWhenIOExceptionOn200()
throws ExecutionException, InterruptedException, TimeoutException, IOException {
Function<HttpResponse, URI> function =
new ParseURIFromListOrLocationHeaderIf20x(uriBuilderProvider);
HttpResponse response = createMock(HttpResponse.class);
Payload payload = createMock(Payload.class);
expect(response.getStatusCode()).andReturn(200).atLeastOnce();
expect(response.getFirstHeaderOrNull(HttpHeaders.CONTENT_TYPE)).andReturn("text/uri-list");
RuntimeException exception = new RuntimeException("bad");
expect(response.getPayload()).andReturn(payload).atLeastOnce();
expect(payload.getInput()).andThrow(exception);
payload.release();
replay(payload);
replay(response);
try {
function.apply(response);
} catch (Exception e) {
assert e.equals(exception);
}
verify(payload);
verify(response);
}
public static EdmEntityType mockSourceEdmEntityType() {
EdmEntityType entityType = EasyMock.createMock(EdmEntityType.class);
EdmMapping mapping = EasyMock.createMock(EdmMapping.class);
List<String> navigationPropertyNames = new ArrayList<String>();
List<String> propertyNames = new ArrayList<String>();
propertyNames.add("id");
propertyNames.add("description");
navigationPropertyNames.add("SalesOrderLineItemDetails");
try {
EasyMock.expect(mapping.getInternalName()).andStubReturn("SalesOrderHeader");
EasyMock.replay(mapping);
EasyMock.expect(entityType.getName()).andStubReturn("SalesOrderHeader");
EasyMock.expect(entityType.getMapping()).andStubReturn(mapping);
EasyMock.expect(entityType.getNavigationPropertyNames())
.andStubReturn(navigationPropertyNames);
EasyMock.expect(entityType.getProperty("SalesOrderLineItemDetails"))
.andStubReturn(mockNavigationProperty());
EdmProperty property1 = mockEdmPropertyOfSource1();
EasyMock.expect(entityType.getProperty("id")).andStubReturn(property1);
EasyMock.expect(entityType.getProperty("description"))
.andStubReturn(mockEdmPropertyOfSource2());
EasyMock.expect(entityType.getPropertyNames()).andStubReturn(propertyNames);
List<EdmProperty> keyProperties = new ArrayList<EdmProperty>();
keyProperties.add(property1);
EasyMock.expect(entityType.getKeyProperties()).andStubReturn(keyProperties);
} catch (EdmException e) {
fail(
ODataJPATestConstants.EXCEPTION_MSG_PART_1
+ e.getMessage()
+ ODataJPATestConstants.EXCEPTION_MSG_PART_2);
}
EasyMock.replay(entityType);
return entityType;
}
/**
* Verify that when adding a second player to a game, the correct information for that player is
* set and it does not conflict with the first player
*/
@Test
public void addSecondPlayerTest() {
// setup dummy entityfactory
EntityFactory dummyEntityFactory = EasyMock.createMock(EntityFactory.class);
SnowmanFlag dummyFlag = EasyMock.createNiceMock(SnowmanFlag.class);
EasyMock.expect(dummyFlag.getID()).andStubReturn(new Integer(0));
EasyMock.replay(dummyFlag);
EasyMock.expect(
dummyEntityFactory.createSnowmanFlag(
EasyMock.isA(SnowmanGame.class),
EasyMock.isA(ETeamColor.class),
EasyMock.isA(Coordinate.class),
EasyMock.isA(Coordinate.class)))
.andStubReturn(dummyFlag);
EasyMock.replay(dummyEntityFactory);
// create the player
ClientSession session = EasyMock.createNiceMock(ClientSession.class);
SnowmanPlayer dummyPlayer = EasyMock.createMock(SnowmanPlayer.class);
ETeamColor color = ETeamColor.Red;
// create the second player
ClientSession session2 = EasyMock.createNiceMock(ClientSession.class);
SnowmanPlayer dummyPlayer2 = EasyMock.createMock(SnowmanPlayer.class);
ETeamColor color2 = ETeamColor.Blue;
// create the game
SnowmanGame game = new SnowmanGameImpl(gameName, 4, dummyEntityFactory);
// record information that should be set on the player1
dummyPlayer.setID(1);
dummyPlayer.setLocation(EasyMock.anyFloat(), EasyMock.anyFloat());
dummyPlayer.setTeamColor(color);
dummyPlayer.setGame(game);
EasyMock.expect(dummyPlayer.getSession()).andStubReturn(session);
EasyMock.replay(dummyPlayer);
// record information that should be set on the player2
dummyPlayer2.setID(2);
dummyPlayer2.setLocation(EasyMock.anyFloat(), EasyMock.anyFloat());
dummyPlayer2.setTeamColor(color2);
dummyPlayer2.setGame(game);
EasyMock.expect(dummyPlayer2.getSession()).andStubReturn(session2);
EasyMock.replay(dummyPlayer2);
// record that the players should be added to the channel
EasyMock.resetToDefault(gameChannel);
EasyMock.expect(gameChannel.join(session)).andReturn(gameChannel);
EasyMock.expect(gameChannel.join(session2)).andReturn(gameChannel);
EasyMock.replay(gameChannel);
// add the player
game.addPlayer(dummyPlayer, color);
game.addPlayer(dummyPlayer2, color2);
// verify the calls
EasyMock.verify(dummyPlayer);
EasyMock.verify(dummyPlayer2);
EasyMock.verify(gameChannel);
}
@Test
public void test401ShouldRetry() {
HttpCommand command = createMock(HttpCommand.class);
HttpRequest request = createMock(HttpRequest.class);
HttpResponse response = createMock(HttpResponse.class);
@SuppressWarnings("unchecked")
LoadingCache<Credentials, Access> cache = createMock(LoadingCache.class);
BackoffLimitedRetryHandler backoffHandler = createMock(BackoffLimitedRetryHandler.class);
expect(command.getCurrentRequest()).andReturn(request);
cache.invalidateAll();
expectLastCall();
expect(response.getPayload()).andReturn(Payloads.newStringPayload("")).anyTimes();
expect(response.getStatusCode()).andReturn(401).atLeastOnce();
replay(command);
replay(response);
replay(cache);
replay(backoffHandler);
RetryOnRenew retry = new RetryOnRenew(cache, backoffHandler);
assertTrue(retry.shouldRetryRequest(command, response));
verify(command);
verify(response);
verify(cache);
}
@Test
public void answer() throws ObjectNotFoundException {
UUID selfHelpGuideResponseId = UUID.randomUUID();
UUID selfHelpGuideQuestionId = UUID.randomUUID();
Boolean answerResponse = true;
SelfHelpGuideResponse selfHelpGuideResponse = new SelfHelpGuideResponse();
SelfHelpGuideQuestion selfHelpGuideQuestion = new SelfHelpGuideQuestion();
expect(service.get(selfHelpGuideResponseId)).andReturn(selfHelpGuideResponse);
expect(selfHelpGuideQuestionService.get(selfHelpGuideQuestionId))
.andReturn(selfHelpGuideQuestion);
expect(
service.answerSelfHelpGuideQuestion(
selfHelpGuideResponse, selfHelpGuideQuestion, answerResponse))
.andReturn(false);
replay(service);
replay(selfHelpGuideQuestionService);
try {
Boolean response =
controller.answer(selfHelpGuideResponseId, selfHelpGuideQuestionId, answerResponse);
verify(service);
verify(selfHelpGuideQuestionService);
assertFalse(response);
} catch (Exception e) {
fail("controller error");
}
}
public void simpleRootTestWithSudoPassword() {
node = createMock(NodeMetadata.class);
expect(node.getCredentials())
.andReturn(new LoginCredentials("tester", "testpassword!", null, true))
.atLeastOnce();
replay(node);
RunScriptOnNodeUsingSsh testMe =
new RunScriptOnNodeUsingSsh(
sshFactory,
eventBus,
node,
exec("echo $USER\necho $USER"),
wrapInInitScript(false).runAsRoot(true));
testMe.init();
sshClient.connect();
expect(sshClient.getUsername()).andReturn("tester");
expect(sshClient.getHostAddress()).andReturn("somewhere.example.com");
expect(
sshClient.exec(
"sudo -S sh <<'RUN_SCRIPT_AS_ROOT_SSH'\n"
+ "testpassword!\n"
+ "echo $USER\n"
+ "echo $USER\n"
+ "RUN_SCRIPT_AS_ROOT_SSH\n"))
.andReturn(new ExecResponse("root\nroot\n", null, 0));
sshClient.disconnect();
replay(sshClient);
testMe.call();
}
private ComponentExecutionRelatedInstances createComponentExecutionRelatedInstances(
Capture<ConsoleRow> consoleRowCapture) {
ComponentExecutionStorageBridge compExeStorageBridgeMock =
EasyMock.createStrictMock(ComponentExecutionStorageBridge.class);
EasyMock.expect(compExeStorageBridgeMock.getComponentExecutionDataManagementId())
.andStubReturn(DM_ID);
EasyMock.replay(compExeStorageBridgeMock);
ComponentExecutionRelatedStates compExeRelatedStates = new ComponentExecutionRelatedStates();
compExeRelatedStates.executionCount.set(EXE_COUNT);
compExeRelatedStates.consoleRowSequenceNumber.set(CONSOLE_ROW_SEQ_NUMBER);
compExeRelatedStates.compHasSentConsoleRowLogMessages.set(true);
batchingConsoleRowForwarderMock = EasyMock.createStrictMock(BatchingConsoleRowsForwarder.class);
batchingConsoleRowForwarderMock.onConsoleRow(EasyMock.capture(consoleRowCapture));
EasyMock.replay(batchingConsoleRowForwarderMock);
ComponentExecutionRelatedInstances compExeRelatedInstances =
new ComponentExecutionRelatedInstances();
compExeRelatedInstances.compExeStorageBridge = compExeStorageBridgeMock;
compExeRelatedInstances.compExeCtx = new ComponentExecutionContextDefaultStub();
compExeRelatedInstances.compExeRelatedStates = compExeRelatedStates;
compExeRelatedInstances.batchingConsoleRowsForwarder = batchingConsoleRowForwarderMock;
return compExeRelatedInstances;
}
@Test
public void testConfigurationEventAdded() throws Exception {
String testPid = SecuredCommandConfigTransformer.PROXY_COMMAND_ACL_PID_PREFIX + "test123";
Configuration conf = EasyMock.createMock(Configuration.class);
EasyMock.expect(conf.getPid()).andReturn(testPid).anyTimes();
EasyMock.replay(conf);
ConfigurationAdmin cm = EasyMock.createMock(ConfigurationAdmin.class);
EasyMock.expect(cm.listConfigurations(EasyMock.isA(String.class))).andReturn(null).anyTimes();
EasyMock.expect(cm.getConfiguration(testPid)).andReturn(conf).anyTimes();
EasyMock.replay(cm);
final List<String> generateCalled = new ArrayList<String>();
SecuredCommandConfigTransformer scct =
new SecuredCommandConfigTransformer() {
@Override
void generateServiceGuardConfig(Configuration config) throws IOException {
generateCalled.add(config.getPid());
}
};
scct.setConfigAdmin(cm);
scct.init();
@SuppressWarnings("unchecked")
ServiceReference<ConfigurationAdmin> cmRef = EasyMock.createMock(ServiceReference.class);
EasyMock.replay(cmRef);
ConfigurationEvent event =
new ConfigurationEvent(cmRef, ConfigurationEvent.CM_UPDATED, null, testPid);
assertEquals("Precondition", 0, generateCalled.size());
scct.configurationEvent(event);
assertEquals(1, generateCalled.size());
assertEquals(testPid, generateCalled.iterator().next());
}
@SuppressWarnings({"rawtypes", "unchecked"})
public void testStartMonitoringWithTimeout() {
ScheduledFuture mockFuture = EasyMock.createMock(ScheduledFuture.class);
ScheduledExecutorService schedulerMock = EasyMock.createMock(ScheduledExecutorService.class);
expect(
schedulerMock.scheduleWithFixedDelay(
anyObject(Runnable.class), anyLong(), anyLong(), anyObject(TimeUnit.class)))
.andReturn(mockFuture);
replay(mockFuture);
replay(schedulerMock);
AsyncMonitor<Object> monitor =
mockMonitor(schedulerMock, new Object(), mockFunction(MonitorStatus.DONE), new EventBus());
assertNull(monitor.getFuture());
assertNull(monitor.getTimeout());
monitor.startMonitoring(100L);
assertNotNull(monitor.getFuture());
assertNotNull(monitor.getTimeout());
assertTrue(monitor.getTimeout() > 100L);
verify(mockFuture);
verify(schedulerMock);
}
@SuppressWarnings({"rawtypes", "unchecked"})
public void testMonitorAndContinueWithoutTimeout() {
ScheduledFuture mockFuture = EasyMock.createMock(ScheduledFuture.class);
ScheduledExecutorService schedulerMock = EasyMock.createMock(ScheduledExecutorService.class);
expect(
schedulerMock.scheduleWithFixedDelay(
anyObject(Runnable.class), anyLong(), anyLong(), anyObject(TimeUnit.class)))
.andReturn(mockFuture);
replay(mockFuture);
replay(schedulerMock);
CoutingEventHandler handler = new CoutingEventHandler();
EventBus eventBus = new EventBus();
eventBus.register(handler);
AsyncMonitor<Object> monitor =
mockMonitor(schedulerMock, new Object(), mockFunction(MonitorStatus.CONTINUE), eventBus);
assertNull(monitor.getFuture());
assertNull(monitor.getTimeout());
monitor.startMonitoring(null);
assertNotNull(monitor.getFuture());
assertNull(monitor.getTimeout());
monitor.run();
assertEquals(handler.numCompletes, 0);
assertEquals(handler.numFailures, 0);
assertEquals(handler.numTimeouts, 0);
verify(mockFuture);
verify(schedulerMock);
}
private void doGet(Map<String, String> parameters, boolean checkResultContent)
throws IOException, ServletException {
final HttpServletRequest request = createNiceMock(HttpServletRequest.class);
expect(request.getRequestURI()).andReturn("/test/monitoring").anyTimes();
expect(request.getRequestURL()).andReturn(new StringBuffer("/test/monitoring")).anyTimes();
expect(request.getContextPath()).andReturn(CONTEXT_PATH).anyTimes();
expect(request.getRemoteAddr()).andReturn("here").anyTimes();
for (final Map.Entry<String, String> entry : parameters.entrySet()) {
if (REQUEST_PARAMETER.equals(entry.getKey())) {
expect(request.getHeader(entry.getKey())).andReturn(entry.getValue()).anyTimes();
} else {
expect(request.getParameter(entry.getKey())).andReturn(entry.getValue()).anyTimes();
}
}
expect(request.getHeaders("Accept-Encoding"))
.andReturn(Collections.enumeration(Arrays.asList("application/gzip")))
.anyTimes();
final HttpServletResponse response = createNiceMock(HttpServletResponse.class);
final ByteArrayOutputStream output = new ByteArrayOutputStream();
expect(response.getOutputStream()).andReturn(new FilterServletOutputStream(output)).anyTimes();
final StringWriter stringWriter = new StringWriter();
expect(response.getWriter()).andReturn(new PrintWriter(stringWriter)).anyTimes();
replay(request);
replay(response);
reportServlet.doGet(request, response);
verify(request);
verify(response);
if (checkResultContent) {
assertTrue("result", output.size() != 0 || stringWriter.getBuffer().length() != 0);
}
}
public void testExceptionIfNot5xx() {
FalseOn5xx function = new FalseOn5xx();
HttpResponse response = EasyMock.createMock(HttpResponse.class);
HttpResponseException exception = EasyMock.createMock(HttpResponseException.class);
// Status code is called twice
expect(response.getStatusCode()).andReturn(600);
expect(response.getStatusCode()).andReturn(600);
// Get response gets called twice
expect(exception.getResponse()).andReturn(response);
expect(exception.getResponse()).andReturn(response);
// Get cause is called to determine the root cause
expect(exception.getCause()).andReturn(null);
replay(response);
replay(exception);
try {
function.createOrPropagate(exception);
} catch (Exception ex) {
assertEquals(ex, exception);
}
verify(response);
verify(exception);
}
public void testGetLatestAlbums() throws SQLException {
final Properties p = createMock(Properties.class);
expect(p.get(Constants.WWW_BROWSE_LATEST_ALBUMS_COUNT, 10)).andReturn(10l);
replay(p);
final ResultSet rs = createNiceMock(ResultSet.class);
expect(rs.next()).andReturn(true);
expect(rs.next()).andReturn(true);
expect(rs.next()).andReturn(false);
replay(rs);
final PreparedStatement st = createMock(PreparedStatement.class);
st.setInt(1, 10);
expect(st.executeQuery()).andReturn(rs).times(1);
replay(st);
final Database db = createMock(Database.class);
expect(db.prepare((String) anyObject())).andReturn(st).times(1);
replay(db);
final Latester b = new Latester();
b.setProperties(p);
b.setDatabase(db);
final Vector<Album> albums = b.getLatestAlbums();
assertNotNull(albums);
assertEquals(2, albums.size());
verify(db);
verify(st);
verify(rs);
verify(p);
}
private ValuesIndexManager setupMockObjects(
String dsName, String table, String indexName, String variableName, Variable variable) {
ValuesIndexManager indexManager = createMock(ValuesIndexManager.class);
Datasource datasource = createMockDatasource(dsName, table);
ValueTable mockTable = datasource.getValueTable(table);
reset(mockTable);
ValueTableValuesIndex mockTableIndex = createMock(ValueTableValuesIndex.class);
expect(mockTableIndex.getIndexName()).andReturn(indexName).anyTimes();
expect(mockTableIndex.getFieldName("LAST_MEAL_WHEN"))
.andReturn(indexName + "-LAST_MEAL_WHEN")
.anyTimes();
expect(mockTableIndex.getFieldName("RES_FIRST_HEIGHT"))
.andReturn(indexName + "-RES_FIRST_HEIGHT")
.anyTimes();
replay(mockTableIndex);
expect(mockTable.getVariable(variableName)).andReturn(variable).anyTimes();
expect(indexManager.getIndex(mockTable)).andReturn(mockTableIndex).anyTimes();
replay(indexManager);
replay(mockTable);
MagmaEngine.get().addDatasource(datasource);
return indexManager;
}
public static EdmEntityType mockTargetEdmEntityType() {
EdmEntityType entityType = EasyMock.createMock(EdmEntityType.class);
EdmMapping mapping = EasyMock.createMock(EdmMapping.class);
List<String> propertyNames = new ArrayList<String>();
propertyNames.add("price");
try {
EasyMock.expect(mapping.getInternalName()).andStubReturn("SalesOrderLineItem");
EasyMock.replay(mapping);
EasyMock.expect(entityType.getName()).andStubReturn("SalesOrderLineItem");
EasyMock.expect(entityType.getMapping()).andStubReturn(mapping);
EdmProperty property = mockEdmPropertyOfTarget();
EasyMock.expect(entityType.getProperty("price")).andStubReturn(property);
EasyMock.expect(entityType.getPropertyNames()).andStubReturn(propertyNames);
List<EdmProperty> keyProperties = new ArrayList<EdmProperty>();
keyProperties.add(property);
EasyMock.expect(entityType.getKeyProperties()).andStubReturn(keyProperties);
} catch (EdmException e) {
fail(
ODataJPATestConstants.EXCEPTION_MSG_PART_1
+ e.getMessage()
+ ODataJPATestConstants.EXCEPTION_MSG_PART_2);
}
EasyMock.replay(entityType);
return entityType;
}
@Before
public void setUp() {
logger = new ByteArrayOutputStream();
kpPairs = new ArrayList<GlobalKeepassPair>();
URL url = getClass().getResource("/TestDB.kdbx");
kpPairs.add(new GlobalKeepassPair(url.getPath(), MASTER_PASS));
vpList = new ArrayList<VarPasswordPair>();
config =
EasyMock.createMockBuilder(MaskPasswordsConfig.class)
.addMockedMethod("getGlobalVarPasswordPairs")
.addMockedMethod("getGlobalKeepassLocations")
.addMockedMethod("isMasked")
.createMock();
wrapper =
EasyMock.createMockBuilder(MaskPasswordsBuildWrapper.class)
.addMockedMethod("getConfig")
.createMock();
EasyMock.expect(config.getGlobalKeepassLocations()).andReturn(kpPairs);
EasyMock.expect(config.getGlobalVarPasswordPairs()).andReturn(vpList);
EasyMock.expect(config.isMasked(EasyMock.anyString())).andReturn(true).anyTimes();
EasyMock.replay(config);
EasyMock.expect(wrapper.getConfig()).andReturn(config).anyTimes();
EasyMock.replay(wrapper);
build = EasyMock.createMock(AbstractBuild.class);
EasyMock.expect(build.getAction(ParametersAction.class)).andReturn(null);
EasyMock.replay(build);
}
// TODO(oana): Added a task in tracker for fixing these dependencies and
// making the mocking of objects easier.
public void testEnterArgumentNode() {
CssDefinitionNode def = new CssDefinitionNode(new CssLiteralNode("COLOR"));
MutatingVisitController visitController = createMock(MutatingVisitController.class);
CssTree tree = createMock(CssTree.class);
expect(tree.getMutatingVisitController()).andReturn(visitController).anyTimes();
ConstantDefinitions definitions = EasyMock.createMock(ConstantDefinitions.class);
expect(definitions.getConstantDefinition("COLOR")).andReturn(def).anyTimes();
replay(definitions);
replay(tree);
ReplaceConstantReferences pass =
new ReplaceConstantReferences(
tree,
definitions,
true /* removeDefs */,
new DummyErrorManager(),
true /* allowUndefinedConstants */);
Capture<List<CssNode>> tempList = new Capture<List<CssNode>>();
visitController.replaceCurrentBlockChildWith(capture(tempList), eq(true));
replay(visitController);
CssConstantReferenceNode node = new CssConstantReferenceNode("COLOR", null);
pass.enterArgumentNode(node);
verify(visitController);
assertEquals(1, tempList.getValue().size());
assertEquals(CssCompositeValueNode.class, tempList.getValue().get(0).getClass());
}
@Test
public void testNext() {
boolean expected = true;
EasyMock.expect(peekIterator.hasNext()).andReturn(expected).times(4);
String defaultString = "S1";
String resString = "S2";
EasyMock.expect(peekIterator.next()).andReturn(defaultString);
EasyMock.expect(binaryFn.apply(EasyMock.eq(defaultString), EasyMock.isNull()))
.andReturn(resString);
EasyMock.expect(peekIterator.next()).andReturn(defaultString);
EasyMock.expect(comparator.compare(EasyMock.eq(resString), EasyMock.eq(defaultString)))
.andReturn(0);
EasyMock.expect(peekIterator.next()).andReturn(defaultString);
EasyMock.expect(binaryFn.apply(EasyMock.eq(resString), EasyMock.eq(defaultString)))
.andReturn(resString);
EasyMock.expect(comparator.compare(EasyMock.eq(resString), EasyMock.eq(defaultString)))
.andReturn(1);
EasyMock.replay(peekIterator);
EasyMock.replay(binaryFn);
EasyMock.replay(comparator);
String actual = testingIterator.next();
Assert.assertEquals(resString, actual);
EasyMock.verify(peekIterator);
EasyMock.verify(comparator);
EasyMock.verify(binaryFn);
}
@Test
public void testConfigurationEventDeletedNonScope() throws Exception {
String testPid = SecuredCommandConfigTransformer.PROXY_COMMAND_ACL_PID_PREFIX + "abc.def";
ConfigurationAdmin cm = EasyMock.createMock(ConfigurationAdmin.class);
EasyMock.expect(cm.listConfigurations(EasyMock.isA(String.class))).andReturn(null).anyTimes();
EasyMock.replay(cm);
SecuredCommandConfigTransformer scct = new SecuredCommandConfigTransformer();
scct.setConfigAdmin(cm);
scct.init();
@SuppressWarnings("unchecked")
ServiceReference<ConfigurationAdmin> cmRef = EasyMock.createMock(ServiceReference.class);
EasyMock.replay(cmRef);
ConfigurationEvent event =
new ConfigurationEvent(cmRef, ConfigurationEvent.CM_DELETED, null, testPid);
EasyMock.reset(cm);
// Do not expect any further calls to cm...
EasyMock.replay(cm);
scct.configurationEvent(event);
EasyMock.verify(cm);
}
@Test
public void testStart() throws Exception {
RoundRobinSchedulerStats stats =
EasyMock.createMockBuilder(RoundRobinSchedulerStats.class)
.withConstructor()
.addMockedMethod("registerMBean")
.addMockedMethod("createMovingAverage")
.createStrictMock();
MovingAverage mavg = EasyMock.createStrictMock(MovingAverage.class);
EasyMock.expect(stats.createMovingAverage()).andReturn(mavg);
mavg.startTimer("RoundRobinAddMavg", stats.getAddMavgPeriod(), TimeUnit.MILLISECONDS);
EasyMock.expectLastCall();
stats.registerMBean();
EasyMock.expectLastCall();
EasyMock.replay(stats, mavg);
stats.start();
EasyMock.verify(stats, mavg);
assertEquals("Mavg not set.", mavg, stats.m_addMavg);
// with already called
EasyMock.reset(stats, mavg);
EasyMock.replay(stats, mavg);
stats.start();
EasyMock.verify(stats, mavg);
}
public void testRetriesLoggedAtInfoWithCount() throws Exception {
SSHClientConnection mockConnection = createMock(SSHClientConnection.class);
net.schmizz.sshj.SSHClient mockClient = createMock(net.schmizz.sshj.SSHClient.class);
mockConnection.clear();
expectLastCall();
mockConnection.create();
expectLastCall().andThrow(new ConnectionException("test1"));
mockConnection.clear();
expectLastCall();
// currently does two clears, one on failure (above) and one on next iteration (below)
mockConnection.clear();
expectLastCall();
mockConnection.create();
expectLastCall().andReturn(mockClient);
replay(mockConnection);
replay(mockClient);
ssh.sshClientConnection = mockConnection;
BufferLogger logcheck = new BufferLogger(ssh.getClass().getCanonicalName());
ssh.logger = logcheck;
logcheck.setLevel(Level.INFO);
ssh.connect();
Assert.assertEquals(ssh.sshClientConnection, mockConnection);
verify(mockConnection);
verify(mockClient);
Record r = logcheck.assertLogContains("attempt 1 of 5");
logcheck.assertLogDoesntContain("attempt 2 of 5");
Assert.assertEquals(Level.INFO, r.getLevel());
}
@Test
public void testStop() throws Exception {
RoundRobinSchedulerStats stats =
EasyMock.createMockBuilder(RoundRobinSchedulerStats.class)
.withConstructor()
.addMockedMethod("unregisterMBean")
.createStrictMock();
MovingAverage mavg = EasyMock.createStrictMock(MovingAverage.class);
stats.m_addMavg = mavg;
stats.m_addMavg.stopTimer();
EasyMock.expectLastCall();
stats.unregisterMBean();
EasyMock.expectLastCall();
EasyMock.replay(stats, mavg);
stats.stop();
EasyMock.verify(stats, mavg);
assertNull("Mavg should be null.", stats.m_addMavg);
// with no avg
EasyMock.reset(stats);
EasyMock.replay(stats);
stats.stop();
EasyMock.verify(stats);
}
@Test
public void initiate() throws Exception {
Person bob = new Person(UUID.randomUUID());
String sessionId = (new Date()).toString();
securityService.setCurrent(bob);
UUID selfHelpGuideId = UUID.randomUUID();
SelfHelpGuide selfHelpGuide = new SelfHelpGuide();
SelfHelpGuideResponse selfHelpGuideResponse = new SelfHelpGuideResponse();
expect(selfHelpGuideService.get(selfHelpGuideId)).andReturn(selfHelpGuide);
expect(service.initiateSelfHelpGuideResponse(selfHelpGuide, bob, sessionId))
.andReturn(selfHelpGuideResponse);
replay(service);
replay(selfHelpGuideService);
String response = controller.initiate(selfHelpGuideId);
verify(service);
verify(selfHelpGuideService);
assertEquals(selfHelpGuideResponse.toString(), response);
}
/** Tests {@link ControllerImpl#saveOrUpdate(Object)}. */
@Test
public void saveOrUpdate() {
final String OTHER_OBJECT = "kkkkk";
// at first, we test with a persistent object
EasyMock.expect(dao.isPersistent(OBJECT)).andReturn(true);
EasyMock.expect(dao.update(OBJECT)).andReturn(OTHER_OBJECT);
EasyMock.replay(dao);
String returned = controller.saveOrUpdate(OBJECT);
EasyMock.verify(dao);
assert returned == OTHER_OBJECT;
// at last, we test with a non-persistent object
EasyMock.reset(dao);
EasyMock.expect(dao.isPersistent(OBJECT)).andReturn(false);
dao.save(OBJECT);
EasyMock.replay(dao);
returned = controller.saveOrUpdate(OBJECT);
EasyMock.verify(dao);
assert returned == OBJECT;
}
@Test
public void test408ShouldRetry() {
HttpCommand command = createMock(HttpCommand.class);
HttpResponse response = createMock(HttpResponse.class);
@SuppressWarnings("unchecked")
LoadingCache<Credentials, Access> cache = createMock(LoadingCache.class);
BackoffLimitedRetryHandler backoffHandler = createMock(BackoffLimitedRetryHandler.class);
expect(response.getPayload())
.andReturn(
Payloads.newStringPayload(
"The server has waited too long for the request to be sent by the client."))
.times(3);
expect(backoffHandler.shouldRetryRequest(command, response)).andReturn(true).once();
expect(response.getStatusCode()).andReturn(408).once();
replay(command);
replay(response);
replay(cache);
replay(backoffHandler);
RetryOnRenew retry = new RetryOnRenew(cache, backoffHandler);
assertTrue(retry.shouldRetryRequest(command, response));
verify(command);
verify(response);
verify(cache);
verify(backoffHandler);
}
@Test
public void testLoadBoardImpl() throws BoardLoadingException {
final ScribbleSettings settings = new ScribbleSettings("Mock", Language.EN, 3);
final Dictionary dictionary = createNiceMock(Dictionary.class);
final TilesBank tilesBank =
new TilesBank(new TilesBankInfoEditor(Language.EN).createTilesBankInfo());
final ScribbleBoard board = createStrictMock(ScribbleBoard.class);
expect(board.getSettings()).andReturn(settings);
expect(board.getPlayersCount()).andReturn(3);
board.initGameAfterLoading(tilesBank, dictionary, personalityManager);
replay(board);
expect(session.get(ScribbleBoard.class, 1L)).andReturn(board);
session.evict(board);
replay(session);
expect(dictionaryManager.getDictionary(Language.EN)).andReturn(dictionary);
replay(dictionaryManager);
expect(tilesBankingHouse.createTilesBank(Language.EN, 3, true)).andReturn(tilesBank);
replay(tilesBankingHouse);
final ScribbleBoard board1 = scribblePlayManager.loadBoardImpl(1L);
assertSame(board, board1);
verify(board);
verify(session);
verify(dictionaryManager);
verify(tilesBankingHouse);
}
/**
* Validates that the stage properly identifies when a message should be restored
*
* @throws Exception on error
*/
@Test
public void testRestoreMissingMessage() throws Exception {
List<IMessageContext> msgs = new ArrayList<IMessageContext>();
IMessageContext msg = EasyMock.createStrictMock(IMessageContext.class);
msgs.add(msg);
// isUpdate & does not need restorage == don't store!
EasyMock.expect(msg.shouldReplaceStorage()).andReturn(false);
EasyMock.expect(msg.isUpdate()).andReturn(true);
EasyMock.replay(msg);
List<IMessageContext> needsStorage = Itertools.filter(PartitionStoreStage.NEEDS_STORAGE, msgs);
assertTrue(needsStorage.isEmpty());
EasyMock.verify(msg);
EasyMock.reset(msg);
// should replace storage will bypass the other tests
EasyMock.expect(msg.shouldReplaceStorage()).andReturn(true);
EasyMock.replay(msg);
needsStorage = Itertools.filter(PartitionStoreStage.NEEDS_STORAGE, msgs);
assertEquals(1, needsStorage.size());
EasyMock.verify(msg);
EasyMock.reset(msg);
// !isUpdate & no filepath & does not need restorage == store!
EasyMock.expect(msg.shouldReplaceStorage()).andReturn(false);
EasyMock.expect(msg.isUpdate()).andReturn(false);
EasyMock.expect(msg.getStoreFileSubPath()).andReturn(null);
EasyMock.replay(msg);
needsStorage = Itertools.filter(PartitionStoreStage.NEEDS_STORAGE, msgs);
assertEquals(1, needsStorage.size());
EasyMock.verify(msg);
EasyMock.reset(msg);
}
@Test
public void testCreateBoardImpl() throws BoardCreationException {
final ScribbleSettings settings = new ScribbleSettings("Mock", Language.EN, 3);
final Dictionary dictionary = createNiceMock(Dictionary.class);
replay(dictionary);
final TilesBankInfoEditor editor = new TilesBankInfoEditor(Language.EN);
final TilesBank tilesBank = new TilesBank(editor.add('A', 100, 1).createTilesBankInfo());
expect(dictionaryManager.getDictionary(Language.EN)).andReturn(dictionary);
replay(dictionaryManager);
expect(tilesBankingHouse.createTilesBank(Language.EN, 2, true)).andReturn(tilesBank);
replay(tilesBankingHouse);
scribblePlayManager.setDictionaryManager(dictionaryManager);
scribblePlayManager.setTilesBankingHouse(tilesBankingHouse);
final ScribbleBoard board1 =
scribblePlayManager.createBoardImpl(settings, Arrays.asList(player1, player2), null);
assertNotNull(board1);
verify(dictionaryManager);
verify(tilesBankingHouse);
}
/** Verify that when adding a second player to a full game, an exception is thrown */
@Test(expected = SnowmanFullException.class)
public void addPlayerFullTest() {
// setup dummy entityfactory
EntityFactory dummyEntityFactory = EasyMock.createMock(EntityFactory.class);
SnowmanFlag dummyFlag = EasyMock.createNiceMock(SnowmanFlag.class);
EasyMock.expect(dummyFlag.getID()).andStubReturn(new Integer(0));
EasyMock.replay(dummyFlag);
EasyMock.expect(
dummyEntityFactory.createSnowmanFlag(
EasyMock.isA(SnowmanGame.class),
EasyMock.isA(ETeamColor.class),
EasyMock.isA(Coordinate.class),
EasyMock.isA(Coordinate.class)))
.andStubReturn(dummyFlag);
EasyMock.replay(dummyEntityFactory);
// create the players
SnowmanPlayer dummyPlayer = EasyMock.createMock(SnowmanPlayer.class);
SnowmanPlayer dummyPlayer2 = EasyMock.createMock(SnowmanPlayer.class);
SnowmanPlayer dummyPlayer3 = EasyMock.createMock(SnowmanPlayer.class);
ETeamColor color = ETeamColor.Red;
// create the game
SnowmanGame game = new SnowmanGameImpl(gameName, 4, dummyEntityFactory);
// add the players
game.addPlayer(dummyPlayer, color);
game.addPlayer(dummyPlayer2, color);
game.addPlayer(dummyPlayer3, color);
}
@SuppressWarnings("unchecked")
public void test5NoSuitableEndpointFound() throws Exception {
ServiceResolverRegistry registry =
OsgiSupport.getReference(bundleContext, ServiceResolverRegistry.class);
registry.register(resolverMock, resolverProps);
EndpointDescription endpointMock = createMock(EndpointDescription.class);
ServiceDescription serviceMock = createMock(ServiceDescription.class);
List<EndpointDescription> endpoints = new ArrayList<EndpointDescription>();
endpoints.add(endpointMock);
expect(resolverMock.getEndpointsFor(service2Interface, null)).andReturn(endpoints).once();
expect(endpointMock.getServiceName()).andReturn(new QName("dummy", "dummy")).times(2);
expect(endpointMock.getAddress()).andReturn("non-existing-one").once();
expect(endpointMock.getName()).andReturn("endpoint-name").once();
replay(resolverMock);
replay(endpointMock);
replay(serviceMock);
try {
setExchangeThroughNMR();
fail("The routing of exchange must fail");
} catch (RuntimeException e) {
// expected result
}
verify(resolverMock);
verify(endpointMock);
verify(serviceMock);
}