def test_getSpanAverageByCode_and_getPercentageDeltaOffSpanAverage(self): testSymbolData = SymbolData('A') span_to_test = [1.34, 5.6, -3.5, -0.3, 2.2] span_expected_average = 1.068 span_even_expected_average = 0.01333 span_odd_expected_average = 2.65 off_average_value_to_test = 1.12 span_code = 'test_span' testSymbolData.initializeSpanByCode(span_code) first_expected_none_value = testSymbolData.getSpanAverageByCode(span_code) self.assertIsNone(first_expected_none_value, 'A None value was not returned when getting the average of a span with no values') second_expected_none_value = testSymbolData.getPercentageDeltaOffSpanAverage(span_code, off_average_value_to_test) self.assertIsNone(second_expected_none_value, 'A None value was not returned when getting the percentage delta off average of a span with no values') unit_label_prefix = 'units_' i = 0 for value in span_to_test: unit_label_suffix = 'even' if ((i % 2) == 0) else 'odd' unit_label = unit_label_prefix + unit_label_suffix unit_labels_list = [unit_label, i] testSymbolData.addSpanValueByCode(span_code, unit_labels_list, value) i += 1 # Test average for all units in span span_test_average = testSymbolData.getSpanAverageByCode(span_code) self.assertEqual(span_expected_average, span_test_average, 'The computed average for a test span for a test SymbolData object was expected to be {0} but was {1}'.format(span_expected_average, span_test_average)) expected_delta_off_average = 0.0486891385768 test_delta_off_average = testSymbolData.getPercentageDeltaOffSpanAverage(span_code, off_average_value_to_test) test_delta_off_average = round(test_delta_off_average, 13) self.assertEqual(expected_delta_off_average, test_delta_off_average, 'The computed delta percentage off average for a test SymbolData object was expected to be {0} but was {1}'.format(expected_delta_off_average, test_delta_off_average)) # Test average for odd/even units in span even_units_label = unit_label_prefix + 'even' test_even_units_average = testSymbolData.getSpanAverageByCode(span_code, even_units_label) test_even_units_average = round(test_even_units_average, 5) self.assertEqual(test_even_units_average, span_even_expected_average) odd_units_label = unit_label_prefix + 'odd' test_odd_units_average = testSymbolData.getSpanAverageByCode(span_code, odd_units_label) self.assertEqual(test_odd_units_average, span_odd_expected_average) # Test off-average for odd/even units in span expected_off_even_average_value = 83.0 expected_off_odd_average_value = -0.57736 test_delta_off_even_average = testSymbolData.getPercentageDeltaOffSpanAverage(span_code, off_average_value_to_test, even_units_label) test_delta_off_even_average = round(test_delta_off_even_average, 1) test_delta_off_odd_average = testSymbolData.getPercentageDeltaOffSpanAverage(span_code, off_average_value_to_test, odd_units_label) test_delta_off_odd_average = round(test_delta_off_odd_average, 5) self.assertEqual(expected_off_even_average_value, test_delta_off_even_average) self.assertEqual(expected_off_odd_average_value, test_delta_off_odd_average)
class TestSymbolData(unittest.TestCase): def tearDown(self): self.unitDeltaTestsSymbol = None self.emptySymbol = None def setUp(self): self.unit_delta_test_symbol = 'tud' self.unitDeltaTestsSymbol = SymbolData(self.unit_delta_test_symbol) self.tud_span_code = 'tud_span' self.unitDeltaTestsSymbol.initializeSpanByCode(self.tud_span_code) self.unit_label_one = 'unit_one' self.unit_delta_test_list_one = [0.3, 13.4, 0.8] self.unit_label_two = 'unit_two' self.unit_delta_test_list_two = [2.8, 13.7, 0.9] self.unit_label_three = 'unit_three' self.unit_delta_test_list_three = [10.9, 14.4, 15.3] self.unit_label_four = 'unit_four' self.unit_delta_test_list_four = [15.3, 16.3, 17.3] self.unit_label_five = 'unit_five' self.unit_delta_test_list_five = [37.3, 16.3, 34.1] self.unit_dict = {self.unit_label_one : self.unit_delta_test_list_one, self.unit_label_two : self.unit_delta_test_list_two, self.unit_label_three : self.unit_delta_test_list_three, self.unit_label_four : self.unit_delta_test_list_four, self.unit_label_five : self.unit_delta_test_list_five} for label, list_of_prices in self.unit_dict.items(): for price in list_of_prices: self.unitDeltaTestsSymbol.addSpanValueByCode(self.tud_span_code, [label], close_price = price, open_price = price) self.max_unit_delta = 4.4 self.max_unit_delta_label = self.unit_label_three self.min_unit_delta = -3.2 self.min_unit_delta_label = self.unit_label_five self.max_unit_delta_percentage = 1.66667 self.max_unit_delta_percentage_label = self.unit_label_one self.min_unit_delta_percentage = -0.678571429 self.min_unit_delta_percentage_label = self.unit_label_two self.tud_span_code_two = 'tud_span_two' self.tud_span_two_unit_label_one = 'span_two_unit_one' self.tud_span_two_unit_delta_test_list_one = [14.3, 13.4, 115.1] self.tud_span_two_unit_label_two = 'span_two_unit_two' self.tud_span_two_unit_delta_test_list_two = [32.8, 13.7, 0.9] self.unitDeltaTestsSymbol.initializeSpanByCode(self.tud_span_code_two) self.unit_dict_two = {self.tud_span_two_unit_label_one : self.tud_span_two_unit_delta_test_list_one, self.tud_span_two_unit_label_two : self.tud_span_two_unit_delta_test_list_two} for label, list_of_prices in self.unit_dict_two.items(): for price in list_of_prices: self.unitDeltaTestsSymbol.addSpanValueByCode(self.tud_span_code_two, [label], close_price = price, open_price = price) self.max_unit_delta_two = 100.8 self.max_unit_delta_percentage_two = 7.048951049 self.max_unit_delta_label_two = self.tud_span_two_unit_label_one self.min_unit_delta_two = -31.9 self.min_unit_delta_percentage_two = -0.972560976 self.min_unit_delta_label_two = self.tud_span_two_unit_label_two self.expected_span_delta_value_to_span_max_delta_ratio = -3.045454545 self.expected_span_delta_value_to_span_max_delta_percentage_ratio = -0.56224 self.expected_span_delta_value_to_span_min_delta_ratio = 4.1875 self.expected_span_delta_value_to_span_min_delta_percentage_ratio = 1.38093 self.empty_symbol_code = 'empty' self.emptySymbol = SymbolData(self.empty_symbol_code) self.emptySymbol.initializeSpanByCode(self.tud_span_code) self.zero_delta_span_code = 'zero_delta' self.zero_delta_span = [1.34, 5.6, -3.5, -0.3, 1.34] self.zero_delta_span_off_average_test_value = 1.56 self.unitDeltaTestsSymbol.initializeSpanByCode(self.zero_delta_span_code) for value in self.zero_delta_span: self.unitDeltaTestsSymbol.addSpanValueByCode(self.zero_delta_span_code, self.zero_delta_span_code, close_price = value, open_price = value) self.expected_percentage_delta_off_zero_delta_span_average = 0.7410714285714288 self.zero_average_span_code = 'zero_average' self.zero_average_span = [1.34, 0.45, -1.65, -1.54, 1.4] self.unitDeltaTestsSymbol.initializeSpanByCode(self.zero_average_span_code) for value in self.zero_average_span: self.unitDeltaTestsSymbol.addSpanValueByCode(self.zero_average_span_code, self.zero_average_span_code, close_price = value, open_price = value) self.expected_percentage_delta_off_zero_delta_span_average = 0.7410714285714288 self.span_unit_deltas = [-1.3, -1.5, .3, 4.4, 5.0, 1.1] self.expected_span_unit_min_delta = -1.5 self.span_unit_delta_percentages = [-.13, -.15, .3, .4, -.04, 2.3] self.expected_unit_delta_percentage = -.15 self.span_code_prefix = 'span_unit_' self.spanUnitDeltasSymbol = SymbolData('span_unit_deltas') for i in range(0, len(self.span_unit_deltas)): unit_delta = self.span_unit_deltas[i] unit_delta_percentage = self.span_unit_delta_percentages[i] span_code = self.span_code_prefix + str(i) self.spanUnitDeltasSymbol.addSpanValueByCode(span_code, [span_code], delta = unit_delta, delta_percentage = unit_delta_percentage) oscillating_span_code = self.span_code_prefix + str(i % 2) self.spanUnitDeltasSymbol.addSpanValueByCode(oscillating_span_code, [oscillating_span_code], delta = unit_delta, delta_percentage = unit_delta_percentage) def test_getMinSpanUnitDelta(self): test_min_unit_delta = self.spanUnitDeltasSymbol.getMinSpanUnitDelta() self.assertEqual(self.expected_span_unit_min_delta, test_min_unit_delta) test_min_unit_delta_percentage = self.spanUnitDeltasSymbol.getMinSpanUnitDelta(get_percentage_delta = True) self.assertEqual(test_min_unit_delta_percentage, self.expected_unit_delta_percentage) def test_getSpanByCode(self): zero_delta_span = self.unitDeltaTestsSymbol.getSpanByCode(self.zero_delta_span_code) self.assertEqual(self.zero_delta_span_code, zero_delta_span.code) self.assertEqual(zero_delta_span.getUnitsCount(), 5) tudSpan = self.unitDeltaTestsSymbol.getSpanByCode(self.tud_span_code) self.assertEqual(self.tud_span_code, tudSpan.code) self.assertEqual(15, tudSpan.getUnitsCount()) tudSpanTwo = self.unitDeltaTestsSymbol.getSpanByCode(self.tud_span_code_two) self.assertEqual(self.tud_span_code_two, tudSpanTwo.code) self.assertEqual(6, tudSpanTwo.getUnitsCount()) def test_getSpanUnitCount(self): self.assertEqual(self.unitDeltaTestsSymbol.getSpanUnitCount(self.zero_delta_span_code), 5) self.assertEqual(self.unitDeltaTestsSymbol.getSpanUnitCount(self.zero_average_span_code), 5) self.assertEqual(self.unitDeltaTestsSymbol.getSpanUnitCount(self.tud_span_code), 15) self.assertEqual(self.unitDeltaTestsSymbol.getSpanUnitCount(self.tud_span_code_two), 6) self.assertEqual(self.emptySymbol.getSpanUnitCount(self.tud_span_code), 0) def test_getPercentageDeltaOffSpanAverage(self): test_percentage_delta_off_zero_delta_span_average = self.unitDeltaTestsSymbol.getPercentageDeltaOffSpanAverage(self.zero_delta_span_code, self.zero_delta_span_off_average_test_value) self.assertEqual(test_percentage_delta_off_zero_delta_span_average, self.expected_percentage_delta_off_zero_delta_span_average) test_percentage_delta_off_zero_average_span_average = self.unitDeltaTestsSymbol.getPercentageDeltaOffSpanAverage(self.zero_average_span_code, self.zero_delta_span_off_average_test_value) self.assertEqual(test_percentage_delta_off_zero_average_span_average, float("inf")) def test_getSpanDeltaValueToSpanMaxDeltaRatio(self): test_max_ratio = round(self.unitDeltaTestsSymbol.getSpanDeltaValueToSpanMaxDeltaRatio(self.tud_span_code_two, self.tud_span_code), 9) self.assertEqual(test_max_ratio, self.expected_span_delta_value_to_span_max_delta_ratio) test_max_ratio_percentage = round(self.unitDeltaTestsSymbol.getSpanDeltaValueToSpanMaxDeltaRatio(self.tud_span_code_two, self.tud_span_code, True), 5) self.assertEqual(test_max_ratio_percentage, self.expected_span_delta_value_to_span_max_delta_percentage_ratio) test_percentage_delta_off_zero_delta_span_average = self.unitDeltaTestsSymbol.getSpanDeltaValueToSpanMaxDeltaRatio(self.tud_span_code_two, self.zero_delta_span_code) self.assertEqual(test_percentage_delta_off_zero_delta_span_average, float("inf")) def test_getSpanDeltaValueToSpanMinDeltaRatio(self): test_min_ratio = round(self.unitDeltaTestsSymbol.getSpanDeltaValueToSpanMinDeltaRatio(self.tud_span_code_two, self.tud_span_code), 4) self.assertEqual(test_min_ratio, self.expected_span_delta_value_to_span_min_delta_ratio) test_min_ratio_percentage = round(self.unitDeltaTestsSymbol.getSpanDeltaValueToSpanMinDeltaRatio(self.tud_span_code_two, self.tud_span_code, True), 5) self.assertEqual(test_min_ratio_percentage, self.expected_span_delta_value_to_span_min_delta_percentage_ratio) test_percentage_delta_off_zero_delta_span_average = self.unitDeltaTestsSymbol.getSpanDeltaValueToSpanMinDeltaRatio(self.tud_span_code_two, self.zero_delta_span_code) self.assertEqual(test_percentage_delta_off_zero_delta_span_average, float("inf")) def test_getMaxDeltaForSpan(self): test_max_delta_for_span_tud_one = self.unitDeltaTestsSymbol.getMaxDeltaForSpan(self.tud_span_code) test_max_value = test_max_delta_for_span_tud_one['delta'] test_max_value_label = test_max_delta_for_span_tud_one['label'] self.assertEqual(test_max_value, self.max_unit_delta) self.assertEqual(test_max_value_label, self.max_unit_delta_label) test_max_delta_percentage = self.unitDeltaTestsSymbol.getMaxDeltaForSpan(self.tud_span_code, True) test_max_delta_percentage_value = round(test_max_delta_percentage['delta'], 5) test_max_delta_percentage_label = test_max_delta_percentage['label'] self.assertEqual(test_max_delta_percentage_value, self.max_unit_delta_percentage) self.assertEqual(test_max_delta_percentage_label, self.max_unit_delta_percentage_label) test_max_delta_two = self.unitDeltaTestsSymbol.getMaxDeltaForSpan(self.tud_span_code_two) test_max_value_two = test_max_delta_two['delta'] test_max_value_label_two = test_max_delta_two['label'] self.assertEqual(test_max_value_two, self.max_unit_delta_two) self.assertEqual(test_max_value_label_two, self.max_unit_delta_label_two) test_max_delta_percentage_two = self.unitDeltaTestsSymbol.getMaxDeltaForSpan(self.tud_span_code_two, True) test_max_delta_percentage_value_two = round(test_max_delta_percentage_two['delta'], 9) test_max_delta_percentage_label_two = test_max_delta_percentage_two['label'] self.assertEqual(test_max_delta_percentage_value_two, self.max_unit_delta_percentage_two) self.assertEqual(test_max_delta_percentage_label_two, self.max_unit_delta_label_two) # Test empty Symbol test_empty_value = self.emptySymbol.getMaxDeltaForSpan(self.tud_span_code) test_value = test_empty_value['delta'] test_label = test_empty_value['label'] self.assertIsNone(test_value) self.assertIsNone(test_label) def test_getMaxDeltaForSpanValue(self): test_max_value_explicit = self.unitDeltaTestsSymbol.getMaxDeltaForSpanValue(self.tud_span_code) self.assertEqual(test_max_value_explicit, self.max_unit_delta) test_max_delta_percentage_value_explicit = round(self.unitDeltaTestsSymbol.getMaxDeltaForSpanValue(self.tud_span_code, True), 5) self.assertEqual(test_max_delta_percentage_value_explicit, self.max_unit_delta_percentage) def test_getMinDeltaForSpan(self): test_min_delta_for_span_tud_one = self.unitDeltaTestsSymbol.getMinDeltaForSpan(self.tud_span_code) test_min_value = round(test_min_delta_for_span_tud_one['delta'], 2) test_min_value_label = test_min_delta_for_span_tud_one['label'] self.assertEqual(test_min_value, self.min_unit_delta) self.assertEqual(test_min_value_label, self.min_unit_delta_label) test_min_delta_percentage = self.unitDeltaTestsSymbol.getMinDeltaForSpan(self.tud_span_code, True) test_min_delta_percentage_value = round(test_min_delta_percentage['delta'], 9) test_min_delta_percentage_label = test_min_delta_percentage['label'] self.assertEqual(test_min_delta_percentage_value, self.min_unit_delta_percentage) self.assertEqual(test_min_delta_percentage_label, self.min_unit_delta_percentage_label) test_min_delta_two = self.unitDeltaTestsSymbol.getMinDeltaForSpan(self.tud_span_code_two) test_min_value_two = round(test_min_delta_two['delta'], 2) test_min_value_label_two = test_min_delta_two['label'] self.assertEqual(test_min_value_two, self.min_unit_delta_two) self.assertEqual(test_min_value_label_two, self.min_unit_delta_label_two) test_min_delta_percentage_two = self.unitDeltaTestsSymbol.getMinDeltaForSpan(self.tud_span_code_two, True) test_min_delta_percentage_value_two = round(test_min_delta_percentage_two['delta'], 9) test_min_delta_percentage_label_two = test_min_delta_percentage_two['label'] self.assertEqual(test_min_delta_percentage_value_two, self.min_unit_delta_percentage_two) self.assertEqual(test_min_delta_percentage_label_two, self.min_unit_delta_label_two) # Test empty Symbol test_empty_value = self.emptySymbol.getMinDeltaForSpan(self.tud_span_code) test_value = test_empty_value['delta'] test_label = test_empty_value['label'] self.assertIsNone(test_value) self.assertIsNone(test_label) def test_getMinDeltaForSpanValue(self): test_min_value_explicit = round(self.unitDeltaTestsSymbol.getMinDeltaForSpanValue(self.tud_span_code), 2) self.assertEqual(test_min_value_explicit, self.min_unit_delta) test_min_delta_percentage_explicit = round(self.unitDeltaTestsSymbol.getMinDeltaForSpanValue(self.tud_span_code, True), 9) self.assertEqual(test_min_delta_percentage_explicit, self.min_unit_delta_percentage) def test_init(self): expected_symbol = 'A' symbolDataTest = SymbolData(expected_symbol) test_symbol = symbolDataTest.symbol self.assertEqual(expected_symbol, test_symbol, 'A SymbolData object was initialized but its symbol was returned as {0} while expected to be {1}'.format(test_symbol, expected_symbol)) def test_getTodayPrice(self): expected_today_price = 12.4 symbolDataTest = SymbolData('A') symbolDataTest.setTodayPrice(expected_today_price) test_today_price = symbolDataTest.getTodayPrice() self.assertEqual(expected_today_price, test_today_price, 'A SymbolData object did not return the expected value when calling getTodayPrice(), expected {0} but returned {1}'.format(expected_today_price, test_today_price)) def test_getSpanAverageByCode_and_getPercentageDeltaOffSpanAverage(self): testSymbolData = SymbolData('A') span_to_test = [1.34, 5.6, -3.5, -0.3, 2.2] span_expected_average = 1.068 span_even_expected_average = 0.01333 span_odd_expected_average = 2.65 off_average_value_to_test = 1.12 span_code = 'test_span' testSymbolData.initializeSpanByCode(span_code) first_expected_none_value = testSymbolData.getSpanAverageByCode(span_code) self.assertIsNone(first_expected_none_value, 'A None value was not returned when getting the average of a span with no values') second_expected_none_value = testSymbolData.getPercentageDeltaOffSpanAverage(span_code, off_average_value_to_test) self.assertIsNone(second_expected_none_value, 'A None value was not returned when getting the percentage delta off average of a span with no values') unit_label_prefix = 'units_' i = 0 for value in span_to_test: unit_label_suffix = 'even' if ((i % 2) == 0) else 'odd' unit_label = unit_label_prefix + unit_label_suffix unit_labels_list = [unit_label, i] testSymbolData.addSpanValueByCode(span_code, unit_labels_list, value) i += 1 # Test average for all units in span span_test_average = testSymbolData.getSpanAverageByCode(span_code) self.assertEqual(span_expected_average, span_test_average, 'The computed average for a test span for a test SymbolData object was expected to be {0} but was {1}'.format(span_expected_average, span_test_average)) expected_delta_off_average = 0.0486891385768 test_delta_off_average = testSymbolData.getPercentageDeltaOffSpanAverage(span_code, off_average_value_to_test) test_delta_off_average = round(test_delta_off_average, 13) self.assertEqual(expected_delta_off_average, test_delta_off_average, 'The computed delta percentage off average for a test SymbolData object was expected to be {0} but was {1}'.format(expected_delta_off_average, test_delta_off_average)) # Test average for odd/even units in span even_units_label = unit_label_prefix + 'even' test_even_units_average = testSymbolData.getSpanAverageByCode(span_code, even_units_label) test_even_units_average = round(test_even_units_average, 5) self.assertEqual(test_even_units_average, span_even_expected_average) odd_units_label = unit_label_prefix + 'odd' test_odd_units_average = testSymbolData.getSpanAverageByCode(span_code, odd_units_label) self.assertEqual(test_odd_units_average, span_odd_expected_average) # Test off-average for odd/even units in span expected_off_even_average_value = 83.0 expected_off_odd_average_value = -0.57736 test_delta_off_even_average = testSymbolData.getPercentageDeltaOffSpanAverage(span_code, off_average_value_to_test, even_units_label) test_delta_off_even_average = round(test_delta_off_even_average, 1) test_delta_off_odd_average = testSymbolData.getPercentageDeltaOffSpanAverage(span_code, off_average_value_to_test, odd_units_label) test_delta_off_odd_average = round(test_delta_off_odd_average, 5) self.assertEqual(expected_off_even_average_value, test_delta_off_even_average) self.assertEqual(expected_off_odd_average_value, test_delta_off_odd_average) def test_getSpanDeltaByCode(self): testSymbolData = SymbolData('A') span_code = 'test_span' testSymbolData.initializeSpanByCode(span_code) span_to_test = [[1.34, 1.10], [5.6, 1.0], [-3.5, 5.6], [-0.3, -3.5], [2.01, -0.3], [2.34, 2.01]] unit_label_prefix = 'units_' i = 0 for unit_data in span_to_test: unit_label_suffix = 'even' if ((i % 2) == 0) else 'odd' unit_label = unit_label_prefix + unit_label_suffix unit_labels_list = [unit_label, i] close_price = unit_data[0] open_price = unit_data[1] testSymbolData.addSpanValueByCode(span_code, unit_labels_list, close_price, open_price) i += 1 expected_span_delta = 1.24 test_span_delta = testSymbolData.getSpanDeltaByCode(span_code) test_span_delta = round(test_span_delta, 2) self.assertEqual(expected_span_delta, test_span_delta) expected_span_delta_percentage = round(expected_span_delta / 1.10, 6) test_span_delta_percentage = round(testSymbolData.getSpanDeltaByCode(span_code, get_percentage = True), 6) self.assertEqual(expected_span_delta_percentage, test_span_delta_percentage) # Test the even/odd span deltas even_units_label = unit_label_prefix + 'even' odd_units_label = unit_label_prefix + 'odd' expected_even_units_delta = 0.91 expected_odd_units_delta = 1.34 test_even_units_delta = testSymbolData.getSpanDeltaByCode(span_code, even_units_label) test_even_units_delta = round(test_even_units_delta, 2) test_odd_units_delta = testSymbolData.getSpanDeltaByCode(span_code, odd_units_label) test_odd_units_delta = round(test_odd_units_delta, 2) self.assertEqual(expected_even_units_delta, test_even_units_delta) self.assertEqual(expected_odd_units_delta, test_odd_units_delta) test_even_units_delta_percentage = round(testSymbolData.getSpanDeltaByCode(span_code, even_units_label, get_percentage = True), 6) expected_even_units_delta_percentage = round(expected_even_units_delta / 1.10, 6) self.assertEqual(expected_even_units_delta_percentage, test_even_units_delta_percentage) test_odd_units_delta_percentage = round(testSymbolData.getSpanDeltaByCode(span_code, odd_units_label, get_percentage = True), 6) expected_even_units_delta_percentage = round(expected_odd_units_delta / 1.0, 6) self.assertEqual(expected_even_units_delta_percentage, test_odd_units_delta_percentage)