コード例 #1
0
class TransactionManagerTestSuite(unittest.TestCase):
    """Transaction manager test cases."""

    def setUp(self):
        # Object creation
        self.memory_transaction_repository = MemoryTransactionRepository("0")
        self.transaction_manager = TransactionManager(self.memory_transaction_repository)

        self.transaction_id = TransactionId(TraderId(b"0"), TransactionNumber(1))
        self.transaction = Transaction(self.transaction_id, AssetPair(AssetAmount(100, 'BTC'), AssetAmount(30, 'MB')),
                                       OrderId(TraderId(b'3'), OrderNumber(2)),
                                       OrderId(TraderId(b'2'), OrderNumber(1)), Timestamp(0.0))
        self.proposed_trade = Trade.propose(TraderId(b'0'),
                                            OrderId(TraderId(b'0'), OrderNumber(1)),
                                            OrderId(TraderId(b'1'), OrderNumber(2)),
                                            AssetPair(AssetAmount(30, 'BTC'), AssetAmount(30, 'MB')),
                                            Timestamp(1462224447.117))
        self.start_transaction = StartTransaction(TraderId(b'0'),
                                                  TransactionId(TraderId(b"0"), TransactionNumber(1)),
                                                  OrderId(TraderId(b'0'), OrderNumber(1)),
                                                  OrderId(TraderId(b'1'), OrderNumber(2)), 1235,
                                                  AssetPair(AssetAmount(20, 'BTC'), AssetAmount(20, 'MB')),
                                                  Timestamp(0.0))

    def test_create_from_proposed_trade(self):
        # Test for create from a proposed trade
        transaction = self.transaction_manager.create_from_proposed_trade(self.proposed_trade, 'a')
        self.assertEquals(transaction, self.transaction_manager.find_by_id(transaction.transaction_id))

    def test_find_by_id(self):
        # Test for find by id
        self.assertEquals(None, self.transaction_manager.find_by_id(self.transaction_id))
        self.memory_transaction_repository.add(self.transaction)
        self.assertEquals(self.transaction, self.transaction_manager.find_by_id(self.transaction_id))

    def test_find_all(self):
        # Test for find all
        self.assertEquals([], list(self.transaction_manager.find_all()))
        self.memory_transaction_repository.add(self.transaction)
        self.assertEquals([self.transaction], list(self.transaction_manager.find_all()))

    def test_create_from_start_transaction(self):
        # Test for create from start transaction
        transaction = self.transaction_manager.create_from_start_transaction(self.start_transaction, 'a')
        self.assertEquals(transaction, self.transaction_manager.find_by_id(transaction.transaction_id))

    def test_create_payment_message(self):
        """
        Test the creation of a payment message
        """
        self.transaction.incoming_address = WalletAddress('abc')
        self.transaction.outgoing_address = WalletAddress('def')
        self.transaction.partner_incoming_address = WalletAddress('ghi')
        self.transaction.partner_outgoing_address = WalletAddress('jkl')
        payment_msg = self.transaction_manager.create_payment_message(TraderId(b"0"),
                                                                      PaymentId('abc'), self.transaction,
                                                                      AssetAmount(1, 'BTC'),
                                                                      True)
        self.assertIsInstance(payment_msg, Payment)
コード例 #2
0
class TransactionManagerTestSuite(unittest.TestCase):
    """Transaction manager test cases."""
    def setUp(self):
        # Object creation
        self.memory_transaction_repository = MemoryTransactionRepository("0")
        self.transaction_manager = TransactionManager(
            self.memory_transaction_repository)

        self.transaction_id = TransactionId(TraderId("0"),
                                            TransactionNumber(1))
        self.transaction = Transaction(self.transaction_id, Price(100, 'BTC'),
                                       Quantity(30, 'MC'),
                                       OrderId(TraderId('3'), OrderNumber(2)),
                                       OrderId(TraderId('2'), OrderNumber(1)),
                                       Timestamp(0.0))
        self.proposed_trade = Trade.propose(
            MessageId(TraderId('0'), MessageNumber('message_number')),
            OrderId(TraderId('0'), OrderNumber(1)),
            OrderId(TraderId('1'), OrderNumber(2)), Price(63400, 'BTC'),
            Quantity(30, 'MC'), Timestamp(1462224447.117))
        self.start_transaction = StartTransaction(
            MessageId(TraderId('0'), MessageNumber('1')),
            TransactionId(TraderId("0"), TransactionNumber(1)),
            OrderId(TraderId('0'), OrderNumber(1)),
            OrderId(TraderId('1'), OrderNumber(2)), 1235, Price(3600, 'BTC'),
            Quantity(20, 'MC'), Timestamp(0.0))

    def test_create_from_proposed_trade(self):
        # Test for create from a proposed trade
        transaction = self.transaction_manager.create_from_proposed_trade(
            self.proposed_trade)
        self.assertEquals(
            transaction,
            self.transaction_manager.find_by_id(transaction.transaction_id))

    def test_find_by_id(self):
        # Test for find by id
        self.assertEquals(
            None, self.transaction_manager.find_by_id(self.transaction_id))
        self.memory_transaction_repository.add(self.transaction)
        self.assertEquals(
            self.transaction,
            self.transaction_manager.find_by_id(self.transaction_id))

    def test_find_all(self):
        # Test for find all
        self.assertEquals([], self.transaction_manager.find_all())
        self.memory_transaction_repository.add(self.transaction)
        self.assertEquals([self.transaction],
                          self.transaction_manager.find_all())

    def test_create_from_start_transaction(self):
        # Test for create from start transaction
        transaction = self.transaction_manager.create_from_start_transaction(
            self.start_transaction)
        self.assertEquals(
            transaction,
            self.transaction_manager.find_by_id(transaction.transaction_id))
