def test_store_result(self):
ctx = self.dummy_ctx()
e = ProfileExecutor(ctx)
with self.assertRaises(ValueError):
e.store_result('smt', 'a')
ctx.profile.add_result('smt', 'Something', units.Time)
ctx.profile.add_result('smt2', 'Something', units.Time)
ctx.profile.add_result('smt3', 'Something', units.Time)
e = ProfileExecutor(ctx)
self.assertEqual(len(e.results), 3)
self.assertIsNone(e.results['smt'])
self.assertIsNone(e.results['smt2'])
self.assertIsNone(e.results['smt3'])
# Check casting for storing
e.store_result('smt', 0)
self.assertEqual(e.results['smt'], units.Time(0))
# Overwrite values
e.store_result('smt', '15 hour')
self.assertNotEqual(e.results['smt'], units.Time(0))
self.assertEqual(e.results['smt'], units.Time('15 hour'))
def test_add_option(self):
d = OptionsDescriptor()
d.add_option('test', 'Hello', float)
o = Options(d)
self.assertLength(o, 1)
self.assertLength(o.supported, 1)
self.assertEqual(o.supported['test'].type, float)
self.assertEqual(o.supported['test'].help, 'Hello')
self.assertEqual(o.supported['test'].id, 'test')
self.assertEqual(o.supported['test'].default, None)
self.assertIsNone(o['test'])
d = OptionsDescriptor()
d.add_option('test', 'Hello', float)
d.add_option('test2', 'Yeah', units.Time, 0)
o = Options(d)
self.assertLength(o, 2)
self.assertLength(o.supported, 2)
self.assertEqual(o.supported['test2'].type, units.Time)
self.assertEqual(o.supported['test2'].help, 'Yeah')
self.assertEqual(o.supported['test2'].id, 'test2')
self.assertEqual(o.supported['test2'].default, units.Time(0))
self.assertIsNone(o['test'])
self.assertEqual(o['test2'], units.Time(0))
def test_mutator(self):
d = OptionsDescriptor()
d.add_option('test', 'Hello', float)
d.add_option('test2', 'Yeah', units.Time, 0)
o = Options(d)
with self.assertRaises(UnknownOptionError):
o['unknown'] = 5
o['test'] = 5
self.assertEqual(o['test'], 5)
o['test2'] = 7.1
self.assertEqual(o['test2'], units.Time(7.1))
# Request for impossible casting
with self.assertRaises(TypeError):
o['test2'] = units.BitRate(0)
# Iterator access
optids = []
values = []
for opt_id in o:
optids.append(opt_id)
values.append(o[opt_id])
self.assertEqual(optids, ['test', 'test2'])
self.assertEqual(values, [5, units.Time(7.1)])
def test_number_constructor(self):
t = units.Time(1.0)
self.assertEqual(t.raw_value, 1.0)
t = units.Time(3)
self.assertEqual(t.raw_value, 3.0)
t = units.Time(477777.54)
self.assertEqual(t.raw_value, 477777.54)
def test_optimal_combined_scale(self):
self.assertEqual(
units.Time('0 ms').optimal_combined_scale(), [(0, 'sec')])
self.assertEqual(
units.Time('1.5 ms').optimal_combined_scale(), [(1, 'ms'),
(500, 'us')])
self.assertEqual(
units.Time('1 hour').optimal_combined_scale(), [(1, 'hour')])
self.assertEqual(
units.Time('25 hour').optimal_combined_scale(), [(1, 'day'),
(1, 'hour')])
self.assertEqual(
units.Time('25.5 hour').optimal_combined_scale(), [(1, 'day'),
(1, 'hour'),
(30, 'min')])
def test_scale(self):
t = units.Time(35.54)
self.assertEqual(t.scale('ms'), 35540)
self.assertEqual(t.scale('us'), 35540000)
self.assertEqual(t.scale('ns'), 35540000000)
self.assertEqual(t.scale('min'), 35.54 / 60)
self.assertEqual(t.scale('hour'), 35.54 / 3600)
self.assertEqual(t.scale('day'), 35.54 / (3600 * 24))
self.assertEqual(t.scale('week'), 35.54 / (3600 * 24 * 7))
def parse_and_store_output(self):
output = self.get_subprocess_output().split("\n")
received = output[1].split(',')
self.store_result('transfer_rate', units.BitRate(received[8]))
self.store_result('jitter', units.Time(received[9] + "ms"))
self.store_result('lost_packets', units.Packet(received[10]))
self.store_result('total_packets', units.Packet(received[11]))
self.store_result('percentage_lost', units.Percentage(received[12]))
def test_access(self):
d = OptionsDescriptor()
d.add_option('test', 'Hello', float)
d.add_option('test2', 'Yeah', units.Time, 0)
o = Options(d)
with self.assertRaises(UnknownOptionError):
o['unknown']
# get item access
self.assertIsNone(o['test'])
self.assertEqual(o['test2'], units.Time(0))
# Iterator access
optids = []
values = []
for opt_id in o:
optids.append(opt_id)
values.append(o[opt_id])
self.assertEqual(optids, ['test', 'test2'])
self.assertEqual(values, [None, units.Time(0)])
def test_optimal_scale(self):
self.assertEqual(units.Time('0 ms').optimal_scale(), (0, 'sec'))
self.assertEqual(units.Time('47 ms').optimal_scale(), (47, 'ms'))
self.assertEqual(
units.Time('4334 ms').optimal_scale(), (4334.0 * 0.001, 'sec'))
self.assertEqual(units.Time('1 hour').optimal_scale(), (1, 'hour'))
self.assertEqual(units.Time('1 day').optimal_scale(), (1, 'day'))
self.assertEqual(units.Time('1.22 day').optimal_scale(), (1.22, 'day'))
self.assertEqual(
units.Time('0.96 day').optimal_scale(), (24 * 0.96, 'hour'))
def run(self):
min_trans = self.context.options['min_transfer'].raw_value
max_trans = self.context.options['max_transfer'].raw_value
min_time = self.context.options['min_time'].raw_value
max_time = self.context.options['max_time'].raw_value
self.store_result('random_transfer',
units.BitRate(random.uniform(min_trans, max_trans)))
self.store_result('random_time',
units.Time(random.uniform(min_time, max_time)))
self.logger.debug(
"Results have been generated. Sending them to client...")
self.propagate_results()
def parse_and_store_output(self):
output = self.get_subprocess_output()
lines = output.split("\n")
try:
if lines[-2][:3] != 'rtt':
raise LookupError(lines)
except LookupError:
self.logger.error("ping failed to complete." + str(output))
raise SpeedTestRuntimeError(
"Ping failed to complete: " + str(output))
values = lines[-2].split()[3].split("/")
unit_name = lines[-2].split()[4]
rtt = units.Time(values[0] + " " + unit_name)
self.store_result('rtt', rtt)
def test_properties(self):
o = OptionValueDescriptor('myid', 'myhelp', units.Time)
self.assertEqual(o.id, 'myid')
self.assertEqual(o.help, 'myhelp')
self.assertEqual(o.type, units.Time)
self.assertEqual(o.default, None)
o = OptionValueDescriptor('myid', 'myhelp', units.Time, default=0)
self.assertEqual(o.id, 'myid')
self.assertEqual(o.help, 'myhelp')
self.assertEqual(o.type, units.Time)
self.assertEqual(o.default, units.Time(0))
o = OptionValueDescriptor(1, '', float, default=10)
self.assertEqual(o.id, '1')
self.assertEqual(o.help, '')
self.assertEqual(o.type, float)
self.assertEqual(o.default, 10)
def test_propage_results(self):
p = Profile('profid', 'profname', ProfileExecutorA, ProfileExecutorB)
p.add_result('testdt', 'name', units.Time)
p.add_result('testbit', 'name', units.BitRate)
c = NullNSTSConnection()
ctxa = ProfileExecution(p, ExecutionDirection('s'),
Options(p.supported_options), c)
a = ctxa.executor
ctxb = ProfileExecution(p, ExecutionDirection('r'),
Options(p.supported_options), c)
b = ctxb.executor
a.store_result('testdt', '10 sec')
a.store_result('testbit', '32 bps')
a.propagate_results()
b.collect_results()
self.assertEqual(b.results['testdt'], units.Time('10 sec'))
self.assertEqual(b.results['testbit'], units.BitRate('32 bps'))
def test_str(self):
self.assertEqual(str(units.Time('0 ms')), '0.0 sec')
self.assertEqual(str(units.Time('1.2 ms')), '1.2 ms')
self.assertEqual(str(units.Time('1500 ms')), '1.5 sec')
self.assertEqual(str(units.Time('1.5 day')), '1.5 day')
self.assertEqual(str(units.Time('1 day')), '1.0 day')
def test_emtpy_constructor(self):
t = units.Time()
self.assertEqual(t.raw_value, 0)
def test_parse_constructor(self):
self.assertEqual(units.Time('0 ms').raw_value, 0)
self.assertEqual(units.Time('1 ms').raw_value, 0.001)
self.assertEqual(units.Time('1.5 ms').raw_value, 0.0015)
self.assertEqual(units.Time('45 sec').raw_value, 45)
self.assertEqual(units.Time('45').raw_value, 45)
self.assertEqual(units.Time('45.7').raw_value, 45.7)
self.assertEqual(units.Time(' 45.7 hour ').raw_value, 45.7 * 3600)
self.assertEqual(units.Time(' 45.7 min ').raw_value, 45.7 * 60)
self.assertEqual(units.Time(' 45.7 day').raw_value, 45.7 * (3600 * 24))
self.assertEqual(
units.Time(' 45.7 week').raw_value, 45.7 * (3600 * 24 * 7))
with self.assertRaises(units.ParseError):
units.Time('46 dummy')
with self.assertRaises(units.ParseError):
units.Time('46.5.6')
with self.assertRaises(units.ParseError):
units.Time('46.5.6 ms')
def test_copy_constructor(self):
t1 = units.Time(15)
t2 = units.Time(t1)
self.assertEqual(t1, t2)
self.assertEqual(t2.raw_value, 15)
def test_repr(self):
self.assertEqual(repr(units.Time('0 ms')), 'Time(0.0 sec)')
self.assertEqual(repr(units.Time('1.2 ms')), 'Time(1.2 ms)')
self.assertEqual(repr(units.Time('1500 ms')), 'Time(1.5 sec)')
self.assertEqual(repr(units.Time('1.5 day')), 'Time(1.5 day)')
self.assertEqual(repr(units.Time('1 day')), 'Time(1.0 day)')
