def test_9(self): pcbms = [] for i in range(3): pcbms.append( create_mock_full({"sig_pack()": bytes("pcbm %i" % i, "ascii")})) inst = ASMarking( create_mock_full({ "isdas": _ISD_AS1, "trcVer": 2, "certVer": 3, "ifIDSize": 4, "hashTreeRoot": b"root", "mtu": 1482, "chain": b"chain" })) inst.iter_pcbms = create_mock_full(return_value=pcbms) expected = b"".join([ _ISD_AS1_BYTES, bytes.fromhex("00000002 00000003 04"), b"pcbm 0", b"pcbm 1", b"pcbm 2", b"root", bytes.fromhex("05ca"), b"chain" ]) # Call ntools.eq_(inst.sig_pack(8), expected)
def test_with_revocation(self, skip_peer): up_pcbms, down_pcbms = self._mk_pcbms() p = create_mock_full({"hashTreeRoot": b"1234"}) up_asm = create_mock_full({"isd_as()": "1-1", "iter_pcbms()": up_pcbms, "p": p}) down_asm = create_mock_full({"isd_as()": "2-1", "iter_pcbms()": down_pcbms, "p": p}) up_peer_rev = create_mock() down_peer_rev = create_mock() peer_revs = create_mock(["get"]) def get_side_effect(key): data = {("1-1", 3): up_peer_rev, ("2-1", 3): down_peer_rev} return data.get(key) peer_revs.get.side_effect = get_side_effect def skip_peer_side_effect(rev, ht_root): if rev in [up_peer_rev, down_peer_rev] and ht_root == b"1234": return True return False skip_peer.side_effect = skip_peer_side_effect # Call peers = path_combinator._find_peer_hfs(up_asm, down_asm, peer_revs) # Tests ntools.eq_(peers, [(up_pcbms[0].hof(), down_pcbms[0].hof(), 500)]) skip_peer.assert_has_calls( [call(None, b"1234"), call(up_peer_rev, b"1234")], any_order=True)
def test_full(self, p_cls): msg = p_cls.new_message.return_value pcbms = [] for i in range(3): pcbms.append(create_mock_full({"p": "pcbm %d" % i})) cchain = create_mock_full({"pack()": "cchain"}) # Call ASMarking.from_values(_ISD_AS1, 2, 3, pcbms, "root", "mtu", cchain, ifid_size=14) # Tests p_cls.new_message.assert_called_once_with(isdas=_ISD_AS1, trcVer=2, certVer=3, ifIDSize=14, hashTreeRoot="root", mtu="mtu", chain="cchain") msg.init.assert_called_once_with("pcbms", 3) for i, pcbm in enumerate(msg.pcbms): ntools.eq_("pcbm %d" % i, pcbm)
def test_with_revocation(self): up_pcbms, down_pcbms = self._mk_pcbms() up_asm = create_mock_full({ "isd_as()": "1-ff00:0:300", "iter_pcbms()": up_pcbms }) down_asm = create_mock_full({ "isd_as()": "2-ff00:0:321", "iter_pcbms()": down_pcbms }) up_peer_rev = create_mock() down_peer_rev = create_mock() peer_revs = create_mock(["get"]) def get_side_effect(key): data = { ("1-ff00:0:300", 3): up_peer_rev, ("2-ff00:0:321", 3): down_peer_rev } return data.get(key) peer_revs.get.side_effect = get_side_effect # Call peers = path_combinator._find_peer_hfs(up_asm, down_asm, peer_revs) # Tests ntools.eq_(peers, [(up_pcbms[0].hof(), down_pcbms[0].hof(), 500)])
def _check_up_down(self, up): asms = [] ifid = 0 for i in range(1, 4): if up: hof = create_mock_full({ "egress_if": ifid, "ingress_if": ifid + 1 }) if i == 3: hof.ingress_if = 0 else: hof = create_mock_full({ "egress_if": ifid + 1, "ingress_if": ifid }) if i == 3: hof.egress_if = 0 ifid += 2 pcbm = create_mock_full({"hof()": hof}) asms.append(create_mock_full({"isd_as()": i, "pcbm()": pcbm})) if_list = path_combinator._build_interface_list(asms, up) ntools.eq_(if_list, [ PathInterface.from_values(1, 1), PathInterface.from_values(2, 2), PathInterface.from_values(2, 3), PathInterface.from_values(3, 4) ])
def _check_up_down(self, up): asms = [] ifid = 0 for i in range(1, 4): if up: hof = create_mock_full({ "egress_if": ifid, "ingress_if": ifid + 1 }) if i == 3: hof.ingress_if = 0 else: hof = create_mock_full({ "egress_if": ifid + 1, "ingress_if": ifid }) if i == 3: hof.egress_if = 0 ifid += 2 pcbm = create_mock_full({"hof()": hof}) asms.append(create_mock_full({"isd_as()": i, "pcbm()": pcbm})) path = create_mock(["interfaces"]) path.interfaces = [] PathCombinator._add_interfaces(path, asms, up) ntools.eq_(path.interfaces, [(1, 1), (2, 2), (2, 3), (3, 4)])
def test_full(self, p_cls): msg = p_cls.new_message.return_value pcbms = [] for i in range(3): pcbms.append(create_mock_full({"p": "pcbm %d" % i})) exts = [] exts.append( create_mock_full({ "EXT_TYPE": ASMExtType.ROUTING_POLICY, "p": { "polType": RoutingPolType.ALLOW_AS, "itf": 0, "isdases": [_ISD_AS1] } })) # Call ASMarking.from_values(_ISD_AS1, 2, 3, pcbms, "root", "mtu", exts, ifid_size=14) # Tests p_cls.new_message.assert_called_once_with(isdas=_ISD_AS1, trcVer=2, certVer=3, ifIDSize=14, hashTreeRoot="root", mtu="mtu") msg.init.assert_called_once_with("hops", 3) for i, pcbm in enumerate(msg.pcbms): ntools.eq_("pcbm %d" % i, pcbm)
def test(self, hash_func_for_type): # Setup siblings = [] siblings.append(create_mock_full({"isLeft": True, "hash": "10s10"})) siblings.append(create_mock_full({"isLeft": False, "hash": "30s300"})) p = create_mock_full({ "ifID": 2, "epoch": 0, "nonce": b"s20", "siblings": siblings, "prevRoot": "p", "nextRoot": "n", "hashType": 0 }) rev_info = create_mock_full({"p": p}) hashes = [ "20s20", "10s1020s20", "10s1020s2030s300", "p10s1020s2030s300", "10s1020s2030s300n" ] hash_func = create_mock_full(side_effect=hashes) hash_func_for_type.return_value = hash_func # Call hash01, hash12 = ConnectedHashTree.get_possible_hashes(rev_info) # Tests ntools.eq_(hash01, "p10s1020s2030s300") ntools.eq_(hash12, "10s1020s2030s300n")
def test_full(self, p_cls): msg = p_cls.new_message.return_value pcbms = [] for i in range(3): pcbms.append(create_mock_full({"p": "pcbm %d" % i})) cchain = create_mock_full({"pack()": "cchain"}) revs = [] for i in range(2): revs.append(create_mock_full({"pack()": "rev %d" % i})) # Call ASMarking.from_values("isdas", 2, 3, pcbms, "eg rev token", "mtu", cchain, ifid_size=14, rev_infos=revs) # Tests p_cls.new_message.assert_called_once_with(isdas="isdas", trcVer=2, certVer=3, ifIDSize=14, egRevToken="eg rev token", mtu="mtu", chain="cchain") msg.init.assert_called_once_with("pcbms", 3) msg.exts.init.assert_called_once_with("revInfos", 2) for i, pcbm in enumerate(msg.pcbms): ntools.eq_("pcbm %d" % i, pcbm) for i, rev in enumerate(msg.exts.revInfos): ntools.eq_("rev %d" % i, rev)
def test_9(self): pcbms = [] for i in range(3): pcbms.append( create_mock_full({"sig_pack()": bytes("pcbm %i" % i, "ascii")})) exts = create_mock_full({"revInfos": [b"rev0", b"rev1"]}) inst = ASMarking( create_mock_full({ "isdas": "isdas", "trcVer": 2, "certVer": 3, "ifIDSize": 4, "egRevToken": b"eg rev", "exts": exts, "mtu": 1482, "chain": b"chain", })) inst.iter_pcbms = create_mock_full(return_value=pcbms) expected = b"".join([ b"isdas", bytes.fromhex("00000002 00000003 04"), b"pcbm 0", b"pcbm 1", b"pcbm 2", b"eg rev", b"rev0", b"rev1", bytes.fromhex("05ca"), b"chain" ]) # Call ntools.eq_(inst.sig_pack(9), expected)
def _setup(self): asms = [] for i in range(3): pcbm = create_mock_full({"hof()": "hof %d" % i}) asms.append(create_mock_full({"pcbm()": pcbm})) inst = PathSegment(None) inst.iter_asms = create_mock_full(return_value=asms) return inst
def _setup(self): inst = PathSegment({}) inst.get_all_iftokens = create_mock_full(return_value=("t0", "t1")) h = create_mock_full({ 'update()': None, 'digest()': "digest", 'hexdigest()': "hexdigest" }) return inst, h
def _setup_connector(self, response, cache=None, remaining_keys=None): cache = cache or {} remaining_keys = remaining_keys or set() counter = create_mock_full({"inc()": self.REQ_ID}) connector = SCIONDConnector("addr", counter) connector._create_socket = create_mock() connector._get_response = create_mock_full(return_value=response) connector._try_cache = create_mock_full(return_value=(remaining_keys, cache)) return connector
def _create_entries(self, descs): response_entries = [] for desc in descs: p = create_mock_full({"ifID": desc[0], "hostInfo": desc[1]}) response_entries.append( create_mock_full({ "p": p, "host_info()": desc[1] })) return response_entries
def _setup_connector(self, svc_info_desc=None): counter = create_mock_full({"inc()": 1}) connector = SCIONDConnector("addr", counter) if svc_info_desc: svc_info = create_mock_full({"host_info()": svc_info_desc[1]}) connector.get_service_info = create_mock_full( return_value={svc_info_desc[0]: svc_info}) else: connector.get_service_info = create_mock() return connector
def test(self): up_pcbms, down_pcbms = self._mk_pcbms() up_asm = create_mock_full({"isd_as()": "1-ff00:0:300", "iter_pcbms()": up_pcbms}) down_asm = create_mock_full({"isd_as()": "2-ff00:0:321", "iter_pcbms()": down_pcbms}) peer_revs = create_mock_full({"get()": None}) # Call ntools.eq_(path_combinator._find_peer_hfs(up_asm, down_asm, peer_revs), [(up_pcbms[0].hof(), down_pcbms[0].hof(), 500), (up_pcbms[2].hof(), down_pcbms[1].hof(), 700)])
def test_outdated(self, db_rec): inst = PathSegmentDB() pcb = self._mk_pcb(-1) cur_rec = create_mock_full({"pcb": self._mk_pcb(0)}) inst._db = create_mock_full(return_value={0: {'record': cur_rec}}) record = create_mock_full({'id': "idstr"}) db_rec.return_value = record # Call ntools.eq_(inst.update(pcb), DBResult.NONE) # Tests pcb.get_expiration_time.assert_called_once_with() cur_rec.pcb.get_expiration_time.assert_called_once_with()
def test(self): inst = SCIONAddrHdr() inst.calc_lens = create_mock_full(return_value=(1, 3)) inst.src = create_mock_full({"host": create_mock(["TYPE"])}) inst.dst = create_mock_full({"host": create_mock(["TYPE"])}) # Call inst.update() # Tests inst.calc_lens.assert_called_once_with(inst.dst.host.TYPE, inst.src.host.TYPE) ntools.eq_(inst._total_len, 1) ntools.eq_(inst._pad_len, 3)
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_add(self, db_rec): inst = PathSegmentDB() inst._db = create_mock_full({'insert()': None}, return_value=[]) pcb = self._mk_pcb() record = create_mock_full({'id': "id str"}) db_rec.return_value = record # Call ntools.eq_(inst.update(pcb), DBResult.ENTRY_ADDED) # Tests db_rec.assert_called_once_with(pcb) inst._db.assert_called_once_with(id="id str", sibra=True) inst._db.insert.assert_called_once_with(record, "id str", 1, 2, 3, 4, True)
def test_3(self, _): asms = [] for i in range(3): asms.append( create_mock_full({"sig_pack()": bytes("asm %i" % i, "ascii")})) inst = PathSegment(create_mock_full({"info": b"info"})) inst.is_sibra = create_mock_full() inst.iter_asms = create_mock_full(return_value=asms) inst.sibra_ext = create_mock_full({"sig_pack()": b"sibraext"}) expected = b"".join( [b"info", b"asm 0", b"asm 1", b"asm 2", b"sibraext"]) # Call ntools.eq_(inst.sig_pack(3), expected)
def test(self): up_pcbms, down_pcbms = self._mk_pcbms() p = create_mock_full({"hashTreeRoot": b"1234"}) up_asm = create_mock_full({"isd_as()": "1-1", "iter_pcbms()": up_pcbms, "p": p}) down_asm = create_mock_full({"isd_as()": "2-1", "iter_pcbms()": down_pcbms, "p": p}) peer_revs = create_mock_full({"get()": None}) # Call ntools.eq_(path_combinator._find_peer_hfs(up_asm, down_asm, peer_revs), [(up_pcbms[0].hof(), down_pcbms[0].hof(), 500), (up_pcbms[2].hof(), down_pcbms[1].hof(), 700)])
def test_peer(self, find): up_asms = [ create_mock_full({"isd_as()": "1-1"}), # peers with 1-10 create_mock_full({"isd_as()": "1-2"}), # peers with 1-12 create_mock_full({"isd_as()": "1-3"}), ] up_seg = create_mock_full({ "iter_asms()": up_asms, "get_rev_map()": {} }) down_asms = [ create_mock_full({"isd_as()": "1-10"}), # peers with 1-1 create_mock_full({"isd_as()": "1-11"}), create_mock_full({"isd_as()": "1-12"}), # peers with 1-2 ] down_seg = create_mock_full({ "iter_asms()": down_asms, "get_rev_map()": {} }) def matching_peers(a, b, c, d): return (a == up_asms[0] and b == down_asms[0]) or (a == up_asms[1] and b == down_asms[2]) find.side_effect = matching_peers # Call ntools.eq_(PathCombinator._get_xovr_peer(up_seg, down_seg), (None, (2, 3)))
def _setup(self, l4_type): inst = SCIONL4Packet() inst._parse_pld_ctrl = create_mock() inst._parse_pld_ctrl.return_value = "pld ctrl" inst._parse_pld_scmp = create_mock() inst._parse_pld_scmp.return_value = "pld scmp" inst.set_payload = create_mock() inst._payload = create_mock(["pack"]) if l4_type == L4Proto.UDP: inst.l4_hdr = create_mock_full({"TYPE": l4_type}) elif l4_type == L4Proto.SCMP: inst.l4_hdr = create_mock_full({"TYPE": l4_type, "class_": "scmp_class", "type": "scmp_type"}) return inst
def test_peer(self, find): up_asms = [ create_mock_full({"isd_as()": "1-ff00:0:300"}), # peers with 1-ff00:0:310 create_mock_full({"isd_as()": "1-ff00:0:301"}), # peers with 1-ff00:0:312 create_mock_full({"isd_as()": "1-ff00:0:302"}), ] up_seg = create_mock_full({"iter_asms()": up_asms}) down_asms = [ create_mock_full({"isd_as()": "1-ff00:0:310"}), # peers with 1-ff00:0:300 create_mock_full({"isd_as()": "1-ff00:0:311"}), create_mock_full({"isd_as()": "1-ff00:0:312"}), # peers with 1-ff00:0:301 ] down_seg = create_mock_full({"iter_asms()": down_asms}) peer_revs = create_mock() def matching_peers(a, b, c): return (a == up_asms[0] and b == down_asms[0]) or (a == up_asms[1] and b == down_asms[2]) find.side_effect = matching_peers # Call ntools.eq_(path_combinator._get_xovr_peer(up_seg, down_seg, peer_revs), (None, (2, 3)))
def _mk_pcb(self, exp=0): ia = [ {"isdas": ISD_AS("1-ff00:0:300"), "ingress_if": 1, "egress_if": 2}, {"isdas": ISD_AS("1-ff00:0:301"), "ingress_if": 3, "egress_if": 4} ] asms = [] for j in range(len(ia)): hof = create_mock_full( {'egress_if': ia[j]['egress_if'], 'ingress_if': ia[j]['ingress_if']}) pcbm = create_mock_full({'hof()': hof}) asms.append(create_mock_full({ "isd_as()": ia[j]['isdas'], "pcbm()": pcbm})) pcb = create_mock_full( {"iter_asms()": asms, "short_desc()": "short desc"}) return pcb
def _setup(self, src_type, haddr, saddr): inst = SCIONAddrHdr() inst.calc_lens = create_mock() inst.update = create_mock() data = create_mock_full({ "pop()...": ("1-1", "2-2", "dst host", "src host"), }) src_host = create_mock_full({"TYPE": src_type}) src = create_mock_full({"host": src_host}) haddr.side_effect = ( create_mock_full({"LEN": 12}, return_value="dst haddr"), create_mock_full({"LEN": 34}, return_value="src haddr"), ) saddr.side_effect = "dst", src return inst, data, src, "dst"
def _setup(self, time_, check_ret): check = create_mock_full(return_value=check_ret) fetch = create_mock() inst = RequestHandler("queue", check, fetch, "reply") inst._expire_reqs = create_mock() time_.return_value = 2 return inst
def test_update(self, db_rec): inst = PathSegmentDB() pcb = self._mk_pcb(1) cur_rec = create_mock_full({ "pcb": self._mk_pcb(0), "id": "cur rec", "exp_time": 44 }) inst._db = create_mock_full(return_value={0: {'record': cur_rec}}) db_rec.return_value = create_mock_full({ 'id': "record", 'exp_time': 32 }) # Call ntools.eq_(inst.update(pcb), DBResult.ENTRY_UPDATED) # Tests ntools.eq_(cur_rec.pcb, pcb)
def test(self, in_cksum): inst = SCIONUDPHeader() inst._dst = create_mock_full( { "isd_as": create_mock_full({"pack()": b"dsIA"}), "host": create_mock_full({"pack()": b"dstH"}), }, class_=SCIONAddr) inst._src = create_mock_full( { "isd_as": create_mock_full({"pack()": b"srIA"}), "host": create_mock_full({"pack()": b"srcH"}), }, class_=SCIONAddr) inst.pack = create_mock_full(return_value=b"packed with null checksum") payload = b"payload" expected_call = b"".join([ b"dsIA", b"srIA", b"dstH", b"srcH", b"\x00", bytes([L4Proto.UDP]), b"packed with null checksum", payload, ]) in_cksum.return_value = 0x3412 # Call ntools.eq_(inst._calc_checksum(payload), bytes.fromhex("3412")) # Tests in_cksum.assert_called_once_with(expected_call)