コード例 #3
0
 def setUp(self):
     # Object creation
     self.memory_transaction_repository = MemoryTransactionRepository("0")
     self.transaction_id = TransactionId(TraderId("0"),
                                         TransactionNumber(1))
     self.transaction = Transaction(self.transaction_id, Price(100, 'BTC'),
                                    Quantity(30, 'MC'),
                                    OrderId(TraderId("0"), OrderNumber(1)),
                                    OrderId(TraderId("2"), OrderNumber(2)),
                                    Timestamp(0.0))
コード例 #4
0
 def setUp(self):
     # Object creation
     self.memory_transaction_repository = MemoryTransactionRepository("0")
     self.transaction_id = TransactionId(TraderId(b"0"),
                                         TransactionNumber(1))
     self.transaction = Transaction(
         self.transaction_id,
         AssetPair(AssetAmount(10, 'BTC'), AssetAmount(10, 'MB')),
         OrderId(TraderId(b"0"), OrderNumber(1)),
         OrderId(TraderId(b"2"), OrderNumber(2)), Timestamp(0.0))
コード例 #5
0
 def setUp(self):
     # Object creation
     self.memory_transaction_repository = MemoryTransactionRepository("0")
     self.transaction_id = TransactionId(TraderId(b"0"), TransactionNumber(1))
     self.transaction = Transaction(self.transaction_id, AssetPair(AssetAmount(10, 'BTC'), AssetAmount(10, 'MB')),
                                    OrderId(TraderId(b"0"), OrderNumber(1)),
                                    OrderId(TraderId(b"2"), OrderNumber(2)), Timestamp(0.0))
コード例 #6
0
    def setUp(self):
        # Object creation
        self.memory_transaction_repository = MemoryTransactionRepository("0")
        self.transaction_manager = TransactionManager(self.memory_transaction_repository)

        self.transaction_id = TransactionId(TraderId(b"0"), TransactionNumber(1))
        self.transaction = Transaction(self.transaction_id, AssetPair(AssetAmount(100, 'BTC'), AssetAmount(30, 'MB')),
                                       OrderId(TraderId(b'3'), OrderNumber(2)),
                                       OrderId(TraderId(b'2'), OrderNumber(1)), Timestamp(0.0))
        self.proposed_trade = Trade.propose(TraderId(b'0'),
                                            OrderId(TraderId(b'0'), OrderNumber(1)),
                                            OrderId(TraderId(b'1'), OrderNumber(2)),
                                            AssetPair(AssetAmount(30, 'BTC'), AssetAmount(30, 'MB')),
                                            Timestamp(1462224447.117))
        self.start_transaction = StartTransaction(TraderId(b'0'),
                                                  TransactionId(TraderId(b"0"), TransactionNumber(1)),
                                                  OrderId(TraderId(b'0'), OrderNumber(1)),
                                                  OrderId(TraderId(b'1'), OrderNumber(2)), 1235,
                                                  AssetPair(AssetAmount(20, 'BTC'), AssetAmount(20, 'MB')),
                                                  Timestamp(0.0))
コード例 #7
0
    def setUp(self):
        # Object creation
        self.memory_transaction_repository = MemoryTransactionRepository("0")
        self.transaction_manager = TransactionManager(
            self.memory_transaction_repository)

        self.transaction_id = TransactionId(TraderId("0"),
                                            TransactionNumber(1))
        self.transaction = Transaction(self.transaction_id, Price(100, 'BTC'),
                                       Quantity(30, 'MC'),
                                       OrderId(TraderId('3'), OrderNumber(2)),
                                       OrderId(TraderId('2'), OrderNumber(1)),
                                       Timestamp(0.0))
        self.proposed_trade = Trade.propose(
            MessageId(TraderId('0'), MessageNumber('message_number')),
            OrderId(TraderId('0'), OrderNumber(1)),
            OrderId(TraderId('1'), OrderNumber(2)), Price(63400, 'BTC'),
            Quantity(30, 'MC'), Timestamp(1462224447.117))
        self.start_transaction = StartTransaction(
            MessageId(TraderId('0'), MessageNumber('1')),
            TransactionId(TraderId("0"), TransactionNumber(1)),
            OrderId(TraderId('0'), OrderNumber(1)),
            OrderId(TraderId('1'), OrderNumber(2)), 1235, Price(3600, 'BTC'),
            Quantity(20, 'MC'), Timestamp(0.0))
