def test_put_allows_to_overwrite_a_node(self):
node = larch.LeafNode(0, [], [])
self.ns.put_node(node)
node = larch.LeafNode(0, ['foo'], ['bar'])
self.ns.put_node(node)
new = self.ns.get_node(0)
self.assertEqual(new.keys(), ['foo'])
self.assertEqual(new.values(), ['bar'])
def test_put_allows_to_overwrite_a_node_after_upload_queue_push(self):
node = larch.LeafNode(0, [], [])
self.ns.put_node(node)
self.ns.commit()
node = larch.LeafNode(0, ['foo'], ['bar'])
self.ns.put_node(node)
self.ns.commit()
new = self.ns.get_node(0)
self.assertEqual(new.keys(), ['foo'])
self.assertEqual(new.values(), ['bar'])
def test_finds_potential_ranges(self):
# The children's keys are 'bar' and 'foo'. We need to test for
# every combination of minkey and maxkey being less than, equal,
# or greater than either child key (as long as minkey <= maxkey).
node = larch.LeafNode(0, ['bar', 'foo'], ['bar', 'foo'])
find = node.find_potential_range
self.assertEqual(find('aaa', 'aaa'), (None, None))
self.assertEqual(find('aaa', 'bar'), (0, 0))
self.assertEqual(find('aaa', 'ccc'), (0, 0))
self.assertEqual(find('aaa', 'foo'), (0, 1))
self.assertEqual(find('aaa', 'ggg'), (0, 1))
self.assertEqual(find('bar', 'bar'), (0, 0))
self.assertEqual(find('bar', 'ccc'), (0, 0))
self.assertEqual(find('bar', 'foo'), (0, 1))
self.assertEqual(find('bar', 'ggg'), (0, 1))
self.assertEqual(find('ccc', 'ccc'), (0, 0))
self.assertEqual(find('ccc', 'foo'), (0, 1))
self.assertEqual(find('ccc', 'ggg'), (0, 1))
self.assertEqual(find('foo', 'foo'), (1, 1))
self.assertEqual(find('foo', 'ggg'), (1, 1))
# This one is a bit special. The last key may refer to a
# child that is an index node, so it _might_ have keys
# in the desired range.
self.assertEqual(find('ggg', 'ggg'), (1, 1))
def test_removes_node(self):
node = larch.LeafNode(0, [], [])
self.ns.put_node(node)
self.ns.commit()
self.ns.remove_node(0)
self.assertRaises(NodeMissing, self.ns.get_node, 0)
self.assertEqual(self.ns.list_nodes(), [])
def test_finds_keys_in_range(self):
# The children's keys are 'bar' and 'foo'. We need to test for
# every combination of minkey and maxkey being less than, equal,
# or greater than either child key (as long as minkey <= maxkey).
node = larch.LeafNode(0, ['bar', 'foo'], ['bar', 'foo'])
find = node.find_keys_in_range
self.assertEqual(find('aaa', 'aaa'), [])
self.assertEqual(find('aaa', 'bar'), ['bar'])
self.assertEqual(find('aaa', 'ccc'), ['bar'])
self.assertEqual(find('aaa', 'foo'), ['bar', 'foo'])
self.assertEqual(find('aaa', 'ggg'), ['bar', 'foo'])
self.assertEqual(find('bar', 'bar'), ['bar'])
self.assertEqual(find('bar', 'ccc'), ['bar'])
self.assertEqual(find('bar', 'foo'), ['bar', 'foo'])
self.assertEqual(find('bar', 'ggg'), ['bar', 'foo'])
self.assertEqual(find('ccc', 'ccc'), [])
self.assertEqual(find('ccc', 'foo'), ['foo'])
self.assertEqual(find('ccc', 'ggg'), ['foo'])
self.assertEqual(find('foo', 'foo'), ['foo'])
self.assertEqual(find('foo', 'ggg'), ['foo'])
self.assertEqual(find('ggg', 'ggg'), [])
def test_put_refuses_too_large_a_node(self):
node = larch.LeafNode(0, ['000'], ['x' * (self.node_size + 1)])
def helper(node):
self.ns.put_node(node)
self.ns.commit()
self.assertRaises(larch.NodeTooBig, helper, node)
def test_gets_node_from_disk(self):
node = larch.LeafNode(0, [], [])
self.ns.put_node(node)
self.ns.commit()
ns2 = self.new_ns()
node2 = ns2.get_node(node.id)
self.assertEqual(node.id, node2.id)
self.assertEqual(node.keys(), node2.keys())
self.assertEqual(node.values(), node2.values())
def test_put_uploads_queue_overflow(self):
self.ns.upload_max = 2
self.ns.upload_queue.max = self.ns.upload_max
ids = range(self.ns.upload_max + 1)
for i in ids:
node = larch.LeafNode(i, [], [])
self.ns.put_node(node)
self.assertEqual(sorted(self.ns.list_nodes()), ids)
for node_id in ids:
self.ns.cache.remove(node_id)
self.assertEqual(self.ns.get_node(node_id).id, node_id)
def decode_leaf(self, encoded):
'''Decode a leaf node from its encoded byte string.'''
buf = buffer(encoded)
cookie, node_id, num_pairs = self.leaf_header.unpack_from(buf)
if cookie != 'ORBL':
raise CodecError('Leaf node does not begin with magic cookie '
'(should be ORBL, is %s)' % repr(cookie))
fmt = '!' + ('%ds' % self.key_bytes) * num_pairs + 'I' * num_pairs
items = struct.unpack_from(fmt, buf, self.leaf_header.size)
keys = items[:num_pairs]
lengths = items[num_pairs:num_pairs * 2]
values = []
offset = self.leaf_header.size + self.leaf_pair_fixed_size * num_pairs
append = values.append
for length in lengths:
append(encoded[offset:offset + length])
offset += length
return larch.LeafNode(node_id, keys, values)
def test_removes_node_from_upload_queue_if_one_exists(self):
node = larch.LeafNode(0, [], [])
self.ns.put_node(node)
self.ns.remove_node(0)
self.assertRaises(NodeMissing, self.ns.get_node, 0)
self.assertEqual(self.ns.list_nodes(), [])
def test_lists_node_zero(self):
node = larch.LeafNode(0, [], [])
self.ns.put_node(node)
self.ns.commit()
node_ids = self.ns.list_nodes()
self.assertEqual(node_ids, [node.id])
def test_unfreezes_node_when_modification_starts(self):
node = larch.LeafNode(0, [], [])
self.ns.put_node(node)
self.ns.set_refcount(node.id, 1)
self.ns.start_modification(node)
self.assertFalse(node.frozen)
def test_put_replaces_existing_node(self):
node2 = larch.LeafNode(1, ['foo'], ['bar'])
self.uq.put(self.node)
self.uq.put(node2)
self.assertEqual(self.uq.get(self.node.id), node2)
def test_puts_and_gets_same_with_cache_emptied(self):
node = larch.LeafNode(0, [], [])
self.ns.put_node(node)
self.ns.cache = larch.LRUCache(100)
self.assertEqualNodes(self.ns.get_node(0), node)
def test_pushes_first_node_after_third_is_pushed(self):
self.uq.put(self.node)
self.uq.put(larch.LeafNode(2, [], []))
self.uq.put(larch.LeafNode(3, [], []))
self.assertEqual(self.nodes, [self.node])
def test_get_freezes_node(self):
node = larch.LeafNode(0, [], [])
self.ns.put_node(node)
node2 = self.ns.get_node(0)
self.assert_(node2.frozen)
def test_returns_ok_delta_for_added_key_value(self):
leaf = larch.LeafNode(0, [], [])
old_size = self.codec.leaf_size(leaf.keys(), leaf.values())
new_size = self.codec.leaf_size_delta_add(old_size, 'bar')
self.assert_(new_size > old_size + len('foo') + len('bar'))
def test_puts_and_gets_same(self):
node = larch.LeafNode(0, [], [])
self.ns.put_node(node)
self.ns.commit()
self.assertEqualNodes(self.ns.get_node(0), node)
def setUp(self):
self.leaf = larch.LeafNode(1234, ['foo', 'yoo'], ['bar', 'yoyo'])
self.index = larch.IndexNode(5678, ['bar', 'foo'], [1234, 7890])
self.codec = larch.NodeCodec(3)
def setUp(self):
self.leaf1 = larch.LeafNode(0, ['bar'], ['bar'])
self.leaf2 = larch.LeafNode(1, ['foo'], ['foo'])
self.index_id = 1234
self.index = larch.IndexNode(self.index_id, ['bar', 'foo'],
[self.leaf1.id, self.leaf2.id])
def test_does_not_push_second_node(self):
self.uq.put(self.node)
self.uq.put(larch.LeafNode(2, [], []))
self.assertEqual(self.nodes, [])
def test_finds_no_potential_range_in_empty_node(self):
node = larch.LeafNode(0, [], [])
self.assertEqual(node.find_potential_range('aaa', 'bbb'), (None, None))
def setUp(self):
self.max_queue = 2
self.nodes = []
self.uq = larch.UploadQueue(self.really_put, self.max_queue)
self.node = larch.LeafNode(1, [], [])
def test_node_not_in_store_can_not_be_modified(self):
node = larch.LeafNode(0, [], [])
self.assertFalse(self.ns.can_be_modified(node))
def test_returns_ok_delta_for_changed_value_of_shorter_size(self):
leaf = larch.LeafNode(0, ['foo'], ['bar'])
old_size = self.codec.leaf_size(leaf.keys(), leaf.values())
new_size = self.codec.leaf_size_delta_replace(old_size, 'bar', '')
self.assertEqual(new_size, old_size - len('foo'))
def test_node_with_refcount_1_can_be_modified(self):
node = larch.LeafNode(0, [], [])
self.ns.put_node(node)
self.ns.set_refcount(node.id, 1)
self.assertTrue(self.ns.can_be_modified(node))
def test_returns_reasonable_size_for_empty_leaf_generic(self):
leaf = larch.LeafNode(0, [], [])
self.assert_(self.codec.size(leaf) > 10)
def test_node_with_refcount_2_can_not_be_modified(self):
node = larch.LeafNode(0, [], [])
self.ns.put_node(node)
self.ns.set_refcount(node.id, 2)
self.assertFalse(self.ns.can_be_modified(node))
def test_put_freezes_node(self):
node = larch.LeafNode(0, [], [])
self.ns.put_node(node)
self.assert_(node.frozen)
def test_pushes_oldest_even_if_recently_used(self):
self.uq.put(self.node)
self.uq.put(larch.LeafNode(2, [], []))
self.uq.get(self.node.id)
self.uq.put(larch.LeafNode(3, [], []))
self.assertEqual(self.nodes, [self.node])
