def test_deadlock_checker(self):
daemon = DaemonFactory(listener_lock=True)
# sleep process to simulate old Daemon instance
sleep(2)
deadlock_checker(2000) # 2 seconds
daemon_test = Daemon.get_solo()
# Test deadlock detection
self.assertEquals(daemon_test.listener_lock, False)
daemon.listener_lock = True
daemon.save()
deadlock_checker()
daemon_test = Daemon.get_solo()
self.assertEquals(daemon_test.listener_lock, True)
def setUp(self):
os.environ.update({'TESTRPC_GAS_LIMIT': '10000000000'})
self.provider = TestRPCProvider()
web3_service = Web3Service(self.provider)
self.web3 = web3_service.web3
# Mock web3
self.daemon = DaemonFactory()
self.tx_data = {'from': self.web3.eth.accounts[0], 'gas': 1000000}
# create oracles
centralized_contract_factory = self.web3.eth.contract(
abi=centralized_oracle_abi, bytecode=centralized_oracle_bytecode)
tx_hash = centralized_contract_factory.deploy()
self.centralized_oracle_factory_address = self.web3.eth.getTransactionReceipt(
tx_hash).get('contractAddress')
self.centralized_oracle_factory = self.web3.eth.contract(
self.centralized_oracle_factory_address,
abi=centralized_oracle_abi)
self.contracts = [{
'NAME':
'Centralized Oracle Factory',
'EVENT_ABI':
centralized_oracle_abi,
'EVENT_DATA_RECEIVER':
'django_eth_events.tests.utils.CentralizedOraclesReceiver',
'ADDRESSES': [self.centralized_oracle_factory_address[2::]]
}]
self.listener_under_test = EventListener(contract_map=self.contracts,
provider=self.provider)
CentralizedOracle().reset()
def setUp(self):
self.web3 = Web3Service(
provider=EthereumTesterProvider(EthereumTester())).web3
self.provider = self.web3.providers[0]
self.web3.eth.defaultAccount = self.web3.eth.coinbase
# Mock web3
self.daemon = DaemonFactory()
self.ipfs = Ipfs()
self.tx_data = {'from': self.web3.eth.accounts[0], 'gas': 1000000}
# create oracles
centralized_contract_factory = self.web3.eth.contract(
abi=load_json_file(abi_file_path('CentralizedOracleFactory.json')),
bytecode=centralized_oracle_bytecode)
tx_hash = centralized_contract_factory.constructor().transact()
self.centralized_oracle_factory_address = self.web3.eth.getTransactionReceipt(
tx_hash).get('contractAddress')
self.centralized_oracle_factory = self.web3.eth.contract(
self.centralized_oracle_factory_address,
abi=load_json_file(abi_file_path('CentralizedOracleFactory.json')))
self.contracts = [{
'NAME':
'Centralized Oracle Factory',
'EVENT_ABI':
load_json_file(abi_file_path('CentralizedOracleFactory.json')),
'EVENT_DATA_RECEIVER':
'chainevents.event_receivers.CentralizedOracleFactoryReceiver',
'ADDRESSES': [self.centralized_oracle_factory_address[2::]]
}]
self.listener_under_test = EventListener(contract_map=self.contracts,
provider=self.provider)
def setUp(self):
os.environ.update({'TESTRPC_GAS_LIMIT': '10000000000'})
self.rpc = TestRPCProvider()
web3_service = Web3Service(self.rpc)
self.web3 = web3_service.web3
# Mock web3
self.daemon = DaemonFactory()
self.ipfs = Ipfs()
self.tx_data = {'from': self.web3.eth.accounts[0], 'gas': 100000000}
# create oracles
centralized_contract_factory = self.web3.eth.contract(
abi=load_json_file(abi_file_path('CentralizedOracleFactory.json')),
bytecode=centralized_oracle_bytecode)
tx_hash = centralized_contract_factory.deploy()
self.centralized_oracle_factory_address = self.web3.eth.getTransactionReceipt(
tx_hash).get('contractAddress')
self.centralized_oracle_factory = self.web3.eth.contract(
self.centralized_oracle_factory_address,
abi=load_json_file(abi_file_path('CentralizedOracleFactory.json')))
self.contracts = [{
'NAME':
'Centralized Oracle Factory',
'EVENT_ABI':
load_json_file(abi_file_path('CentralizedOracleFactory.json')),
'EVENT_DATA_RECEIVER':
'chainevents.event_receivers.CentralizedOracleFactoryReceiver',
'ADDRESSES': [self.centralized_oracle_factory_address[2::]]
}]
self.listener_under_test = EventListener(self.contracts)
def test_singleton(self):
self.assertEqual(0, Daemon.objects.all().count())
DaemonFactory()
d1 = Daemon.get_solo()
self.assertEqual(1, Daemon.objects.all().count())
d2 = Daemon.get_solo()
self.assertEqual(1, Daemon.objects.all().count())
self.assertEqual(d1.pk, d2.pk)
def setUp(self):
# Run mocked testrpc for reorgs
print('Starting httpd...')
self.server_process = Process(target=start_mock_server)
self.server_process.start()
cache.set('block_number', '0x0')
sleep(1)
print('served')
self.rpc = RPCProvider(host='127.0.0.1', port='8545', ssl=0)
web3_service = Web3Service(self.rpc)
self.web3 = web3_service.web3
# Mock web3
self.daemon = DaemonFactory()
def test_event_listener(self):
daemon_factory = DaemonFactory(listener_lock=False)
# Number of blocks analyzed by Event Listener
n_blocks = Block.objects.all().count()
# Create centralized oracle factory contract
centralized_contract_factory = self.web3.eth.contract(
abi=centralized_oracle_abi, bytecode=centralized_oracle_bytecode)
tx_hash = centralized_contract_factory.deploy()
centralized_oracle_factory_address = self.web3.eth.getTransactionReceipt(
tx_hash).get('contractAddress')
centralized_oracle_factory = self.web3.eth.contract(
centralized_oracle_factory_address, abi=centralized_oracle_abi)
# Event receiver
centralized_event_receiver = {
'NAME': 'Centralized Oracle Factory',
'EVENT_ABI': centralized_oracle_abi,
'EVENT_DATA_RECEIVER':
'django_eth_events.tests.test_celery.DummyEventReceiver',
'ADDRESSES': [centralized_oracle_factory_address[2::]]
}
self.event_receivers.append(centralized_event_receiver)
setattr(settings, 'ETH_EVENTS', self.event_receivers)
# Start Celery Task
event_listener()
# Create centralized oracle
centralized_oracle_factory.transact(
self.tx_data).createCentralizedOracle(
'QmYwAPJzv5CZsnA625s3Xf2nemtYgPpHdWEz79ojWnPbdG')
# Run event listener again
event_listener()
# Do checks
daemon = Daemon.get_solo()
self.assertEquals(daemon.block_number, daemon_factory.block_number + 1)
self.assertEquals(Block.objects.all().count(), n_blocks + 1)
self.assertFalse(daemon.listener_lock)
def setUp(self):
self.rpc = TestRPCProvider()
self.daemon = DaemonFactory()
self.bot = EventListener(self.rpc)
self.bot.decoder.methods = {}
self.maxDiff = None
def test_default_value(self):
daemon = DaemonFactory()
self.assertIsNotNone(daemon.pk)
self.assertEqual(daemon.block_number, 0)
def setUp(self):
self.daemon = DaemonFactory()