def test(self, init, zone_resolver, dns_server, udp_server, tcp_server, dns_logger, zookeeper): # Setup server = SCIONDnsServer("srvid", "conf_dir") server.lock = "lock" server.domain = "domain" server.addr = create_mock(["host"]) server.addr.host = "127.0.0.1" server.id = "srvid" server.topology = create_mock(["isd_as", "zookeepers"]) server.topology.isd_as = "isd as" server.topology.zookeepers = ["zk0", "zk1"] server._setup_parties = create_mock() # Call server.setup() # Tests zone_resolver.assert_called_once_with("lock", "domain") dns_server.assert_any_call(zone_resolver.return_value, port=SCION_DNS_PORT, address="127.0.0.1", server=udp_server, logger=dns_logger.return_value) dns_server.assert_any_call(zone_resolver.return_value, port=SCION_DNS_PORT, address="127.0.0.1", server=tcp_server, logger=dns_logger.return_value) ntools.eq_(dns_server.call_count, 2) zookeeper.assert_called_once_with( "isd as", DNS_SERVICE, "srvid\0%d\000127.0.0.1" % SCION_DNS_PORT, ["zk0", "zk1"]) ntools.eq_(server._parties, {}) server._setup_parties.assert_called_once_with()
def test_success(self, init): # Setup services = { BEACON_SERVICE: ["bs1", "bs2", "bs3"], CERTIFICATE_SERVICE: ["cs1"], DNS_SERVICE: ["ds1", "ds2"], PATH_SERVICE: [], SIBRA_SERVICE: ["sb1"], } server = SCIONDnsServer("srvid", "conf_dir") server.zk = create_mock(['wait_connected']) server.domain = self.DOMAIN server._parties = {} for i in SCIONDnsServer.SRV_TYPES: party = create_mock(["list"]) party.list.return_value = services[i] server._parties[i] = party server._parse_srv_inst = create_mock() server.lock = create_mock(['__enter__', '__exit__']) server.resolver = create_mock(["services"]) domain_set = set( [self.DOMAIN.add(srv) for srv in SCIONDnsServer.SRV_TYPES]) # Call server._sync_zk_state() # Tests server.zk.wait_connected.assert_called_once_with(timeout=10.0) ntools.eq_(domain_set, set(server.services)) for type_, insts in services.items(): for inst in insts: server._parse_srv_inst.assert_any_call(inst, self.DOMAIN.add(type_)) ntools.ok_(server.lock.mock_calls) ntools.eq_(server.resolver.services, server.services)
def _setup(self, check_ret=True): check = create_mock() check.return_value = check_ret reply = create_mock() inst = RequestHandler("queue", check, "fetch", reply) inst._expire_reqs = create_mock() return inst
def test(self): inst = SCIONBasePacket() cmn_hdr = create_mock([ "__len__", "src_addr_type", "dst_addr_type", "addrs_len", "hdr_len", "hdr_len_bytes", "bytes_to_hdr_len", "total_len", "set_of_idxs", "next_hdr", "update", ]) cmn_hdr.__len__.return_value = SCIONCommonHdr.LEN cmn_hdr.bytes_to_hdr_len = lambda x: x//8 cmn_hdr.hdr_len_bytes.return_value = 32 addrs = create_mock(["__len__", "src_type", "dst_type"]) addrs.__len__.return_value = 16 path = create_mock(["__len__", "get_of_idxs"]) path.__len__.return_value = 8 path.get_of_idxs.return_value = 3, 7 inst.cmn_hdr = cmn_hdr inst.addrs = addrs inst.path = path inst._get_offset_len = create_mock() inst._get_offset_len.return_value = 42 inst._get_next_hdr = create_mock() # Call inst._update_cmn_hdr() # Tests ntools.eq_(cmn_hdr.src_addr_type, addrs.src_type.return_value) ntools.eq_(cmn_hdr.dst_addr_type, addrs.dst_type.return_value) ntools.eq_(cmn_hdr.addrs_len, 16) ntools.eq_(cmn_hdr.hdr_len, (8 + 16 + 8)//8) ntools.eq_(cmn_hdr.total_len, 32 + 42) cmn_hdr.set_of_idxs.assert_called_once_with(3, 7) ntools.eq_(cmn_hdr.next_hdr, inst._get_next_hdr.return_value)
def _setup(self, time_, check_ret=False): check = create_mock() check.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 _setup(self, time_, entries): inst = ZkSharedCache("zk", "path", "handler") inst._zk = create_mock(["is_connected"]) time_.return_value = 1000 inst._entries = entries inst._kazoo = create_mock(["delete"]) inst._path = "/path" return inst
def _setup(self, filter_=True): inst = PathStore("path_policy") inst.path_policy = create_mock(["check_filters"]) if not filter_: inst.path_policy.check_filters.side_effect = SCIONPathPolicyViolated() pcb = create_mock(["get_hops_hash", "get_timestamp"], class_=PathSegment) return inst, pcb
def test_basic(self, init): p = ZkParty("zk", "path", "id", "autojoin") p._party = create_mock(["join"]) p.list = create_mock() # Call p.join() # Tests p._party.join.assert_called_once_with()
def _setup(self, unwanted=None, reasons=None): inst = PathPolicy() inst._check_unwanted_ases = create_mock() inst._check_unwanted_ases.return_value = unwanted inst._check_property_ranges = create_mock() inst._check_property_ranges.return_value = reasons pcb = create_mock(["short_desc"], class_=PathSegment) return inst, pcb
def test_release(self, init): inst = self._init_basic_setup() inst._lock = create_mock(["clear"]) inst.is_connected = create_mock() inst._zk_lock = create_mock(["is_acquired", "release"]) # Call inst.release_lock() # Tests inst._zk_lock.release.assert_called_once_with()
def test(self): inst = SCIONBasePacket() inst.addrs = create_mock(['reverse']) inst.path = create_mock(['reverse']) # Call inst.reverse() # Tests inst.addrs.reverse.assert_called_once_with() inst.path.reverse.assert_called_once_with()
def test(self): inst = SCMPInfoPathOffsets() pkt = create_mock(["addrs", "cmn_hdr"]) pkt.addrs = "addrs" pkt.cmn_hdr = create_mock(["__len__", "get_of_idxs"]) pkt.cmn_hdr.__len__.return_value = 7 pkt.cmn_hdr.get_of_idxs.return_value = 3, 5 # Call ntools.eq_(inst._calc_offsets(pkt), (12 + 24, 12 + 40))
def test(self): up_iof = create_mock(["hops"]) up_hofs = ["up hof 1", "up hof 2", "up hof 3"] down_iof = create_mock(["hops"]) down_hofs = ["down hof"] ret = path_combinator._shortcut_path_args(up_iof, up_hofs, down_iof, down_hofs) ntools.eq_(ret, [up_iof, up_hofs]) ntools.eq_(up_iof.hops, 3)
def test(self): inst = SCIONBasePacket() inst.addrs = create_mock(["update"]) inst._update_cmn_hdr = create_mock() # Call inst.update() # Tests inst.addrs.update.assert_called_once_with() inst._update_cmn_hdr.assert_called_once_with()
def test_egress_forward(self, super_process): inst = SibraExtEphemeral() inst.get_next_ifid = create_mock() meta = create_mock(["from_local_as"]) # Call ntools.eq_(inst._process_setup(meta), [(RouterFlag.FORWARD, inst.get_next_ifid.return_value)]) # Tests super_process.assert_called_once_with(inst, meta)
def _setup(self, data_offset=10, hdr_len=20): inst = SCIONBasePacket() inst.cmn_hdr = create_mock(["get_of_idxs", "hdr_len"]) inst.cmn_hdr.get_of_idxs.return_value = "iof", "hof" inst.cmn_hdr.hdr_len = hdr_len data = create_mock(["__len__", "get", "offset", "pop"]) data.__len__.return_value = 40 - data_offset data.offset.return_value = data_offset return inst, data
def test(self, iof): inst = SCIONPath() data = create_mock(["pop"]) inst._ofs = create_mock(["set"]) # Call ntools.eq_(inst._parse_iof(data, "label"), iof.return_value) # Tests data.pop.assert_called_once_with(iof.LEN) iof.assert_called_once_with(data.pop.return_value) inst._ofs.set.assert_called_once_with("label", [iof.return_value])
def test_basic(self, init): inst = self._init_basic_setup() inst.wait_connected = create_mock() f = create_mock() # Call ntools.eq_(inst.retry("desc", f, "arg1", _timeout=5.4, kwarg1="k"), f.return_value) # Tests inst.wait_connected.assert_called_once_with(timeout=5.4) f.assert_called_once_with("arg1", kwarg1="k")
def _setup(self, connected=True): inst = self._init_basic_setup() inst.is_connected = create_mock() inst.is_connected.return_value = connected inst.prefix = "/prefix" inst.kazoo = create_mock() inst.ensure_path = create_mock() inst._srv_id = "srvid" inst._parties = {} return inst
def test_unknown(self, warning): # Setup inst = self._setup_zoneresolver() reply = create_mock(["header"]) reply.header = create_mock(["rcode"]) # Call inst.resolve_forward(self.FQDN, "A", reply) # Tests ntools.ok_(warning.called) ntools.eq_(reply.header.rcode, RCODE.NXDOMAIN)
def test_connloss(self, init): # Setup server = SCIONDnsServer("srvid", "conf_dir") server.zk = create_mock(['wait_connected']) server.domain = self.DOMAIN party = create_mock(["list"]) party.list.side_effect = ZkNoConnection server._parties = {SCIONDnsServer.SRV_TYPES[0]: party} # Call server._sync_zk_state()
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 test_no_lock(self, init): inst = self._init_basic_setup() inst._lock = create_mock(["clear"]) inst._zk_lock = None inst.is_connected = create_mock() # Call inst.release_lock() # Tests inst._lock.clear.assert_called_once_with() ntools.assert_false(inst.is_connected.called)
def _setup(self, connected, l_epoch, c_epoch, lock_is_set): inst = self._init_basic_setup() inst.is_connected = create_mock() inst.is_connected.return_value = connected inst._lock_epoch = l_epoch inst.conn_epoch = c_epoch inst._lock = create_mock(["is_set"]) inst._lock.is_set.return_value = lock_is_set inst.release_lock = create_mock() return inst
def _setup(self, up_first, core_last, core_first, down_first): up = create_mock(['first_ia']) up.first_ia.return_value = up_first yield up core = create_mock(['first_ia', 'last_ia']) core.first_ia.return_value = core_first core.last_ia.return_value = core_last yield core down = create_mock(['first_ia']) down.first_ia.return_value = down_first yield down
def _check_core_local(self, is_core, core_called, local_called, signals, argparse, init_log, topo): core_type = create_mock() local_type = create_mock() topo.return_value = create_mock(["is_core_as"]) topo.return_value.is_core_as = is_core # Call main_default(core_type, local_type) # Tests ntools.eq_(core_type.called, core_called) ntools.eq_(local_type.called, local_called)
def test_ingress_deliver(self, super_process): inst = SibraExtEphemeral() inst._setup_switch_block = create_mock() inst.get_next_ifid = create_mock() inst.get_next_ifid.return_value = 0 meta = create_mock(["from_local_as"]) meta.from_local_as = False # Call ntools.eq_(inst._process_setup(meta), [(RouterFlag.DELIVER, )]) # Tests inst._setup_switch_block.assert_called_once_with()
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 _setup(self): inst = PathStore("path_policy") inst._remove_expired_segments = create_mock() inst._update_all_fidelity = create_mock() inst.candidates = [] for i, fidelity in enumerate([0, 5, 2, 6, 3]): candidate = create_mock(["pcb", "fidelity", "sending"]) candidate.pcb = "pcb%d" % i candidate.fidelity = fidelity inst.candidates.append(candidate) return inst
def test_copy_down(self, deepcopy, copy_hofs): seg = create_mock(["iter_asms", "info"]) info = create_mock(["up_flag"]) deepcopy.return_value = info copy_hofs.return_value = "hofs", None # Call ntools.eq_(path_combinator._copy_segment(seg, False, False, up=False), (info, "hofs", None)) # Tests copy_hofs.assert_called_once_with(seg.iter_asms.return_value, reverse=False)