test_plotting_data.py

"""Tests for functions defined in sohstationviewer.controller.plottingData"""

from unittest import TestCase

from obspy import UTCDateTime

from sohstationviewer.controller.plottingData import (
    getMassposValueColors,
    formatTime,
    getTitle,
    getGaps,
    getTimeTicks,
    getDayTicks,
    getUnitBitweight
)


class TestGetGaps(TestCase):
    """Test suite for getGaps."""
    def test_mixed_gap_sizes(self):
        """
        Test getGaps - the given list of gaps contain both gaps that are too
        short and gaps that are long enough.
        """
        gaps = [(0, 60), (60, 180), (180, 360)]
        min_gap = 3
        self.assertListEqual(getGaps(gaps, min_gap), [(180, 360)])

    def test_empty_gap_list(self):
        """
        Test getGaps - the given list of gaps is empty.
        """
        gaps = []
        min_gap = 3
        self.assertListEqual(getGaps(gaps, min_gap), [])

    def test_all_gaps_are_too_short(self):
        """
        Test getGaps - the given list of gaps only contain gaps that are too
        short.
        """
        gaps = [(0, 60), (60, 180)]
        min_gap = 3
        self.assertListEqual(getGaps(gaps, min_gap), [])

    def test_all_gaps_are_long_enough(self):
        """
        Test getGaps - the given list of gaps only contain gaps that are long
        enough.
        """
        gaps = [(0, 180), (180, 360)]
        min_gap = 3
        self.assertListEqual(getGaps(gaps, min_gap), [(0, 180), (180, 360)])


class TestGetDayTicks(TestCase):
    """Test suite for getDayTicks."""
    def test_get_day_ticks(self):
        """Test getDayTicks."""
        expected = (
            [12, 24, 36, 48, 60, 72, 84, 96, 108, 120, 132, 144, 156, 168, 180,
             192, 204, 216, 228, 240, 252, 264, 276],
            [48, 96, 144, 192, 240],
            ['04', '08', '12', '16', '20']
        )
        self.assertTupleEqual(getDayTicks(), expected)


class TestGetMassposValue(TestCase):
    """Test suite for getMasspossValue"""
    def test_string_output(self):
        """
        Test basic functionality of getMassposValueColors - the range option
        and color mode are correct, and the output is a string.
        """
        expected_input_output_pairs = {
            ('regular', 'B'): '0.5:C|2.0:G|4.0:Y|7.0:R|7.0:+M',
            ('regular', 'W'): '0.5:B|2.0:B|4.0:B|7.0:B|7.0:+B',
            ('trillium', 'B'): '0.5:C|1.8:G|2.4:Y|3.5:R|3.5:+M',
            ('trillium', 'W'): '0.5:B|1.8:B|2.4:B|3.5:B|3.5:+B',
        }
        test_names = (
            'test_regular_B',
            'test_regular_W',
            'test_trillium_B',
            'test_trillium_W',
        )
        idx = 0
        for input_val in expected_input_output_pairs:
            with self.subTest(test_names[idx]):
                self.assertEqual(
                    getMassposValueColors(input_val[0], '', input_val[1], []),
                    expected_input_output_pairs[input_val]
                )
            idx += 1

    def test_list_output(self):
        """
        Test basic functionality of getMassposValueColors - the range option
        and color mode are correct, and the output is a list.
        """
        expected_input_output_pairs = {
            ('regular', 'B'):
                [(0.5, 'C'), (2.0, 'G'), (4.0, 'Y'), (7.0, 'R'), (7.0, 'M')],
            ('regular', 'W'):
                [(0.5, 'B'), (2.0, 'B'), (4.0, 'B'), (7.0, 'B'), (7.0, 'B')],
            ('trillium', 'B'):
                [(0.5, 'C'), (1.8, 'G'), (2.4, 'Y'), (3.5, 'R'), (3.5, 'M')],
            ('trillium', 'W'):
                [(0.5, 'B'), (1.8, 'B'), (2.4, 'B'), (3.5, 'B'), (3.5, 'B')],
        }
        test_names = (
            'test_regular_B',
            'test_regular_W',
            'test_trillium_B',
            'test_trillium_W',
        )
        for i, input_val in enumerate(expected_input_output_pairs):
            with self.subTest(test_names[i]):
                self.assertListEqual(
                    getMassposValueColors(
                        input_val[0], '', input_val[1], [], retType=''),
                    expected_input_output_pairs[input_val]
                )

    def test_range_option_not_supported(self):
        """
        Test basic functionality of getMassposValueColors - the range option
        is not supported.
        """
        errors = []
        empty_color_option = ''
        self.assertIsNone(
            getMassposValueColors(empty_color_option, '', 'B', errors))
        self.assertGreater(len(errors), 0)

        errors = []
        bad_color_option = 'unsupported'
        self.assertIsNone(
            getMassposValueColors(bad_color_option, '', 'B', errors))
        self.assertGreater(len(errors), 0)

    def test_color_mode_not_supported(self):
        """
        Test basic functionality of getMassposValueColors - the color mode is
        not supported.
        """
        errors = []
        empty_color_mode = ''
        with self.assertRaises(KeyError):
            getMassposValueColors('regular', '', empty_color_mode, errors)

        errors = []
        bad_color_mode = 'unsupported'
        with self.assertRaises(KeyError):
            getMassposValueColors('regular', '', bad_color_mode, errors)


