test_util.py

"""Test suite for functions defined in sohstationviewer.controller.util."""

import os

from unittest import TestCase
from unittest.mock import patch
from tempfile import TemporaryDirectory, NamedTemporaryFile
import string


from sohstationviewer.controller.util import (
    validateFile,
    getDirSize,
    getTime6,
    getTime6_2y,
    getTime6_4y,
    getTime4,
    getVal,
    rtnPattern,
    fmti
)

TEST_DATA_DIR = os.path.realpath(os.path.join(
    os.path.dirname(os.path.realpath(__file__)),
    os.pardir,
    'test_data',
))


class TestGetTime(TestCase):
    """Test suite for getTime6, getTime6_2y, getTime6_4y, and getTime4."""
    def setUp(self):
        """Set up text fixtures."""
        self.time6_2y = '01:251:09:41:35:656'
        self.time6_4y = '2001:251:09:41:35:656'
        self.time4_day_1 = '1:09:41:35'
        self.time4 = '251:09:41:35'

    @patch('sohstationviewer.controller.util.getTime6_4y')
    @patch('sohstationviewer.controller.util.getTime6_2y')
    def test_get_time6(self, mock_2y, mock_4y):
        """
        Test getTime6 - check that getTime6 delegates work to the appropriate
        helper function depending on the input.
        """
        with self.subTest('test_2_digit_year'):
            getTime6(self.time6_2y)
            self.assertTrue(mock_2y.called)
            self.assertFalse(mock_4y.called)
        mock_2y.reset_mock()
        mock_4y.reset_mock()
        with self.subTest('test_4_digit_year'):
            getTime6(self.time6_4y)
            self.assertTrue(mock_4y.called)
            self.assertFalse(mock_2y.called)

    def test_get_time6_invalid_input(self):
        """Test getTime6 - the input is not one of the expected formats."""
        with self.subTest('test_input_contains_colon'):
            bad_inputs = [':523:531:', 'fs:523:531:', 'towe:523:531:']
            for input_str in bad_inputs:
                with self.assertRaises(ValueError):
                    getTime6(input_str)
        with self.subTest('test_input_does_not_contain_colon'):
            input_str = 'fq31dqrt63'
            with self.assertRaises(ValueError):
                getTime6(input_str)

    def test_get_time6_2y(self):
        """Test getTime6_2y."""
        epoch_time, year = getTime6_2y(self.time6_2y)
        self.assertAlmostEqual(epoch_time, 999942095.656)
        self.assertEqual(year, 2001)

    def test_get_time6_4y(self):
        """Test getTime6_4y."""
        epoch_time, year = getTime6_4y(self.time6_4y)
        self.assertAlmostEqual(epoch_time, 999942095.656)
        self.assertEqual(year, 2001)

    def test_get_time4_year_added(self):
        """Test getTime4 - a year has been added."""
        year = 2001
        year_added = True
        with self.subTest('test_first_day_of_year'):
            epoch_time, ret_year, ret_year_added = (
                getTime4(self.time4_day_1, year, year_added)
            )
            self.assertEqual(epoch_time, 978342095)
            self.assertEqual(ret_year, year)
            self.assertTrue(ret_year_added)

        with self.subTest('test_other_days'):
            epoch_time, ret_year, ret_year_added = (
                getTime4(self.time4, year, year_added)
            )
            self.assertEqual(epoch_time, 999942095)
            self.assertEqual(ret_year, year)
            self.assertTrue(ret_year_added)

    def test_get_time4_year_not_added(self):
        """Test getTime4 - a year has not been added."""
        year = 2001
        year_added = False
        with self.subTest('test_first_day_of_year'):
            epoch_time, ret_year, ret_year_added = (
                getTime4(self.time4_day_1, year, year_added)
            )
            self.assertEqual(epoch_time, 1009878095)
            self.assertEqual(ret_year, year + 1)
            self.assertTrue(ret_year_added)

        with self.subTest('test_other_days'):
            epoch_time, ret_year, ret_year_added = (
                getTime4(self.time4, year, year_added)
            )
            self.assertEqual(epoch_time, 999942095)
            self.assertEqual(ret_year, year)
            self.assertFalse(ret_year_added)


