class TestStatCalculator(TestCase):
def setUp(self):
self.calculator = StatCalculator()
self.data = [6, 9, 15, -2, 92, 11]
def test_min(self):
minimal = self.calculator.get_minimum(self.data)
self.assertEqual(-2, minimal)
def test_max(self):
maximum = self.calculator.get_maximum(self.data)
self.assertEqual(92, maximum)
def test_count(self):
count = self.calculator.get_count(self.data)
self.assertEqual(6, count)
def test_average(self):
average = self.calculator.get_average(self.data)
self.assertAlmostEqual(21.833, average, places=3)
def test_sum(self):
sum = self.calculator.get_sum(self.data)
self.assertEqual(131, sum)
def test_median(self):
median = self.calculator.get_median(self.data)
self.assertEqual(10, median)
def test_median2(self):
data = self.data
data.append(0)
median = self.calculator.get_median(data)
self.assertEqual(9, median)
def test_median3(self):
data = self.data
data.append(100)
median = self.calculator.get_median(data)
self.assertEqual(11, median)
def test_median4(self):
data = self.data
data.extend([10, 12])
median = self.calculator.get_median(data)
self.assertEqual(10.5, median)
class TestStatCalculator(TestCase):
def setUp(self):
self.calculator = StatCalculator()
self.data = [6, 9, 15, -2, 92, 11]
def test_min(self):
minimal = self.calculator.get_minimum(self.data)
self.assertEqual(-2, minimal)
def test_max(self):
maximum = self.calculator.get_maximum(self.data)
self.assertEqual(92, maximum)
def test_count(self):
count = self.calculator.get_count(self.data)
self.assertEqual(6, count)
def test_average(self):
average = self.calculator.get_average(self.data)
self.assertAlmostEqual(21.833, average, places=3)
def test_sum(self):
sum = self.calculator.get_sum(self.data)
self.assertEqual(131, sum)
def test_median(self):
median = self.calculator.get_median(self.data)
self.assertEqual(10, median)
def test_median2(self):
data = self.data
data.append(0)
median = self.calculator.get_median(data)
self.assertEqual(9, median)
def test_median3(self):
data = self.data
data.append(100)
median = self.calculator.get_median(data)
self.assertEqual(11, median)
def test_median4(self):
data = self.data
data.extend([10, 12])
median = self.calculator.get_median(data)
self.assertEqual(10.5, median)
def test_calculate_stats_with_empty_cached_row(self):
row = {'k': 1, 'v': 1000}
cached_row = {}
calculated = StatCalculator.calculate_row_delta(row=row,
cached_row=cached_row,
data_key_col='k',
timestamp=1)
self.assertEquals(calculated.delta_fields['v'].measured, 1000)
self.assertEquals(calculated.delta_fields['v'].delta, None)
self.assertEquals(calculated.delta_fields['v'].previous, None)
def test_should_not_calculate_text_fields(self):
row = {'k': 1, 'v': 200, 'v2': 'abc'}
cached_row = {'k': 1, 'v': 50, 'v2': 'def'}
calculated_row = StatCalculator.calculate_row_delta(row=row,
cached_row=cached_row,
data_key_col='k',
timestamp=1)
self.assertEquals(calculated_row.delta_fields['v'].measured, 200)
self.assertEquals(calculated_row.delta_fields['v'].delta, 150)
self.assertEquals(calculated_row.delta_fields['v'].previous, 50)
self.assertEquals(calculated_row.delta_fields['v2'].measured, 'abc')
self.assertEquals(calculated_row.delta_fields['v2'].delta, None)
self.assertEquals(calculated_row.delta_fields['v2'].previous, None)
def test_calculate_stats_for_several_fields(self):
row = {'k': 1, 'v': 1000, 'v2': 40.6}
cached_row = {'k': 1, 'v': 300, 'v2': 10.3}
calculated = StatCalculator.calculate_row_delta(row=row,
cached_row=cached_row,
data_key_col='k',
timestamp=1)
self.assertEquals(calculated.delta_fields['v'].measured, 1000)
self.assertEquals(calculated.delta_fields['v'].delta, 700)
self.assertEquals(calculated.delta_fields['v'].previous, 300)
self.assertEquals(calculated.delta_fields['v2'].measured, 40.6)
self.assertEquals(calculated.delta_fields['v2'].delta, 30.3)
self.assertEquals(calculated.delta_fields['v2'].previous, 10.3)
def test_calculate_stats_value_which_was_reset(self):
# new row is much less than old row values
row = {'k': 1, 'v': 200, 'v2': 1.6}
cached_row = {'k': 1, 'v': 300, 'v2': 10.3}
calculated = StatCalculator.calculate_row_delta(row=row,
cached_row=cached_row,
data_key_col='k',
timestamp=1)
self.assertEquals(calculated.delta_fields['v'].measured, 200)
self.assertEquals(calculated.delta_fields['v'].delta, None)
self.assertEquals(calculated.delta_fields['v'].previous, None)
self.assertEquals(calculated.delta_fields['v2'].measured, 1.6)
self.assertEquals(calculated.delta_fields['v2'].delta, None)
self.assertEquals(calculated.delta_fields['v2'].previous, None)
def test_should_get_value_from_index_also(self):
row = {'k': 1, 'v': 200, 'v2': 'abc'}
cached_row = {'k': 1, 'v': 50, 'v2': 'def'}
calculated_row = StatCalculator.calculate_row_delta(row=row,
cached_row=cached_row,
data_key_col='k',
timestamp=1)
# DeltaRow is indexable
self.assertEquals(
calculated_row.delta_fields['v'].measured,
calculated_row['v'].measured)
self.assertEquals(
calculated_row.delta_fields['v'].delta,
calculated_row['v'].delta)
self.assertEquals(
calculated_row.delta_fields['v'].previous,
calculated_row['v'].previous)
def test_calculate_stats(self):
row = {'k': 1, 'v': 1000}
cached_row = {'k': 1, 'v': 700}
calculated = StatCalculator.calculate_row_delta(row=row,
cached_row=cached_row,
data_key_col='k',
timestamp=1)
self.assertEquals(calculated.key_column_name, 'k')
self.assertEquals(calculated.timestamp, 1)
self.assertEquals(len(calculated.delta_fields), 2)
self.assertEquals(calculated.delta_fields['k'].measured, 1, "delta of key should be the value of the key")
self.assertEquals(calculated.delta_fields['k'].delta, None, "delta of key should be None")
self.assertEquals(calculated.delta_fields['k'].previous, None)
# self.assertEquals(calculated.delta_fields['timestamp'].measured, 1)
self.assertEquals(calculated.delta_fields['v'].measured, 1000)
self.assertEquals(calculated.delta_fields['v'].delta, 300)
self.assertEquals(calculated.delta_fields['v'].previous, 700)
def setUp(self):
self.calculator = StatCalculator()
class TestStatCalculator(TestCase):
def setUp(self):
self.calculator = StatCalculator()
def test_calc(self):
self.assertEqual(1, 1)
def test_minimum(self):
self.assertEqual(
self.calculator.calc([6, 9, 15, -2, 92, 11])["min"], -2)
self.assertEqual(
self.calculator.calc([6, 9, 15, -3, 92, 11])["min"], -3)
def test_maximum(self):
self.assertEqual(
self.calculator.calc([6, 9, 15, -2, 92, 11])["max"], 92)
self.assertEqual(
self.calculator.calc([6, 9, 15, -3, 93, 11])["max"], 93)
def test_number_of_elements(self):
self.assertEqual(
self.calculator.calc([6, 9, 15, -2, 92, 11])["count"], 6)
def test_average_value(self):
self.assertEqual(
self.calculator.calc([6, 9, 15, -2, 92, 11])["average"],
21.833333333333332)
self.assertEqual(self.calculator.calc([])["average"], None)
def test_sum(self):
self.assertEqual(
self.calculator.calc([6, 9, 15, -2, 92, 11])["sum"], 131)
def test_median(self):
self.assertEqual(
self.calculator.calc([6, 9, 15, -2, 92, 11])["median"], 10)
def test_removeDuplicates(self):
self.assertEqual(
self.calculator.calc([6, 9, 15, -2, 92, 11, 11], True)["median"],
10)
def test_remove_odd_numbers(self):
self.assertEqual(
self.calculator.calc([1, 2, 3], remove_odd_numbers=True)["sum"], 4)
def test_remove_even_numbers(self):
self.assertEqual(
self.calculator.calc([1, 2, 3], remove_even_numbers=True)["sum"],
2)
def test_remove_minmal_and_maximal_numbers(self):
self.assertEqual(
self.calculator.calc(
[6, 9, 15, -2, 92, 11, 11],
remove_minmal_and_maximal_numbers=True)["sum"], 52)
def setUp(self):
self.calculator = StatCalculator()
class TestStatCalculator(TestCase):
def setUp(self):
self.calculator = StatCalculator()
def test_calc(self):
self.assertEqual(1, 1)
def test_minimum(self):
self.assertEqual( self.calculator.calc([6, 9, 15, -2, 92, 11])["min"], -2 )
self.assertEqual( self.calculator.calc([6, 9, 15, -3, 92, 11])["min"], -3 )
def test_maximum(self):
self.assertEqual( self.calculator.calc([6, 9, 15, -2, 92, 11])["max"], 92 )
self.assertEqual( self.calculator.calc([6, 9, 15, -3, 93, 11])["max"], 93 )
def test_number_of_elements(self):
self.assertEqual( self.calculator.calc([6, 9, 15, -2, 92, 11])["count"], 6 )
def test_average_value(self):
self.assertEqual( self.calculator.calc([6, 9, 15, -2, 92, 11])["average"], 21.833333333333332 )
self.assertEqual( self.calculator.calc([])["average"], None )
def test_sum(self):
self.assertEqual( self.calculator.calc([6, 9, 15, -2, 92, 11])["sum"], 131 )
def test_median(self):
self.assertEqual(self.calculator.calc([6, 9, 15, -2, 92, 11])["median"], 10)
def test_removeDuplicates(self):
self.assertEqual(self.calculator.calc([6, 9, 15, -2, 92, 11, 11], True)["median"], 10)
def test_remove_odd_numbers(self):
self.assertEqual(self.calculator.calc([1,2,3], remove_odd_numbers=True)["sum"], 4)
def test_remove_even_numbers(self):
self.assertEqual(self.calculator.calc([1,2,3], remove_even_numbers=True)["sum"], 2)
def test_remove_minmal_and_maximal_numbers(self):
self.assertEqual(self.calculator.calc([6, 9, 15, -2, 92, 11, 11], remove_minmal_and_maximal_numbers=True)["sum"], 52)
def setUp(self):
self.calculator = StatCalculator()
self.data = [6, 9, 15, -2, 92, 11]
def setUp(self):
self.calculator = StatCalculator()
self.data = [6, 9, 15, -2, 92, 11]
