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()