def test(self, raw, bwcls):
inst = OfferBlockBase()
inst.NAME = "ResvInfoBase"
inst.RESVINFO = create_mock()
offers = []
for i in range(4):
offers.append("fwd %d" % i)
offers.append("rev %d" % i)
data = create_mock(["__bool__", "__len__", "pop"])
data.__bool__.side_effect = ([True] * 4) + [False]
data.pop.side_effect = ["resv info"] + offers
data.__len__.return_value = 4 * inst.OFFER_LEN
raw.return_value = data
# Call
inst._parse("data")
# Tests
inst.RESVINFO.assert_called_once_with("resv info")
ntools.eq_(inst.info, inst.RESVINFO.return_value)
ntools.eq_(inst.offer_hops, 4)
assert_these_calls(bwcls, [
call("fwd 0", "rev 0"),
call("fwd 1", "rev 1"),
call("fwd 2", "rev 2"),
call("fwd 3", "rev 3"),
])
def test(self, l4_protos, ext_map):
data = create_mock(["pop"])
data.pop.side_effect = (
bytes.fromhex("881103"),
"ext0 data",
bytes.fromhex("011699"),
"ext1 data",
bytes.fromhex("FF0806"),
"ext1 data",
)
l4_protos.append(0xFF)
ext0 = create_mock()
ext1 = create_mock()
ext_map[(7, 3)] = ext0
ext_map[(1, 6)] = ext1
# Call
ext_hdrs, hdr_type, unknown = parse_extensions(data, 7)
# Tests
assert_these_calls(data.pop, (
call(ExtensionHeader.SUBHDR_LEN),
call(0x11 * ExtensionHeader.LINE_LEN - ExtensionHeader.SUBHDR_LEN),
call(ExtensionHeader.SUBHDR_LEN),
call(0x16 * ExtensionHeader.LINE_LEN - ExtensionHeader.SUBHDR_LEN),
call(ExtensionHeader.SUBHDR_LEN),
call(0x08 * ExtensionHeader.LINE_LEN - ExtensionHeader.SUBHDR_LEN),
))
ntools.eq_(ext_hdrs, [ext0.return_value, ext1.return_value])
ntools.eq_(hdr_type, 0xFF)
ntools.eq_(unknown, {0x88: [1]})
def test_basic(self, _, sha):
inst, h = self._setup()
sha.new.return_value = h
# Call
ntools.eq_(inst.get_hops_hash(), 'digest')
# Tests
assert_these_calls(h.update, [call("t0"), call("t1")])
def test_with_free_up(self):
key1 = ("1-ff00:0:300", 1)
key2 = ("1-ff00:0:301", 1)
now = int(time.time())
rev_info1 = self._create_rev_info(key1[0], key1[1], timestamp=now)
rev_info2 = self._create_rev_info(key2[0], key2[1], timestamp=now + 1)
def check_active_side_effect(srev_info):
del rev_cache._cache[(srev_info.rev_info().isd_as(),
srev_info.rev_info().p.ifID)]
return False
rev_cache = RevCache(capacity=1)
rev_cache._cache[key1] = rev_info1
rev_cache._check_active = create_mock()
rev_cache._check_active.side_effect = check_active_side_effect
rev_cache.get = create_mock()
rev_cache.get.return_value = None
# Call
ntools.assert_true(rev_cache.add(rev_info2))
# Tests
ntools.eq_(rev_cache._cache[key2], rev_info2)
ntools.assert_true(key1 not in rev_cache._cache)
assert_these_calls(rev_info2.rev_info().active, [call()])
assert_these_calls(rev_cache.get, [call(key2)])
def test(self, server):
topo_dict = {
'BeaconService': {"bs1": "bs1 val"},
'CertificateService': {"cs1": "cs1 val"},
'PathService': {"ps1": "ps1 val", "ps2": "ps2 val"},
'SIG': {"sig1": "sig1 val"},
'DiscoveryService': {"ds1": "ds1 val"},
}
inst = Topology()
server.side_effect = lambda v, k: "%s-%s" % (k, v)
# Call
inst._parse_srv_dicts(topo_dict)
# Tests
assert_these_calls(server, [
call("bs1 val", "bs1"),
call("cs1 val", "cs1"),
call("ps1 val", "ps1"),
call("ps2 val", "ps2"),
call("sig1 val", "sig1"),
call("ds1 val", "ds1"),
], any_order=True)
ntools.eq_(inst.beacon_servers, ["bs1-bs1 val"])
ntools.eq_(inst.certificate_servers, ["cs1-cs1 val"])
ntools.eq_(sorted(inst.path_servers),
sorted(["ps1-ps1 val", "ps2-ps2 val"]))
ntools.eq_(inst.discovery_servers, ["ds1-ds1 val"])
def test_full(self, formatter, rotate, console, basic_config):
levels = "DEBUG", "INFO", "WARNING", "ERROR", "CRITICAL"
file_handlers = [
create_mock(["setLevel", "setFormatter"]),
create_mock(["setLevel", "setFormatter"]),
create_mock(["setLevel", "setFormatter"]),
create_mock(["setLevel", "setFormatter"]),
create_mock(["setLevel", "setFormatter"]),
]
console_handler = console.return_value
rotate.side_effect = file_handlers
# Call
init_logging("logbase",
file_level=logging.DEBUG,
console_level=logging.CRITICAL)
# Tests
rotate_calls = []
for lvl in levels:
rotate_calls.append(
call("logbase.%s" % lvl,
maxBytes=LOG_MAX_SIZE,
backupCount=LOG_BACKUP_COUNT,
encoding="utf-8"))
assert_these_calls(rotate, rotate_calls)
for lvl, f_h in zip(levels, file_handlers):
f_h.setLevel.assert_called_once_with(logging._nameToLevel[lvl])
f_h.setFormatter.assert_called_once_with(formatter.return_value)
console_handler.setLevel.assert_called_once_with(logging.CRITICAL)
console_handler.setFormatter.assert_called_once_with(
formatter.return_value)
basic_config.assert_called_once_with(level=logging.DEBUG,
handlers=file_handlers +
[console_handler])
def test_full(self, raw):
inst = SCIONPath()
inst._parse_iof = create_mock()
inst._parse_hofs = create_mock()
inst._init_of_idxs = create_mock()
iof_list = []
for i in 2, 4, 6:
iof = create_mock(["hops", "shortcut"])
iof.hops = i
iof.shortcut = False
iof_list.append(iof)
inst._parse_iof.side_effect = iof_list
data = create_mock()
data.side_effect = ("A IOF", "A HOFS", "B IOF", "B HOFS", "C IOF",
"C HOFS")
raw.return_value = data
# Call
inst._parse("data")
# Tests
assert_these_calls(inst._parse_iof, [
call(data, inst.A_IOF),
call(data, inst.B_IOF),
call(data, inst.C_IOF)
])
assert_these_calls(inst._parse_hofs, [
call(data, inst.A_HOFS, 2),
call(data, inst.B_HOFS, 4),
call(data, inst.C_HOFS, 6)
])
inst._init_of_idxs.assert_called_once_with()
def test(self, raw, scmp_info):
inst = SCMPPayload()
data = create_mock(["pop"])
data.pop.side_effect = (
bytes.fromhex("0102030405060700"),
"info",
"cmn hdr",
"addrs",
"path",
"exts",
"l4 hdr",
)
raw.return_value = data
# Call
inst._parse("class", "type", "data")
# Tests
raw.assert_called_once_with("data", inst.NAME)
ntools.eq_(inst.l4_proto, 0x07)
pop_calls = [call(inst.META_LEN)
] + [call(x * LINE_LEN) for x in range(1, 7)]
assert_these_calls(data.pop, pop_calls)
scmp_info.assert_called_once_with("class", "type", "info")
ntools.eq_(inst.info, scmp_info.return_value)
ntools.eq_(inst._cmn_hdr, "cmn hdr")
ntools.eq_(inst._addrs, "addrs")
ntools.eq_(inst._path, "path")
ntools.eq_(inst._exts, "exts")
ntools.eq_(inst._l4_hdr, "l4 hdr")
def test(self, raw, super_parse, isd_as):
inst = TracerouteExt()
inst.append_hop = create_mock()
data = create_mock(["pop"])
data.pop.side_effect = (
None,
"isd as 1",
bytes.fromhex('1111 2222'),
"isd as 2",
bytes.fromhex('3333 4444'),
)
raw.return_value = data
isd_as.LEN = 4
isd_as.side_effect = "1-11", "2-22"
dlen = inst.MIN_LEN + 2 * inst.HOP_LEN
arg = bytes([2]) + bytes(dlen - 1)
# Call
inst._parse(arg)
# Tests
raw.assert_called_once_with(arg, "TracerouteExt", dlen, min_=True)
super_parse.assert_called_once_with(inst, data)
assert_these_calls(isd_as, (call("isd as 1"), call("isd as 2")))
assert_these_calls(inst.append_hop, (
call("1-11", 0x1111, 0x2222),
call("2-22", 0x3333, 0x4444),
))
def test_invalid_entry(self, verify_epoch):
rev_info = self._create_rev_info("1-1", 1, 2)
verify_epoch.return_value = ConnectedHashTree.EPOCH_PAST
rev_cache = RevCache()
# Call
ntools.assert_false(rev_cache.add(rev_info))
assert_these_calls(verify_epoch, [call(rev_info.p.epoch)])
def test_setup_new_block(self):
inst = SibraExtEphemeral()
inst._get_ifids = create_mock()
inst._get_ifids.side_effect = (
("prev_ingress", "prev_egress"),
("curr_ingress", "curr_egress"),
)
inst._get_prev_raw = create_mock()
inst.setup = True
inst.block_idx = 1
inst.rel_sof_idx = 0
prev_block = create_mock(["info", "sofs"])
prev_block.info = create_mock(["fwd_dir"])
prev_block.sofs = ["prev sof0", "prev sof1"]
curr_block = create_mock(["info", "sofs"])
curr_block.info = create_mock(["fwd_dir"])
curr_block.sofs = ["curr sof0", "curr sof1"]
inst.active_blocks = [prev_block, curr_block]
inst.req_block = create_mock(["add_hop"])
inst.path_ids = "path_ids"
# Call
inst._add_hop("key")
# Tests
assert_these_calls(inst._get_ifids, [
call("prev sof1", prev_block.info.fwd_dir),
call("curr sof0", curr_block.info.fwd_dir),
])
inst.req_block.add_hop.assert_called_once_with(
"prev_ingress", "curr_egress", inst._get_prev_raw.return_value,
"key", "path_ids")
def test_invalid_entry(self):
rev_info = self._create_rev_info("1-ff00:0:300",
1,
timestamp=int(time.time()) - 20)
rev_cache = RevCache()
# Call
ntools.assert_false(rev_cache.add(rev_info))
assert_these_calls(rev_info.rev_info().active, [call()])
def test(self):
inst = PathSegmentDB()
inst.delete = create_mock()
inst.delete.side_effect = (DBResult.ENTRY_DELETED, DBResult.NONE,
DBResult.ENTRY_DELETED)
# Call
ntools.eq_(inst.delete_all((0, 1, 2)), 2)
# Tests
assert_these_calls(inst.delete, [call(i) for i in (0, 1, 2)])
def test(self, build_path):
up_segments = ['up0', 'up1']
down_segments = ['down0', 'down1']
build_path.side_effect = ['path0', 'path1', None, 'path1']
ntools.eq_(
PathCombinator.build_shortcut_paths(up_segments, down_segments),
["path0", "path1"])
calls = [call(*x) for x in product(up_segments, down_segments)]
assert_these_calls(build_path, calls)
def test_v4(self, parse):
parse.side_effect = iter([SCIONParseError, "v4 parsed"])
# Call
ntools.eq_(haddr_parse_interface("v4 addr"), "v4 parsed")
# Tests
assert_these_calls(parse, [
call(AddrType.IPV6, "v4 addr"),
call(AddrType.IPV4, "v4 addr"),
])
def test(self):
inst = OfferBlockBase()
inst.info = create_mock(["fail_hop"])
inst.info.fail_hop = 2
offer = create_mock(["min"])
inst.offers = [offer] * 5
# Call
ret = inst.get_min(5)
# Tests
assert_these_calls(ret.min, [call(offer)] * 3)
def _check(self, type_lens, exp_total, exp_pad, calc_len, calc_padding):
calc_len.side_effect = type_lens
calc_padding.return_value = exp_pad
# Call
results = SCIONAddrHdr.calc_lens(1, 2)
# Tests
assert_these_calls(calc_len, [call(1), call(2)])
calc_padding.assert_called_once_with(sum(type_lens),
SCIONAddrHdr.BLK_SIZE)
ntools.eq_(results, (exp_total, exp_pad))
def _check_three(self, curr_label, new_label):
inst = self._setup(curr_label, b_seg=True, c_seg=True)
# Call
inst.reverse()
# Tests
assert_these_calls(
inst._ofs.swap,
[call(inst.A_IOF, inst.C_IOF),
call(inst.A_HOFS, inst.C_HOFS)])
inst._ofs.get_idx_by_label.assert_called_once_with(new_label)
def test_expired_entry(self):
key = ("1-1", 1)
default = "default"
rev_info = "rev_info"
rev_cache = RevCache()
rev_cache._cache[key] = rev_info
rev_cache._validate_entry = create_mock_full(return_value=False)
# Call
ntools.eq_(rev_cache.get(key, default=default), default)
# Tests
assert_these_calls(rev_cache._validate_entry, [call(rev_info)])
def test(self, hof):
inst = SCIONPath()
data = create_mock(["pop"])
inst._ofs = create_mock(["set"])
hof.side_effect = ["hof0", "hof1", "hof2"]
# Call
inst._parse_hofs(data, "label", 3)
# Tests
assert_these_calls(data.pop, [call(hof.LEN)] * 3)
inst._ofs.set.assert_called_once_with("label",
["hof0", "hof1", "hof2"])
def test_peer(self):
inst = self._setup()
iof_1 = self._mk_iof(True)
iof_2 = self._mk_iof(True)
inst._ofs.get_by_label.side_effect = [iof_1], [iof_2], None
# Call
ntools.eq_(inst.get_as_hops(), 10)
# Tests
assert_these_calls(inst._ofs.get_by_label,
[call(l) for l in inst.IOF_LABELS])
assert_these_calls(inst._get_as_hops, [call(iof_1), call(iof_2)])
def test_one(self):
inst = self._setup()
iof = self._mk_iof()
inst._ofs.get_by_label.side_effect = [iof], None
# Call
ntools.eq_(inst.get_as_hops(), 5)
# Tests
assert_these_calls(
inst._ofs.get_by_label,
[call(inst.A_IOF), call(inst.B_IOF)])
inst._get_as_hops.assert_called_once_with(iof)
def test_success(self, init, get_time):
entries = {}
for last_seen in 1000, 999, 996, 995, 994, 990, 1001:
entries["entry%d" % last_seen] = last_seen
inst = self._setup(get_time, entries)
# Call
inst.expire(5)
# Tests
assert_these_calls(inst._kazoo.delete, [
call("/path/entry994"), call("/path/entry990")
], any_order=True)
def test_setup(self):
inst = SibraExtEphemeral()
inst.setup = True
inst._parse_block = create_mock()
inst._parse_block.side_effect = "block0", "block1"
inst.path_lens = [3, 4, 0]
# Call
ntools.eq_(inst._parse_active_blocks("data"), ["block0", "block1"])
# Tests
assert_these_calls(inst._parse_block,
[call("data", 3), call("data", 4)])
def test_one(self):
inst = self._setup()
# Call
inst.reverse()
# Tests
assert_these_calls(inst._ofs.reverse_up_flag,
[call(l) for l in inst.IOF_LABELS])
assert_these_calls(inst._ofs.reverse_label,
[call(l) for l in inst.HOF_LABELS])
inst._ofs.get_idx_by_label.assert_called_once_with(inst.A_IOF)
inst.set_of_idxs.assert_called_once_with(
inst._ofs.get_idx_by_label.return_value, 9)
def test(self, build_path):
up_segments = ['up0', 'up1']
down_segments = ['down0', 'down1']
build_path.side_effect = [['path0'], ['path1'], [], ['path1']]
peer_revs = create_mock()
ntools.eq_(
path_combinator.build_shortcut_paths(
up_segments, down_segments, peer_revs),
["path0", "path1"])
calls = [call(*x, peer_revs)
for x in product(up_segments, down_segments)]
assert_these_calls(build_path, calls)
def test_expired_entry(self):
key = ("1-ff00:0:300", 1)
default = "default"
rev_info = "rev_info"
srev_info = create_mock_full({"rev_info()": rev_info})
rev_cache = RevCache()
rev_cache._cache[key] = srev_info
rev_cache._check_active = create_mock_full(return_value=False)
# Call
ntools.eq_(rev_cache.get(key, default=default), default)
# Tests
assert_these_calls(rev_cache._check_active, [call(srev_info)])
def test(self):
key = ("1-ff00:0:300", 1)
rev_info = self._create_rev_info(key[0], key[1])
rev_cache = RevCache()
rev_cache.get = create_mock()
rev_cache.get.return_value = None
# Call
ntools.assert_true(rev_cache.add(rev_info))
# Tests
ntools.eq_(rev_cache._cache[key], rev_info)
assert_these_calls(rev_cache.get, [call(key)])
assert_these_calls(rev_info.rev_info().active, [call()])
def test_reqs(self):
inst = self._setup()
inst._req_map["key"] = [(0, "req0"), (1, "req1"), (2, "req2")]
# Call
inst._answer_reqs("key")
# Tests
inst._expire_reqs.assert_called_once_with("key")
assert_these_calls(
inst._reply,
[call("key", "req0"),
call("key", "req1"),
call("key", "req2")])
ntools.assert_not_in("key", inst._req_map)
def test(self, verify_epoch):
key = ("1-1", 1)
rev_info = self._create_rev_info(key[0], key[1], 2)
verify_epoch.return_value = ConnectedHashTree.EPOCH_OK
rev_cache = RevCache()
rev_cache.get = create_mock()
rev_cache.get.return_value = None
# Call
ntools.assert_true(rev_cache.add(rev_info))
# Tests
ntools.eq_(rev_cache._cache[key], rev_info)
assert_these_calls(rev_cache.get, [call(key)])
assert_these_calls(verify_epoch, [call(rev_info.p.epoch)])
