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 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)
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,