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)
