class TestValidateWallet(unittest.TestCase): def setUp(self): self.testnet_api = BtcTxStore(dryrun=True, testnet=True) self.mainnet_api = BtcTxStore(dryrun=True, testnet=False) self.testnet_wallet = self.testnet_api.create_wallet() self.mainnet_wallet = self.mainnet_api.create_wallet() self.testnet_key = self.testnet_api.get_key(self.testnet_wallet) self.mainnet_key = self.mainnet_api.get_key(self.mainnet_wallet) def test_checks_networks(self): self.assertTrue(self.testnet_api.validate_wallet(self.testnet_wallet)) self.assertTrue(self.mainnet_api.validate_wallet(self.mainnet_wallet)) self.assertFalse(self.testnet_api.validate_wallet(self.mainnet_wallet)) self.assertFalse(self.mainnet_api.validate_wallet(self.testnet_wallet)) def test_doesnt_validate_keys(self): self.assertFalse(self.testnet_api.validate_wallet(self.testnet_key)) self.assertFalse(self.mainnet_api.validate_wallet(self.testnet_key)) self.assertFalse(self.testnet_api.validate_wallet(self.mainnet_key)) self.assertFalse(self.mainnet_api.validate_wallet(self.mainnet_key)) def test_correct_types(self): self.assertTrue(self.testnet_api.validate_wallet(S_HWIF)) self.assertTrue(self.testnet_api.validate_wallet(B_HWIF)) self.assertTrue(self.testnet_api.validate_wallet(U_HWIF))
class AppAuthenticationHeadersTest(unittest.TestCase): def setUp(self): app.config["SKIP_AUTHENTICATION"] = False # monkey patch self.app = app.test_client() self.btctxstore = BtcTxStore() db.create_all() def tearDown(self): db.session.remove() db.drop_all() def test_success(self): # create header date and authorization signature wif = self.btctxstore.create_key() btc_addr = self.btctxstore.get_address(wif) header_date = formatdate(timeval=mktime(datetime.now().timetuple()), localtime=True, usegmt=True) message = app.config["ADDRESS"] + " " + header_date header_authorization = self.btctxstore.sign_unicode(wif, message) headers = {"Date": header_date, "Authorization": header_authorization} url = '/api/register/{0}'.format(btc_addr) rv = self.app.get(url, headers=headers) data = json.loads(rv.data.decode("utf-8")) self.assertEqual(btc_addr, data["btc_addr"]) self.assertEqual(rv.status_code, 200) def test_fail(self): # register without auth headres fails btc_addr = self.btctxstore.get_address(self.btctxstore.get_key(self.btctxstore.create_wallet())) rv = self.app.get('/api/register/{0}'.format(btc_addr)) self.assertEqual(rv.status_code, 401) # register first because ping is lazy wif = self.btctxstore.get_key(self.btctxstore.create_wallet()) btc_addr = self.btctxstore.get_address(wif) header_date = formatdate(timeval=mktime(datetime.now().timetuple()), localtime=True, usegmt=True) message = app.config["ADDRESS"] + " " + header_date header_authorization = self.btctxstore.sign_unicode(wif, message) headers = {"Date": header_date, "Authorization": header_authorization} url = '/api/register/{0}'.format(btc_addr) rv = self.app.get(url, headers=headers) self.assertEqual(rv.status_code, 200) # ping without auth headres fails time.sleep(app.config["MAX_PING"]) rv = self.app.get('/api/ping/{0}'.format(btc_addr)) self.assertEqual(rv.status_code, 401) # set height without auth headres fails btc_addr = self.btctxstore.get_address(self.btctxstore.get_key(self.btctxstore.create_wallet())) rv = self.app.get('/api/height/{0}/10'.format(btc_addr)) self.assertEqual(rv.status_code, 401)
class TestGetWalletKey(unittest.TestCase): def setUp(self): self.api = BtcTxStore(dryrun=True, testnet=True) def test_standard(self): hwif = self.api.create_wallet() wif = self.api.get_key(hwif) self.assertTrue(validate.is_wif_valid(wif, allowable_netcodes=['XTN'])) def test_input_validation(self): # test correct types a = self.api.get_key(S_HWIF) b = self.api.get_key(B_HWIF) c = self.api.get_key(U_HWIF) self.assertEqual(a, b, c) # TODO invalid types # TODO invalid input data def test_standards_compliant(self): pass # FIXME check generated against expected output from 3rd parties
class FarmerUpTime(unittest.TestCase): def setUp(self): app.config["SKIP_AUTHENTICATION"] = True # monkey patch app.config["DISABLE_CACHING"] = True self.btctxstore = BtcTxStore() db.create_all() def tearDown(self): db.session.remove() db.drop_all() def test_register(self): btc_addr = self.btctxstore.get_address( self.btctxstore.get_key(self.btctxstore.create_wallet())) farmer = Farmer(btc_addr) farmer.register() test_json = { "height": 0, "btc_addr": btc_addr, 'payout_addr': btc_addr, "last_seen": 0, "uptime": 100 } call_payload = json.loads(farmer.to_json()) call_payload["uptime"] = round(call_payload["uptime"]) self.assertEqual(test_json, call_payload) # reg_time = max online time -> 100% uptime delta = timedelta(minutes=app.config["ONLINE_TIME"]) farmer.last_seen = datetime.utcnow() - delta farmer.reg_time = datetime.utcnow() - delta test_json = { "height": 0, "btc_addr": btc_addr, 'payout_addr': btc_addr, "last_seen": delta.seconds, "uptime": 100 } call_payload = json.loads(farmer.to_json()) call_payload["uptime"] = round(call_payload["uptime"]) self.assertEqual(test_json, call_payload) # reg_time = 2 * max online time -> 50% uptime delta = timedelta(minutes=(2 * app.config["ONLINE_TIME"])) farmer.last_seen = datetime.utcnow() - delta farmer.reg_time = datetime.utcnow() - delta farmer.ping() test_json = { "height": 0, "btc_addr": btc_addr, 'payout_addr': btc_addr, "last_seen": 0, "uptime": 50 } call_payload = json.loads(farmer.to_json()) call_payload["uptime"] = round(call_payload["uptime"]) self.assertEqual(test_json, call_payload) def test_ping_100(self): btc_addr = self.btctxstore.get_address( self.btctxstore.get_key(self.btctxstore.create_wallet())) farmer = Farmer(btc_addr) farmer.register() # lastest ping for 100% delta = timedelta(minutes=app.config["ONLINE_TIME"]) farmer.last_seen = datetime.utcnow() - delta farmer.reg_time = datetime.utcnow() - delta farmer.ping() test_json = { "height": 0, "btc_addr": btc_addr, 'payout_addr': btc_addr, "last_seen": 0, "uptime": 100 } call_payload = json.loads(farmer.to_json()) call_payload["uptime"] = round(call_payload["uptime"]) self.assertEqual(test_json, call_payload) def test_ping_50(self): btc_addr = self.btctxstore.get_address( self.btctxstore.get_key(self.btctxstore.create_wallet())) farmer = Farmer(btc_addr) farmer.register() # lastest ping for 100% delta = timedelta(minutes=(2 * app.config["ONLINE_TIME"])) farmer.last_seen = datetime.utcnow() - delta farmer.reg_time = datetime.utcnow() - delta farmer.ping() test_json = { "height": 0, "btc_addr": btc_addr, 'payout_addr': btc_addr, "last_seen": 0, "uptime": 50 } call_payload = json.loads(farmer.to_json()) call_payload["uptime"] = round(call_payload["uptime"]) self.assertEqual(test_json, call_payload) def test_ping_25(self): btc_addr = self.btctxstore.get_address( self.btctxstore.get_key(self.btctxstore.create_wallet())) farmer = Farmer(btc_addr) farmer.register() # ping to late -> 50% delta = timedelta(minutes=(4 * app.config["ONLINE_TIME"])) farmer.last_seen = datetime.utcnow() - delta farmer.reg_time = datetime.utcnow() - delta farmer.ping() test_json = { "height": 0, "btc_addr": btc_addr, 'payout_addr': btc_addr, "last_seen": 0, "uptime": 25 } call_payload = json.loads(farmer.to_json()) call_payload["uptime"] = round(call_payload["uptime"]) self.assertEqual(test_json, call_payload) def test_ping_days(self): btc_addr = self.btctxstore.get_address( self.btctxstore.get_key(self.btctxstore.create_wallet())) farmer = Farmer(btc_addr) farmer.register() # ping to late -> 50% delta = timedelta(days=2) farmer.last_seen = datetime.utcnow() - delta farmer.reg_time = datetime.utcnow() - delta farmer.uptime = 86401 # 1 / 2 days farmer was online farmer.ping() test_json = { "height": 0, "btc_addr": btc_addr, 'payout_addr': btc_addr, "last_seen": 0, "uptime": 50 } call_payload = json.loads(farmer.to_json()) call_payload["uptime"] = round(call_payload["uptime"]) self.assertEqual(test_json, call_payload) def test_height_100(self): btc_addr = self.btctxstore.get_address( self.btctxstore.get_key(self.btctxstore.create_wallet())) farmer = Farmer(btc_addr) farmer.register() # lastest ping for 100% delta = timedelta(minutes=app.config["ONLINE_TIME"]) farmer.last_seen = datetime.utcnow() - delta farmer.reg_time = datetime.utcnow() - delta farmer.set_height(100) test_json = { "height": 100, "btc_addr": btc_addr, 'payout_addr': btc_addr, "last_seen": 0, "uptime": 100 } call_payload = json.loads(farmer.to_json()) call_payload["uptime"] = round(call_payload["uptime"]) self.assertEqual(test_json, call_payload) def test_height_50(self): btc_addr = self.btctxstore.get_address( self.btctxstore.get_key(self.btctxstore.create_wallet())) farmer = Farmer(btc_addr) farmer.register() # lastest ping for 100% delta = timedelta(minutes=(2 * app.config["ONLINE_TIME"])) farmer.last_seen = datetime.utcnow() - delta farmer.reg_time = datetime.utcnow() - delta farmer.set_height(50) test_json = { "height": 50, "btc_addr": btc_addr, 'payout_addr': btc_addr, "last_seen": 0, "uptime": 50 } call_payload = json.loads(farmer.to_json()) call_payload["uptime"] = round(call_payload["uptime"]) self.assertEqual(test_json, call_payload) def test_height_25(self): btc_addr = self.btctxstore.get_address( self.btctxstore.get_key(self.btctxstore.create_wallet())) farmer = Farmer(btc_addr) farmer.register() #ping to late -> 50% delta = timedelta(minutes=(4 * app.config["ONLINE_TIME"])) farmer.last_seen = datetime.utcnow() - delta farmer.reg_time = datetime.utcnow() - delta farmer.set_height(25) test_json = { "height": 25, "btc_addr": btc_addr, 'payout_addr': btc_addr, "last_seen": 0, "uptime": 25 } call_payload = json.loads(farmer.to_json()) call_payload["uptime"] = round(call_payload["uptime"]) self.assertEqual(test_json, call_payload)
class FarmerTest(unittest.TestCase): def setUp(self): app.config["SKIP_AUTHENTICATION"] = True # monkey patch app.config["DISABLE_CACHING"] = True self.btctxstore = BtcTxStore() self.bad_addr = 'notvalidaddress' db.create_all() def tearDown(self): db.session.remove() db.drop_all() def test_repr(self): farmer = Farmer('191GVvAaTRxLmz3rW3nU5jAV1rF186VxQc') ans = "<Farmer BTC Address: '191GVvAaTRxLmz3rW3nU5jAV1rF186VxQc'>" self.assertEqual(repr(farmer), ans) def test_sha256(self): an = 'c059c8035bbd74aa81f4c787c39390b57b974ec9af25a7248c46a3ebfe0f9dc8' self.assertEqual(sha256("storj"), an) self.assertNotEqual(sha256("not storj"), an) def test_register(self): # test success btc_addr = self.btctxstore.get_address( self.btctxstore.get_key(self.btctxstore.create_wallet())) farmer1 = Farmer(btc_addr) self.assertFalse(farmer1.exists()) farmer1.register() self.assertTrue(farmer1.exists()) # test duplicate error self.assertRaises(LookupError, farmer1.register) def callback_a(): Farmer(self.bad_addr) self.assertRaises(ValueError, callback_a) def test_ping(self): btc_addr = self.btctxstore.get_address( self.btctxstore.get_key(self.btctxstore.create_wallet())) farmer = Farmer(btc_addr) # test ping before registration self.assertRaises(LookupError, farmer.ping) # register farmer farmer.register() # get register time, and make sure the ping work register_time = farmer.last_seen # ping faster than max_ping would be ignored time.sleep(app.config["MAX_PING"] + 1) farmer.ping() # update last seen ping_time = farmer.last_seen self.assertTrue(register_time < ping_time) def test_ping_time_limit(self): btc_addr = self.btctxstore.get_address( self.btctxstore.get_key(self.btctxstore.create_wallet())) farmer = Farmer(btc_addr) farmer.register() register_time = farmer.last_seen time.sleep(2) farmer.ping() # should still be around 0 delta_seconds = int((farmer.last_seen - register_time).seconds) self.assertEqual(delta_seconds, 0) def test_height(self): btc_addr = self.btctxstore.get_address( self.btctxstore.get_key(self.btctxstore.create_wallet())) farmer = Farmer(btc_addr) farmer.register() # set height and check function output self.assertEqual(farmer.height, 0) self.assertEqual(farmer.set_height(5), 5) self.assertEqual(farmer.height, 5) # check the db object as well farmer2 = farmer.lookup() self.assertEqual(farmer2.height, 5) def test_audit(self): btc_addr = self.btctxstore.get_address( self.btctxstore.get_key(self.btctxstore.create_wallet())) farmer = Farmer(btc_addr) # test audit before registration self.assertRaises(LookupError, farmer.audit) # register farmer farmer.register() # get register time, and make sure the ping work register_time = farmer.last_seen # ping faster than max_ping would be ignored time.sleep(app.config["MAX_PING"] + 1) farmer.audit() ping_time = farmer.last_seen self.assertTrue(register_time < ping_time) def test_to_json(self): btc_addr = self.btctxstore.get_address( self.btctxstore.get_key(self.btctxstore.create_wallet())) farmer = Farmer(btc_addr) farmer.register() farmer.ping() farmer.set_height(50) test_json = { "height": 50, "btc_addr": btc_addr, 'payout_addr': btc_addr, "last_seen": 0, "uptime": 100 } call_payload = json.loads(farmer.to_json()) self.assertEqual(test_json, call_payload)
class TestCreateWallet(unittest.TestCase): def setUp(self): self.api = BtcTxStore(dryrun=True, testnet=True) def test_standard(self): hwif = self.api.create_wallet() self.assertTrue(validate.is_private_bip32_valid( hwif, allowable_netcodes=['XTN'] )) def test_random(self): a = self.api.create_wallet() b = self.api.create_wallet() self.assertTrue(a != b) def test_master_secret(self): a = self.api.create_wallet(master_secret="foo") b = self.api.create_wallet(master_secret="foo") self.assertEqual(a, b) def test_input_validation(self): # correct types a = self.api.create_wallet(master_secret="foo") b = self.api.create_wallet(master_secret=b"foo") c = self.api.create_wallet(master_secret=u"foo") self.assertEqual(a, b, c) self.assertTrue(self.api.create_wallet(master_secret="üöä") != None) self.assertTrue(self.api.create_wallet(master_secret=u"üöä") != None) # incorrect types def callback(): self.api.create_wallet(master_secret=None) self.assertRaises(exceptions.InvalidInput, callback) def callback(): self.api.create_wallet(master_secret=1) self.assertRaises(exceptions.InvalidInput, callback) def callback(): self.api.create_wallet(master_secret=object()) self.assertRaises(exceptions.InvalidInput, callback) def test_standards_compliant(self): pass # FIXME check generated against expected output from 3rd parties
import storjnode import time from crochet import setup setup() # isolate swarm bootstrap_nodes = [("127.0.0.1", 1337)] # Create nodes. node_no = 2 nodes = [] for i in range(0, node_no): # Create node. btctxstore = BtcTxStore(testnet=False) node = storjnode.network.Node( btctxstore.create_wallet(), port=1339 + i, ksize=8, bootstrap_nodes=[("127.0.0.1", 1337)], refresh_neighbours_interval=0.0, store_config={tempfile.mkdtemp(): None}, nat_type="preserving", node_type="passive", wan_ip=get_wan_ip(), passive_port=10500 + i, disable_data_transfer=False, simulate_dht=True ) # Record node. nodes.append(node)
class Client(object): def __init__(self, url=common.DEFAULT_URL, debug=False, max_size=common.DEFAULT_MAX_SIZE, store_path=common.DEFAULT_STORE_PATH, config_path=common.DEFAULT_CONFIG_PATH, set_master_secret=None, set_payout_address=None, connection_retry_limit=common.DEFAULT_CONNECTION_RETRY_LIMIT, connection_retry_delay=common.DEFAULT_CONNECTION_RETRY_DELAY): # FIXME validate master_secret self.url = url self.config = None # lazy self.messanger = None # lazy self.debug = debug # TODO validate self.retry_limit = deserialize.positive_integer(connection_retry_limit) self.retry_delay = deserialize.positive_integer(connection_retry_delay) self.max_size = deserialize.byte_count(max_size) # paths self.config_path = os.path.realpath(config_path) # TODO validate self._ensure_path_exists(os.path.dirname(self.config_path)) self.store_path = os.path.realpath(store_path) self._ensure_path_exists(self.store_path) # validate payout address self.btctxstore = BtcTxStore() if set_payout_address and (not self.btctxstore.validate_address(set_payout_address)): raise exceptions.InvalidAddress(set_payout_address) self._initialize_config(set_master_secret, set_payout_address) def _initialize_config(self, set_master_secret, set_payout_address): if os.path.exists(self.config_path): self._load_config() else: # initialize config if not set_master_secret: # create random master secret secret_data = base64.b64encode(os.urandom(256)) set_master_secret = secret_data.decode('utf-8') if not set_payout_address: # use root address if not given set_payout_address = self._get_root_address(set_master_secret) if set_master_secret or set_payout_address: self.config = { "version": __version__, "master_secret": set_master_secret, "payout_address": set_payout_address, } config.save(self.config_path, self.config) def _ensure_path_exists(self, path): if not os.path.exists(path): os.makedirs(path) def _load_config(self): if self.config is None: if not os.path.exists(self.config_path): raise exceptions.ConfigNotFound(self.config_path) self.config = config.load(self.config_path) def _get_root_wif(self, master_secret): master_secret = base64.b64decode(master_secret) hwif = self.btctxstore.create_wallet(master_secret=master_secret) return self.btctxstore.get_key(hwif) def _get_root_address(self, master_secret): wif = self._get_root_wif(master_secret) return self.btctxstore.get_address(wif) def _init_messanger(self): if self.messanger is None: wif = self._get_root_wif(self.config["master_secret"]) self.messanger = messaging.Messaging(self.url, wif, self.retry_limit, self.retry_delay) def version(self): print(__version__) return __version__ def register(self): """Attempt to register the config address.""" self._init_messanger() registered = self.messanger.register(self.config["payout_address"]) auth_addr = self.messanger.auth_address() if registered: print("Address {0} now registered on {1}.".format(auth_addr, self.url)) else: print("Failed to register address {0} on {1}.".format(auth_addr, self.url)) return True def show_config(self): """Display saved config.""" print(json.dumps(self.config, indent=2)) return self.config def ping(self): """Attempt keep-alive with the server.""" self._init_messanger() print("Pinging {0} with address {1}.".format( self.messanger.server_url(), self.messanger.auth_address())) self.messanger.ping() return True def poll(self, register_address=False, delay=common.DEFAULT_DELAY, limit=None): """TODO doc string""" stop_time = _now() + timedelta(seconds=int(limit)) if limit else None if register_address: self.register() while True: self.ping() if stop_time and _now() >= stop_time: return True time.sleep(int(delay)) def build(self, cleanup=False, rebuild=False, set_height_interval=common.DEFAULT_SET_HEIGHT_INTERVAL): """TODO doc string""" self._init_messanger() def _on_generate_shard(height, seed, file_hash): first = height == 1 set_height = (height % set_height_interval) == 0 last = (int(self.max_size / common.SHARD_SIZE) + 1) == height if first or set_height or last: self.messanger.height(height) bldr = builder.Builder(self.config["payout_address"], common.SHARD_SIZE, self.max_size, debug=self.debug, on_generate_shard=_on_generate_shard) generated = bldr.build(self.store_path, cleanup=cleanup, rebuild=rebuild) height = len(generated) self.messanger.height(height) return generated
class TestCreateWallet(unittest.TestCase): def setUp(self): self.api = BtcTxStore(dryrun=True, testnet=True) def test_standard(self): hwif = self.api.create_wallet() self.assertTrue( validate.is_private_bip32_valid(hwif, allowable_netcodes=['XTN'])) def test_random(self): a = self.api.create_wallet() b = self.api.create_wallet() self.assertTrue(a != b) def test_master_secret(self): a = self.api.create_wallet(master_secret="foo") b = self.api.create_wallet(master_secret="foo") self.assertEqual(a, b) def test_input_validation(self): # correct types a = self.api.create_wallet(master_secret="foo") b = self.api.create_wallet(master_secret=b"foo") c = self.api.create_wallet(master_secret=u"foo") self.assertEqual(a, b, c) self.assertTrue(self.api.create_wallet(master_secret="üöä") != None) self.assertTrue(self.api.create_wallet(master_secret=u"üöä") != None) # incorrect types def callback(): self.api.create_wallet(master_secret=None) self.assertRaises(exceptions.InvalidInput, callback) def callback(): self.api.create_wallet(master_secret=1) self.assertRaises(exceptions.InvalidInput, callback) def callback(): self.api.create_wallet(master_secret=object()) self.assertRaises(exceptions.InvalidInput, callback) def test_standards_compliant(self): pass # FIXME check generated against expected output from 3rd parties
class TestConfig(unittest.TestCase): def setUp(self): self.btctxstore = BtcTxStore() def test_roundtrip_unencrypted(self): path = tempfile.mktemp() saved_data = config.create(self.btctxstore, path) loaded_data = config.get(self.btctxstore, path) self.assertEqual(saved_data, loaded_data) os.remove(path) def test_save_overwrites(self): path = tempfile.mktemp() # create config created_data = config.create(self.btctxstore, path) # update config updated_data = copy.deepcopy(created_data) updated_data["payout_address"] = "1A8WqiJDh3tGVeEefbMN5BVDYxx2XSoWgG" config.save(self.btctxstore, path, updated_data) # confirm overwriten loaded_data = config.get(self.btctxstore, path) self.assertEqual(updated_data, loaded_data) os.remove(path) def test_password_validation(self): pass # TODO implement def test_validation(self): wallet = self.btctxstore.create_wallet() key = self.btctxstore.get_key(wallet) address = self.btctxstore.get_address(key) # must be a dict def callback(): config.validate(self.btctxstore, None) self.assertRaises(exceptions.InvalidConfig, callback) # must have the correct version def callback(): config.validate(self.btctxstore, { "payout_address": address, "wallet": wallet, }) self.assertRaises(exceptions.InvalidConfig, callback) # must have a valid payout address def callback(): config.validate(self.btctxstore, { "version": __version__, "wallet": wallet, }) self.assertRaises(exceptions.InvalidConfig, callback) # must have a valid wallet def callback(): config.validate(self.btctxstore, { "version": __version__, "payout_address": address, }) self.assertRaises(exceptions.InvalidConfig, callback) # valid config self.assertTrue( config.validate( self.btctxstore, { "version": __version__, "payout_address": address, "wallet": wallet, })) def test_migrate(self): path = tempfile.mktemp() # initial unmigrated 2.0.0 config cfg = { "version": "2.0.0", "master_secret": "test_master_secret", "payout_address": "1A8WqiJDh3tGVeEefbMN5BVDYxx2XSoWgG", } # test its invalid with current build def callback(): config.validate(self.btctxstore, cfg) self.assertRaises(exceptions.InvalidConfig, callback) # migrate cfg = config.migrate(self.btctxstore, path, cfg) # test its now valid self.assertTrue(config.validate(self.btctxstore, cfg))