class TestGetTimeTicks(TestCase):
    """Test suite for getTimeTicks."""
    def setUp(self) -> None:
        """Set up text fixtures."""
        self.label_cnt = 5
        self.date_fmt = 'YYYYMMDD'

    def test_expected_time_range(self):
        """
        Test basic functionality of getTimeTicks - the given time range is
        expected in the data.
        """

        with self.subTest('test_less_than_a_minute'):
            earliest = UTCDateTime(1970, 1, 1, 0, 0, 0).timestamp
            latest = UTCDateTime(1970, 1, 1, 0, 0, 5).timestamp
            expected = (
                [1.0, 2.0, 3.0, 4.0],
                [1.0, 2.0, 3.0, 4.0],
                ['19700101 00:00:01', '19700101 00:00:02',
                 '19700101 00:00:03', '19700101 00:00:04']
            )
            self.assertTupleEqual(
                getTimeTicks(earliest, latest, self.date_fmt, self.label_cnt),
                expected
            )

        with self.subTest('test_at_least_a_minute'):
            earliest = UTCDateTime(1970, 1, 1, 0, 0, 0).timestamp
            latest = UTCDateTime(1970, 1, 1, 0, 5, 53).timestamp
            expected = (
                [60.0, 120.0, 180.0, 240.0, 300.0],
                [60.0, 120.0, 180.0, 240.0, 300.0],
                ['19700101 00:01:00', '19700101 00:02:00', '19700101 00:03:00',
                 '19700101 00:04:00', '19700101 00:05:00']
            )
            self.assertTupleEqual(
                getTimeTicks(earliest, latest, self.date_fmt, self.label_cnt),
                expected
            )

        with self.subTest('test_at_least_an_hour'):
            earliest = UTCDateTime(1970, 1, 1, 0, 0, 0).timestamp
            latest = UTCDateTime(1970, 1, 1, 7, 45, 51).timestamp
            expected = (
                [3600.0, 7200.0, 10800.0, 14400.0, 18000.0, 21600.0, 25200.0],
                [3600.0, 10800.0, 18000.0, 25200.0],
                ['19700101 01:00', '19700101 03:00', '19700101 05:00',
                 '19700101 07:00']
            )
            self.assertTupleEqual(
                getTimeTicks(earliest, latest, self.date_fmt, self.label_cnt),
                expected
            )

        with self.subTest('test_at_least_ten_days'):
            # Exactly 10 days
            earliest = UTCDateTime(1970, 1, 1, 0, 0, 0).timestamp
            latest = UTCDateTime(1970, 1, 11, 0, 0, 0).timestamp
            expected = (
                [86400.0, 172800.0, 259200.0, 345600.0, 432000.0,
                 518400.0, 604800.0, 691200.0, 777600.0],
                [86400.0, 259200.0, 432000.0, 604800.0, 777600.0],
                ['19700102', '19700104', '19700106', '19700108', '19700110']
            )
            self.assertTupleEqual(
                getTimeTicks(earliest, latest, self.date_fmt, self.label_cnt),
                expected
            )

            # More than 10 days but fewer than 30 days
            earliest = UTCDateTime(1970, 1, 1, 0, 0, 0).timestamp
            latest = UTCDateTime(1970, 1, 14, 3, 5, 21).timestamp
            expected = (
                [86400.0, 172800.0, 259200.0, 345600.0, 432000.0,
                 518400.0, 604800.0, 691200.0, 777600.0, 864000.0,
                 950400.0, 1036800.0, 1123200.0],
                [86400.0, 345600.0, 604800.0, 864000.0, 1123200.0],
                ['19700102', '19700105', '19700108', '19700111', '19700114']
            )
            self.assertTupleEqual(
                getTimeTicks(earliest, latest, self.date_fmt, self.label_cnt),
                expected
            )

        with self.subTest('test_at_least_thirty_days'):
            # Exactly 30 days
            earliest = UTCDateTime(1970, 1, 1, 0, 0, 0).timestamp
            latest = UTCDateTime(1970, 1, 31, 0, 0, 0).timestamp
            expected = ([864000.0, 1728000.0],
                        [864000.0, 1728000.0],
                        ['19700111', '19700121'])
            self.assertTupleEqual(
                getTimeTicks(earliest, latest, self.date_fmt, self.label_cnt),
                expected
            )

            # More than 30 days
            earliest = UTCDateTime(1970, 1, 1, 0, 0, 0).timestamp
            latest = UTCDateTime(1970, 3, 21, 21, 43, 53).timestamp
            expected = (
                [864000.0, 1728000.0, 2592000.0, 3456000.0, 4320000.0,
                 5184000.0, 6048000.0],
                [864000.0, 2592000.0, 4320000.0, 6048000.0],
                ['19700111', '19700131', '19700220', '19700312']
            )
            self.assertTupleEqual(
                getTimeTicks(earliest, latest, self.date_fmt, self.label_cnt),
                expected
            )

    def test_boundary_time_range(self):
        """
        Test basic functionality of getTimeTicks - the given time range is
        exactly 1 second, 1 minute, or 1 hour. Test the behavior where these
        time ranges make getTimeTicks returns a tuple that contains empty
        lists.
        """
        expected = ([], [], [])
        with self.subTest('test_exactly_one_second'):
            earliest = UTCDateTime(1970, 1, 1, 0, 0, 0).timestamp
            latest = UTCDateTime(1970, 1, 1, 0, 0, 1).timestamp
            self.assertTupleEqual(
                getTimeTicks(earliest, latest, self.date_fmt, self.label_cnt),
                expected
            )
        with self.subTest('test_exactly_one_minute'):
            earliest = UTCDateTime(1970, 1, 1, 0, 0, 0).timestamp
            latest = UTCDateTime(1970, 1, 1, 0, 1, 0).timestamp
            self.assertTupleEqual(
                getTimeTicks(earliest, latest, self.date_fmt, self.label_cnt),
                expected
            )
        with self.subTest('test_exactly_one_hour'):
            earliest = UTCDateTime(1970, 1, 1, 0, 0, 0).timestamp
            latest = UTCDateTime(1970, 1, 1, 1, 0, 0).timestamp
            self.assertTupleEqual(
                getTimeTicks(earliest, latest, self.date_fmt, self.label_cnt),
                expected
            )

    def test_earliest_time_later_than_latest_time(self):
        """
        Test basic functionality of getTimeTicks - the given latest time is
        earlier than the earliest time.
        """
        self.assertTupleEqual(
            getTimeTicks(100, 0, self.date_fmt, self.label_cnt),
            ([], [], [])
        )

    def test_time_range_is_zero(self):
        """
        Test basic functionality of getTimeTicks - the given time range is 0.
        """
        self.assertTupleEqual(
            getTimeTicks(0, 0, self.date_fmt, self.label_cnt),
            ([], [], [])
        )

    def test_get_time_ticks_no_label_displayed(self):
        """
        Test basic functionality of getTimeTicks - no time label is requested
        to be displayed.
        """
        zero_label_cnt = 0
        with self.assertRaises(ZeroDivisionError):
            getTimeTicks(0, 1000, self.date_fmt, zero_label_cnt)


