def test_transferCoins_get_unsigned(self): with set_qrl_dir('test_wallet'): with State() as db_state: p2p_factory = Mock(spec=P2PFactory) p2p_factory.pow = Mock(spec=POW) chain_manager = ChainManager(db_state) qrlnode = QRLNode(db_state, mining_address=b'') qrlnode.set_chain_manager(chain_manager) qrlnode._p2pfactory = p2p_factory qrlnode._pow = p2p_factory.pow qrlnode._peer_addresses = ['127.0.0.1', '192.168.1.1'] service = PublicAPIService(qrlnode) context = Mock(spec=ServicerContext) alice = get_alice_xmss() bob = get_bob_xmss() request = qrl_pb2.TransferCoinsReq(addresses_to=[bob.address], amounts=[101], fee=12, xmss_pk=alice.pk) response = service.TransferCoins(request=request, context=context) context.set_code.assert_not_called() context.set_details.assert_not_called() self.assertIsNotNone(response) self.assertIsNotNone(response.extended_transaction_unsigned) self.assertEqual( 'transfer', response.extended_transaction_unsigned.tx.WhichOneof( 'transactionType')) self.assertEqual(12, response.extended_transaction_unsigned.tx.fee) self.assertEqual( alice.pk, response.extended_transaction_unsigned.tx.public_key) self.assertEqual( 0, response.extended_transaction_unsigned.tx.nonce) self.assertEqual( b'', response.extended_transaction_unsigned.tx.signature) self.assertEqual( b'', response.extended_transaction_unsigned.tx.transaction_hash) self.assertEqual( bob.address, response.extended_transaction_unsigned.tx. transfer.addrs_to[0]) self.assertEqual( 101, response.extended_transaction_unsigned.tx.transfer. amounts[0])
def test_generate_bitfield_key(self): with set_qrl_dir('no_data'): state = State() paginated_bitfield = PaginatedBitfield(True, state._db) address = b'addr1' page = 1 expected_key = b'bitfield_' + address + b'_' + page.to_bytes(8, byteorder='big', signed=False) found_key = paginated_bitfield.generate_bitfield_key(address, page) self.assertEqual(expected_key, found_key)
def test_addAddressFromSeed2(self): with set_qrl_dir("wallet_ver1"): walletd = WalletD() service = WalletAPIService(walletd) resp = service.AddAddressFromSeed( qrlwallet_pb2.AddAddressFromSeedReq(seed=self.mnemonic), context=None) self.assertEqual(resp.code, 0) self.assertEqual(resp.address, self.qaddress)
def test_add_address_from_seed(self): with set_qrl_dir("wallet_ver1"): walletd = WalletD() qaddress1 = walletd.add_address_from_seed( seed=self.hex_seed) # Using hexseed self.assertEqual(self.qaddress, qaddress1) self.assertEqual(len(walletd.list_address()), 1)
def test_get_block_metadata(self): with set_qrl_dir('no_data'): with State() as state: self.assertIsNone(state.get_block_metadata(b'test1')) state.put_block_metadata(b'block_headerhash2', BlockMetadata(), None) self.assertEqual( state.get_block_metadata(b'block_headerhash2').to_json(), b'{}')
def test_authenticate(self): with set_qrl_dir("wallet_ver1"): walletd = WalletD() walletd.authenticate() walletd._wallet = Mock() walletd._wallet.encrypted = Mock(return_value=True) with self.assertRaises(ValueError): walletd.authenticate()
def test_get_block_number_mapping(self): with set_qrl_dir('no_data'): with State() as state: self.assertIsNone(state.get_block_number_mapping(0)) bm = qrl_pb2.BlockNumberMapping() state.put_block_number_mapping(0, bm, None) read_bm = state.get_block_number_mapping(0) self.assertEqual(bm.SerializeToString(), read_bm.SerializeToString())
def test_release_state(self): with set_qrl_dir('no_data'): with State() as state: self.assertIsNotNone( state) # to avoid warning (unused variable) with State() as state: self.assertIsNotNone( state) # to avoid warning (unused variable)
def test_delete(self): with set_qrl_dir('no_data'): with State() as state: block = Block() state.put_block(block, None) block1 = state.get_block(block.headerhash) self.assertEqual(block.serialize(), block1.serialize()) state._delete(block.headerhash, None) self.assertIsNone(state.get_block(block.headerhash))
def test_list_address(self): with set_qrl_dir("wallet_ver1"): walletd = WalletD() qaddress = walletd.add_new_address(height=4) self.assertEqual(qaddress[0], 'Q') self.assertEqual(len(walletd.list_address()), 1) list_address = walletd.list_address() self.assertEqual(list_address[0], qaddress)
def test_get_measurement(self): def block(headerhash): nth_block = Block() if headerhash == b'test_block_1': nth_block.blockheader._data.timestamp_seconds = 50000 elif headerhash == b'test_block_2': nth_block.blockheader._data.timestamp_seconds = 80000 elif headerhash == b'test_block_3': nth_block.blockheader._data.timestamp_seconds = 90000 return nth_block with set_qrl_dir('no_data'): with State() as state: parent_metadata = BlockMetadata.create(block_difficulty=b'\x00' * 32, cumulative_difficulty=b'\x00' * 32, child_headerhashes=[]) measurement = state.get_measurement(block_timestamp=100000, parent_headerhash=b'', parent_metadata=parent_metadata) # Test Case, when count_headerhashes equals 0 self.assertEqual(measurement, config.dev.mining_setpoint_blocktime) state.get_block = MagicMock(side_effect=block) parent_metadata.update_last_headerhashes([], b'test_block_1') measurement = state.get_measurement(block_timestamp=100000, parent_headerhash=b'test_block_1', parent_metadata=parent_metadata) # Test Case, when count_headerhashes equals 1 self.assertEqual(measurement, (100000 - 50000 + config.dev.mining_setpoint_blocktime) // 2) parent_metadata.update_last_headerhashes([b'test_block_1'], b'test_block_2') measurement = state.get_measurement(block_timestamp=100000, parent_headerhash=b'test_block_2', parent_metadata=parent_metadata) # Test Case, when count_headerhashes is greater than 1 # but less than config.dev.N_measurement self.assertEqual(measurement, (100000 - 80000 + config.dev.mining_setpoint_blocktime) // 2) parent_metadata.update_last_headerhashes([b'test_block_3'] * config.dev.N_measurement, b'test_block_2') measurement = state.get_measurement(block_timestamp=100000, parent_headerhash=b'test_block_2', parent_metadata=parent_metadata) # Test Case, when count_headerhashes is greater than config.dev.N_measurement self.assertEqual(measurement, (100000 - 90000) // config.dev.N_measurement)
def test_basic_state_funcs(self): with set_qrl_dir('no_data'): with State() as state: alice_xmss = get_alice_xmss() self.assertTrue(state.get_address_is_used(alice_xmss.address)) self.assertEqual(state._return_all_addresses(), []) batch = state.batch self.assertIsNotNone(batch) state.write_batch(batch) self.assertEqual(state.total_coin_supply, 0)
def test_put(self, mock_dev_config): with set_qrl_dir('no_data'): state = State() p = PaginatedData(b'p_tx_hash', True, state._db) key = b'test_key' value = [b'hello world'] storage_key = p.generate_key(key, 11) p.put(storage_key, value, None) found_value = p.get_paginated_data(key, 11) self.assertEqual(value, found_value)
def test_getRecoverySeeds(self): with set_qrl_dir("wallet_ver1"): walletd = WalletD() service = WalletAPIService(walletd) service.AddAddressFromSeed(qrlwallet_pb2.AddAddressFromSeedReq(seed=self.mnemonic), context=None) resp = service.GetRecoverySeeds(qrlwallet_pb2.GetRecoverySeedsReq(address=self.qaddress), context=None) self.assertEqual(resp.hexseed, self.hex_seed) self.assertEqual(resp.mnemonic, self.mnemonic)
def test_create_custom_hash_function_load(self): with set_qrl_dir("no_data"): wallet = Wallet() xmss = wallet.add_new_address(height=4, hash_function="sha2_256") wallet.save() self.assertEqual("sha2_256", xmss.hash_function) wallet_reloaded = Wallet() self.assertEqual("sha2_256", wallet_reloaded.address_items[0].hashFunction)
def test_addNewAddressWithSlaves(self): with set_qrl_dir("wallet_ver1"): walletd = WalletD() walletd._public_stub.PushTransaction = Mock( return_value=qrl_pb2.PushTransactionResp(error_code=qrl_pb2.PushTransactionResp.SUBMITTED)) service = WalletAPIService(walletd) resp = service.AddNewAddressWithSlaves(qrlwallet_pb2.AddNewAddressWithSlavesReq(), context=None) self.assertEqual(resp.code, 0) self.assertEqual(resp.address[0], 'Q')
def test_get_ots(self): with set_qrl_dir("wallet_ver1"): walletd = WalletD() walletd._public_stub.GetOTS = Mock(return_value=qrl_pb2.GetOTSResp( ots_bitfield=[b'\x00'] * 10, next_unused_ots_index=1)) ots_bitfield, next_unused_ots_index = walletd.get_ots( self.qaddress) self.assertEqual(ots_bitfield, [b'\x00'] * 10) self.assertEqual(next_unused_ots_index, 1)
def test_encrypt_last_item(self): with set_qrl_dir("wallet_ver1"): walletd = WalletD() walletd.authenticate() walletd.add_new_address(height=4) self.assertFalse(walletd.get_wallet_info()[2]) walletd._passphrase = self.passphrase walletd._encrypt_last_item() self.assertTrue(walletd.get_wallet_info()[2])
def test_listAddresses(self): with set_qrl_dir("wallet_ver1"): walletd = WalletD() service = WalletAPIService(walletd) resp = service.AddNewAddress(qrlwallet_pb2.AddNewAddressReq(), context=None) address = resp.address resp = service.ListAddresses(qrlwallet_pb2.ListAddressesReq(), context=None) self.assertEqual(resp.addresses[0], address)
def test_addAddressFromSeed(self): with set_qrl_dir("wallet_ver1"): qaddress = "Q010400ff39df1ba4d1d5b8753e6d04c51c34b95b01fc3650c10ca7b296a18bdc105412c59d0b3b" hex_seed = "0104008441d43524996f76236141d16b7b324323abf796e77ad7c874622a82f5744bb803f9b404d25733d0db82be7ac6f3c4cf" walletd = WalletD() service = WalletAPIService(walletd) resp = service.AddAddressFromSeed(qrlwallet_pb2.AddAddressFromSeedReq(seed=hex_seed), context=None) self.assertEqual(resp.code, 0) self.assertEqual(resp.address, qaddress)
def test_get_token_metadata(self): with set_qrl_dir('no_data'): with State() as state: token_txhash = bytes(sha2_256(b'alpha')) token_metadata = TokenMetadata.create(token_txhash, [bytes(sha2_256(b'delta')), bytes(sha2_256(b'gamma'))]) state._db.get_raw = MagicMock(return_value=token_metadata.serialize()) self.assertEqual(state.get_token_metadata(token_txhash).to_json(), token_metadata.to_json())
def test_create_load(self): with set_qrl_dir("no_data"): wallet = Wallet() wallet.add_new_address(height=4) wallet_b = Wallet() self.assertEqual(1, len(wallet_b.address_items)) self.assertEqual(wallet.address_items[0], wallet_b.address_items[0])
def test_getWalletInfo(self): with set_qrl_dir("wallet_ver1"): walletd = WalletD() service = WalletAPIService(walletd) resp = service.GetWalletInfo(qrlwallet_pb2.GetWalletInfoReq(), context=None) self.assertEqual(resp.version, 1) self.assertEqual(resp.address_count, 0) self.assertFalse(resp.is_encrypted)
def setUp(self): with set_qrl_dir('no_data'): self.state = State() self.state.get_measurement = Mock(return_value=10000000) del GenesisBlock.instance # Removing Singleton instance self.genesis_block = GenesisBlock() self.chain_manager = ChainManager(self.state) self.chain_manager._difficulty_tracker = Mock()
def __init__(self, *args, **kwargs): super(TestTokenTransaction, self).__init__(*args, **kwargs) with set_qrl_dir('no_data'): self.state = State() self.alice = get_alice_xmss() self.bob = get_bob_xmss() self._decimals = 15 self.alice.set_ots_index(10) self.maxDiff = None
def test_read_wallet_ver0_saves_wallet_ver1(self): with set_qrl_dir("wallet_ver0"): wallet = Wallet() self.assertEqual(wallet.version, 0) wallet.version = 1 wallet.save() wallet_reloaded = Wallet() self.assertEqual(wallet_reloaded.version, 1)
def test_decrease_txn_count(self): with set_qrl_dir('no_data'): with State() as state: self.assertEqual(state.get_txn_count(b'q1'), 0) with self.assertRaises(ValueError): state._decrease_txn_count(0, b'q1') state._decrease_txn_count(5, b'q1') self.assertEqual(state.get_txn_count(b'q1'), 4)
def test_increase_txn_count(self): with set_qrl_dir('no_data'): with State() as state: self.assertEqual(state.get_txn_count(b'q1'), 0) state._increase_txn_count(0, b'q1') self.assertEqual(state.get_txn_count(b'q1'), 1) state._increase_txn_count(5, b'q1') self.assertEqual(state.get_txn_count(b'q1'), 6)
def test_put_paginated_data(self, mock_dev_config): with set_qrl_dir('no_data'): state = State() p = PaginatedData(b'p_tx_hash', True, state._db) alice_address_state = OptimizedAddressState.get_default( address=self.alice.address) for i in range(0, 10): p.insert( alice_address_state, b'p_tx_hash_' + i.to_bytes(8, byteorder='big', signed=False)) self.assertEqual( alice_address_state.get_counter_by_name(p.name), i + 1) p.put_paginated_data(None) self.assertEqual(alice_address_state.get_counter_by_name(p.name), 10) for i in range(10, 25): p.insert( alice_address_state, b'p_tx_hash_' + i.to_bytes(8, byteorder='big', signed=False)) self.assertEqual( alice_address_state.get_counter_by_name(p.name), i + 1) p.put_paginated_data(None) self.assertEqual(alice_address_state.get_counter_by_name(p.name), 25) self.assertEqual(len(p.key_value), 0) pages_data = [] for i in range(0, (25 // config.dev.data_per_page) + 1): data = p.get_paginated_data( self.alice.address, (i + 1) * config.dev.data_per_page - 1) pages_data.append(data) self.assertEqual(len(pages_data), 3) self.assertEqual(len(pages_data[0]), 10) for i in range(0, 10): self.assertEqual( pages_data[0][i], b'p_tx_hash_' + i.to_bytes(8, byteorder='big', signed=False)) self.assertEqual(len(pages_data[1]), 10) for i in range(10, 20): self.assertEqual( pages_data[1][i - 10], b'p_tx_hash_' + i.to_bytes(8, byteorder='big', signed=False)) self.assertEqual(len(pages_data[2]), 5) for i in range(20, 25): self.assertEqual( pages_data[2][i - 20], b'p_tx_hash_' + i.to_bytes(8, byteorder='big', signed=False))
def test_get_mainchain_height(self): with set_qrl_dir('no_data'): with State() as state: # Test Case: Check default value self.assertEqual(state.get_mainchain_height(), -1) state.update_mainchain_height(15, None) self.assertEqual(state.get_mainchain_height(), 15) state.update_mainchain_height(5, None) self.assertEqual(state.get_mainchain_height(), 5)