def test_get_measurement_kwargs_ping(self):
spec = Configuration.DEFAULT["specification"]["types"]["ping"]
cmd = PingMeasureCommand()
cmd.init_args(["ping", "--target", "ripe.net"])
self.assertEqual(
cmd._get_measurement_kwargs(), {
"af": Configuration.DEFAULT["specification"]["af"],
"description": "Ping measurement to ripe.net",
"target": "ripe.net",
"packets": spec["packets"],
"packet_interval": spec["packet-interval"],
"size": spec["size"]
})
cmd = PingMeasureCommand()
cmd.init_args([
"ping", "--target", "ripe.net", "--af", "6", "--description",
"This is my description", "--packets", "7", "--packet-interval",
"200", "--size", "24"
])
self.assertEqual(
cmd._get_measurement_kwargs(), {
"af": 6,
"description": "This is my description",
"target": "ripe.net",
"packets": 7,
"packet_interval": 200,
"size": 24
})
def test_get_measurement_kwargs_ping(self):
spec = Configuration.DEFAULT["specification"]["types"]["ping"]
cmd = PingMeasureCommand()
cmd.init_args(["ping", "--target", "ripe.net"])
self.assertEqual(
cmd._get_measurement_kwargs(), {
"af": Configuration.DEFAULT["specification"]["af"],
"description": "Ping measurement to ripe.net",
"target": "ripe.net",
"packets": spec["packets"],
"packet_interval": spec["packet-interval"],
"size": spec["size"]
})
cmd = PingMeasureCommand()
cmd.init_args([
"ping",
"--target",
"ripe.net",
"--af",
"6",
"--description",
"This is my description",
"--packets",
"7",
"--packet-interval",
"200",
"--size",
"24",
"--group-id",
"1000001",
"--include-probe-id",
"--spread",
"60",
"--resolve-on-probe",
])
self.assertEqual(
cmd._get_measurement_kwargs(), {
"af": 6,
"description": "This is my description",
"target": "ripe.net",
"packets": 7,
"packet_interval": 200,
"size": 24,
"group_id": 1000001,
"include_probe_id": True,
"spread": 60,
"resolve_on_probe": True,
})
def test_clean_target(self):
cmd = PingMeasureCommand()
with capture_sys_output():
cmd.init_args(["ping", "--target", "ripe.net"])
self.assertEqual(cmd.clean_target(), "ripe.net")
cmd = DnsMeasureCommand()
with capture_sys_output():
cmd.init_args(["dns", "--query-argument", "ripe.net"])
self.assertEqual(cmd.clean_target(), None)
def test_clean_target(self):
cmd = PingMeasureCommand()
with capture_sys_output():
cmd.init_args(["ping", "--target", "ripe.net"])
self.assertEqual(cmd.clean_target(), "ripe.net")
cmd = DnsMeasureCommand()
with capture_sys_output():
cmd.init_args(["dns", "--query-argument", "ripe.net"])
self.assertEqual(cmd.clean_target(), None)
def test_set_alias(self):
path_aliases = "ripe.atlas.tools.commands.measure.base.aliases"
new_aliases = copy.deepcopy(AliasesDB.DEFAULT)
with mock.patch(path_aliases, new_aliases):
path_AliasesDB = "ripe.atlas.tools.commands.measure.base.AliasesDB"
with mock.patch(path_AliasesDB, autospec=True) as new_AliasesDB:
new_AliasesDB.write.return_value = True
path_create = "ripe.atlas.tools.commands.measure.base.Command.create"
with mock.patch(path_create) as mock_create:
mock_create.return_value = (
True,
{"measurements": [1234]}
)
cmd = PingMeasureCommand()
cmd.init_args([
"ping",
"--target",
"www.ripe.net",
"--no-report",
"--set-alias",
"PING_RIPE"
])
cmd.run()
self.assertEqual(
new_aliases["measurement"]["PING_RIPE"],
1234
)
def test_get_measurement_kwargs_ping(self):
spec = Configuration.DEFAULT["specification"]["types"]["ping"]
cmd = PingMeasureCommand()
cmd.init_args(["ping", "--target", "ripe.net"])
self.assertEqual(
cmd._get_measurement_kwargs(),
{
"af": Configuration.DEFAULT["specification"]["af"],
"description": "Ping measurement to ripe.net",
"target": "ripe.net",
"packets": spec["packets"],
"packet_interval": spec["packet-interval"],
"size": spec["size"],
},
)
cmd = PingMeasureCommand()
cmd.init_args(
[
"ping",
"--target",
"ripe.net",
"--af",
"6",
"--description",
"This is my description",
"--packets",
"7",
"--packet-interval",
"200",
"--size",
"24",
]
)
self.assertEqual(
cmd._get_measurement_kwargs(),
{
"af": 6,
"description": "This is my description",
"target": "ripe.net",
"packets": 7,
"packet_interval": 200,
"size": 24,
},
)
def test_dry_run(self):
with capture_sys_output() as (stdout, stderr):
cmd = PingMeasureCommand()
cmd.init_args(["ping", "--target", "ripe.net", "--dry-run"])
cmd.run()
expected = (
"\n"
"Definitions:\n"
"================================================================================\n"
"target ripe.net\n"
"packet_interval 1000\n"
"description Ping measurement to ripe.net\n"
"af 4\n"
"packets 3\n"
"size 48\n"
"\n"
"Sources:\n"
"================================================================================\n"
"requested 50\n"
"type area\n"
"value WW\n"
"tags\n"
" include system-ipv4-works\n"
" exclude \n"
"\n")
self.assertEqual(set(stdout.getvalue().split("\n")),
set(expected.split("\n")))
with capture_sys_output() as (stdout, stderr):
cmd = PingMeasureCommand()
cmd.init_args([
"ping", "--target", "ripe.net", "--af", "6", "--include-tag",
"alpha", "--include-tag", "bravo", "--include-tag", "charlie",
"--exclude-tag", "delta", "--exclude-tag", "echo",
"--exclude-tag", "foxtrot", "--dry-run"
])
cmd.run()
expected = (
"\n"
"Definitions:\n"
"================================================================================\n"
"target ripe.net\n"
"packet_interval 1000\n"
"description Ping measurement to ripe.net\n"
"af 6\n"
"packets 3\n"
"size 48\n"
"\n"
"Sources:\n"
"================================================================================\n"
"requested 50\n"
"type area\n"
"value WW\n"
"tags\n"
" include alpha, bravo, charlie\n"
" exclude delta, echo, foxtrot\n"
"\n")
self.assertEqual(set(stdout.getvalue().split("\n")),
set(expected.split("\n")))
def test_account_for_selected_probes(self):
spec = Configuration.DEFAULT["specification"]
cmd = PingMeasureCommand()
cmd.init_args(["ping", "--target", "ripe.net"])
cmd._account_for_selected_probes(),
self.assertEqual(cmd.arguments.probes, spec["source"]["requested"])
cmd = PingMeasureCommand()
cmd.init_args(["ping", "--target", "ripe.net", "--probes", "7"])
cmd._account_for_selected_probes(),
self.assertEqual(cmd.arguments.probes, 7)
cmd = PingMeasureCommand()
cmd.init_args(["ping", "--target", "ripe.net", "--from-probes", "1,2"])
cmd._account_for_selected_probes(),
self.assertEqual(cmd.arguments.probes, 2)
cmd = PingMeasureCommand()
cmd.init_args([
"ping", "--target", "ripe.net", "--from-probes", "1,2", "--probes",
"7"
])
with capture_sys_output() as (stdout, stderr):
with self.assertRaises(RipeAtlasToolsException):
cmd._account_for_selected_probes(),
def test_add_arguments(self):
with capture_sys_output() as (stdout, stderr):
with self.assertRaises(SystemExit):
PingMeasureCommand().init_args(
["ping", "--renderer", "not-a-renderer"])
self.assertTrue(stderr.getvalue().split("\n")[-2].startswith(
"ripe-atlas measure: error: argument --renderer: invalid "
"choice: 'not-a-renderer' (choose from"))
with capture_sys_output() as (stdout, stderr):
with self.assertRaises(SystemExit):
PingMeasureCommand().init_args(["ping", "--af", "5"])
self.assertEqual(
stderr.getvalue().split("\n")[-2],
"ripe-atlas measure: error: argument --af: invalid choice: 5 "
"(choose from 4, 6)")
with capture_sys_output() as (stdout, stderr):
with self.assertRaises(SystemExit):
PingMeasureCommand().init_args(
["ping", "--target", "not a target"])
self.assertEqual(
stderr.getvalue().split("\n")[-2],
"ripe-atlas measure: error: argument --target: "
"\"not a target\" does not appear to be an IP address or host "
"name")
with capture_sys_output() as (stdout, stderr):
with self.assertRaises(SystemExit):
PingMeasureCommand().init_args(
["ping", "--from-area", "not an area"])
self.assertTrue(stderr.getvalue().split("\n")[-2].startswith(
"ripe-atlas measure: error: argument --from-area: invalid "
"choice:"))
with capture_sys_output() as (stdout, stderr):
with self.assertRaises(SystemExit):
PingMeasureCommand().init_args(
["ping", "--from-probes", "0,50000"])
self.assertEqual(
stderr.getvalue().split("\n")[-2],
"ripe-atlas measure: error: argument --from-probes: 0 "
"is lower than the minimum permitted value of 1.")
for clude in ("in", "ex"):
with capture_sys_output() as (stdout, stderr):
for tag in ("NotATag", "tag!", "not a tag", "νοτ α ταγ"):
with self.assertRaises(SystemExit):
PingMeasureCommand().init_args(
["ping", "--{}clude-tag".format(clude), tag])
self.assertEqual(
stderr.getvalue().split("\n")[-2],
'ripe-atlas measure: error: argument --{}clude-tag: '
'"{}" does not appear to be valid.'.format(clude, tag))
with capture_sys_output() as (stdout, stderr):
with self.assertRaises(SystemExit):
TracerouteMeasureCommand().init_args(
["traceroute", "--protocol", "invalid"])
self.assertEqual(
stderr.getvalue().split("\n")[-2],
"ripe-atlas measure: error: argument --protocol: invalid "
"choice: 'invalid' (choose from 'ICMP', 'UDP', 'TCP')")
with capture_sys_output() as (stdout, stderr):
with self.assertRaises(SystemExit):
DnsMeasureCommand().init_args(["dns", "--protocol", "invalid"])
self.assertEqual(
stderr.getvalue().split("\n")[-2],
"ripe-atlas measure: error: argument --protocol: invalid "
"choice: 'invalid' (choose from 'UDP', 'TCP')")
with capture_sys_output() as (stdout, stderr):
with self.assertRaises(SystemExit):
HttpMeasureCommand().init_args(
["http", "--timing-verbosity", "3"])
self.assertEqual(
stderr.getvalue().split("\n")[-2],
"ripe-atlas measure: error: argument --timing-verbosity: "
"invalid choice: 3 (choose from 0, 1, 2)")
min_options = {
"from-measurement": ((PingMeasureCommand, ), 1),
"probes": ((PingMeasureCommand, ), 1),
"packets": ((PingMeasureCommand, TracerouteMeasureCommand,
NtpMeasureCommand), 1),
"size": ((PingMeasureCommand, TracerouteMeasureCommand), 1),
"packet-interval": ((PingMeasureCommand, ), 1),
"timeout": ((
TracerouteMeasureCommand,
NtpMeasureCommand,
), 1),
"destination-option-size": ((TracerouteMeasureCommand, ), 1),
"hop-by-hop-option-size": ((TracerouteMeasureCommand, ), 1),
"retry": ((DnsMeasureCommand, ), 1),
"udp-payload-size": ((DnsMeasureCommand, ), 1),
}
for option, (klasses, minimum) in min_options.items():
for klass in klasses:
with capture_sys_output() as (stdout, stderr):
test_value = minimum - 1
with self.assertRaises(SystemExit):
klass().init_args([
klass.__name__.replace("MeasureCommand",
"").lower(),
"--{}".format(option),
str(test_value)
])
self.assertEqual(
stderr.getvalue().split("\n")[-2],
"ripe-atlas measure: error: argument --{}: "
"The integer must be greater than {}.".format(
option, minimum))
min_max_options = {
"from-asn": ((PingMeasureCommand, ), (0, 2**32 - 2 + 1)),
"paris": ((TracerouteMeasureCommand, ), (-1, 65)),
"first-hop": ((TracerouteMeasureCommand, ), (0, 256)),
"max-hops": ((TracerouteMeasureCommand, ), (0, 256)),
"port": ((TracerouteMeasureCommand, SslcertMeasureCommand,
HttpMeasureCommand), (0, 2**16 + 1)),
"header-bytes": ((HttpMeasureCommand, ), (-1, 2049)),
"body-bytes": ((HttpMeasureCommand, ), (0, 1020049)),
}
for option, (klasses, extremes) in min_max_options.items():
for klass in klasses:
for val in extremes:
with capture_sys_output() as (stdout, stderr):
with self.assertRaises(SystemExit):
klass().init_args([
klass.__name__.replace("MeasureCommand",
"").lower(),
"--{}".format(option),
str(val)
])
self.assertEqual(
stderr.getvalue().split("\n")[-2],
"ripe-atlas measure: error: argument --{}: The "
"integer must be between {} and {}.".format(
option, extremes[0] + 1, extremes[1] - 1))
def test_account_for_selected_probes(self):
spec = Configuration.DEFAULT["specification"]
cmd = PingMeasureCommand()
cmd.init_args(["ping", "--target", "ripe.net"])
cmd._account_for_selected_probes(),
self.assertEqual(cmd.arguments.probes, spec["source"]["requested"])
cmd = PingMeasureCommand()
cmd.init_args(["ping", "--target", "ripe.net", "--probes", "7"])
cmd._account_for_selected_probes(),
self.assertEqual(cmd.arguments.probes, 7)
cmd = PingMeasureCommand()
cmd.init_args(["ping", "--target", "ripe.net", "--from-probes", "1,2"])
cmd._account_for_selected_probes(),
self.assertEqual(cmd.arguments.probes, 2)
cmd = PingMeasureCommand()
cmd.init_args([
"ping",
"--target", "ripe.net",
"--from-probes", "1,2",
"--probes", "7"
])
with capture_sys_output() as (stdout, stderr):
with self.assertRaises(RipeAtlasToolsException):
cmd._account_for_selected_probes(),
def test_dry_run(self):
with capture_sys_output() as (stdout, stderr):
cmd = PingMeasureCommand()
cmd.init_args(["ping", "--target", "ripe.net", "--dry-run"])
cmd.run()
expected = (
"\n"
"Definitions:\n"
"================================================================================\n"
"target ripe.net\n"
"packet_interval 1000\n"
"description Ping measurement to ripe.net\n"
"af 4\n"
"packets 3\n"
"size 48\n"
"\n"
"Sources:\n"
"================================================================================\n"
"requested 50\n"
"type area\n"
"value WW\n"
"tags\n"
" include system-ipv4-works\n"
" exclude \n"
"\n"
)
self.assertEqual(
set(stdout.getvalue().split("\n")),
set(expected.split("\n"))
)
with capture_sys_output() as (stdout, stderr):
cmd = PingMeasureCommand()
cmd.init_args([
"ping",
"--target", "ripe.net",
"--af", "6",
"--include-tag", "alpha",
"--include-tag", "bravo",
"--include-tag", "charlie",
"--exclude-tag", "delta",
"--exclude-tag", "echo",
"--exclude-tag", "foxtrot",
"--dry-run"
])
cmd.run()
expected = (
"\n"
"Definitions:\n"
"================================================================================\n"
"target ripe.net\n"
"packet_interval 1000\n"
"description Ping measurement to ripe.net\n"
"af 6\n"
"packets 3\n"
"size 48\n"
"\n"
"Sources:\n"
"================================================================================\n"
"requested 50\n"
"type area\n"
"value WW\n"
"tags\n"
" include alpha, bravo, charlie\n"
" exclude delta, echo, foxtrot\n"
"\n"
)
self.assertEqual(
set(stdout.getvalue().split("\n")),
set(expected.split("\n"))
)
def test_add_arguments(self):
with capture_sys_output() as (stdout, stderr):
with self.assertRaises(SystemExit):
PingMeasureCommand().init_args(
["ping", "--set-alias", "\\invalid"])
self.assertEqual(
stderr.getvalue().split("\n")[-2],
'ripe-atlas measure: error: argument --set-alias: '
'"\\invalid" does not appear to be a valid alias.')
with capture_sys_output() as (stdout, stderr):
with self.assertRaises(SystemExit):
PingMeasureCommand().init_args(
["ping", "--renderer", "not-a-renderer"])
self.assertTrue(stderr.getvalue().split("\n")[-2].startswith(
"ripe-atlas measure: error: argument --renderer: invalid "
"choice: 'not-a-renderer' (choose from"))
with capture_sys_output() as (stdout, stderr):
with self.assertRaises(SystemExit):
PingMeasureCommand().init_args(["ping", "--af", "5"])
self.assertEqual(
stderr.getvalue().split("\n")[-2],
"ripe-atlas measure: error: argument --af: invalid choice: 5 "
"(choose from 4, 6)")
with capture_sys_output() as (stdout, stderr):
with self.assertRaises(SystemExit):
PingMeasureCommand().init_args(
["ping", "--target", "not a target"])
self.assertEqual(
stderr.getvalue().split("\n")[-2],
"ripe-atlas measure: error: argument --target: "
"\"not a target\" does not appear to be an IP address or host "
"name")
with capture_sys_output() as (stdout, stderr):
with self.assertRaises(SystemExit):
PingMeasureCommand().init_args(
["ping", "--from-area", "not an area"])
self.assertTrue(stderr.getvalue().split("\n")[-2].startswith(
"ripe-atlas measure: error: argument --from-area: invalid "
"choice:"))
with capture_sys_output() as (stdout, stderr):
with self.assertRaises(SystemExit):
PingMeasureCommand().init_args(
["ping", "--from-probes", "0,50000"])
self.assertEqual(
stderr.getvalue().split("\n")[-2],
"ripe-atlas measure: error: argument --from-probes: 0 "
"is lower than the minimum permitted value of 1.")
for clude in ("in", "ex"):
with capture_sys_output() as (stdout, stderr):
for tag in ("NotATag", "tag!", "not a tag", "νοτ α ταγ"):
with self.assertRaises(SystemExit):
PingMeasureCommand().init_args(
["ping", "--{}clude-tag".format(clude), tag])
self.assertEqual(
stderr.getvalue().split("\n")[-2],
'ripe-atlas measure: error: argument --{}clude-tag: '
'"{}" does not appear to be a valid tag.'.format(
clude, tag))
with capture_sys_output() as (stdout, stderr):
with self.assertRaises(SystemExit):
TracerouteMeasureCommand().init_args(
["traceroute", "--protocol", "invalid"])
self.assertEqual(
stderr.getvalue().split("\n")[-2],
"ripe-atlas measure: error: argument --protocol: invalid "
"choice: 'INVALID' (choose from 'ICMP', 'UDP', 'TCP')")
with capture_sys_output() as (stdout, stderr):
with self.assertRaises(SystemExit):
DnsMeasureCommand().init_args(["dns", "--protocol", "invalid"])
self.assertEqual(
stderr.getvalue().split("\n")[-2],
"ripe-atlas measure: error: argument --protocol: invalid "
"choice: 'INVALID' (choose from 'UDP', 'TCP')")
with capture_sys_output() as (stdout, stderr):
with self.assertRaises(SystemExit):
HttpMeasureCommand().init_args(
["http", "--timing-verbosity", "3"])
self.assertEqual(
stderr.getvalue().split("\n")[-2],
"ripe-atlas measure: error: argument --timing-verbosity: "
"invalid choice: 3 (choose from 0, 1, 2)")
min_options = [
("from-measurement", ((PingMeasureCommand, ), 1)),
("probes", ((PingMeasureCommand, ), 1)),
("timeout", ((TracerouteMeasureCommand, ), 1)),
]
for option, (klasses, minimum) in min_options:
for klass in klasses:
with capture_sys_output() as (stdout, stderr):
test_value = minimum - 1
with self.assertRaises(SystemExit):
klass().init_args([
klass.__name__.replace("MeasureCommand",
"").lower(),
"--{}".format(option),
str(test_value)
])
self.assertEqual(
stderr.getvalue().split("\n")[-2],
"ripe-atlas measure: error: argument --{}: "
"The integer must be greater than {}.".format(
option, minimum))
min_max_options = [
("from-asn", ((PingMeasureCommand, ), (1, 2**32 - 2))),
("paris", ((TracerouteMeasureCommand, ), (0, 64))),
("first-hop", ((TracerouteMeasureCommand, ), (1, 255))),
("max-hops", ((TracerouteMeasureCommand, ), (1, 255))),
("port", ((TracerouteMeasureCommand, SslcertMeasureCommand,
HttpMeasureCommand), (1, 65535))),
("header-bytes", ((HttpMeasureCommand, ), (0, 2048))),
("body-bytes", ((HttpMeasureCommand, ), (1, 1020048))),
("size", ((PingMeasureCommand, ), (1, 2048))),
("size", ((TracerouteMeasureCommand, ), (0, 2048))),
("packets", ((
PingMeasureCommand,
TracerouteMeasureCommand,
NtpMeasureCommand,
), (1, 16))),
("packet-interval", ((PingMeasureCommand, ), (2, 30000))),
("timeout", ((NtpMeasureCommand, ), (1, 60000))),
("destination-option-size", ((TracerouteMeasureCommand, ),
(0, 1024))),
("hop-by-hop-option-size", ((TracerouteMeasureCommand, ), (0,
2048))),
("retry", ((DnsMeasureCommand, ), (0, 10))),
("udp-payload-size", ((DnsMeasureCommand, ), (512, 4096))),
]
for option, (klasses, extremes) in min_max_options:
for klass in klasses:
lower = extremes[0] - 1
upper = extremes[1] + 1
for invalid in lower, upper:
with capture_sys_output() as (stdout, stderr):
try:
klass().init_args([
klass.__name__.replace("MeasureCommand",
"").lower(),
"--{}".format(option),
str(invalid)
])
except SystemExit:
pass
else:
self.fail(
"--{} for {} should fail for value {}".format(
option, klass.__name__, invalid))
self.assertEqual(
stderr.getvalue().split("\n")[-2],
"ripe-atlas measure: error: argument --{}: The "
"integer must be between {} and {}.".format(
option, extremes[0], extremes[1]))