class TestFormatTimeAndGetTitle(TestCase):
    """Test suite for formatTime and getTitle"""
    def setUp(self) -> None:
        """Set up text fixtures."""
        self.positive_epoch_time = 67567567
        self.positive_formatted_dates = {
            'YYYY-MM-DD': '1972-02-22',
            'YYYYMMDD': '19720222',
            'YYYY:DOY': '1972:053',
        }
        self.positive_formatted_time = '00:46:07'

        self.negative_epoch_time = -67567567
        self.negative_formatted_dates = {
            'YYYY-MM-DD': '1967-11-10',
            'YYYYMMDD': '19671110',
            'YYYY:DOY': '1967:314',
        }
        self.negative_formatted_time = '23:13:53'

    def test_format_time_epoch_time_date_only(self):
        """
        Test basic functionality of formatTime - given time is epoch time and
        uses only a date format. Tests three cases for each date format: epoch
        time is positive, negative, and zero.
        """
        # formatter:off
        test_name_to_date_mode_map = {
            'test_year_month_day_format':         'YYYY-MM-DD',
            'test_year_month_day_format_no_dash': 'YYYYMMDD',
            'test_day_of_year_format':            'YYYY:DOY'
        }
        zero_epoch_formatted = {
            'test_year_month_day_format':         '1970-01-01',
            'test_year_month_day_format_no_dash': '19700101',
            'test_day_of_year_format':            '1970:001',
        }
        # formatter:on
        for test_name, date_mode in test_name_to_date_mode_map.items():
            with self.subTest(test_name):
                self.assertEqual(
                    formatTime(self.positive_epoch_time, date_mode),
                    self.positive_formatted_dates[date_mode])
                self.assertEqual(
                    formatTime(self.negative_epoch_time, date_mode),
                    self.negative_formatted_dates[date_mode])
                self.assertEqual(
                    formatTime(0, date_mode),
                    zero_epoch_formatted[test_name])

    def test_format_time_epoch_time_date_and_time(self):
        """
        Test basic functionality of formatTime - given time is epoch time and
        both a time and a date format are used. Tests three cases for each date
        format: epoch time is positive, negative, and zero.
        """
        # formatter:off
        test_name_to_date_mode_map = {
            'test_year_month_day_format':         'YYYY-MM-DD',
            'test_year_month_day_format_no_dash': 'YYYYMMDD',
            'test_day_of_year_format':            'YYYY:DOY',
        }
        zero_epoch_formatted = {
            'test_year_month_day_format':         '1970-01-01 00:00:00',
            'test_year_month_day_format_no_dash': '19700101 00:00:00',
            'test_day_of_year_format':            '1970:001 00:00:00',
        }
        # formatter:on
        for test_name, date_mode in test_name_to_date_mode_map.items():
            with self.subTest(test_name):
                positive_time_expected = (
                    f'{self.positive_formatted_dates[date_mode]} '
                    f'{self.positive_formatted_time}'
                )
                negative_time_expected = (
                    f'{self.negative_formatted_dates[date_mode]} '
                    f'{self.negative_formatted_time}'
                )

                self.assertEqual(
                    formatTime(self.positive_epoch_time, date_mode,
                               'HH:MM:SS'),
                    positive_time_expected
                )
                self.assertEqual(
                    formatTime(self.negative_epoch_time, date_mode,
                               'HH:MM:SS'),
                    negative_time_expected
                )
                self.assertEqual(formatTime(0, date_mode, 'HH:MM:SS'),
                                 zero_epoch_formatted[test_name])

    def test_format_time_UTCDateTime_date_only(self):
        """
        Test basic functionality of formatTime - given time is an UTCDateTime
        instance and uses only a date format.
        """
        test_name_to_date_mode_map = {
            'test_year_month_day_format': 'YYYY-MM-DD',
            'test_year_month_day_format_no_dash': 'YYYYMMDD',
            'test_day_of_year_format': 'YYYY:DOY',
        }
        utc_date_time = UTCDateTime(self.positive_epoch_time)
        expected_dates = self.positive_formatted_dates
        for test_name, date_mode in test_name_to_date_mode_map.items():
            with self.subTest(test_name):
                self.assertEqual(formatTime(utc_date_time, date_mode),
                                 expected_dates[date_mode])

    def test_format_time_UTCDateTime_date_and_time(self):
        """
        Test basic functionality of formatTime - given time is an UTCDateTime
        instance and both a time and a date format are used.
        """
        test_name_to_date_mode_map = {
            'test_year_month_day_format': 'YYYY-MM-DD',
            'test_year_month_day_format_no_dash': 'YYYYMMDD',
            'test_day_of_year_format': 'YYYY:DOY',
        }
        test_time = UTCDateTime(self.positive_epoch_time)
        expected_dates = self.positive_formatted_dates
        expected_time = self.positive_formatted_time
        for test_name, date_mode in test_name_to_date_mode_map.items():
            with self.subTest('test_year_month_day_format'):
                self.assertEqual(
                    formatTime(test_time, date_mode, 'HH:MM:SS'),
                    f'{expected_dates[date_mode]} {expected_time}'
                )

    def test_format_time_unsupported_date_format(self):
        """
        Test basic functionality of formatTime - given date format is not
        supported.
        """
        test_time = self.positive_epoch_time
        empty_format = ''
        bad_format = 'bad_format'

        with self.subTest('test_without_time_format'):
            expected = ''
            self.assertEqual(formatTime(test_time, empty_format),
                             expected)
            self.assertEqual(formatTime(test_time, bad_format),
                             expected)

        with self.subTest('test_with_time_format'):
            expected = f' {self.positive_formatted_time}'
            self.assertEqual(formatTime(test_time, empty_format, 'HH:MM:SS'),
                             expected)
            self.assertEqual(formatTime(test_time, bad_format, 'HH:MM:SS'),
                             expected)

    def test_format_time_unsupported_time_format(self):
        """
        Test basic functionality of formatTime - given time format is not
        supported.
        """
        test_time = self.positive_epoch_time
        date_format = 'YYYYMMDD'
        empty_format = ''
        bad_format = 'bad_format'

        expected = self.positive_formatted_dates[date_format]
        self.assertEqual(formatTime(test_time, date_format, empty_format),
                         expected)
        self.assertEqual(formatTime(test_time, date_format, bad_format),
                         expected)

    def test_format_time_unsupported_date_and_time_format(self):
        """
        Test basic functionality of formatTime - both given date and time
        format are unsupported.
        """
        test_time = self.positive_epoch_time
        expected = ''
        bad_date_formats = ['', 'bad_date_format']
        bad_time_format = ['', 'bad_time_format']
        for date_format in bad_date_formats:
            for time_format in bad_time_format:
                self.assertEqual(
                    formatTime(test_time, date_format, time_format),
                    expected
                )

    def test_get_title(self):
        """Test basic functionality of getTitle."""
        date_mode = 'YYYYMMDD'
        min_time = 0
        max_time = self.positive_epoch_time
        formatted_max_time = (f'{self.positive_formatted_dates[date_mode]}'
                              f' {self.positive_formatted_time}')
        with self.subTest('test_mseed'):
            key = '3734'
            expected = (f'3734  19700101 00:00:00  to  '
                        f'{formatted_max_time}  (18768.77)')
            self.assertEqual(getTitle(key, min_time, max_time, date_mode),
                             expected)
        with self.subTest('test_rt130'):
            key = ('92EB', 25)
            expected = (f"('92EB', 25)  19700101 00:00:00  to  "
                        f"{formatted_max_time}  (18768.77)")
            self.assertEqual(getTitle(key, min_time, max_time, date_mode),
                             expected)

    def test_get_title_max_time_earlier_than_min_time(self):
        """
        Test basic functionality of getTitle - the given maximum time is
        chronologically earlier than the given minimum time.
        """
        date_mode = 'YYYYMMDD'
        min_time = self.positive_epoch_time
        max_time = 0
        formatted_max_time = (f'{self.positive_formatted_dates[date_mode]}'
                              f' {self.positive_formatted_time}')
        with self.subTest('test_mseed'):
            key = '3734'
            expected = (f'3734  {formatted_max_time}  to  '
                        f'19700101 00:00:00  (-18768.77)')
            self.assertEqual(getTitle(key, min_time, max_time, date_mode),
                             expected)
        with self.subTest('test_rt130'):
            key = ('92EB', 25)
            expected = (f"('92EB', 25)  {formatted_max_time}  to  "
                        f"19700101 00:00:00  (-18768.77)")
            self.assertEqual(getTitle(key, min_time, max_time, date_mode),
                             expected)


