def test_handleCreateAccount_DoubledTransaction(self): accountRepository = InMemoryRepository() transactionRepository = InMemoryRepository() commandHandler = TransactionCommandHandler(transactionRepository, accountRepository) accountRepository.add(Account(True, 75)) transactionRepository.add( Transaction( "Burger King", 10, datetime.strptime("2019-02-13T11:00:00.000Z", '%Y-%m-%dT%H:%M:%S.%fZ'))) transactionRepository.add( Transaction( "Burger King", 10, datetime.strptime("2019-02-13T11:01:59.000Z", '%Y-%m-%dT%H:%M:%S.%fZ'))) command = AuthorizeTransaction( '{ "transaction": { "merchant": "Burger King", "amount": 10, "time": "2019-02-13T11:02:00.000Z" } }' ) expectedResult = { "account": { "activeCard": True, "availableLimit": 75 }, "violations": ['doubled-transaction'] } result = commandHandler.handle_AuthorizeTransaction(command) self.assertEqual(expectedResult, result)
def test_handleCreateAccount_ok(self): repository = InMemoryRepository() commandHandler = AccountCommandHandler(repository) command = CreateAccount( '{ "account": { "activeCard": true, "availableLimit": 100 } }') expectedResult = { "account": { "activeCard": True, "availableLimit": 100 }, "violations": [] } expectedAccount = { "account": { "activeCard": True, "availableLimit": 100 } } result = commandHandler.handle_CreateAccount(command) self.assertEqual(expectedResult, result) resultAccount = repository.getByFilter(lambda _: True)[0].toDict() self.assertDictEqual(resultAccount, expectedAccount)
def main(): # Operates each line from STDIN. Supposing the program is called as following: # python ./src/application/app.py < operations # Repository Setup accountRepository = InMemoryRepository() transactionRepository = InMemoryRepository() # Command Bus Setup commandBus = InMemoryCommandBus() accountCommandsHandler = AccountCommandHandler(accountRepository) commandBus.subscribe(accountCommandsHandler) transactionCommandsHandler = TransactionCommandHandler( transactionRepository, accountRepository) commandBus.subscribe(transactionCommandsHandler) # Main loop for line in sys.stdin: command = getCommandFromJson(line) result = commandBus.send(command) output = json.dumps(result) print(output)
def test_TransactionCommandHandlerCtor_ok(self): transactionRepository = InMemoryRepository() accountRepository = InMemoryRepository() commandHandler = TransactionCommandHandler(transactionRepository, accountRepository) self.assertEqual(transactionRepository, commandHandler.transactionRepository) self.assertEqual(accountRepository, commandHandler.accountRepository) self.assertEqual(['AuthorizeTransaction'], commandHandler.commandHandlerFuncNames)
def test_RepoGetByFilter_NotFound(self): repo = InMemoryRepository() class TestModel(Model): def __init__(self): super().__init__() model = TestModel() repo.add(model) result = repo.getByFilter(lambda x: False) self.assertListEqual([], result)
def test_RepoGetById_ok(self): repo = InMemoryRepository() class TestModel(Model): def __init__(self): super().__init__() model = TestModel() repo.add(model) result = repo.getById(model.id) self.assertEqual(model, result)
def test_RepoGetByFilter_ok(self): repo = InMemoryRepository() class TestModel(Model): def __init__(self): super().__init__() model = TestModel() repo.add(model) result = repo.getByFilter(lambda x: x.id == model.id) self.assertListEqual([model], result)
def test_RepoGetById_NotFound(self): repo = InMemoryRepository() class TestModel(Model): def __init__(self): super().__init__() model = TestModel() repo.add(model) result = repo.getById(uuid.uuid4()) self.assertIsNone(result)
def test_RepoAdd_ok(self): repo = InMemoryRepository() class TestModel(Model): def __init__(self): super().__init__() model = TestModel() rowsAffected = repo.add(model) self.assertIsNotNone(model.id) self.assertIsNotNone(model.created_at) self.assertEqual(1, len(repo.dbSet)) self.assertEqual(1, rowsAffected)
def test_handleCreateAccount_CommandNotAnInstance(self): accountRepository = InMemoryRepository() transactionRepository = InMemoryRepository() commandHandler = TransactionCommandHandler(transactionRepository, accountRepository) command = object() def handleAuthorizeTransactionFunc(): commandHandler.handle_AuthorizeTransaction(command) self.assertRaisesWithMessage( AssertionError, '{} must be of type \'AuthorizeTransaction\''.format(command), handleAuthorizeTransactionFunc)
def test_handleCreateAccount_InsufficientLimit(self): accountRepository = InMemoryRepository() transactionRepository = InMemoryRepository() commandHandler = TransactionCommandHandler(transactionRepository, accountRepository) accountRepository.add(Account(True, 100)) command = AuthorizeTransaction( '{ "transaction": { "merchant": "Burger King", "amount": 101, "time": "2019-02-13T10:00:00.000Z" } }' ) expectedResult = { "account": { "activeCard": True, "availableLimit": 100 }, "violations": ['insufficient-limit'] } result = commandHandler.handle_AuthorizeTransaction(command) self.assertEqual(expectedResult, result) transactions = transactionRepository.getByFilter(lambda _: True) self.assertListEqual([], transactions)
def test_AccountCommandHandlerCtor_ok(self): repository = InMemoryRepository() commandHandler = AccountCommandHandler(repository) self.assertEqual(repository, commandHandler.accountRepository) self.assertEqual(['CreateAccount'], commandHandler.commandHandlerFuncNames)
def test_TransactionCommandHandlerCtor_transactionRepo_nok(self): transactionRepository = object() accountRepository = InMemoryRepository() def createAccountCommandHandler(): TransactionCommandHandler(transactionRepository, accountRepository) self.assertRaisesWithMessage( AssertionError, '{} must be of type \'Repository\''.format(transactionRepository), createAccountCommandHandler)
def test_handleCreateAccount_ok(self): accountRepository = InMemoryRepository() transactionRepository = InMemoryRepository() commandHandler = TransactionCommandHandler(transactionRepository, accountRepository) accountRepository.add(Account(True, 100)) command = AuthorizeTransaction( '{ "transaction": { "merchant": "Burger King", "amount": 10, "time": "2019-02-13T10:00:00.000Z" } }' ) expectedResult = { "account": { "activeCard": True, "availableLimit": 90 }, "violations": [] } expectedAccount = { "account": { "activeCard": True, "availableLimit": 90 } } result = commandHandler.handle_AuthorizeTransaction(command) self.assertEqual(expectedResult, result) resultAccount = accountRepository.getByFilter( lambda _: True)[0].toDict() self.assertDictEqual(resultAccount, expectedAccount)
def test_handleCreateAccount_NotAnInstance(self): repository = InMemoryRepository() commandHandler = AccountCommandHandler(repository) command = object() def handleCreateAccountFunc(): commandHandler.handle_CreateAccount(command) self.assertRaisesWithMessage( AssertionError, '{} must be of type \'CreateAccount\''.format(command), handleCreateAccountFunc)
def test_RepoAdd_NotModelInstance(self): repo = InMemoryRepository() model = object() def tryAddingNotModelInstance(): repo.add(model) self.assertRaisesWithMessage( AssertionError, '{} entity must be of type \'Model\''.format(model), tryAddingNotModelInstance )
def test_handleCreateAccount_AlreadyInitialized(self): repository = InMemoryRepository() repository.add(Account(True, 42)) commandHandler = AccountCommandHandler(repository) command = CreateAccount( '{ "account": { "activeCard": true, "availableLimit": 100 } }') expectedResult = { "account": { "activeCard": True, "availableLimit": 42 }, "violations": ["account-already-initialized"] } result = commandHandler.handle_CreateAccount(command) self.assertDictEqual(expectedResult, result) emptyResults = repository.getByFilter( lambda account: account.availableLimit == 100) self.assertListEqual([], emptyResults)
def test_RepoUpdate_NotFound(self): repo = InMemoryRepository() class TestModel(Model): def __init__(self): self.verified = False super().__init__() model = TestModel() repo.add(model) self.assertIsNone(model.updated_at) self.assertFalse(model.verified) newModel = Model() affectedRows = repo.update(newModel) self.assertEqual(0, affectedRows) notUpdatedModel = repo.getById(model.id) self.assertIsNone(notUpdatedModel.updated_at) self.assertFalse(notUpdatedModel.verified)
def test_RepoUpdate_ok(self): repo = InMemoryRepository() class TestModel(Model): def __init__(self): self.verified = False super().__init__() model = TestModel() repo.add(model) self.assertIsNone(model.updated_at) self.assertFalse(model.verified) model.verified = True affectedRows = repo.update(model) self.assertEqual(1, affectedRows) updatedModel = repo.getById(model.id) self.assertIsNotNone(updatedModel.updated_at) self.assertTrue(updatedModel.verified)
def test_RepoCtor_ok(self): repo = InMemoryRepository() self.assertDictEqual({}, repo.dbSet)
def test_handleCreateAccount_HighFrequencySmallInterval(self): accountRepository = InMemoryRepository() transactionRepository = InMemoryRepository() commandHandler = TransactionCommandHandler(transactionRepository, accountRepository) accountRepository.add(Account(True, 75)) transactionRepository.add( Transaction( "Burger King", 10, datetime.strptime("2019-02-13T11:00:00.000Z", '%Y-%m-%dT%H:%M:%S.%fZ'))) transactionRepository.add( Transaction( "Burger Queen", 10, datetime.strptime("2019-02-13T11:01:00.000Z", '%Y-%m-%dT%H:%M:%S.%fZ'))) transactionRepository.add( Transaction( "Burger Prince", 5, datetime.strptime("2019-02-13T11:01:59.000Z", '%Y-%m-%dT%H:%M:%S.%fZ'))) command = AuthorizeTransaction( '{ "transaction": { "merchant": "Burger Pleb", "amount": 10, "time": "2019-02-13T10:00:00.000Z" } }' ) expectedResult = { "account": { "activeCard": True, "availableLimit": 75 }, "violations": ['high-frequency-small-interval'] } result = commandHandler.handle_AuthorizeTransaction(command) self.assertEqual(expectedResult, result)