def test_chain_consistency_no_blocks(self):
"""
Check if a chaining is valid without previous or next blocks.
"""
result = ValidationResult()
block = TestBlock()
block.update_chain_consistency(None, None, result)
self.assertEqual(ValidationResult.valid, result.state)
def test_invariant_negative_timestamp(self):
"""
Test if negative sequence number blocks are not valid.
"""
result = ValidationResult()
block = TestBlock()
block.timestamp = -1.0
block.update_block_invariant(None, result)
self.assertEqual(ValidationResult.invalid, result.state)
def test_validation_level_no_blocks_genesis(self):
"""
Test the validation level for no previous and no next block, if this is the genesis block.
"""
result = ValidationResult()
block = TestBlock()
block.sequence_number = 1
block.update_validation_level(None, None, result)
self.assertEqual(result.state, ValidationResult.partial_next)
def test_invariant_invalid_link_key(self):
"""
Test if illegal key linked-block blocks are not valid.
"""
result = ValidationResult()
block = TestBlock()
block.link_public_key = b"definitelynotakey"
block.update_block_invariant(None, result)
self.assertEqual(ValidationResult.invalid, result.state)
def test_validation_level_no_blocks(self):
"""
Test the validation level for no previous and no next block.
"""
result = ValidationResult()
block = TestBlock()
block.sequence_number = 2
block.update_validation_level(None, None, result)
self.assertEqual(result.state, ValidationResult.no_info)
def test_invariant_linked_own_key(self):
"""
Test if self-signed blocks are not valid.
"""
result = ValidationResult()
block = TestBlock()
block.link_public_key = block.public_key
block.update_block_invariant(None, result)
self.assertEqual(ValidationResult.invalid, result.state)
def test_invariant_link_null_pointer(self):
"""
Test if 0 sequence number linked blocks are valid.
"""
result = ValidationResult()
block = TestBlock()
block.link_sequence_number = 0
block.update_block_invariant(None, result)
self.assertEqual(ValidationResult.valid, result.state)
def test_invariant_link_negative_sq(self):
"""
Test if negative sequence number linked blocks are not valid.
"""
result = ValidationResult()
block = TestBlock()
block.link_sequence_number = -1
block.update_block_invariant(None, result)
self.assertEqual(ValidationResult.invalid, result.state)
def test_block_consistency_hash(self):
"""
Test for error on hash mismatch.
"""
result = ValidationResult()
block1 = TestBlock()
block1.pack = lambda: b"1234"
block2 = TestBlock()
block2.pack = lambda: b"5678"
block1.update_block_consistency(block2, result, MockDatabase())
self.assertEqual(ValidationResult.invalid, result.state)
def test_block_consistency_signature(self):
"""
Test for error on signature mismatch.
"""
result = ValidationResult()
block1 = TestBlock()
block1.signature = b"1234"
block2 = TestBlock()
block2.signature = b"5678"
block1.update_block_consistency(block2, result, MockDatabase())
self.assertEqual(ValidationResult.invalid, result.state)
def test_block_consistency_link_key(self):
"""
Test for error on linked keys mismatch.
"""
result = ValidationResult()
block1 = TestBlock()
block1.link_public_key = b"1234"
block2 = TestBlock()
block2.link_public_key = b"5678"
block1.update_block_consistency(block2, result, MockDatabase())
self.assertEqual(ValidationResult.invalid, result.state)
def test_invariant_genesis_hash(self):
"""
Test if genesis hash blocks with non-zero sequence number are not valid.
"""
result = ValidationResult()
block = TestBlock()
block.sequence_number = 2
block.previous_hash = GENESIS_HASH
block.sign(block.key)
block.update_block_invariant(None, result)
self.assertEqual(ValidationResult.invalid, result.state)
def test_invariant_genesis_sq(self):
"""
Test if genesis sq blocks with non-genesis hash are not valid.
"""
result = ValidationResult()
block = TestBlock()
block.sequence_number = GENESIS_SEQ
block.previous_hash = b"abcdefg"
block.sign(block.key)
block.update_block_invariant(None, result)
self.assertEqual(ValidationResult.invalid, result.state)
def test_link_consistency_key(self):
"""
Test for error on key mismatch.
"""
result = ValidationResult()
block = TestBlock()
block.link_public_key = b"1234"
link = TestBlock()
link.public_key = b"5678"
block.update_linked_consistency(None, link, result)
self.assertEqual(ValidationResult.invalid, result.state)
def test_invariant_tx_errors(self):
"""
Test if transaction errors get added to the validation result.
"""
result = ValidationResult()
errors = ["a", "b"]
block = TestBlock()
block.transaction_validation_result = (ValidationResult.invalid, errors)
block.update_block_invariant(None, result)
self.assertEqual(errors, result.errors)
self.assertEqual(ValidationResult.invalid, result.state)
def test_validation_level_next_block_gap_genesis(self):
"""
Test the validation level for next block with gap, if this is the genesis block.
"""
result = ValidationResult()
block = TestBlock()
block.sequence_number = 1
next_block = TestBlock()
next_block.sequence_number = 3
block.update_validation_level(None, next_block, result)
self.assertEqual(result.state, ValidationResult.partial_next)
def test_validation_level_prev_block_gap(self):
"""
Test the validation level for previous block with gap.
"""
result = ValidationResult()
block = TestBlock()
block.sequence_number = 4
prev_block = TestBlock()
prev_block.sequence_number = 2
block.update_validation_level(prev_block, None, result)
self.assertEqual(result.state, ValidationResult.partial)
def test_validation_level_next_block_gap(self):
"""
Test the validation level for next block with gap.
"""
result = ValidationResult()
block = TestBlock()
block.sequence_number = 2
next_block = TestBlock()
next_block.sequence_number = 4
block.update_validation_level(None, next_block, result)
self.assertEqual(result.state, ValidationResult.partial)
def test_block_consistency_link_sq(self):
"""
Test for error on link sequence number mismatch.
"""
result = ValidationResult()
block1 = TestBlock()
block1.link_sequence_number = 0
block2 = TestBlock()
block2.link_sequence_number = 1
block1.update_block_consistency(block2, result, MockDatabase())
self.assertEqual(ValidationResult.invalid, result.state)
def test_chain_consistency_key_next_block(self):
"""
Check if a chaining is invalid on public key mismatch.
"""
result = ValidationResult()
block = TestBlock()
block.sequence_number = 3
next_block = TestBlock()
next_block.sequence_number = 4
next_block.previous_hash = block.hash
block.update_chain_consistency(None, next_block, result)
self.assertEqual(ValidationResult.invalid, result.state)
def test_chain_consistency_hash_next_block_gap(self):
"""
Check if a chaining is valid on hash mismatch with non-next block.
"""
result = ValidationResult()
block = TestBlock()
block.sequence_number = 2
next_block = TestBlock()
next_block.public_key = block.public_key
next_block.sequence_number = 4
next_block.previous_hash = b"definitelynotthathash"
block.update_chain_consistency(None, next_block, result)
self.assertEqual(ValidationResult.valid, result.state)
def test_chain_consistency_sq_next_block(self):
"""
Check if a chaining is invalid on next sequence number in the past.
"""
result = ValidationResult()
block = TestBlock()
block.sequence_number = 5
next_block = TestBlock()
next_block.public_key = block.public_key
next_block.sequence_number = 4
next_block.previous_hash = block.hash
block.update_chain_consistency(None, next_block, result)
self.assertEqual(ValidationResult.invalid, result.state)
def test_chain_consistency_next_block(self):
"""
Check if a chaining is valid if the next block connects to our block.
"""
result = ValidationResult()
block = TestBlock()
block.sequence_number = 3
next_block = TestBlock()
next_block.public_key = block.public_key
next_block.sequence_number = 4
next_block.previous_hash = block.hash
block.update_chain_consistency(None, next_block, result)
self.assertEqual(ValidationResult.valid, result.state)
def test_chain_consistency_sq_previous_block(self):
"""
Check if a chaining is invalid on sequence number in the future.
"""
result = ValidationResult()
prev_block = TestBlock()
prev_block.sequence_number = 5
block = TestBlock()
block.public_key = prev_block.public_key
block.sequence_number = 4
block.previous_hash = prev_block.hash
block.update_chain_consistency(prev_block, None, result)
self.assertEqual(ValidationResult.invalid, result.state)
def test_chain_consistency_hash_previous_block(self):
"""
Check if a chaining is invalid on hash mismatch.
"""
result = ValidationResult()
prev_block = TestBlock()
prev_block.sequence_number = 3
block = TestBlock()
block.public_key = prev_block.public_key
block.sequence_number = 4
block.previous_hash = b"definitelynotthathash"
block.update_chain_consistency(prev_block, None, result)
self.assertEqual(ValidationResult.invalid, result.state)
def test_chain_consistency_previous_block(self):
"""
Check if a chaining is valid if the previous block connects to our block.
"""
result = ValidationResult()
prev_block = TestBlock()
prev_block.sequence_number = 3
block = TestBlock()
block.public_key = prev_block.public_key
block.sequence_number = 4
block.previous_hash = prev_block.hash
block.update_chain_consistency(prev_block, None, result)
self.assertEqual(ValidationResult.valid, result.state)
def test_validation_level_both_block_prev_gap(self):
"""
Test the validation level for both next and only previous block with gap.
"""
result = ValidationResult()
block = TestBlock()
block.sequence_number = 3
prev_block = TestBlock()
prev_block.sequence_number = 1
next_block = TestBlock()
next_block.sequence_number = 4
block.update_validation_level(prev_block, next_block, result)
self.assertEqual(result.state, ValidationResult.partial_previous)
def test_link_consistency_key_theirs(self):
"""
Test for error on key mismatch on linked block.
"""
result = ValidationResult()
block = TestBlock()
block.sequence_number = 1
block.link_sequence_number = 0
link = TestBlock()
link.sequence_number = 4
link.link_sequence_number = 1
block.link_public_key = link.public_key
block.update_linked_consistency(None, link, result)
self.assertEqual(ValidationResult.invalid, result.state)
def test_link_consistency_sq_valid_theirs(self):
"""
Test for success on sequence number match through the linked block.
"""
result = ValidationResult()
block = TestBlock()
block.sequence_number = 1
block.link_sequence_number = 0
link = TestBlock()
link.sequence_number = 4
link.link_sequence_number = 1
block.link_public_key = link.public_key
link.link_public_key = block.public_key
block.update_linked_consistency(None, link, result)
self.assertEqual(ValidationResult.valid, result.state)
def test_link_consistency_double_countersign(self):
"""
Test for error on double countersign fraud.
"""
class FakeDB(object):
def get_linked(self, _):
return TestBlock(transaction={"a": "b"})
result = ValidationResult()
block = TestBlock()
block.sequence_number = 1
block.link_sequence_number = 4
link = TestBlock()
link.sequence_number = 4
link.link_sequence_number = 0
block.link_public_key = link.public_key
link.link_public_key = block.public_key
block.update_linked_consistency(FakeDB(), link, result)
self.assertEqual(ValidationResult.invalid, result.state)