1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
|
import pytest
from random_order.shuffler import _shuffle_items
def identity_key(item, session):
return item
def modulus_2_key(item, session):
return item % 2
def lt_10_key(item, session):
return item < 10
def disable_if_gt_1000(item, session):
# if disable returns a truthy value, it must also be usable as a key.
if item > 1000:
return item // 1000
else:
return False
@pytest.mark.parametrize(
"key",
[
None,
lambda item, session: None,
lambda item, session: item % 2,
],
)
def test_shuffles_empty_list_in_place(key):
items = []
items_id = id(items)
_shuffle_items(items, bucket_key=key)
assert items == []
assert id(items) == items_id
@pytest.mark.parametrize(
"key",
[
None,
lambda item, session: None,
lambda item, session: item % 2,
],
)
def test_shuffles_one_item_list_in_place(key):
items = [42]
items_id = id(items)
_shuffle_items(items, bucket_key=key)
assert items == [42]
assert id(items) == items_id
def test_identity_key_results_in_complete_reshuffle():
items = list(range(20))
items_copy = list(items)
_shuffle_items(items, bucket_key=identity_key)
assert items != items_copy
def test_two_bucket_reshuffle():
# If we separate a list of 20 integers from 0 to 19 into two buckets
# [[0..9], [10..19]] then the result should be
# either [{0..9}, {10..19}]
# or [{10..19}, {0..9}]
items = list(range(20))
items_copy = list(items)
_shuffle_items(items, bucket_key=lt_10_key)
assert items != items_copy
for i, item in enumerate(items):
if lt_10_key(i, None):
assert lt_10_key(item, None) == lt_10_key(items[0], None), items
else:
assert lt_10_key(item, None) == lt_10_key(items[10], None), items
def test_eight_bucket_reshuffle():
# This is a cross-check to test shuffling of buckets.
items = [
1,
1,
2,
2,
3,
3,
4,
4,
5,
5,
6,
6,
7,
7,
8,
8,
]
items_copy = list(items)
_shuffle_items(items, bucket_key=identity_key)
assert items != items_copy
# Items of the same bucket should remain next to each other.
assert items[0] == items[1]
assert items[2] == items[3]
assert items[-1] == items[-2]
def test_shuffle_respects_single_disabled_group_in_each_of_two_buckets():
items = [
11,
13,
9995,
9997,
19,
21,
23,
25,
27,
29, # bucket 1 -- odd numbers
12,
14,
9996,
9998,
20,
22,
24,
26,
28,
30, # bucket 2 -- even numbers
]
items_copy = list(items)
_shuffle_items(items, bucket_key=modulus_2_key, disable=disable_if_gt_1000)
assert items != items_copy
assert items.index(9995) + 1 == items.index(9997)
assert items.index(9996) + 1 == items.index(9998)
def test_shuffle_respects_two_distinct_disabled_groups_in_one_bucket():
# all items are in one oddity bucket, but the two groups
# of large numbers are separate because they are disabled
# from two different units.
# This is simulating two disabled modules within same package.
# The two modules shouldn't be mixed up in one bucket.
items = [
11,
13,
8885,
8887,
8889,
21,
23,
9995,
9997,
9999,
]
items_copy = list(items)
for i in range(5):
_shuffle_items(items, bucket_key=modulus_2_key, disable=disable_if_gt_1000)
if items != items_copy:
assert items[items.index(8885) : items.index(8885) + 3] == [8885, 8887, 8889]
assert items[items.index(9995) : items.index(9995) + 3] == [9995, 9997, 9999]
return
assert False
def test_shuffle_respects_seed():
sorted_items = list(range(30))
for seed in range(20):
# Reset
items1 = list(range(30))
_shuffle_items(items1, seed=seed)
assert items1 != sorted_items
items2 = list(range(30))
_shuffle_items(items2, seed=seed)
assert items2 == items1
|
