def test_get_balance(self, async_run, *_):
c = self.client
result = (None, None, None)
deferred = Deferred()
deferred.result = result
deferred.called = True
async_run.return_value = deferred
c.transaction_system = Mock()
c.transaction_system.get_balance.return_value = result
balance = sync_wait(c.get_balance())
assert balance == (None, None, None)
result = (None, 1, None)
deferred.result = result
balance = sync_wait(c.get_balance())
assert balance == (None, None, None)
result = (1, 1, None)
deferred.result = result
balance = sync_wait(c.get_balance())
assert balance == (u"1", u"1", u"None")
assert all(isinstance(entry, unicode) for entry in balance)
c.transaction_system = None
balance = sync_wait(c.get_balance())
assert balance == (None, None, None)
def test_execute(self, reactor, _):
deferred = Deferred()
deferred.result = "Success"
deferred.called = True
reactor.callWhenRunning = lambda m, *a, **kw: m(*a, **kw)
@contextmanager
def rpc_context():
connect = Session.connect
Session.connect = Mock()
Session.connect.return_value = deferred
yield
Session.connect = connect
with rpc_context():
ws_cli = WebSocketCLI(Mock(), '127.0.0.1', '12345', realm=u'golem')
ws_cli.execute()
assert isinstance(ws_cli.cli.register_client.call_args_list[0][0][0], Client)
with rpc_context():
deferred.result = Failure(Exception("Failure"))
deferred.called = True
ws_cli = WebSocketCLI(Mock(), '127.0.0.1', '12345', realm=u'golem')
ws_cli.execute()
assert isinstance(ws_cli.cli.register_client.call_args_list[0][0][0], WebSocketCLI.NoConnection)
def test_wait_for_deferred(self):
self.assertEqual(sync_wait('1234'), '1234')
deferred = Deferred()
deferred.result = '5678'
deferred.called = True
self.assertEqual(sync_wait(deferred), '5678')
with self.assertRaises(TimeoutError):
deferred_2 = Deferred()
sync_wait(deferred_2, timeout=0)
def test_min_max_price(self):
self.logic.get_res_dirs.return_value = {'computing': os.getcwd(),
'distributed': os.getcwd(),
'received': os.getcwd()}
config_mock = MagicMock()
config_mock.max_price = int(2.01 * denoms.ether)
config_mock.min_price = int(2.0 * denoms.ether)
config_deferred = Deferred()
config_deferred.result = config_mock
config_deferred.called = True
res_dirs_deferred = Deferred()
res_dirs_deferred.result = MagicMock()
res_dirs_deferred.called = True
self.logic.get_config.return_value = config_deferred
self.logic.get_res_dirs.return_value = res_dirs_deferred
customizer = ConfigurationDialogCustomizer(self.gui.main_window, self.logic)
self.assertIsInstance(customizer, ConfigurationDialogCustomizer)
self.assertEqual(float(customizer.gui.ui.maxPriceLineEdit.text()), 2.01)
self.assertEqual(float(customizer.gui.ui.minPriceLineEdit.text()), 2.0)
customizer.gui.ui.maxPriceLineEdit.setText(u"{}".format(1))
customizer.gui.ui.minPriceLineEdit.setText(u"{}".format(0.0011))
self.__click_ok(customizer)
ccd = self.logic.change_config.call_args_list[0][0][0]
self.assertEqual(ccd.min_price, int(0.0011 * denoms.ether))
self.assertEqual(round(float(ccd.max_price) / denoms.ether), 1)
customizer.gui.ui.maxPriceLineEdit.setText(u"ABCDEF")
with self.assertLogs(logger, level=1):
self.__click_ok(customizer)
customizer.gui.ui.maxPriceLineEdit.setText(u"{}".format(0.3))
customizer.gui.ui.minPriceLineEdit.setText(u"0.1 ETH")
with self.assertLogs(logger, level=1):
self.__click_ok(customizer)
def test_update_payments_view(self):
logic = GuiApplicationLogic()
logic.client = Mock()
logic.customizer = Mock()
ether = denoms.ether
balance_deferred = Deferred()
balance_deferred.result = (3 * ether, 1 * ether, 0.3 * ether)
balance_deferred.called = True
logic.client.get_balance.return_value = balance_deferred
logic.update_payments_view()
ui = logic.customizer.gui.ui
ui.localBalanceLabel.setText.assert_called_once_with("3.00000000 GNT")
ui.reservedBalanceLabel.setText.assert_called_once_with(
"2.00000000 GNT")
ui.availableBalanceLabel.setText.assert_called_once_with(
"1.00000000 GNT")
ui.depositBalanceLabel.setText.assert_called_once_with(
"0.30000000 ETH")
