def test_event_address_getter(self):
getter = EventAddressGetter()
self.assertListEqual([], getter.get_addresses())
event = EventFactory.create()
self.assertIsNotNone(event)
self.assertTrue(getter.__contains__(event.address))
self.assertListEqual([event.address], getter.get_addresses())
event2 = EventFactory.create()
self.assertListEqual([event.address, event2.address],
getter.get_addresses())
def test_transfer_outcome_token(self):
outcome_token_balance = OutcomeTokenBalanceFactory()
event = EventFactory()
outcome_token_balance.balance = 20
outcome_token_balance.save()
transfer_event = {
'name':
'Transfer',
'address':
outcome_token_balance.outcome_token.address,
'params': [{
'name': 'from',
'value': outcome_token_balance.owner
}, {
'name': 'to',
'value': event.address
}, {
'name': 'value',
'value': outcome_token_balance.balance,
}]
}
s = OutcomeTokenTransferSerializer(data=transfer_event)
self.assertTrue(s.is_valid(), s.errors)
instance = s.save()
self.assertEqual(
OutcomeTokenBalance.objects.get(
owner=outcome_token_balance.owner).balance, 0)
self.assertIsNotNone(instance)
self.assertEqual(instance.owner, event.address)
self.assertEqual(instance.balance, 20)
def test_issuance_outcome_token(self):
outcome_token = OutcomeTokenFactory()
event = EventFactory()
issuance_event = {
'name':
'Issuance',
'address':
outcome_token.address,
'params': [{
'name': 'owner',
'value': event.address
}, {
'name': 'amount',
'value': 20,
}]
}
s = OutcomeTokenIssuanceSerializer(data=issuance_event)
self.assertTrue(s.is_valid(), s.errors)
instance = s.save()
balance = OutcomeTokenBalance.objects.get(owner=event.address)
self.assertEqual(balance.balance, 20)
self.assertIsNotNone(instance)
self.assertEqual(
OutcomeToken.objects.get(
address=outcome_token.address).total_supply,
outcome_token.total_supply + 20)
def test_event_instance_outcome_assignment_receiver(self):
event_factory = EventFactory()
assignment_event = {
'name': 'OutcomeAssignment',
'address': event_factory.address,
'params': [{
'name': 'outcome',
'value': 1,
}]
}
EventInstanceReceiver().save(assignment_event)
event = Event.objects.get(address=event_factory.address)
self.assertTrue(event.is_winning_outcome_set)
def test_create_scalar_event(self):
event = EventFactory()
oracle = OracleFactory()
block = {
'number': oracle.creation_block,
'timestamp': mktime(oracle.creation_date_time.timetuple())
}
scalar_event = {
'address':
oracle.factory[1:-8] + 'GIACOMO1',
'params': [{
'name': 'creator',
'value': oracle.creator
}, {
'name': 'collateralToken',
'value': event.collateral_token
}, {
'name': 'oracle',
'value': oracle.address
}, {
'name': 'upperBound',
'value': 1
}, {
'name': 'lowerBound',
'value': 0
}]
}
s = ScalarEventSerializer(data=scalar_event, block=block)
self.assertFalse(s.is_valid(), s.errors)
scalar_event.get('params').append({
'name':
'scalarEvent',
'value':
event.address[1:-8] + 'GIACOMO2'
})
s = ScalarEventSerializer(data=scalar_event, block=block)
self.assertTrue(s.is_valid(), s.errors)
instance = s.save()
self.assertIsNotNone(instance)
def test_scalar_event_receiver(self):
oracle = OracleFactory()
event = EventFactory()
event_address = event.address[0:33] + 'GIACOMO'
block = {
'number': oracle.creation_block,
'timestamp': self.to_timestamp(oracle.creation_date_time)
}
scalar_event = {
'address':
oracle.factory[0:33] + 'GIACOMO',
'name':
'ScalarEventCreation',
'params': [{
'name': 'creator',
'value': oracle.creator
}, {
'name': 'collateralToken',
'value': event.collateral_token
}, {
'name': 'oracle',
'value': oracle.address
}, {
'name': 'outcomeCount',
'value': 1
}, {
'name': 'upperBound',
'value': 1
}, {
'name': 'lowerBound',
'value': 0
}, {
'name': 'scalarEvent',
'value': event_address
}]
}
EventFactoryReceiver().save(scalar_event, block)
event = ScalarEvent.objects.get(address=event_address)
self.assertIsNotNone(event.pk)
def test_event_instance_winnings_redemption_receiver(self):
event_factory = EventFactory()
redemption_event = {
'name':
'WinningsRedemption',
'address':
event_factory.address,
'params': [{
'name': 'receiver',
'value': event_factory.creator[0:-7] + 'GIACOMO',
}, {
'name': 'winnings',
'value': 1
}]
}
EventInstanceReceiver().save(redemption_event)
event = Event.objects.get(address=event_factory.address)
self.assertEquals(event.redeemed_winnings,
event_factory.redeemed_winnings + 1)
def test_create_categorical_event(self):
event_factory = EventFactory()
oracle = OracleFactory()
block = {
'number': oracle.creation_block,
'timestamp': mktime(oracle.creation_date_time.timetuple())
}
categorical_event = {
'address':
oracle.factory[1:-7] + 'GIACOMO',
'params': [{
'name': 'creator',
'value': oracle.creator
}, {
'name': 'collateralToken',
'value': event_factory.collateral_token
}, {
'name': 'oracle',
'value': oracle.address
}, {
'name': 'outcomeCount',
'value': 1
}]
}
s = CategoricalEventSerializer(data=categorical_event, block=block)
self.assertFalse(s.is_valid(), s.errors)
categorical_event.get('params').append({
'name':
'categoricalEvent',
'value':
event_factory.address[1:-7] + 'GIACOMO'
})
s = CategoricalEventSerializer(data=categorical_event, block=block)
self.assertTrue(s.is_valid(), s.errors)
instance = s.save()
self.assertIsNotNone(instance)
def test_create_outcome_token_instance(self):
outcome_token_factory = OutcomeTokenFactory()
oracle_factory = OracleFactory()
event_factory = EventFactory()
event = None
block = {
'number': oracle_factory.creation_block,
'timestamp': mktime(oracle_factory.creation_date_time.timetuple())
}
scalar_event = {
'address':
oracle_factory.factory[1:-12] + 'TESTINSTANCE',
'params': [{
'name': 'creator',
'value': oracle_factory.creator
}, {
'name': 'collateralToken',
'value': event_factory.collateral_token
}, {
'name': 'oracle',
'value': oracle_factory.address
}, {
'name': 'outcomeCount',
'value': 1
}, {
'name': 'upperBound',
'value': 1
}, {
'name': 'lowerBound',
'value': 0
}, {
'name': 'scalarEvent',
'value': event_factory.address[1:-12] + 'TESTINSTANCE'
}]
}
s = ScalarEventSerializer(data=scalar_event, block=block)
s.is_valid()
event = s.save()
block = {
'number': oracle_factory.creation_block,
'timestamp': mktime(oracle_factory.creation_date_time.timetuple())
}
oracle_event = {
'address':
oracle_factory.factory[0:-7] + 'GIACOMO',
'params': [{
'name': 'creator',
'value': event.creator
}, {
'name': 'address',
'value': event.address
}, {
'name': 'outcomeToken',
'value': oracle_factory.address[1:-8] + 'INSTANCE',
}, {
'name': 'index',
'value': outcome_token_factory.index
}]
}
s = OutcomeTokenInstanceSerializer(data=oracle_event)
self.assertTrue(s.is_valid(), s.errors)
instance = s.save()
self.assertIsNotNone(instance)
def test_event_instance_receiver(self):
outcome_token_factory = OutcomeTokenFactory()
oracle_factory = OracleFactory()
event_factory = EventFactory()
event_address = event_factory.address[0:-7] + 'GIACOMO'
block = {
'number': oracle_factory.creation_block,
'timestamp': mktime(oracle_factory.creation_date_time.timetuple())
}
scalar_event = {
'name':
'ScalarEventCreation',
'address':
oracle_factory.factory[1:-12] + 'TESTINSTANCE',
'params': [{
'name': 'creator',
'value': oracle_factory.creator
}, {
'name': 'collateralToken',
'value': event_factory.collateral_token
}, {
'name': 'oracle',
'value': oracle_factory.address
}, {
'name': 'outcomeCount',
'value': 1
}, {
'name': 'upperBound',
'value': 1
}, {
'name': 'lowerBound',
'value': 0
}, {
'name': 'scalarEvent',
'value': event_address
}]
}
EventFactoryReceiver().save(scalar_event, block)
event = ScalarEvent.objects.get(address=event_address)
block = {
'number': oracle_factory.creation_block,
'timestamp': mktime(oracle_factory.creation_date_time.timetuple())
}
outcome_token_address = oracle_factory.address[1:-8] + 'INSTANCE'
outcome_event = {
'name':
'OutcomeTokenCreation',
'address':
oracle_factory.factory[0:-7] + 'GIACOMO',
'params': [{
'name': 'creator',
'value': event.creator
}, {
'name': 'address',
'value': event.address
}, {
'name': 'outcomeToken',
'value': outcome_token_address,
}, {
'name': 'index',
'value': outcome_token_factory.index
}]
}
EventInstanceReceiver().save(outcome_event, block)
self.assertIsNotNone(
OutcomeToken.objects.get(address=outcome_token_address))