class TestValidateFile(TestCase):
    """Test suite for validateFile."""
    def test_valid_file(self):
        """
        Test basic functionality of validateFile - given file exists and is not
        an info file.
        """
        with NamedTemporaryFile() as valid_file:
            self.assertTrue(
                validateFile(valid_file.name,
                             os.path.basename(valid_file.name))
            )

    def test_info_file(self):
        """
        Test basic functionality of validateFile - given file exists and is an
        info file.
        """
        with self.subTest('test_dot_DS_Store'):
            with TemporaryDirectory() as temp_dir:
                # There are two ways to create a temporary file with a
                # custom name. The first way is to create a temporary
                # directory, then create a file in that directory. When the
                # temporary directory is deleted, the file is also deleted.
                # This automatic deletion effectively makes the file we created
                # a temporary file.
                # The second way is to create a temporary file and rename it
                # to the name we want. Then, we need to rename the file back
                # to its original name once we are done. This renaming is
                # needed because temporary file deletes itself based on its
                # name attribute, which is not changed in the first
                # renaming. While the second way makes it explicit that we
                # only want a temporary file, it might not be clear why the
                # second renaming is needed. In order to cause less
                # confusion in the code, we create this temporary file the
                # first way.
                ds_store_path = os.path.join(temp_dir, '.DS_Store')
                with open(ds_store_path, 'w+') as ds_store_file:
                    self.assertFalse(
                        validateFile(ds_store_path,
                                     os.path.basename(ds_store_file.name))
                    )

        with self.subTest('test_dot_underscore'):
            with NamedTemporaryFile(prefix='._') as info_file:
                self.assertFalse(
                    validateFile(info_file.name,
                                 os.path.basename(info_file.name))
                )

    def test_file_does_not_exist(self):
        """
        Test basic functionality of validateFile - given file does not exist.
        """
        empty_name_file = ''
        self.assertFalse(validateFile(empty_name_file, empty_name_file))

        not_exist_file = 'file_does_not_exist'
        self.assertFalse(validateFile(not_exist_file, not_exist_file))


class TestGetDirSize(TestCase):
    """Test suite for getDirSize."""
    def test_files_have_size_zero(self):
        """Test getDirSize - all files in the given directory has size zero."""
        expected_file_count = 10
        with TemporaryDirectory() as directory:
            files = []
            for i in range(expected_file_count):
                files.append(NamedTemporaryFile(dir=directory))
            dir_size, dir_file_count = getDirSize(directory)
            self.assertEqual(dir_size, 0)
            self.assertEqual(dir_file_count, expected_file_count)
            # Explicitly clean up the temporary files. If we don't do this,
            # the temporary directory will clean up itself and delete the
            # temporary files. Then, when the function returns, the references
            # to these temporary files will attempt to clean up the files. This
            # leads to exceptions being raised because the files being cleaned
            # up does not exist any more.
            files = [file.close() for file in files]

    def test_files_have_size_greater_than_zero(self):
        """
        Test getDirSize - all files in the given directory have a size greater
        than zero.
        """
        expected_file_count = 10
        size_one_file = 10
        # Each byte character is 1 byte, so we can obtain a byte string of n
        # bytes by creating a byte string with n characters.
        byte_to_write = b'a' * size_one_file
        temp_dir = TemporaryDirectory()
        with TemporaryDirectory(dir=temp_dir.name) as directory:
            files = []
            for i in range(expected_file_count):
                temp_file = NamedTemporaryFile(dir=directory)
                temp_file.write(byte_to_write)
                # Writing to file is not done until requested so we need to
                # explicitly tell Python to finish the write. Otherwise, the
                # size of the file on disk will stay 0.
                temp_file.flush()
                files.append(temp_file)
            dir_size, dir_file_count = getDirSize(temp_dir.name)
            self.assertEqual(dir_size, size_one_file * expected_file_count)
            self.assertEqual(dir_file_count, expected_file_count)
            # Explicitly clean up the temporary files. If we don't do this,
            # the temporary directory will clean up itself and delete the
            # temporary files. Then, when the function returns, the references
            # to these temporary files will attempt to clean up the files. This
            # leads to exceptions being raised because the files being cleaned
            # up does not exist any more.
            files = [file.close() for file in files]

    def test_nested_folder_structure(self):
        """
        Test getDirSize - the given directory contains nested directories.
        """
        test_folder = os.path.join(TEST_DATA_DIR, 'Pegasus-sample')
        dir_size, dir_file_count = getDirSize(test_folder)
        self.assertEqual(dir_size, 7909115)
        self.assertEqual(dir_file_count, 8)

    def test_empty_directory(self):
        """Test getDirSize - the given directory contains no file."""
        with TemporaryDirectory() as temp_dir:
            dir_size, dir_file_count = getDirSize(temp_dir)
            self.assertEqual(dir_size, 0)
            self.assertEqual(dir_file_count, 0)

    def test_directory_does_not_exist(self):
        """Test getDirSize - the given directory does not exist."""
        empty_name_dir = ''
        dir_size, dir_file_count = getDirSize(empty_name_dir)
        self.assertEqual(dir_size, 0)
        self.assertEqual(dir_file_count, 0)

        non_existent_dir = 'directory does not exist'
        dir_size, dir_file_count = getDirSize(non_existent_dir)
        self.assertEqual(dir_size, 0)
        self.assertEqual(dir_file_count, 0)


