def test_build_formset_creates_initial_data_if_whitelist_is_present(self):
num_ranges = random.randint(1, 10)
wl = Whitelist.objects.create(
name='anything',
slug='anything',
)
l = []
for i in range(num_ranges):
r = wl.range_set.create(
ip=fmt_ip(random.randint(0, 0xFFFFFFFF)),
cidr=random.randint(0, 32)
)
l.append(r)
wlf = WhitelistForm(None, wl)
self.assertEqual(len(wlf.formset.initial), num_ranges)
for idx, initial in enumerate(wlf.formset.initial):
self.assertEqual(
initial['ip'], l[idx].ip
)
self.assertEqual(
initial['cidr'], l[idx].cidr
)
def test_process_view_passes_curried_mithril_reset_view(self):
expected = fmt_ip(random.randint(1, 0xFFFFFFFF))
req = self.fake_request(expected)
strat = CachedStrategy()
wl = CachedWhitelist.objects.create(
name='okay',
slug='okay'
)
wl.range_set.create(
ip='0.0.0.0',
cidr=32
)
strat.return_one = lambda *a, **kw: wl.pk
strat.actions = [['return_one', 'pk']]
view = lambda:None
view.mithril_reset = \
lambda request, view, args, kwargs: check(
request, view, args, kwargs)
def check(request, target_view, target_args, target_kwargs):
self.assertTrue(request is req)
self.assertEqual(target_view, view)
return expected
self.assertEqual(
strat.process_view(req, view, (), {}),
expected
)
def test_save_sets_appropriate_ranges(self):
num_forms = random.randint(1, 10)
name = ' '.join([str(random.randint(0, 10)) for i in range(10)])
data = {
'name': name,
'current_ip': 'x',
'_formset-TOTAL_FORMS': '%d' % num_forms,
'_formset-INITIAL_FORMS': '0',
'_formset-MAX_FORMS': '',
}
for i in range(num_forms):
data['_formset-%d-ip' % i] = fmt_ip(random.randint(0, 0xFFFFFFFF))
data['_formset-%d-cidr' % i] = random.randint(0, 32)
wlf = WhitelistForm(None, None, data)
wlf.is_valid()
self.assertTrue(wlf.is_valid())
wl = wlf.save()
for i in range(num_forms):
self.assertTrue(wl.range_set.filter(
ip=data['_formset-%d-ip' % i],
cidr=data['_formset-%d-cidr' % i]
).exists())
def test_netaddr_integration(self):
# just a tiny range, here
test_ip = random.randint(0, 0xFFFFFFFF)
num_ranges = random.randint(1, 10)
whitelist = Whitelist.objects.create(name="anything", slug="anything")
cidrs = []
for idx in range(num_ranges):
r = whitelist.range_set.create(ip=fmt_ip(random.randint(0, 0xFFFFFFFF)), cidr=random.randint(1, 32))
cidrs.append("%s/%d" % (r.ip, r.cidr))
self.assertEqual(whitelist.okay(test_ip), len(netaddr.all_matching_cidrs(test_ip, cidrs)) > 0)
def test_process_view_skips_lookups_raising_fielderror(self):
expected = fmt_ip(random.randint(1, 0xFFFFFFFF))
req = self.fake_request(expected)
strat = Strategy()
strat.return_one = lambda *a, **kw: 1
strat.actions = [['return_one', 'anything']]
self.assertEqual(
strat.process_view(req, None, (), {}),
None
)
def test_process_view_skips_methods_returning_none(self):
expected = fmt_ip(random.randint(1, 0xFFFFFFFF))
req = self.fake_request(expected)
strat = CachedStrategy()
strat.return_none = lambda *a, **kw: None
strat.actions = [['return_none', 'anything']]
self.assertEqual(
strat.process_view(req, None, (), {}),
None
)
def test_get_authentication_backend_authenticate(self):
Expected = object()
class MyStrategy(CachedStrategy):
partial_credential_lookup = (
('pk', 'pk'),
)
def authenticate(*args, **kwargs):
return Expected
base_backend = type('Any', (object,), {'authenticate':authenticate})
new_backend = MyStrategy.get_authentication_backend(base_backend)
backend = new_backend()
whitelist = CachedWhitelist.objects.create(name='asdf', slug='asdf')
whitelist.range_set.create(
ip='0.0.0.0',
cidr=32
)
# when the key isn't there.
self.assertEqual(backend.authenticate(), None)
# when the key is there and it fails.
mithril.set_current_ip(fmt_ip(random.randint(1, 10)))
self.assertEqual(backend.authenticate(pk=whitelist.pk), None)
# when the key is there and it succeeds.
mithril.set_current_ip(fmt_ip(0))
self.assertEqual(backend.authenticate(pk=whitelist.pk), Expected)
# when the key is there, but there are no whitelists
mithril.set_current_ip(fmt_ip(0))
self.assertEqual(backend.authenticate(pk=whitelist.pk+1), Expected)
def test_whitelist_ip_returns_response_fn_on_not_okay(self):
strat = Strategy()
ip = fmt_ip(random.randint(1, 0xFFFFFFFF))
whitelist = Whitelist.objects.create(name='asdf', slug='asdf')
whitelist.range_set.create(
ip='0.0.0.0',
cidr=32
)
Expected = object()
self.assertEqual(
strat.whitelist_ip(ip, [whitelist], lambda:Expected),
Expected
)
def test_process_view_skips_methods_returning_no_whitelists(self):
expected = fmt_ip(random.randint(1, 0xFFFFFFFF))
req = self.fake_request(expected)
strat = Strategy()
# there are no whitelists at this point,
# so a 'pk' lookup will return nothing!
strat.return_one = lambda *a, **kw: 1
strat.actions = [['return_one', 'pk']]
self.assertEqual(
strat.process_view(req, None, (), {}),
None
)
def test_process_view_passes_forbidden_response_class(self):
expected = fmt_ip(random.randint(1, 0xFFFFFFFF))
req = self.fake_request(expected)
strat = CachedStrategy()
wl = CachedWhitelist.objects.create(
name='okay',
slug='okay'
)
wl.range_set.create(
ip='0.0.0.0',
cidr=32
)
strat.return_one = lambda *a, **kw: wl.pk
strat.actions = [['return_one', 'pk']]
self.assertTrue(
isinstance(strat.process_view(req, None, (), {}),
HttpResponseForbidden)
)
