def test_simple(self):
r = routing_range.Range("AB", "AC", True, False)
self.validate_against_cached_collection_results([r])
ranges = [
routing_range.Range("0000000040", "0000000045", True, False),
routing_range.Range("0000000045", "0000000046", True, False),
routing_range.Range("0000000046", "0000000050", True, False)
]
self.validate_against_cached_collection_results(ranges)
def test_two_ranges_in_one_partition_key_range(self):
# two ranges fall in the same partition key range
ranges = [
routing_range.Range("05C1C9CD673400", "05C1C9CD673401", True,
False),
routing_range.Range("05C1C9CD673402", "05C1C9CD673403", True,
False),
]
self.validate_against_cached_collection_results(ranges)
self.validate_overlapping_ranges_results(
ranges, self.partition_key_ranges[1:2])
def test_two_adjacent_boundary(self):
ranges = [
# self.partition_key_ranges[1]
routing_range.Range("05C1C9CD673398", "05C1D9CD673398", True,
False),
# self.partition_key_ranges[2]
routing_range.Range("05C1D9CD673398", "05C1D9CD673399", True,
False),
]
self.validate_against_cached_collection_results(ranges)
self.validate_overlapping_ranges_results(
ranges, self.partition_key_ranges[1:3])
def test_advanced(self):
partition_key_ranges = [{
u'id': u'0',
u'minInclusive': u'',
u'maxExclusive': u'05C1C9CD673398'
}, {
u'id': u'1',
u'minInclusive': u'05C1C9CD673398',
u'maxExclusive': u'05C1D9CD673398'
}, {
u'id': u'2',
u'minInclusive': u'05C1D9CD673398',
u'maxExclusive': u'05C1E399CD6732'
}, {
u'id': u'3',
u'minInclusive': u'05C1E399CD6732',
u'maxExclusive': u'05C1E9CD673398'
}, {
u'id': u'4',
u'minInclusive': u'05C1E9CD673398',
u'maxExclusive': u'FF'
}]
partitionRangeWithInfo = [(r, True) for r in partition_key_ranges]
pkRange = routing_range.Range("", "FF", True, False)
collection_routing_map = CollectionRoutingMap.CompleteRoutingMap(
partitionRangeWithInfo, 'sample collection id')
overlapping_partition_key_ranges = collection_routing_map.get_overlapping_ranges(
pkRange)
self.assertEqual(len(overlapping_partition_key_ranges),
len(partition_key_ranges))
self.assertEqual(overlapping_partition_key_ranges,
partition_key_ranges)
def test_simple_boundary(self):
ranges = [
routing_range.Range("05C1C9CD673398", "05C1D9CD673398", True,
False),
]
self.validate_against_cached_collection_results(ranges)
self.validate_overlapping_ranges_results(
ranges, self.partition_key_ranges[1:2])
def test_full_range(self):
# query range is the whole partition key range
pkRange = routing_range.Range("", "FF", True, False)
overlapping_partition_key_ranges = self.get_overlapping_ranges(
[pkRange])
self.assertEqual(len(overlapping_partition_key_ranges),
len(self.partition_key_ranges))
self.assertEqual(overlapping_partition_key_ranges,
self.partition_key_ranges)
pkRange = routing_range.Range("", "FF", False, False)
overlapping_partition_key_ranges = self.get_overlapping_ranges(
[pkRange])
self.assertEqual(overlapping_partition_key_ranges,
self.partition_key_ranges)
self.assertEqual(
self.cached_collection_routing_map.get_overlapping_ranges(
[pkRange]), self.partition_key_ranges)
def test_routing_map_provider(self):
partition_key_ranges = list(
self.client.client_connection._ReadPartitionKeyRanges(
self.collection_link))
routing_mp = PartitionKeyRangeCache(self.client.client_connection)
overlapping_partition_key_ranges = routing_mp.get_overlapping_ranges(
self.collection_link, routing_range.Range("", "FF", True, False))
self.assertEqual(len(overlapping_partition_key_ranges),
len(partition_key_ranges))
self.assertEqual(overlapping_partition_key_ranges,
partition_key_ranges)
def test_bad_overlapping_query_ranges(self):
# they share AA point
r1 = routing_range.Range("", "AA", True, True)
r2 = routing_range.Range("AA", "FF", True, False)
def func_one_point_overlap():
self.smart_routing_map_provider.get_overlapping_ranges(
"sample collection id", [r1, r2])
self.assertRaises(ValueError, func_one_point_overlap)
# overlapping range
r1 = routing_range.Range("", "AB", True, False)
r2 = routing_range.Range("AA", "FA", True, False)
def func_overlap():
self.smart_routing_map_provider.get_overlapping_ranges(
"sample collection id", [r1, r2])
self.assertRaises(ValueError, func_overlap)
r1 = routing_range.Range("AB", "AC", True, False)
r1 = routing_range.Range("AA", "AB", True, False)
def func_non_sorted():
self.smart_routing_map_provider.get_overlapping_ranges(
"sample collection id", [r1, r2])
self.assertRaises(ValueError, func_overlap)
def __init__(self, range_by_id, range_by_info,
ordered_partition_key_ranges, ordered_partition_info,
collection_unique_id):
self._rangeById = range_by_id
self._rangeByInfo = range_by_info
self._orderedPartitionKeyRanges = ordered_partition_key_ranges
self._orderedRanges = [
routing_range.Range(pkr[PartitionKeyRange.MinInclusive],
pkr[PartitionKeyRange.MaxExclusive], True,
False) for pkr in ordered_partition_key_ranges
]
self._orderedPartitionInfo = ordered_partition_info
self._collectionUniqueId = collection_unique_id
def test_empty_ranges(self):
# query range is the whole partition key range
pkRange = routing_range.Range("", "FF", True, False)
overlapping_partition_key_ranges = self.get_overlapping_ranges(
[pkRange])
self.assertEqual(len(overlapping_partition_key_ranges),
len(self.partition_key_ranges))
self.assertEqual(overlapping_partition_key_ranges,
self.partition_key_ranges)
# query range list is empty
overlapping_partition_key_ranges = self.get_overlapping_ranges([])
self.assertEqual(len(overlapping_partition_key_ranges), 0)
# validate the overlaping partition key ranges results for empty ranges is empty
empty_start_range = routing_range.Range("", "", False, True)
empty_end_range = routing_range.Range("FF", "FF", False, True)
empty_range = routing_range.Range("AA", "AA", False, True)
self.validate_empty_query_ranges(
[empty_range], [empty_start_range], [empty_end_range],
[empty_start_range, empty_range],
[empty_start_range, empty_end_range],
[empty_range, empty_end_range],
[empty_range, empty_range, empty_end_range])
def test_empty_ranges_are_thrown_away(self):
e1 = routing_range.Range("", "", True, False)
r1 = routing_range.Range("", "AB", True, False)
e2 = routing_range.Range("AB", "AB", True, False)
r2 = routing_range.Range("AB", "AC", True, False)
e3 = routing_range.Range("AC", "AC", True, False)
e4 = routing_range.Range("AD", "AD", True, False)
self.validate_overlapping_ranges_results([e1, r1, e2, r2, e3, e4],
self.get_overlapping_ranges(
[r1, r2]))
self.validate_against_cached_collection_results(
[e1, r1, e2, r2, e3, e4])
def test_complex(self):
ranges = [
# all are covered by self.partition_key_ranges[1]
routing_range.Range("05C1C9CD673398", "05C1D9CD673391", True,
False),
routing_range.Range("05C1D9CD673391", "05C1D9CD673392", True,
False),
routing_range.Range("05C1D9CD673393", "05C1D9CD673395", True,
False),
routing_range.Range("05C1D9CD673395", "05C1D9CD673395", True,
False),
# all are covered by self.partition_key_ranges[4]]
routing_range.Range("05C1E9CD673398", "05C1E9CD673401", True,
False),
routing_range.Range("05C1E9CD673402", "05C1E9CD673403", True,
False),
# empty range
routing_range.Range("FF", "FF", True, False),
]
self.validate_against_cached_collection_results(ranges)
self.validate_overlapping_ranges_results(
ranges,
[self.partition_key_ranges[1], self.partition_key_ranges[4]])
def test_collection_routing_map(self):
Id = 'id'
MinInclusive = 'minInclusive'
MaxExclusive = 'maxExclusive'
partitionKeyRanges = \
[
({Id : "2",
MinInclusive : "0000000050",
MaxExclusive : "0000000070"},
2),
({Id : "0",
MinInclusive : "",
MaxExclusive : "0000000030"},
0),
({Id : "1",
MinInclusive : "0000000030",
MaxExclusive : "0000000050"},
1),
({Id : "3",
MinInclusive : "0000000070",
MaxExclusive : "FF"},
3)
]
crm = CollectionRoutingMap.CompleteRoutingMap(partitionKeyRanges, "")
self.assertEqual("0", crm._orderedPartitionKeyRanges[0][Id])
self.assertEqual("1", crm._orderedPartitionKeyRanges[1][Id])
self.assertEqual("2", crm._orderedPartitionKeyRanges[2][Id])
self.assertEqual("3", crm._orderedPartitionKeyRanges[3][Id])
self.assertEqual(0, crm._orderedPartitionInfo[0])
self.assertEqual(1, crm._orderedPartitionInfo[1])
self.assertEqual(2, crm._orderedPartitionInfo[2])
self.assertEqual(3, crm._orderedPartitionInfo[3])
self.assertEqual("0", crm.get_range_by_effective_partition_key("")[Id])
self.assertEqual(
"0",
crm.get_range_by_effective_partition_key("0000000000")[Id])
self.assertEqual(
"1",
crm.get_range_by_effective_partition_key("0000000030")[Id])
self.assertEqual(
"1",
crm.get_range_by_effective_partition_key("0000000031")[Id])
self.assertEqual(
"3",
crm.get_range_by_effective_partition_key("0000000071")[Id])
self.assertEqual("0", crm.get_range_by_partition_key_range_id("0")[Id])
self.assertEqual("1", crm.get_range_by_partition_key_range_id("1")[Id])
fullRangeMinToMaxRange = routing_range.Range(
CollectionRoutingMap.MinimumInclusiveEffectivePartitionKey,
CollectionRoutingMap.MaximumExclusiveEffectivePartitionKey, True,
False)
overlappingRanges = crm.get_overlapping_ranges(
[fullRangeMinToMaxRange])
self.assertEqual(4, len(overlappingRanges))
onlyParitionRanges = [item[0] for item in partitionKeyRanges]
def getKey(r):
return r['id']
onlyParitionRanges.sort(key=getKey)
self.assertEqual(overlappingRanges, onlyParitionRanges)
noPoint = routing_range.Range(
CollectionRoutingMap.MinimumInclusiveEffectivePartitionKey,
CollectionRoutingMap.MinimumInclusiveEffectivePartitionKey, False,
False)
self.assertEqual(0, len(crm.get_overlapping_ranges([noPoint])))
onePoint = routing_range.Range("0000000040", "0000000040", True, True)
overlappingPartitionKeyRanges = crm.get_overlapping_ranges([onePoint])
self.assertEqual(1, len(overlappingPartitionKeyRanges))
self.assertEqual("1", overlappingPartitionKeyRanges[0][Id])
ranges = [
routing_range.Range("0000000040", "0000000045", True, True),
routing_range.Range("0000000045", "0000000046", True, True),
routing_range.Range("0000000046", "0000000050", True, True)
]
overlappingPartitionKeyRanges = crm.get_overlapping_ranges(ranges)
self.assertEqual(2, len(overlappingPartitionKeyRanges))
self.assertEqual("1", overlappingPartitionKeyRanges[0][Id])
self.assertEqual("2", overlappingPartitionKeyRanges[1][Id])
