class BackupTestCase(unittest.TestCase):
def __init__(self, method_name='runTest'):
super().__init__(method_name)
init_test()
self.cli = HttpClient(f'/api/v2')
@staticmethod
def _subscribe():
HttpClient(f'/api/v2').put('/subscription/vault')
@classmethod
def setUpClass(cls):
cls._subscribe()
def test01_get_state(self):
r = self.cli.get('/vault-deprecated/content')
self.assertEqual(r.status_code, 200)
@unittest.skip
def test02_backup(self):
self.backup(self.cli.get_backup_credential())
@unittest.skip
def test03_restore(self):
self.restore(self.cli.get_backup_credential())
def backup(self, credential):
r = self.cli.post('/vault-deprecated/content?to=hive_node', body={'credential': credential})
self.assertEqual(r.status_code, 201)
def restore(self, credential):
r = self.cli.post('/vault-deprecated/content?from=hive_node', body={'credential': credential})
self.assertEqual(r.status_code, 201)
class AuthTestCase(unittest.TestCase):
def __init__(self, method_name='runTest'):
super().__init__(method_name)
init_test()
self.cli = HttpClient(f'/api/v2')
def test01_signin_invalid_parameter(self):
response = self.cli.post(f'/did/signin', body=dict(), need_token=False)
self.assertEqual(response.status_code, 400)
def test02_auth_invalid_parameter(self):
response = self.cli.post(f'/did/auth', body=dict(), need_token=False)
self.assertEqual(response.status_code, 400)
class PaymentTestCase(unittest.TestCase):
def __init__(self, method_name='runTest'):
super().__init__(method_name)
init_test()
self.cli = HttpClient(f'/api/v2/payment')
# TODO: update order_id when do separately testing
self.order_id = '60ee8c056fdd17b16bb5b4c2'
self.transaction_id = '280a24034bfb241c31b5a73c792c9d05df2b1f79bb98733c5358aeb909c27010'
@staticmethod
def _subscribe():
HttpClient(f'/api/v2').put('/subscription/vault')
@classmethod
def setUpClass(cls):
cls._subscribe()
def test01_get_version(self):
response = self.cli.get('/version')
self.assertEqual(response.status_code, 200)
self.assertTrue('version' in response.json())
@unittest.skip
def test02_place_order(self):
response = self.cli.put('/order',
body={
'subscription': 'vault',
'pricing_name': 'Rookie'
})
self.assertEqual(response.status_code, 200)
self.assertTrue('order_id' in response.json())
self.order_id = response.json().get('order_id')
@unittest.skip
def test03_pay_order(self):
response = self.cli.post(f'/order/{self.order_id}',
body={'transaction_id': self.transaction_id})
self.assertEqual(response.status_code, 201)
self.assertTrue('receipt_id' in response.json())
self.assertTrue('order_id' in response.json())
@unittest.skip
def test04_get_orders(self):
response = self.cli.get('/order?subscription=vault')
self.assertEqual(response.status_code, 200)
self.assertTrue('orders' in response.json())
@unittest.skip
def test05_get_receipt(self):
response = self.cli.get(f'/receipt?order_id={self.order_id}')
self.assertEqual(response.status_code, 200)
self.assertTrue('order_id' in response.json())
self.assertTrue('receipt_id' in response.json())
class IpfsBackupTestCase(unittest.TestCase):
def __init__(self, method_name='runTest'):
super().__init__(method_name)
init_test()
self.cli = HttpClient(f'/api/v2')
self.backup_cli = HttpClient(f'/api/v2', is_backup_node=True)
@staticmethod
def _subscribe_vault():
HttpClient(f'/api/v2').put('/subscription/vault')
@staticmethod
def _unsubscribe_vault_on_backup_node():
HttpClient(f'/api/v2', is_backup_node=True).delete('/subscription/vault')
@classmethod
def setUpClass(cls):
cls._subscribe_vault()
def test01_subscribe(self):
response = self.backup_cli.put('/subscription/backup')
self.assertTrue(response.status_code in [200, 455])
def test02_get_info(self):
response = self.backup_cli.get('/subscription/backup')
self.assertEqual(response.status_code, 200)
def test03_backup(self):
r = self.cli.post('/vault/content?to=hive_node',
body={'credential': self.cli.get_backup_credential()})
self.assertEqual(r.status_code, 201)
time.sleep(10)
def test03_backup_invalid_parameter(self):
r = self.cli.post('/vault/content?to=hive_node')
self.assertEqual(r.status_code, 400)
@unittest.skip
def test03_backup_force(self):
r = self.cli.post('/vault/content?to=hive_node&is_force=true',
body={'credential': self.cli.get_backup_credential()})
self.assertEqual(r.status_code, 201)
def test04_state(self):
r = self.cli.get('/vault/content')
self.assertEqual(r.status_code, 200)
def test05_restore(self):
r = self.cli.post('/vault/content?from=hive_node',
body={'credential': self.cli.get_backup_credential()})
self.assertEqual(r.status_code, 201)
time.sleep(10)
def test05_restore_invalid_parameter(self):
r = self.cli.post('/vault/content?from=hive_node')
self.assertEqual(r.status_code, 400)
@unittest.skip
def test05_restore_force(self):
r = self.cli.post('/vault/content?from=hive_node&is_force=true',
body={'credential': self.cli.get_backup_credential()})
self.assertEqual(r.status_code, 201)
@unittest.skip
def test06_promotion(self):
# PREPARE: backup and remove the vault for local test.
self.__class__._unsubscribe_vault_on_backup_node()
# do promotion.
r = self.backup_cli.post('/backup/promotion')
self.assertEqual(r.status_code, 201)
# check the vault state.
response = self.backup_cli.get('/subscription/vault')
self.assertEqual(response.status_code, 200)
@unittest.skip
def test07_unsubscribe(self):
response = self.backup_cli.delete('/subscription/backup')
self.assertEqual(response.status_code, 204)
self.__class__._unsubscribe_vault_on_backup_node()
class DatabaseTestCase(unittest.TestCase):
def __init__(self, method_name='runTest'):
super().__init__(method_name)
init_test()
self.cli = HttpClient(f'/api/v2/vault')
self.collection_name = 'test_collection'
@staticmethod
def _subscribe():
HttpClient(f'/api/v2').put('/subscription/vault')
@classmethod
def setUpClass(cls):
cls._subscribe()
def test01_create_collection(self):
response = self.cli.put(f'/db/collections/{self.collection_name}')
self.assertTrue(response.status_code in [200, 455])
if response.status_code == 200:
self.assertEqual(response.json().get('name'), self.collection_name)
def test02_insert_document(self):
response = self.cli.post(f'/db/collection/{self.collection_name}',
body={
"document": [{
"author": "john doe1",
"title": "Eve for Dummies1"
}, {
"author": "john doe1",
"title": "Eve for Dummies1"
}, {
"author": "john doe2",
"title": "Eve for Dummies2"
}, {
"author": "john doe2",
"title": "Eve for Dummies2"
}],
"options": {
"bypass_document_validation": False,
"ordered": True
}
})
self.assertEqual(response.status_code, 201)
self.assertEqual(len(response.json().get('inserted_ids')), 4)
def test02_insert_document_invalid_parameter(self):
response = self.cli.post(f'/db/collection/{self.collection_name}')
self.assertEqual(response.status_code, 400)
def test03_update_document(self):
response = self.cli.patch(f'/db/collection/{self.collection_name}',
body={
"filter": {
"author": "john doe1",
},
"update": {
"$set": {
"author": "john doe1_1",
"title": "Eve for Dummies1_1"
}
},
"options": {
"upsert": True,
"bypass_document_validation": False
}
})
self.assertEqual(response.status_code, 200)
self.assertEqual(response.json().get('matched_count'), 2)
def test03_update_document_invalid_parameter(self):
response = self.cli.patch(f'/db/collection/{self.collection_name}')
self.assertEqual(response.status_code, 400)
def test03_update_one_document(self):
response = self.cli.patch(
f'/db/collection/{self.collection_name}?updateone=true',
body={
"filter": {
"author": "john doe1_1",
},
"update": {
"$set": {
"author": "john doe1_2",
"title": "Eve for Dummies1_2"
}
},
"options": {
"upsert": True,
"bypass_document_validation": False
}
})
self.assertEqual(response.status_code, 200)
self.assertEqual(response.json().get('matched_count'), 1)
def test04_count_document(self):
response = self.cli.post(
f'/db/collection/{self.collection_name}?op=count',
body={
"filter": {
"author": "john doe2",
},
"options": {
"skip": 0,
"limit": 10,
"maxTimeMS": 1000000000
}
})
self.assertEqual(response.status_code, 201)
self.assertEqual(response.json().get('count'), 2)
def test04_count_document_invalid_parameter(self):
response = self.cli.post(
f'/db/collection/{self.collection_name}?op=count')
self.assertEqual(response.status_code, 400)
def test05_find_document(self):
response = self.cli.get(f'/db/{self.collection_name}' +
'?filter={"author":"john doe2"}&skip=0')
self.assertEqual(response.status_code, 200)
self.assertTrue('items' in response.json())
def test05_find_document_invalid_parameter(self):
response = self.cli.get(f'/db/{self.collection_name}' +
'?filter=&skip=')
self.assertEqual(response.status_code, 400)
def test06_query_document(self):
response = self.cli.post(f'/db/query',
body={
"collection": self.collection_name,
"filter": {
"author": "john doe2",
},
"options": {
"skip": 0,
"limit": 3,
"projection": {
"_id": False
},
'sort': [('_id', pymongo.DESCENDING)],
"allow_partial_results": False,
"return_key": False,
"show_record_id": False,
"batch_size": 0
}
})
self.assertEqual(response.status_code, 201)
self.assertTrue('items' in response.json())
def test06_query_document_invalid_parameter(self):
response = self.cli.post(f'/db/query')
self.assertEqual(response.status_code, 400)
def test07_delete_one_document(self):
response = self.cli.delete(
f'/db/collection/{self.collection_name}?deleteone=true',
body={"filter": {
"author": "john doe1_2",
}},
is_json=True)
self.assertEqual(response.status_code, 204)
def test07_delete_one_document_invalid_parameter(self):
response = self.cli.delete(
f'/db/collection/{self.collection_name}?deleteone=true')
self.assertEqual(response.status_code, 400)
def test07_delete_document(self):
response = self.cli.delete(f'/db/collection/{self.collection_name}',
body={"filter": {
"author": "john doe2",
}},
is_json=True)
self.assertEqual(response.status_code, 204)
def test08_delete_collection(self):
self.__delete_collection()
def __delete_collection(self):
response = self.cli.delete(f'/db/{self.collection_name}')
self.assertEqual(response.status_code, 204)
