def setUp(self):
queue = Queue()
send_queue = Queue()
self.r_th = ReaderThread(queue, send_queue, 'name')
def setUp(self):
self.raw_q = Queue()
self.send_q = Queue()
self.r_th = ReaderThread(self.raw_q, self.send_q, 'TestThread')
class TestReaderThreadBandwidth(unittest2.TestCase):
def setUp(self):
queue = Queue()
send_queue = Queue()
self.r_th = ReaderThread(queue, send_queue, 'name')
def tearDown(self):
self.r_th = None
def test_creation_null_input_queue(self):
"""ReaderThread(): ensure input queue is not None"""
queue = Queue()
with self.assertRaises(TypeError):
r_th = ReaderThread(None, queue, 'Name')
def test_creation_null_output_queue(self):
"""ReaderThread(): ensure output queue is not None"""
queue = Queue()
with self.assertRaises(TypeError):
r_th = ReaderThread(queue, None, 'Name')
def test_creation_null_name(self):
"""ReaderThread(): ensure thread Name is not None"""
queue1 = Queue()
queue2 = Queue()
with self.assertRaises(TypeError):
r_th = ReaderThread(queue1, queue2, None)
def test_zero_division_error(self):
""" ReaderThread.bandwidth_calculation: ensure raies ValueError"""
seconds = 0
speed = 1000000
increment_in_octets = 30
increment_out_octets = 50
with self.assertRaises(ValueError):
self.r_th.bandwidth_calculation(
seconds,
speed,
increment_in_octets,
increment_out_octets)
def test_hundred_percent_in (self):
""" ReaderThread.bandwidth_calculation: return 1 (100%) ussing full in incremental octects"""
seconds = 30
speed = 1000000
increment_in_octets = seconds * speed / 8
increment_out_octets = 50
result = self.r_th.bandwidth_calculation(
seconds,
speed,
increment_in_octets,
increment_out_octets)
self.assertEqual( result==1 , True)
def test_hundred_percent_out (self):
""" ReaderThread.bandwidth_calculation: return 1 (100%) ussing full out incremental octects"""
seconds = 30
speed = 1000000
increment_out_octets = seconds * speed / 8
increment_in_octets = 50
result = self.r_th.bandwidth_calculation(
seconds,
speed,
increment_in_octets,
increment_out_octets)
self.assertEqual( result==1 , True)
def test_fifty_percent_out (self):
""" ReaderThread.bandwidth_calculation: 50% for output octets"""
seconds = 30
speed = 1000000
increment_in_octets = 3
increment_out_octets = 0.5 * seconds * speed / 8
result = self.r_th.bandwidth_calculation(
seconds,
speed,
increment_in_octets,
increment_out_octets)
self.assertEqual( result==0.5 , True)
def test_fifty_percent_in (self):
""" ReaderThread.bandwidth_calculation: 50% for input octets """
seconds = 30
speed = 1000000
increment_out_octets = 3
increment_in_octets = 0.5 * seconds * speed / 8
result = self.r_th.bandwidth_calculation(
seconds,
speed,
increment_in_octets,
increment_out_octets)
self.assertEqual( result==0.5 , True)
def test_creation_null_name(self):
"""ReaderThread(): ensure thread Name is not None"""
queue1 = Queue()
queue2 = Queue()
with self.assertRaises(TypeError):
r_th = ReaderThread(queue1, queue2, None)
class TestSampleClass(unittest.TestCase):
def setUp(self):
self.raw_q = Queue()
self.send_q = Queue()
self.r_th = ReaderThread(self.raw_q, self.send_q, 'TestThread')
def tearDown(self):
self.r_th.stop()
self.r_th = None
def testGetIncrementals_1(self):
""" ReaderThread.get_incrementals() returns normal Diff value valueIncrement = 7 and timeIncrement = 30
"""
name = 'devil_metric'
# Δvalue = 3
old_value = '1'
new_value = '4'
# Δs = 30
old_ts = '2015-07-06 12:17:15'
new_ts = '2015-07-06 12:17:45'
# range is [0, 2³-1]
register_bytes = 3
result = self.r_th.get_incrementals(metric_name=name,
new_value=new_value,
old_value=old_value,
new_ts=new_ts,
old_ts=old_ts,
register_bytes=register_bytes)
self.assertIsNotNone(result[name + 'Diff'])
self.assertEqual(result[name + 'Diff'] == 3, True)
self.assertEqual(result[name + 'DiffRate'] == None, False)
self.assertEqual(result[name + 'DiffRate'] == 3 / 30, True)
def testGetIncrementals_2(self):
""" ReaderThread.get_incrementals() returns check behaviour with overflow valueIncrement = 3 and timeINcrement = 30
"""
name = 'devil_metric'
# value = 3
old_value = '5'
new_value = '1'
# Δs = 30
old_ts = '2015-07-06 12:17:15'
new_ts = '2015-07-06 12:17:45'
# range is [0, 2³-1] => [0, 7]
register_bytes = 3
result = self.r_th.get_incrementals(metric_name=name,
new_value=new_value,
old_value=old_value,
new_ts=new_ts,
old_ts=old_ts,
register_bytes=register_bytes)
self.assertEqual(result[name + 'Diff'] == None, False)
self.assertEqual(result[name + 'Diff'] == 3, True)
self.assertEqual(result[name + 'DiffRate'] == None, False)
self.assertEqual(result[name + 'DiffRate'] == 3 / 30, True)
def testGetIncrementals_3(self):
""" ReaderThread.get_incrementals() when time increment is 0, the new DiffRate value cant be calculated, None
"""
name = 'devil_metric'
#Δvalue = 3
old_value = '5'
new_value = '1'
# Δs = 0
single_ts = '2015-07-06 12:17:15'
# range is [0, 2³-1] => [0, 7]
register_bytes = 3
result = self.r_th.get_incrementals(metric_name=name,
new_value=new_value,
old_value=old_value,
new_ts=single_ts,
old_ts=single_ts,
register_bytes=register_bytes)
self.assertEqual(result[name + 'Diff'] == None, False)
self.assertEqual(result[name + 'Diff'] == 3, True)
with self.assertRaises(KeyError):
result[name + 'DiffRate']
def testGetIncrementals_4(self):
""" ReaderThread.get_incrementals() when value is high than maximum supported by the counter, None is returned
"""
name = 'devil_metric'
register_bytes = 3
#Δvalue doesn't matter
# range is [0, 2³-1] => [0, 7]
old_value = '5'
# new value is double of register maximum
new_value = str((pow(2, register_bytes) - 1) * 2)
# Δs = 0
old_ts = '2015-07-06 12:17:15'
new_ts = '2015-07-06 12:47:15'
result = self.r_th.get_incrementals(metric_name=name,
new_value=new_value,
old_value=old_value,
new_ts=new_ts,
old_ts=old_ts,
register_bytes=register_bytes)
self.assertEqual(result, dict())
def setUp(self):
queue = Queue()
send_queue = Queue()
self.r_th = ReaderThread(queue, send_queue, 'name')
def test_creation_null_output_queue(self):
"""ReaderThread(): ensure output queue is not None"""
queue = Queue()
with self.assertRaises(TypeError):
r_th = ReaderThread(queue, None, 'Name')
class TestReaderThreadBandwidth(unittest2.TestCase):
def setUp(self):
queue = Queue()
send_queue = Queue()
self.r_th = ReaderThread(queue, send_queue, 'name')
def tearDown(self):
self.r_th = None
def test_creation_null_input_queue(self):
"""ReaderThread(): ensure input queue is not None"""
queue = Queue()
with self.assertRaises(TypeError):
r_th = ReaderThread(None, queue, 'Name')
def test_creation_null_output_queue(self):
"""ReaderThread(): ensure output queue is not None"""
queue = Queue()
with self.assertRaises(TypeError):
r_th = ReaderThread(queue, None, 'Name')
def test_creation_null_name(self):
"""ReaderThread(): ensure thread Name is not None"""
queue1 = Queue()
queue2 = Queue()
with self.assertRaises(TypeError):
r_th = ReaderThread(queue1, queue2, None)
def test_zero_division_error(self):
""" ReaderThread.bandwidth_calculation: ensure raies ValueError"""
seconds = 0
speed = 1000000
increment_in_octets = 30
increment_out_octets = 50
with self.assertRaises(ValueError):
self.r_th.bandwidth_calculation(seconds, speed,
increment_in_octets,
increment_out_octets)
def test_hundred_percent_in(self):
""" ReaderThread.bandwidth_calculation: return 1 (100%) ussing full in incremental octects"""
seconds = 30
speed = 1000000
increment_in_octets = seconds * speed / 8
increment_out_octets = 50
result = self.r_th.bandwidth_calculation(seconds, speed,
increment_in_octets,
increment_out_octets)
self.assertEqual(result == 1, True)
def test_hundred_percent_out(self):
""" ReaderThread.bandwidth_calculation: return 1 (100%) ussing full out incremental octects"""
seconds = 30
speed = 1000000
increment_out_octets = seconds * speed / 8
increment_in_octets = 50
result = self.r_th.bandwidth_calculation(seconds, speed,
increment_in_octets,
increment_out_octets)
self.assertEqual(result == 1, True)
def test_fifty_percent_out(self):
""" ReaderThread.bandwidth_calculation: 50% for output octets"""
seconds = 30
speed = 1000000
increment_in_octets = 3
increment_out_octets = 0.5 * seconds * speed / 8
result = self.r_th.bandwidth_calculation(seconds, speed,
increment_in_octets,
increment_out_octets)
self.assertEqual(result == 0.5, True)
def test_fifty_percent_in(self):
""" ReaderThread.bandwidth_calculation: 50% for input octets """
seconds = 30
speed = 1000000
increment_out_octets = 3
increment_in_octets = 0.5 * seconds * speed / 8
result = self.r_th.bandwidth_calculation(seconds, speed,
increment_in_octets,
increment_out_octets)
self.assertEqual(result == 0.5, True)
def setUp(self):
self.raw_q = Queue()
self.send_q = Queue()
self.r_th = ReaderThread(self.raw_q, self.send_q, 'TestThread')
class TestSampleClass(unittest.TestCase):
def setUp(self):
self.raw_q = Queue()
self.send_q = Queue()
self.r_th = ReaderThread(self.raw_q, self.send_q, 'TestThread')
def tearDown(self):
self.r_th.stop()
self.r_th = None
def testGetIncrementals_1(self):
""" ReaderThread.get_incrementals() returns normal Diff value valueIncrement = 7 and timeIncrement = 30
"""
name = 'devil_metric'
# Δvalue = 3
old_value = '1'
new_value = '4'
# Δs = 30
old_ts = '2015-07-06 12:17:15'
new_ts = '2015-07-06 12:17:45'
# range is [0, 2³-1]
register_bytes = 3
result = self.r_th.get_incrementals(metric_name=name, new_value=new_value,
old_value=old_value, new_ts=new_ts, old_ts=old_ts,
register_bytes=register_bytes)
self.assertIsNotNone(result[name+'Diff'])
self.assertEqual(result[name+'Diff'] == 3, True)
self.assertEqual(result[name+'DiffRate'] == None, False)
self.assertEqual(result[name+'DiffRate'] == 3/30, True)
def testGetIncrementals_2(self):
""" ReaderThread.get_incrementals() returns check behaviour with overflow valueIncrement = 3 and timeINcrement = 30
"""
name = 'devil_metric'
# value = 3
old_value = '5'
new_value = '1'
# Δs = 30
old_ts = '2015-07-06 12:17:15'
new_ts = '2015-07-06 12:17:45'
# range is [0, 2³-1] => [0, 7]
register_bytes = 3
result = self.r_th.get_incrementals(metric_name=name, new_value=new_value, old_value=old_value, new_ts=new_ts, old_ts=old_ts, register_bytes=register_bytes)
self.assertEqual(result[name+'Diff'] == None, False)
self.assertEqual(result[name+'Diff'] == 3, True)
self.assertEqual(result[name+'DiffRate'] == None, False)
self.assertEqual(result[name+'DiffRate'] == 3/30, True)
def testGetIncrementals_3(self):
""" ReaderThread.get_incrementals() when time increment is 0, the new DiffRate value cant be calculated, None
"""
name = 'devil_metric'
#Δvalue = 3
old_value = '5'
new_value = '1'
# Δs = 0
single_ts = '2015-07-06 12:17:15'
# range is [0, 2³-1] => [0, 7]
register_bytes = 3
result = self.r_th.get_incrementals(metric_name=name, new_value=new_value,
old_value=old_value, new_ts=single_ts, old_ts=single_ts,
register_bytes=register_bytes)
self.assertEqual(result[name+'Diff'] == None, False)
self.assertEqual(result[name+'Diff'] == 3, True)
with self.assertRaises(KeyError):
result[name+'DiffRate']
def testGetIncrementals_4(self):
""" ReaderThread.get_incrementals() when value is high than maximum supported by the counter, None is returned
"""
name = 'devil_metric'
register_bytes = 3
#Δvalue doesn't matter
# range is [0, 2³-1] => [0, 7]
old_value = '5'
# new value is double of register maximum
new_value = str((pow(2, register_bytes) - 1 ) * 2)
# Δs = 0
old_ts = '2015-07-06 12:17:15'
new_ts = '2015-07-06 12:47:15'
result = self.r_th.get_incrementals(metric_name=name, new_value=new_value,
old_value=old_value, new_ts=new_ts, old_ts=old_ts,
register_bytes=register_bytes)
self.assertEqual(result, dict())
if args.debug_mode:
logging.basicConfig(
format='%(asctime)s - %(pathname)s:%(lineno)d - %(threadName)s : %(levelname)s : %(message)s',
level=logging.DEBUG)
else:
logging.basicConfig(
format='%(asctime)s - %(pathname)s:%(lineno)d - %(threadName)s : %(message)s',
level=logging.ERROR)
task_list = []
raw_data_queue = Queue()
send_queue = Queue()
r_th = ReaderThread(raw_data_queue, send_queue, name='ReaderThread')
r_th.start()
output_config = cf.get_output_section()
s_th = SenderThread(send_queue, output_config, name='SenderThread')
s_th.start()
task_list.append(r_th)
task_list.append(s_th)
# create producers threads
for rq_config in cf.get_requests():
th = StoppableTimerThread(interval=rq_config['interval'],
target=task,
if args.debug_mode:
logging.basicConfig(
format=
'%(asctime)s - %(pathname)s:%(lineno)d - %(threadName)s : %(levelname)s : %(message)s',
level=logging.DEBUG)
else:
logging.basicConfig(
format=
'%(asctime)s - %(pathname)s:%(lineno)d - %(threadName)s : %(message)s',
level=logging.ERROR)
task_list = []
raw_data_queue = Queue()
send_queue = Queue()
r_th = ReaderThread(raw_data_queue, send_queue, name='ReaderThread')
r_th.start()
output_config = cf.get_output_section()
s_th = SenderThread(send_queue, output_config, name='SenderThread')
s_th.start()
task_list.append(r_th)
task_list.append(s_th)
# create producers threads
for rq_config in cf.get_requests():
th = StoppableTimerThread(
interval=rq_config['interval'],
target=task,