コード例 #8
0
class MemoryTransactionRepositoryTestSuite(unittest.TestCase):
    """Memory transaction repository test cases."""
    def setUp(self):
        # Object creation
        self.memory_transaction_repository = MemoryTransactionRepository("0")
        self.transaction_id = TransactionId(TraderId("0"),
                                            TransactionNumber(1))
        self.transaction = Transaction(self.transaction_id, Price(100, 'BTC'),
                                       Quantity(30, 'MC'),
                                       OrderId(TraderId("0"), OrderNumber(1)),
                                       OrderId(TraderId("2"), OrderNumber(2)),
                                       Timestamp(0.0))

    def test_find_by_id(self):
        # Test for find by id
        self.assertEquals(
            None,
            self.memory_transaction_repository.find_by_id(self.transaction_id))
        self.memory_transaction_repository.add(self.transaction)
        self.assertEquals(
            self.transaction,
            self.memory_transaction_repository.find_by_id(self.transaction_id))

    def test_delete_by_id(self):
        # Test for delete by id
        self.memory_transaction_repository.add(self.transaction)
        self.assertEquals(
            self.transaction,
            self.memory_transaction_repository.find_by_id(self.transaction_id))
        self.memory_transaction_repository.delete_by_id(self.transaction_id)
        self.assertEquals(
            None,
            self.memory_transaction_repository.find_by_id(self.transaction_id))

    def test_find_all(self):
        # Test for find all
        self.assertEquals([], self.memory_transaction_repository.find_all())
        self.memory_transaction_repository.add(self.transaction)
        self.assertEquals([self.transaction],
                          self.memory_transaction_repository.find_all())

    def test_next_identity(self):
        # Test for next identity
        self.assertEquals(TransactionId(TraderId("0"), TransactionNumber(1)),
                          self.memory_transaction_repository.next_identity())
        self.assertEquals(TransactionId(TraderId("0"), TransactionNumber(2)),
                          self.memory_transaction_repository.next_identity())

    def test_update(self):
        # Test for update
        self.memory_transaction_repository.add(self.transaction)
        self.memory_transaction_repository.update(self.transaction)
        self.assertEquals(
            self.transaction,
            self.memory_transaction_repository.find_by_id(self.transaction_id))
コード例 #9
0
class MemoryTransactionRepositoryTestSuite(unittest.TestCase):
    """Memory transaction repository test cases."""

    def setUp(self):
        # Object creation
        self.memory_transaction_repository = MemoryTransactionRepository("0")
        self.transaction_id = TransactionId(TraderId(b"0"), TransactionNumber(1))
        self.transaction = Transaction(self.transaction_id, AssetPair(AssetAmount(10, 'BTC'), AssetAmount(10, 'MB')),
                                       OrderId(TraderId(b"0"), OrderNumber(1)),
                                       OrderId(TraderId(b"2"), OrderNumber(2)), Timestamp(0.0))

    def test_find_by_id(self):
        # Test for find by id
        self.assertEquals(None, self.memory_transaction_repository.find_by_id(self.transaction_id))
        self.memory_transaction_repository.add(self.transaction)
        self.assertEquals(self.transaction, self.memory_transaction_repository.find_by_id(self.transaction_id))

    def test_delete_by_id(self):
        # Test for delete by id
        self.memory_transaction_repository.add(self.transaction)
        self.assertEquals(self.transaction, self.memory_transaction_repository.find_by_id(self.transaction_id))
        self.memory_transaction_repository.delete_by_id(self.transaction_id)
        self.assertEquals(None, self.memory_transaction_repository.find_by_id(self.transaction_id))

    def test_find_all(self):
        # Test for find all
        self.assertEquals([], list(self.memory_transaction_repository.find_all()))
        self.memory_transaction_repository.add(self.transaction)
        self.assertEquals([self.transaction], list(self.memory_transaction_repository.find_all()))

    def test_next_identity(self):
        # Test for next identity
        self.assertEquals(TransactionId(TraderId(b"0"), TransactionNumber(1)),
                          self.memory_transaction_repository.next_identity())
        self.assertEquals(TransactionId(TraderId(b"0"), TransactionNumber(2)),
                          self.memory_transaction_repository.next_identity())

    def test_update(self):
        # Test for update
        self.memory_transaction_repository.add(self.transaction)
        self.memory_transaction_repository.update(self.transaction)
        self.assertEquals(self.transaction, self.memory_transaction_repository.find_by_id(self.transaction_id))