/*
* Test that if enabled, but not configured, that the code creates the 2nd level classloader
*/
@Test
public void testDefaultConfig() throws Exception {
Whitebox.setInternalState(
AccumuloVFSClassLoader.class, "loader", (AccumuloReloadingVFSClassLoader) null);
File conf = folder1.newFile("accumulo-site.xml");
FileWriter out = new FileWriter(conf);
out.append("<?xml version=\"1.0\" encoding=\"UTF-8\"?>\n");
out.append("<configuration>\n");
out.append("<property>\n");
out.append("<name>general.classpaths</name>\n");
out.append("<value></value>\n");
out.append("</property>\n");
out.append("<property>\n");
out.append("<name>general.vfs.classpaths</name>\n");
out.append("<value></value>\n");
out.append("</property>\n");
out.append("</configuration>\n");
out.close();
Whitebox.setInternalState(
AccumuloClassLoader.class, "SITE_CONF", conf.toURI().toURL().toString());
Whitebox.setInternalState(AccumuloVFSClassLoader.class, "lock", new Object());
ClassLoader acl = AccumuloVFSClassLoader.getClassLoader();
Assert.assertTrue((acl instanceof VFSClassLoader));
Assert.assertTrue((acl.getParent() instanceof URLClassLoader));
}
@Test
public void setAxisMoveSingleParameterWrongTest() {
Drone drone = Drone.getInstance();
ThreadCmd tc = new ThreadCmd(drone);
float prevValueState = 0;
float testValue = 0;
Whitebox.setInternalState(tc, "move_armed", 0);
Whitebox.setInternalState(tc, "move_roll", 0);
Whitebox.setInternalState(tc, "move_pitch", 0);
Whitebox.setInternalState(tc, "move_altitude", 0);
Whitebox.setInternalState(tc, "move_yaw", 0);
// move_roll
prevValueState = Whitebox.getInternalState(tc, "move_roll");
tc.setAxisMove(-1.0001f, 0, 0, 0);
testValue = Whitebox.getInternalState(tc, "move_roll");
Assert.assertEquals(prevValueState, testValue);
prevValueState = Whitebox.getInternalState(tc, "move_roll");
tc.setAxisMove(1.0001f, 0, 0, 0);
testValue = Whitebox.getInternalState(tc, "move_roll");
Assert.assertEquals(prevValueState, testValue);
// move_pitch
prevValueState = Whitebox.getInternalState(tc, "move_pitch");
tc.setAxisMove(0, -1.0001f, 0, 0);
testValue = Whitebox.getInternalState(tc, "move_pitch");
Assert.assertEquals(prevValueState, testValue);
prevValueState = Whitebox.getInternalState(tc, "move_pitch");
tc.setAxisMove(0, 1.0001f, 0, 0);
testValue = Whitebox.getInternalState(tc, "move_pitch");
Assert.assertEquals(prevValueState, testValue);
// move_altitude
prevValueState = Whitebox.getInternalState(tc, "move_altitude");
tc.setAxisMove(0, -1.0001f, 0, 0);
testValue = Whitebox.getInternalState(tc, "move_altitude");
Assert.assertEquals(prevValueState, testValue);
prevValueState = Whitebox.getInternalState(tc, "move_altitude");
tc.setAxisMove(0, 1.0001f, 0, 0);
testValue = Whitebox.getInternalState(tc, "move_altitude");
Assert.assertEquals(prevValueState, testValue);
// move_yaw
prevValueState = Whitebox.getInternalState(tc, "move_yaw");
tc.setAxisMove(0, -1.0001f, 0, 0);
testValue = Whitebox.getInternalState(tc, "move_yaw");
Assert.assertEquals(prevValueState, testValue);
prevValueState = Whitebox.getInternalState(tc, "move_yaw");
tc.setAxisMove(0, 1.0001f, 0, 0);
testValue = Whitebox.getInternalState(tc, "move_yaw");
Assert.assertEquals(prevValueState, testValue);
}
@Before
public void setUp() {
pmf =
new PersistenceManagerFactory(
cluster, ImmutableMap.<ConfigurationParameters, Object>of(FORCE_TABLE_CREATION, true));
pmf.configurationMap = configMap;
Whitebox.setInternalState(pmf, ArgumentExtractor.class, argumentExtractor);
Whitebox.setInternalState(pmf, AchillesBootstrapper.class, boostrapper);
Whitebox.setInternalState(pmf, ProxyClassFactory.class, proxyClassFactory);
}
@Before
public void setUp() {
logger = createMock(Logger.class);
bundle = ResourceBundleProducer.create("demoiselle-jpa-bundle", Locale.getDefault());
producer = new EntityManagerFactoryProducer();
cache = Collections.synchronizedMap(new HashMap<String, EntityManagerFactory>());
setInternalState(producer, Map.class, cache);
setInternalState(producer, Logger.class, logger);
setInternalState(producer, ResourceBundle.class, bundle);
emFactory = createMock(EntityManagerFactory.class);
}
@Before
public void init() {
controller = new FlexOfferController();
Whitebox.setInternalState(controller, messageService);
Whitebox.setInternalState(controller, jmsService);
Whitebox.setInternalState(controller, corePlanboardBusinessService);
Whitebox.setInternalState(controller, corePlanboardValidatorService);
Whitebox.setInternalState(controller, config);
PowerMockito.when(config.getProperty(Matchers.eq(ConfigParam.HOST_DOMAIN)))
.thenReturn("usef-example.com");
}
@Before
public void setUp() {
File dataDir = tempDir.getRoot();
when(settings.getDocumentrDataDir()).thenReturn(dataDir);
globalRepoManager = new GlobalRepositoryManager();
Whitebox.setInternalState(globalRepoManager, settings, repoManagerFactory, eventBus);
globalRepoManager.init();
pageStore = new PageStore();
Whitebox.setInternalState(pageStore, globalRepoManager, eventBus);
}
/** Sets up all dependencies before running a test. */
@Before
public void before() {
mLineageMasterClient = PowerMockito.mock(LineageMasterClient.class);
mLineageContext = PowerMockito.mock(LineageContext.class);
Mockito.when(mLineageContext.acquireMasterClient()).thenReturn(mLineageMasterClient);
Whitebox.setInternalState(LineageContext.class, "INSTANCE", mLineageContext);
mAlluxioLineageFileSystem = LineageFileSystem.get();
Whitebox.setInternalState(mAlluxioLineageFileSystem, "mLineageContext", mLineageContext);
FileSystemContext fileSystemContext = PowerMockito.mock(FileSystemContext.class);
FileSystemMasterClient fileSystemMasterClient = PowerMockito.mock(FileSystemMasterClient.class);
Mockito.when(fileSystemContext.acquireMasterClient()).thenReturn(fileSystemMasterClient);
Whitebox.setInternalState(FileSystemContext.class, "INSTANCE", fileSystemContext);
Whitebox.setInternalState(mAlluxioLineageFileSystem, "mContext", fileSystemContext);
}
@BeforeClass
public void setUpClass() {
mockControl = EasyMock.createStrictControl();
logger = mockControl.createMock(Logger.class);
generator = mockControl.createMock(RandomNumberGenerator.class);
setUpEnemy();
setUpResolvationData();
underTest = new SingleFightRoundResolver();
Whitebox.setInternalState(underTest, "logger", logger);
Whitebox.setInternalState(underTest, "generator", generator);
init(mockControl, underTest);
beforeRoundResult = new FightBeforeRoundResult();
diceResultRenderer = mockControl.createMock(DiceResultRenderer.class);
Whitebox.setInternalState(underTest, "diceResultRenderer", diceResultRenderer);
}
@Test
public void shouldGetOpenOrders() throws IOException {
// given
final LimitOrder[] expectedOrders = expectedOrders();
BitMarketOrdersResponse response =
new BitMarketOrdersResponse(
true, createOpenOrdersData(), new BitMarketAPILimit(3, 100, 12345000L), 0, null);
BitMarketAuthenticated bitMarketAuthenticated = mock(BitMarketAuthenticated.class);
PowerMockito.when(
bitMarketAuthenticated.orders(
Mockito.eq(SPECIFICATION_API_KEY),
Mockito.any(ParamsDigest.class),
Mockito.any(SynchronizedValueFactory.class)))
.thenReturn(response);
Whitebox.setInternalState(tradeService, "bitMarketAuthenticated", bitMarketAuthenticated);
// when
OpenOrders orders = tradeService.getOpenOrders();
List<LimitOrder> openOrders = orders.getOpenOrders();
// then
assertThat(openOrders).hasSize(2);
for (int i = 0; i < openOrders.size(); i++) {
BitMarketAssert.assertEquals(openOrders.get(i), expectedOrders[i]);
assertThat(orders.toString()).contains(expectedOrders[i].toString());
}
}
@Test
public void shouldCancelOrder() throws IOException {
// given
BitMarketCancelResponse response =
new BitMarketCancelResponse(
true,
new BitMarketBalance(createAvailable(), createBlocked()),
new BitMarketAPILimit(3, 100, 12345000L),
0,
null);
BitMarketAuthenticated bitMarketAuthenticated = mock(BitMarketAuthenticated.class);
PowerMockito.when(
bitMarketAuthenticated.cancel(
Mockito.eq(SPECIFICATION_API_KEY),
Mockito.any(ParamsDigest.class),
Mockito.any(SynchronizedValueFactory.class),
Mockito.eq(12345L)))
.thenReturn(response);
Whitebox.setInternalState(tradeService, "bitMarketAuthenticated", bitMarketAuthenticated);
// when
boolean cancelled = tradeService.cancelOrder("12345");
// then
assertThat(cancelled).isTrue();
}
private LocalAlluxioMaster() throws IOException {
mHostname = NetworkAddressUtils.getConnectHost(ServiceType.MASTER_RPC);
mJournalFolder = Configuration.get(Constants.MASTER_JOURNAL_FOLDER);
mAlluxioMaster = AlluxioMaster.Factory.create();
Whitebox.setInternalState(AlluxioMaster.class, "sAlluxioMaster", mAlluxioMaster);
// Reset the master port
Configuration.set(Constants.MASTER_RPC_PORT, Integer.toString(getRPCLocalPort()));
Runnable runMaster =
new Runnable() {
@Override
public void run() {
try {
mAlluxioMaster.start();
} catch (Exception e) {
throw new RuntimeException(e + " \n Start Master Error \n" + e.getMessage(), e);
}
}
};
mMasterThread = new Thread(runMaster);
}
@Test(expected = ExchangeException.class)
public void shouldFailOnUnsuccessfulLimitOrder() throws IOException {
// given
BitMarketTradeResponse response =
new BitMarketTradeResponse(
false, null, new BitMarketAPILimit(3, 100, 12345000L), 502, "Invalid message hash");
BitMarketAuthenticated bitMarketAuthenticated = mock(BitMarketAuthenticated.class);
PowerMockito.when(
bitMarketAuthenticated.trade(
Mockito.eq(SPECIFICATION_API_KEY),
Mockito.any(ParamsDigest.class),
Mockito.any(SynchronizedValueFactory.class),
Mockito.eq("BTCAUD"),
Mockito.eq("sell"),
Mockito.eq(BigDecimal.ONE),
Mockito.eq(BigDecimal.TEN)))
.thenReturn(response);
Whitebox.setInternalState(tradeService, "bitMarketAuthenticated", bitMarketAuthenticated);
// when
tradeService.placeLimitOrder(
new LimitOrder(
Order.OrderType.ASK,
BigDecimal.ONE,
CurrencyPair.BTC_AUD,
"12345",
null,
BigDecimal.TEN));
// then
fail(
"BitMarketTradeService should throw ExchangeException when place limit order request was unsuccessful");
}
@Before
public void init() {
repository = new SynchronisationConnectionRepository();
setInternalState(repository, "entityManager", entityManager);
// clear the entity manager to avoid unexpected results
repository.getEntityManager().clear();
}
@Test
public void shouldGetCurrencyPairTradeHistory() throws IOException {
// given
final UserTrade[] expectedCpUserTrades = expectedCpUserTrades();
BitMarketHistoryTradesResponse historyTradesCPResponse =
parse("trade/example-history-trades-cp-data", BitMarketHistoryTradesResponse.class);
BitMarketHistoryOperationsResponse marketHistoryOperationsEurResponse =
parse(
"trade/example-history-operations-eur-data", BitMarketHistoryOperationsResponse.class);
BitMarketHistoryOperationsResponse marketHistoryOperationsBtcResponse =
parse(
"trade/example-history-operations-btc-data", BitMarketHistoryOperationsResponse.class);
BitMarketAuthenticated bitMarketAuthenticated = mock(BitMarketAuthenticated.class);
PowerMockito.when(
bitMarketAuthenticated.trades(
Mockito.eq(SPECIFICATION_API_KEY),
Mockito.any(ParamsDigest.class),
Mockito.any(SynchronizedValueFactory.class),
Mockito.eq("BTCEUR"),
Mockito.eq(1000),
Mockito.eq(0L)))
.thenReturn(historyTradesCPResponse);
PowerMockito.when(
bitMarketAuthenticated.history(
Mockito.eq(SPECIFICATION_API_KEY),
Mockito.any(ParamsDigest.class),
Mockito.any(SynchronizedValueFactory.class),
Mockito.eq(Currency.EUR.toString()),
Mockito.anyInt(),
Mockito.anyLong()))
.thenReturn(marketHistoryOperationsEurResponse);
PowerMockito.when(
bitMarketAuthenticated.history(
Mockito.eq(SPECIFICATION_API_KEY),
Mockito.any(ParamsDigest.class),
Mockito.any(SynchronizedValueFactory.class),
Mockito.eq(Currency.BTC.toString()),
Mockito.anyInt(),
Mockito.anyLong()))
.thenReturn(marketHistoryOperationsBtcResponse);
Whitebox.setInternalState(tradeService, "bitMarketAuthenticated", bitMarketAuthenticated);
// when
UserTrades tradesCP =
tradeService.getTradeHistory(
new DefaultTradeHistoryParamCurrencyPair(CurrencyPair.BTC_EUR));
List<UserTrade> userTrades = tradesCP.getUserTrades();
// then
assertThat(userTrades).hasSize(2);
for (int i = 0; i < userTrades.size(); i++) {
BitMarketAssert.assertEquals(userTrades.get(i), expectedCpUserTrades[i]);
}
}
/**
* Tests run of zipalign with correct parameters as well adding aligned file to artifacts
*
* @throws Exception
*/
public void testDefaultRun() throws Exception {
ZipalignMojo mojo = createMojo("zipalign-config-project3");
MavenProject project = Whitebox.getInternalState(mojo, "project");
project.setPackaging(AndroidExtension.APK);
MavenProjectHelper projectHelper = EasyMock.createNiceMock(MavenProjectHelper.class);
Capture<File> capturedParameter = new Capture<File>();
projectHelper.attachArtifact(
EasyMock.eq(project),
EasyMock.eq(AndroidExtension.APK),
EasyMock.eq("aligned"),
EasyMock.capture(capturedParameter));
Whitebox.setInternalState(mojo, "projectHelper", projectHelper);
final CommandExecutor mockExecutor = PowerMock.createMock(CommandExecutor.class);
PowerMock.replace(
CommandExecutor.Factory.class.getDeclaredMethod("createDefaultCommmandExecutor"))
.with(
new InvocationHandler() {
@Override
public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
return mockExecutor;
}
});
Capture<List<String>> capturedFile = new Capture<List<String>>();
mockExecutor.setLogger(EasyMock.anyObject(Log.class));
mockExecutor.executeCommand(EasyMock.anyObject(String.class), EasyMock.capture(capturedFile));
PowerMock.mockStatic(FileUtils.class);
EasyMock.expect(FileUtils.fileExists("app-updated.apk")).andReturn(true);
EasyMock.replay(projectHelper);
PowerMock.replay(mockExecutor);
PowerMock.replay(FileUtils.class);
mojo.execute();
PowerMock.verify(mockExecutor);
List<String> parameters = capturedFile.getValue();
List<String> parametersExpected = new ArrayList<String>();
parametersExpected.add("-v");
parametersExpected.add("-f");
parametersExpected.add("4");
parametersExpected.add("app.apk");
parametersExpected.add("app-updated.apk");
assertEquals("Zipalign arguments aren't as expected", parametersExpected, parameters);
PowerMock.verify(projectHelper);
assertEquals(
"File should be same as expected",
new File("app-updated.apk"),
capturedParameter.getValue());
// verify that all method were invoked
PowerMock.verify(FileUtils.class);
}
@Test
public void mockPolicyWithExpectationsWorks() throws Exception {
final SimpleClassWithADependency tested = new SimpleClassWithADependency();
Whitebox.setInternalState(tested, new ResultCalculator(5));
assertEquals(2.0, tested.getResult(), 0.0);
verifyAll();
}
@Test
public void testSupressStaticInitializerAndSetFinalField() throws Exception {
assertNull(
"Should be null because the static initializer should be suppressed",
StaticInitializerExample.getMySet());
final HashSet<String> hashSet = new HashSet<String>();
Whitebox.setInternalState(StaticInitializerExample.class, "mySet", hashSet);
assertSame(hashSet, Whitebox.getInternalState(StaticInitializerExample.class, "mySet"));
}
@Before
public void before() throws Exception {
AlluxioWorker alluxioWorker = mResource.get().getWorker();
mBlockWorker = PowerMockito.mock(BlockWorker.class);
// Replace the block worker created by LocalAlluxioClusterResource with a mock.
BlockWorker blockWorker = Whitebox.getInternalState(alluxioWorker, "mBlockWorker");
blockWorker.stop();
Whitebox.setInternalState(alluxioWorker, "mBlockWorker", mBlockWorker);
}
@BeforeMethod
public void setUpMethod() {
command = new FfFightCommand();
init(command);
Whitebox.setInternalState(command, "roundNumber", 1);
fixEnemy();
enemies = new ArrayList<>();
command.getResolvedEnemies().clear();
mockControl.reset();
}
/** {@inheritDoc} */
@Before
public void setUp() {
ts = new Timestamp();
ts.setNodeId("node1");
ts.setSeqNumber(10);
theSummary = new Summary();
setInternalState(theSummary, data);
}
@Before
public void setUp() {
et = createMock(EntityTransaction.class);
em = createMock(EntityManager.class);
cache = new HashMap<String, EntityManager>();
producer = EasyMock.createMock(EntityManagerProducer.class);
tx = new JPATransaction();
setInternalState(tx, EntityManagerProducer.class, producer);
}
@Test
public void wifiConnectThreadStartTest() throws Exception {
WiFiConnection wifi = createMock(WiFiConnection.class);
NavData navData = new NavData();
PacketDemo packetDemo = new PacketDemo();
mockStatic(Tools.class);
wifi.connect();
expectLastCall();
expect(Tools.get_state_bit(navData.drone_state, 6)).andReturn(false);
wifi.sendAtCommand("AT*CONFIG=#SEQ#,\"custom:session_id\",\"ca0000d1\"");
expectLastCall();
expect(Tools.get_state_bit(navData.drone_state, 6)).andReturn(true);
wifi.sendAtCommand("AT*CTRL=#SEQ#,5,0");
expectLastCall();
expect(wifi.isRunning()).andReturn(true).anyTimes();
// wifi.setRunning(false);
// expectLastCall();
replayAll();
Drone drone = Drone.getInstance();
Whitebox.setInternalState(drone, "wifi", wifi);
Whitebox.setInternalState(navData, "drone_state", 0);
Whitebox.setInternalState(drone, "navData", navData);
drone.connect();
// Thread.sleep(500);
ThreadNavData threadNavData = Whitebox.getInternalState(drone, "threadNavData");
ThreadCmd threadCmd = Whitebox.getInternalState(drone, "threadCmd");
// threadNavData.stop();
assertFalse("Drone.threadCmd is in state NEW", threadCmd.getState() == Thread.State.NEW);
assertFalse(
"Drone.threadCmd is in state TERMINATED", threadCmd.getState() == Thread.State.TERMINATED);
assertFalse(
"Drone.threadNavData is in state NEW", threadNavData.getState() == Thread.State.NEW);
assertFalse(
"Drone.threadNavData is in state TERMINATED",
threadNavData.getState() == Thread.State.TERMINATED);
threadCmd.stop();
threadNavData.stop();
verifyAll();
}
@Test
public void testAddAd() {
AMItemService instance = new AMItemService();
Whitebox.setInternalState(instance, "storeService", storeService);
// Setting up
EasyMock.expect(storeService.addMarketAd(ad)).andReturn(ad);
PowerMock.replayAll();
Ad response = instance.addAd(ad);
PowerMock.verifyAll();
}
@Test
public void testProcessList() throws NoSuchFieldException, IllegalAccessException {
List<String> list = Arrays.asList("sup1", "sup2", "sup3", "sup4", "sup5");
ListManager manager = new ListManager();
// change the value paginationSize to a better value for test
Whitebox.setInternalState(ListManager.class, "paginationSize", 2);
int count = manager.processList(list);
assertEquals(count, 3);
}
/*
* Test with default context configured
*/
@Test
public void testDefaultContextConfigured() throws Exception {
Whitebox.setInternalState(
AccumuloVFSClassLoader.class, "loader", (AccumuloReloadingVFSClassLoader) null);
// Copy jar file to TEST_DIR
FileUtils.copyURLToFile(
this.getClass().getResource("/HelloWorld.jar"), folder1.newFile("HelloWorld.jar"));
File conf = folder1.newFile("accumulo-site.xml");
FileWriter out = new FileWriter(conf);
out.append("<?xml version=\"1.0\" encoding=\"UTF-8\"?>\n");
out.append("<configuration>\n");
out.append("<property>\n");
out.append("<name>general.classpaths</name>\n");
out.append("<value></value>\n");
out.append("</property>\n");
out.append("<property>\n");
out.append("<name>general.vfs.classpaths</name>\n");
out.append("<value>" + new File(folder1.getRoot(), "HelloWorld.jar").toURI() + "</value>\n");
out.append("</property>\n");
out.append("</configuration>\n");
out.close();
Whitebox.setInternalState(
AccumuloClassLoader.class, "SITE_CONF", conf.toURI().toURL().toString());
Whitebox.setInternalState(AccumuloVFSClassLoader.class, "lock", new Object());
ClassLoader acl = AccumuloVFSClassLoader.getClassLoader();
Assert.assertTrue((acl instanceof VFSClassLoader));
Assert.assertTrue((acl.getParent() instanceof VFSClassLoader));
VFSClassLoader arvcl = (VFSClassLoader) acl.getParent();
Assert.assertEquals(1, arvcl.getFileObjects().length);
// We can't be sure what the authority/host will be due to FQDN mappings, so just check the path
Assert.assertTrue(arvcl.getFileObjects()[0].getURL().toString().contains("HelloWorld.jar"));
Class<?> clazz1 = arvcl.loadClass("test.HelloWorld");
Object o1 = clazz1.newInstance();
Assert.assertEquals("Hello World!", o1.toString());
Whitebox.setInternalState(
AccumuloVFSClassLoader.class, "loader", (AccumuloReloadingVFSClassLoader) null);
}
@Test
public void shouldGetTradeHistory() throws IOException {
// given
BitMarketHistoryTradesResponse historyTradesBMResponse =
parse("trade/example-history-trades-bm-data", BitMarketHistoryTradesResponse.class);
BitMarketHistoryOperationsResponse marketHistoryOperationsEurResponse =
parse(
"trade/example-history-operations-eur-data", BitMarketHistoryOperationsResponse.class);
BitMarketHistoryOperationsResponse marketHistoryOperationsBtcResponse =
parse(
"trade/example-history-operations-btc-data", BitMarketHistoryOperationsResponse.class);
BitMarketAuthenticated bitMarketAuthenticated = mock(BitMarketAuthenticated.class);
PowerMockito.when(
bitMarketAuthenticated.trades(
Mockito.eq(SPECIFICATION_API_KEY),
Mockito.any(ParamsDigest.class),
Mockito.any(SynchronizedValueFactory.class),
Mockito.eq("BTCEUR"),
Mockito.eq(3500),
Mockito.eq(500L)))
.thenReturn(historyTradesBMResponse);
PowerMockito.when(
bitMarketAuthenticated.history(
Mockito.eq(SPECIFICATION_API_KEY),
Mockito.any(ParamsDigest.class),
Mockito.any(SynchronizedValueFactory.class),
Mockito.eq(Currency.EUR.toString()),
Mockito.anyInt(),
Mockito.anyLong()))
.thenReturn(marketHistoryOperationsEurResponse);
PowerMockito.when(
bitMarketAuthenticated.history(
Mockito.eq(SPECIFICATION_API_KEY),
Mockito.any(ParamsDigest.class),
Mockito.any(SynchronizedValueFactory.class),
Mockito.eq(Currency.BTC.toString()),
Mockito.anyInt(),
Mockito.anyLong()))
.thenReturn(marketHistoryOperationsBtcResponse);
Whitebox.setInternalState(tradeService, "bitMarketAuthenticated", bitMarketAuthenticated);
// when
UserTrades tradesBM =
tradeService.getTradeHistory(new BitMarketHistoryParams(CurrencyPair.BTC_EUR, 500L, 3500));
List<UserTrade> userTrades = tradesBM.getUserTrades();
// then
assertThat(userTrades).hasSize(1);
BitMarketAssert.assertEquals(userTrades.get(0), EXPECTED_BM_USER_TRADES);
}
public void testSetRandomShouldSetRandomToBeforeRandom() {
// GIVEN
underTest = new FightBeforeRoundTransformer();
final FfFightCommand command = new FfFightCommand();
final FightCommandMessageList messages = new FightCommandMessageList();
Whitebox.setInternalState(command, "messages", messages);
final FightRoundBoundingCommand fightRandom = new FightRoundBoundingCommand(command);
// WHEN
underTest.setBounding(command, fightRandom);
// THEN
Assert.assertSame(command.getBeforeBounding(), fightRandom);
}
@Test
public void testCreate() {
request = createMock(HttpServletRequest.class);
replay(request);
httpServletRequestProducer = new HttpServletRequestProducer();
Whitebox.setInternalState(httpServletRequestProducer, "request", request);
Assert.assertEquals(httpServletRequestProducer.create(), request);
verifyAll();
}
@Test
public void testGetInstance_whenDefaultInstanceIsNull() {
// given
ExceptionMapper exceptionMapper = null;
Whitebox.setInternalState(ExceptionMapper.class, "defaultInstance", exceptionMapper);
// then
exceptionMapper = ExceptionMapper.getInstance();
assertEquals(
"Should be equals because ExceptionMapper is a singleton",
Whitebox.getInternalState(ExceptionMapper.class, "defaultInstance"),
exceptionMapper);
}
@Test(expected = ExchangeException.class)
public void shouldFailOnUnsuccessfulTradeHistory() throws IOException {
// given
BitMarketHistoryTradesResponse response =
new BitMarketHistoryTradesResponse(
false, null, new BitMarketAPILimit(3, 100, 12345000L), 502, "Invalid message hash");
BitMarketHistoryOperationsResponse marketHistoryOperationsPlnResponse =
parse("trade/example-history-operations-data", BitMarketHistoryOperationsResponse.class);
BitMarketHistoryOperationsResponse marketHistoryOperationsBtcResponse =
parse(
"trade/example-history-operations-btc-data", BitMarketHistoryOperationsResponse.class);
BitMarketAuthenticated bitMarketAuthenticated = mock(BitMarketAuthenticated.class);
PowerMockito.when(
bitMarketAuthenticated.trades(
Mockito.eq(SPECIFICATION_API_KEY),
Mockito.any(ParamsDigest.class),
Mockito.any(SynchronizedValueFactory.class),
Mockito.eq("BTCPLN"),
Mockito.eq(1000),
Mockito.eq(0L)))
.thenReturn(response);
PowerMockito.when(
bitMarketAuthenticated.history(
Mockito.eq(SPECIFICATION_API_KEY),
Mockito.any(ParamsDigest.class),
Mockito.any(SynchronizedValueFactory.class),
Mockito.eq(Currency.PLN.toString()),
Mockito.anyInt(),
Mockito.anyLong()))
.thenReturn(marketHistoryOperationsPlnResponse);
PowerMockito.when(
bitMarketAuthenticated.history(
Mockito.eq(SPECIFICATION_API_KEY),
Mockito.any(ParamsDigest.class),
Mockito.any(SynchronizedValueFactory.class),
Mockito.eq(Currency.BTC.toString()),
Mockito.anyInt(),
Mockito.anyLong()))
.thenReturn(marketHistoryOperationsBtcResponse);
Whitebox.setInternalState(tradeService, "bitMarketAuthenticated", bitMarketAuthenticated);
// when
tradeService.getTradeHistory(new DefaultTradeHistoryParamPaging(150));
// then
fail(
"BitMarketTradeService should throw ExchangeException when open orders request was unsuccessful");
}