class TestGetUnitBitweight(TestCase):
    """Test suite for getUnitBitweight."""

    def setUp(self) -> None:
        """Set up test fixtures."""
        self.chan_info = {
            'channel': 'Test Channel Name',
            'fixPoint': 0,
            'plotType': 'test_plot_type',
            'unit': 'test_unit'
        }
        # In most cases, we do not care about the value of bitweightOpt. So, we
        # give it a default value unless needed.
        self.default_bitweight_opt = 'low'

    def test_soh_channel_linesDots_linesSRate_linesMasspos_plot_type(self):
        """
        Test basic functionality of getUnitBitweight - the given plot type is
        linesDots, linesSRate, or linesMassposs.
        """
        self.chan_info['plotType'] = 'linesDots'
        with self.subTest('test_no_fix_point'):
            self.assertEqual(
                getUnitBitweight(self.chan_info, self.default_bitweight_opt),
                '{}test_unit'
            )
        with self.subTest('test_have_fix_point'):
            self.chan_info['fixPoint'] = 1
            self.assertEqual(
                getUnitBitweight(self.chan_info, self.default_bitweight_opt),
                '{:.1f}test_unit'
            )

    def test_soh_channel_other_plot_type(self):
        """
        Test basic functionality of getUnitBitweight - the given plot type is
        not linesDots, linesSRate, or linesMassposs and the channel is not a
        seismic data channel.
        """
        self.assertEqual(
            getUnitBitweight(self.chan_info, self.default_bitweight_opt),
            ''
        )

    def test_seismic_channel_have_fix_point(self):
        """
        Test basic functionality of getUnitBitweight - the given plot type is
        not linesDots, linesSRate, or linesMassposs, the channel is a
        seismic data channel, and there is a fix point.
        """
        self.chan_info['channel'] = 'SEISMIC'
        self.chan_info['fixPoint'] = 1
        self.assertEqual(
            getUnitBitweight(self.chan_info, self.default_bitweight_opt),
            '{:.1f}test_unit'
        )

    def test_seismic_channel_no_fix_point(self):
        """
        Test basic functionality of getUnitBitweight - the given plot type is
        not linesDots, linesSRate, or linesMassposs, the channel is a
        seismic data channel, and there is no fix point.
        """
        self.chan_info['channel'] = 'SEISMIC'
        with self.subTest('test_no_bitweight_option'):
            self.assertEqual(getUnitBitweight(self.chan_info, 'high'), '{}V')
        with self.subTest('test_have_bitweight_option'):
            self.assertEqual(getUnitBitweight(self.chan_info, ''),
                             '{}test_unit')

    def test_no_fix_point(self):
        """
        Test basic functionality of getUnitBitweight - the given channel info
        does not contain a value for fixPoint.
        """
        del self.chan_info['fixPoint']
        # Asserts that an error is not raised. TestCase does not have a method
        # to check that an exception was not raised so we have to use this
        # workaround. For more discussion on this topic, see these
        # stackoverflow questions and the answers
        # https://stackoverflow.com/questions/6181555/pass-a-python-unittest-if-an-exception-isnt-raised?noredirect=1&lq=1 # noqa
        # https://stackoverflow.com/questions/4319825/python-unittest-opposite-of-assertraises/4319870#4319870 # noqa:E501

        # Some context for this code: in getUnitBitWeight, if chanDB does not
        # have 'fix_point' as a key, then the value of fix_point defaults to 0.
        # This is implemented by getting the value of 'fix_point' in chanDB and
        # catching the resulting KeyError. So, in order to test that
        # getUnitBitweight handles this case correctly, we assert that no
        # exception was raised.
        try:
            getUnitBitweight(self.chan_info, '')
        except KeyError:
            self.fail()