class TestRtnPattern(TestCase):
    """Test suite for rtnPattern."""
    def test_no_upper(self):
        """Test rtnPattern - characters are not converted to uppercase."""
        with self.subTest('test_digit'):
            digits = '123456789'
            self.assertEqual(rtnPattern(digits), '0' * len(digits))
        with self.subTest('test_lowercase'):
            lowercase_chars = string.ascii_lowercase
            self.assertEqual(rtnPattern(lowercase_chars),
                             'a' * len(lowercase_chars))
        with self.subTest('test_uppercase'):
            uppercase_chars = string.ascii_uppercase
            self.assertEqual(rtnPattern(uppercase_chars),
                             'A' * len(uppercase_chars))

    def test_with_upper(self):
        """Test rtnPattern - all characters are converted to uppercase."""
        lowercase_chars = string.ascii_lowercase
        self.assertEqual(rtnPattern(lowercase_chars, upper=True),
                         'A' * len(lowercase_chars))


class TestGetVal(TestCase):
    """Test suite for getVal."""
    def test_normal_case(self):
        """Test getVal - the input is of an expected value."""
        # formatter:off
        test_name_to_test_map = {
            'test_with_decimal_point':      ('60.3V',   60.3),
            'test_no_decimal_point':        ('15V',     15.0),
            'test_with_plus_sign':          ('+35.5V',  35.5),
            'test_with_negative_sign':      ('-35.2V', -35.2),
            'test_multiple_decimal_digits': ('52.523V', 52.5),
            'test_no_decimal_digit':        ('12.V',    12.0),
        }
        # formatter:on
        for test_name, inout_pair in test_name_to_test_map.items():
            with self.subTest(test_name):
                self.assertEqual(getVal(inout_pair[0]), inout_pair[1])

    def test_positive_negative_sign_in_front(self):
        """
        Test rtnPattern - the input has both a positive sign and a negative
        sign in the front.
        """
        with self.assertRaises(ValueError):
            getVal('+-1.0V')

    def test_bad_input(self):
        """Test rtnPattern - the input has a value that is not expected."""
        with self.assertRaises(AttributeError):
            getVal('')


class TestFmti(TestCase):
    """Test suite for fmti."""
    def test_absolute_value_below_1000(self):
        """
        Test fmti - the input is greater than -1000 but smaller than 1000.
        """
        with self.subTest('test_positive'):
            val = 52.521
            self.assertEqual(fmti(val), '52')
        with self.subTest('test_negative'):
            val = -232.42
            self.assertEqual(fmti(val), '-232')

    def test_absolute_value_above_1000(self):
        """
        Test fmti - the input is greater than 1000 or smaller than -1000.
        """
        with self.subTest('test_positive'):
            val = 136235646.215151
            expected = '136,235,646'
            self.assertEqual(fmti(val), expected)
        with self.subTest('test_negative'):
            val = -62362.32523
            expected = '-62,362'
            self.assertEqual(fmti(val), expected)