def setUp(self):
self.api = MarketAPI(MarketDatabase(MemoryBackend()))
mock = Mock()
self.api.community = mock
mock.send_api_message_candidate.return_value = True
mock.send_api_message_community.return_value = True
def __init__(self, *argv):
QApplication.__init__(self, *argv)
from market.api.api import MarketAPI
from market.database.database import MarketDatabase
from market.database.backends import MemoryBackend
from market.models.user import User
from market.models.role import Role
self._api = MarketAPI(MarketDatabase(MemoryBackend()))
# Create users
user, _, _ = self._api.create_user()
bank_role = Role.FINANCIAL_INSTITUTION.value
bank1, _, _ = self._api.create_user()
bank2, _, _ = self._api.create_user()
bank3, _, _ = self._api.create_user()
bank4, _, _ = self._api.create_user()
bank1.role_id = bank_role
bank2.role_id = bank_role
bank3.role_id = bank_role
bank4.role_id = bank_role
self._api.db.put(User.type, bank1.id, bank1)
self._api.db.put(User.type, bank2.id, bank2)
self._api.db.put(User.type, bank3.id, bank3)
self._api.db.put(User.type, bank4.id, bank4)
self.user = user
self.bank1 = bank1
self.bank2 = bank2
self.bank3 = bank3
self.bank4 = bank4
def setUp(self):
# Faking IOThread
registerAsIOThread()
# Object creation and preperation
self.dispersy = Dispersy(ManualEnpoint(0),
unicode("dispersy_temporary"))
self.api = MarketAPI(MarketDatabase(MemoryBackend()))
self.api.db.backend.clear()
user, _, priv = self.api.create_user()
self.bank, _, _ = self.api.create_user()
self.user = user
self.private_key = priv
self.dispersy._database.open()
self.master_member = DummyMember(self.dispersy, 1, "a" * 20)
self.member = self.dispersy.get_member(
private_key=self.private_key.decode("HEX"))
self.community = MortgageMarketCommunity.init_community(
self.dispersy, self.master_member, self.member)
self.community.api = self.api
self.community.user = self.user
self.api.community = self.community
# Add our conversion to the community.
self.conversion = MortgageMarketConversion(self.community)
self.community._conversions = []
self.community.add_conversion(self.conversion)
self.setupModels()
def initialize_api(self):
from market.api.api import MarketAPI
from market.database.database import MarketDatabase
from market.database.backends import PersistentBackend
self._api = MarketAPI(
MarketDatabase(
PersistentBackend(
'.', u'sqlite/%s-market.db' % self.database_prefix)))
def setUp(self):
self.api = MarketAPI(MarketDatabase(MemoryBackend()))
mock = Mock()
self.api.community = mock
self.api.incoming_queue.assign_message_handlers(mock)
mock.on_loan_request_receive.return_value = True
mock.on_loan_request_reject.return_value = True
mock.on_mortgage_accept_signed.return_value = True
mock.on_mortgage_accept_unsigned.return_value = True
mock.on_investment_accept.return_value = True
mock.on_mortgage_reject.return_value = True
mock.on_investment_reject.return_value = True
mock.on_mortgage_offer.return_value = True
mock.on_investment_offer.return_value = True
def setUp(self):
self.db = MarketDatabase(MemoryBackend())
self.api = MarketAPI(self.db)
self.db.backend.set_option('user_key_pub', "3081a7301006072a8648ce3d020106052b810400270381920004040a3d5712482be45375958745cdd3134ff079303bcf0ecf02ff6dff5b49cfde221a4068f1a243e31ba36052ed4836c77df8c1729cb9875ed703b23ccc9488f0b81ddba6e51b1caa01bc4e4c0152554c38b805ae6d9fb9d0a20172266b814a4f20e5ced5eb8f657c521b76dc6c10eb695444d69db8426a39232bd3e166eb22bcb7704642ca26a276774dc13d249b9e29")
self.db.backend.set_option('user_key_priv', "3081ee0201010448017a656efdf1a6203fee24074e8e9aba1c329563321bbb17ddc069fccee0b9b5e5b505f4ac2131760b82cfb56301cac7a00341c812b7ae6b4867910c5ac8d4c23152ccaf64ba7956a00706052b81040027a181950381920004040a3d5712482be45375958745cdd3134ff079303bcf0ecf02ff6dff5b49cfde221a4068f1a243e31ba36052ed4836c77df8c1729cb9875ed703b23ccc9488f0b81ddba6e51b1caa01bc4e4c0152554c38b805ae6d9fb9d0a20172266b814a4f20e5ced5eb8f657c521b76dc6c10eb695444d69db8426a39232bd3e166eb22bcb7704642ca26a276774dc13d249b9e29")
class ModelTestSuite(unittest.TestCase):
def setUp(self):
self.db = MarketDatabase(MemoryBackend())
self.api = MarketAPI(self.db)
self.db.backend.set_option('user_key_pub', "3081a7301006072a8648ce3d020106052b810400270381920004040a3d5712482be45375958745cdd3134ff079303bcf0ecf02ff6dff5b49cfde221a4068f1a243e31ba36052ed4836c77df8c1729cb9875ed703b23ccc9488f0b81ddba6e51b1caa01bc4e4c0152554c38b805ae6d9fb9d0a20172266b814a4f20e5ced5eb8f657c521b76dc6c10eb695444d69db8426a39232bd3e166eb22bcb7704642ca26a276774dc13d249b9e29")
self.db.backend.set_option('user_key_priv', "3081ee0201010448017a656efdf1a6203fee24074e8e9aba1c329563321bbb17ddc069fccee0b9b5e5b505f4ac2131760b82cfb56301cac7a00341c812b7ae6b4867910c5ac8d4c23152ccaf64ba7956a00706052b81040027a181950381920004040a3d5712482be45375958745cdd3134ff079303bcf0ecf02ff6dff5b49cfde221a4068f1a243e31ba36052ed4836c77df8c1729cb9875ed703b23ccc9488f0b81ddba6e51b1caa01bc4e4c0152554c38b805ae6d9fb9d0a20172266b814a4f20e5ced5eb8f657c521b76dc6c10eb695444d69db8426a39232bd3e166eb22bcb7704642ca26a276774dc13d249b9e29")
def test_signed_model_no_save(self):
"""
Test if signing an unsaved model raises an error.
"""
model = DatabaseModel()
with self.assertRaises(RuntimeError):
model.sign(self.api)
def test_signed_model(self):
"""
Test is models can be signed, and if the signature is read as valid
"""
model = DatabaseModel()
model.post_or_put(self.db)
pre_hash = model.generate_sha1_hash()
# Sign the model
model.sign(self.api)
post_hash = model.generate_sha1_hash()
self.assertEqual(pre_hash, post_hash)
self.assertEqual(model.signer, self.db.backend.get_option('user_key_pub'))
self.assertTrue(DatabaseModel.signature_valid(model))
def test_signed_model_detect_tamper(self):
"""
Test is models can be signed, and if the signature is read as valid
"""
model = DatabaseModel()
model.post_or_put(self.db)
pre_hash = model.generate_sha1_hash()
# Sign the model
model.sign(self.api)
#Tamper with the model
model._id = 'different'
post_hash = model.generate_sha1_hash()
self.assertNotEqual(pre_hash, post_hash)
self.assertEqual(model.signer, self.db.backend.get_option('user_key_pub'))
self.assertFalse(DatabaseModel.signature_valid(model))
def test_model_equal(self):
"""
Test if identical models have the same hash and are eveluated as equal
"""
model1 = DatabaseModel()
model2 = DatabaseModel()
#self.assertEqual(hash(model1), hash(model2))
self.assertEqual(model1, model2)
def test_model_unequal(self):
"""
Test if different models have different hashes and are evaluated as unequal
"""
model1 = DatabaseModel()
model2 = DatabaseModel()
# Change the models by saving one and giving it an id
model2.post_or_put(self.db)
self.assertNotEqual(hash(model1), hash(model2))
self.assertNotEqual(model1, model2)
def test_post_or_put_time(self):
model = DatabaseModel()
# Save the model, sign it, then save the signed version.
model.post_or_put(self.db)
model.sign(self.api)
model.post_or_put(self.db)
original_sign_time = model.time_signed
# get a copy
model_copy = self.db.get('database_model', model.id)
self.assertEqual(original_sign_time, model_copy.time_signed)
model_copy.sign(self.api)
new_sign_time = model.time_signed
model_copy.post_or_put(self.db)
model_new_copy = self.db.get('database_model', model.id)
self.assertEqual(new_sign_time, model_new_copy.time_signed)
# Now we check that older models arent saved.
model_new_copy._time_signed = 0
model_new_copy.post_or_put(self.db, check_time=True)
model_last_copy = self.db.get('database_model', model.id)
self.assertEqual(new_sign_time, model_last_copy.time_signed)
def test_user_key_immutable(self):
"""
Test is an error is raised when attempting to change the user key.
"""
public_key = 'pk'
time_added = 100
user = User(public_key, time_added)
user.post_or_put(self.api.db)
self.assertEqual(user.time_added, time_added)
with self.assertRaises(IndexError) as cm:
user.generate_id(force=True)
exception = cm.exception
self.assertEqual(exception.message, "User key is immutable")
def test_document_model(self):
file_name = 'test.py'
mime = 'text/x-python'
file_path = os.path.join(os.path.dirname(sys.modules['market'].__file__), '__init__.py')
document = Document.encode_document(file_name, file_path)
self.assertTrue(isinstance(document, Document))
self.assertEqual(document.name, file_name)
self.assertEqual(document.mime, mime)
this_folder = os.getcwd()
document.decode_document(os.path.join(this_folder, file_name))
new_file_path = os.path.join(this_folder, file_name)
self.assertEqual(open(file_path).read(), open(new_file_path).read())
# Cleanup
os.remove(new_file_path)
def test_init(self):
database = MarketDatabase(MemoryBackend())
# Raise an error if no backend is given
with self.assertRaises(AssertionError):
database2 = MarketDatabase(None)
def setUp(self):
self.database = MarketDatabase(MemoryBackend())
# Some database models
self.model1 = DatabaseModel()
self.model2 = DatabaseModel()
class MarketDatabaseTestSuite(unittest.TestCase):
def setUp(self):
self.database = MarketDatabase(MemoryBackend())
# Some database models
self.model1 = DatabaseModel()
self.model2 = DatabaseModel()
def test_init(self):
database = MarketDatabase(MemoryBackend())
# Raise an error if no backend is given
with self.assertRaises(AssertionError):
database2 = MarketDatabase(None)
def test_post(self):
# Check if it has no id prior to saving
self.assertIsNone(self.model1.id)
id = self.database.post(self.model1.type, self.model1)
# Check if id saved to model
self.assertEqual(
self.model1.id,
self.database.get(self.model1.type, self.model1.id).id)
def test_get(self):
self.database.post(self.model1.type, self.model1)
# Get the same object
self.assertEqual(self.model1,
self.database.get(self.model1.type, self.model1.id))
# Get a noneexisting model
self.assertIsNone(self.database.get(self.model1.type, 'invalid_id'))
def test_put(self):
# Put an unsaved model
with self.assertRaises(AssertionError):
self.assertFalse(
self.database.put(self.model1.type, self.model1.id,
self.model1))
# Fake an id
self.model1._id = "fake"
# Replace a nonexisting element
self.assertFalse(
self.database.put(self.model1.type, self.model1.id, self.model1))
# Replace an existing element correctly
test_string = "boo"
with self.assertRaises(AttributeError):
self.assertEqual(self.model1.test, test_string)
self.model1.test = test_string
self.database.post(self.model1.type, self.model1)
# Check if the test string was saved in the db
self.assertEqual(
self.database.get(self.model1.type, self.model1.id).test,
test_string)
# Change the string
test_string2 = "baa"
self.model1.test = test_string2
self.assertTrue(
self.database.put(self.model1.type, self.model1.id, self.model1))
self.assertEqual(
self.database.get(self.model1.type, self.model1.id).test,
test_string2)
# Finally check if we can't replace it with another id
self.model2._id = "not_id_of_model1"
with self.assertRaises(AssertionError):
self.assertFalse(
self.database.put(self.model1.type, self.model1.id,
self.model2))
def test_delete_assert(self):
with self.assertRaises(AssertionError):
self.database.delete(None)
def test_delete(self):
self.database.post(self.model1.type, self.model1)
self.assertTrue(self.database.delete(self.model1))
self.assertIsNone(self.database.get(self.model1.type, self.model1.id))
def test_get_all(self):
self.database.backend.clear()
self.database.post(self.model1.type, self.model1)
self.database.post(self.model2.type, self.model2)
# Get the same object
all_tests = self.database.get_all(self.model1.type)
self.assertIsInstance(all_tests, list)
self.assertIn(self.model1, self.database.get_all(self.model1.type))
self.assertIn(self.model2, self.database.get_all(self.model2.type))
# Get a noneexisting model
self.assertIsNone(self.database.get_all('hi'))
@mock.patch('market.models.DatabaseModel.encode')
def test_generate_id_on_clash(self, encode_patch):
encode_patch.return_value = True
model = DatabaseModel()
self.database.post(model.type, model)
model2 = DatabaseModel()
unique_id = 'unique_id'
model2.generate_id = Mock()
model2.generate_id.side_effect = [model.id, unique_id]
self.database.post(model2.type, model2)
self.assertEqual(model2.id, unique_id)
self.assertEqual(model2.generate_id.call_count, 2)
def setUp(self):
self.database = MarketDatabase(PersistentBackend('.'))
self.database.backend.clear()
# Some database models
self.model1 = DatabaseModel()
self.model2 = DatabaseModel()
def initialize_api(self):
from market.api.api import MarketAPI
from market.database.backends import PersistentBackend, MemoryBackend
from market.database.database import MarketDatabase
self._api = MarketAPI(
MarketDatabase(PersistentBackend('.', u'sqlite/market.db')))
def setUp(self):
# Faking IOThread
registerAsIOThread()
# Object creation and preperation
self.dispersy = Dispersy(ManualEnpoint(0),
unicode("dispersy_temporary_mc1"))
self.dispersy_bank = Dispersy(ManualEnpoint(0),
unicode("dispersy_temporary_mc2"))
self.api = MarketAPI(
MarketDatabase(PersistentBackend('.', u'borrower.db')))
self.api_bank = MarketAPI(
MarketDatabase(PersistentBackend('.', u'bank.db')))
self.api.db.backend.clear()
self.api_bank.db.backend.clear()
self.user, _, priv_user = self.api.create_user()
self.bank, _, priv_bank = self.api_bank.create_user()
self.dispersy._database.open()
self.dispersy_bank._database.open()
self.master_member = DummyMember(self.dispersy, 1, "a" * 20)
self.member = self.dispersy.get_member(
private_key=priv_user.decode("HEX"))
self.member_bank = self.dispersy_bank.get_member(
private_key=priv_bank.decode("HEX"))
self.community = MortgageMarketCommunity.init_community(
self.dispersy, self.master_member, self.member)
self.community_bank = MortgageMarketCommunity.init_community(
self.dispersy_bank, self.master_member, self.member_bank)
self.community.api = self.api
self.community.user = self.user
self.api.community = self.community
self.community_bank.api = self.api_bank
self.community_bank.user = self.bank
self.api_bank.community = self.community_bank
self.db = self.api.db.backend
self.bank_db = self.api_bank.db.backend
self.community.persistence = self.db
self.community_bank.persistence = self.bank_db
# Models
self.mortgage = Mortgage(UUID('b97dfa1c-e125-4ded-9b1a-5066462c529c'),
UUID('b97dfa1c-e125-4ded-9b1a-5066462c520c'),
'ING', 80000, 1, 2.5, 1.5, 2.5, 36, 'A', [],
STATUS.ACCEPTED)
t = int(time.time())
self.payload = (
self.bank.id,
self.user.id,
self.mortgage,
self.mortgage,
2,
1,
'prev_hash_bene',
'prev_hash_beni',
'sig_bene',
'sig_beni',
t,
)
self.payload2 = (
self.bank.id,
'',
self.mortgage,
None,
2,
1,
'prev_hash_bene',
'',
'sig_bene',
'',
t,
)
def setUp(self):
# Faking IOThread
registerAsIOThread()
# Object creation and preperation
self.dispersy = Dispersy(ManualEnpoint(0),
unicode("dispersy_temporary"))
self.dispersy_bank = Dispersy(ManualEnpoint(0),
unicode("dispersy_temporary2"))
self.dispersy_investor = Dispersy(ManualEnpoint(0),
unicode("dispersy_temporary3"))
# a neutral api to generate the intial id's for loan requests and such to skip
# having to save the loan request to the (sending) user from each test as that
# isn't relevant.
self.neutral_api = MarketAPI(MarketDatabase(MemoryBackend()))
self.api = MarketAPI(MarketDatabase(MemoryBackend()))
self.api_bank = MarketAPI(MarketDatabase(MemoryBackend()))
self.api_investor = MarketAPI(MarketDatabase(MemoryBackend()))
self.api.db.backend.clear()
self.api_bank.db.backend.clear()
self.api_investor.db.backend.clear()
self.user, _, priv_user = self.api.create_user()
self.bank, _, priv_bank = self.api.create_user()
self.investor, _, priv_investor = self.api.create_user()
# save the user to the bank and investor db
self.user.post_or_put(self.api_bank.db)
self.bank.post_or_put(self.api_bank.db)
self.investor.post_or_put(self.api_bank.db)
self.user.post_or_put(self.api_investor.db)
self.bank.post_or_put(self.api_investor.db)
self.investor.post_or_put(self.api_investor.db)
self.dispersy._database.open()
self.dispersy_bank._database.open()
self.dispersy_investor._database.open()
self.master_member = DummyMember(self.dispersy, 1, "a" * 20)
self.member = self.dispersy.get_member(
private_key=priv_user.decode("HEX"))
self.member_bank = self.dispersy.get_member(
private_key=priv_bank.decode("HEX"))
self.member_investor = self.dispersy.get_member(
private_key=priv_investor.decode("HEX"))
self.community = MortgageMarketCommunity.init_community(
self.dispersy, self.master_member, self.member)
self.community_bank = MortgageMarketCommunity.init_community(
self.dispersy_bank, self.master_member, self.member_bank)
self.community_investor = MortgageMarketCommunity.init_community(
self.dispersy_investor, self.master_member, self.member_investor)
self.community.api = self.api
self.community.user = self.user
self.api.community = self.community
self.community_bank.api = self.api_bank
self.community_bank.user = self.bank
self.api.community = self.community_bank
self.community_investor.api = self.api_investor
self.community_investor.user = self.investor
self.api.community = self.community_investor
# Add our conversion to the community.
self.conversion = MortgageMarketConversion(self.community)
self.dispersy_mock = Mock()
self.dispersy_mock.store_update_forward.return_value = True
self.setupModels()
