tests.unit.test_util

Complexity

Total Complexity

35

Size/Duplication

Total Lines	117
Duplicated Lines	0 %

Importance

Changes

0

15 Functions

Rating	Name	Duplication	Size	Complexity
A	test_wrap_bad_n_type_float()	0	4	2
A	test_wrap_bad_m_type_float()	0	4	2
A	test_wrap_bad_m_negative()	0	4	2
A	test_wrap_bad_m_type_str()	0	4	2
A	test_load_dataset_bad_dataset_missing()	0	4	2
A	test_load_dataset_bad_root_missing()	0	4	2
A	test_wrap_bad_n_zero()	0	4	2
A	test_load_dataset_correctness()	0	4	3
A	test_wrap_bad_para_type_float()	0	4	2
A	test_wrap_bad_n_type_str()	0	4	2
A	test_load_dataset_bad_root_type_float()	0	5	2
B	test_wrap_correctness()	0	11	6
A	test_load_dataset_bad_data_type()	0	6	2
A	test_load_dataset_bad_dataset_type_float()	0	5	2
A	test_load_dataset_bad_separator_type_float()	0	6	2

"""
:mod:`tests.unit.test_util` -- Unit Tests
=========================================

.. module:: tests.unit.test_util
   :synopsis: Unit tests for the lib.util module.

.. moduleauthor:: Bill Maroney <bill@invalid.com>
"""

import pytest

from lib.util import wrap, load_dataset


def test_wrap_correctness():
    """ Test the correctness of :func:`lib.util.wrap` by examining outputs for expected properties """

This line is too long as per the coding-style (102/100).

    long_line = "I'm a long line, but how long, really, is a line?"
    long_para = 400 * long_line
    m, n = 4, 120

The name m does not conform to the variable naming conventions ((([a-z][a-z0-9_]{2,30})|(_[a-z0-9_]*))$).

The name n does not conform to the variable naming conventions ((([a-z][a-z0-9_]{2,30})|(_[a-z0-9_]*))$).

    wrapped_para = wrap(long_para, m, n)
    assert isinstance(wrapped_para, str), "wrong type"
    for line in wrapped_para.split("\n"):
        assert isinstance(line, str), "wrong type"
        assert line.startswith(m * " "), "incorrect white-space padding at front of line"
        assert len(line) <= n, "line is too long"


def test_wrap_bad_para_type_float():
    """ Test that :func:`lib.util.wrap` raises a ``TypeError`` for a non-``int`` value for `para` (``float``) """

This line is too long as per the coding-style (113/100).

    with pytest.raises(TypeError):
        wrap(3.14, 4, 80)


def test_wrap_bad_m_type_str():
    """ Test that :func:`lib.util.wrap` raises a ``TypeError`` for a non-``int`` value for `m` (``str``) """

This line is too long as per the coding-style (108/100).

    with pytest.raises(TypeError):
        wrap("paragraph I be...", "bad", 80)


def test_wrap_bad_m_type_float():
    """ Test that :func:`lib.util.wrap` raises a ``TypeError`` for a non-``int`` value for `m` (``float``) """

This line is too long as per the coding-style (110/100).

    with pytest.raises(TypeError):
        wrap("paragraph I be...", 3.14, 80)


def test_wrap_bad_m_negative():
    """ Test that :func:`lib.util.wrap` raises a ``ValueError`` for a :math:`m \\lt 0` """
    with pytest.raises(ValueError):
        wrap("paragraph I be...", -14, 80)


def test_wrap_bad_n_type_str():
    """ Test that :func:`lib.util.wrap` raises a ``TypeError`` for a non-``int`` value for `n` (``str``) """

This line is too long as per the coding-style (108/100).

    with pytest.raises(TypeError):
        wrap("paragraph I be...", 4, "bad")


def test_wrap_bad_n_type_float():
    """ Test that :func:`lib.util.wrap` raises a ``TypeError`` for a non-``int`` value for `n` (``float``) """

This line is too long as per the coding-style (110/100).

    with pytest.raises(TypeError):
        wrap("paragraph I be...", 4, 3.14)


def test_wrap_bad_n_zero():
    """ Test that :func:`lib.util.wrap` raises a ``ValueError`` for :math:`n = 0` """
    with pytest.raises(ValueError):
        wrap("paragraph I be...", 4, 0)


def test_load_dataset_correctness():
    """ Test the correctness of :func:`lib.util.load_dataset` by examining datatypes of outputs """
    for elt in load_dataset("general", "primes", data_type=int):
        assert isinstance(elt, int), "wrong type"


def test_load_dataset_bad_root_type_float():

The name test_load_dataset_bad_root_type_float does not conform to the function naming conventions ((([a-z][a-z0-9_]{2,30})|(_[a-z0-9_]*))$).

    """ Test that :func:`lib.util.load_dataset` raises a ``TypeError`` for a non-``str`` value for `root` (``float``)

This line is too long as per the coding-style (117/100).

    """
    with pytest.raises(TypeError):
        load_dataset(3.14, "primes")


def test_load_dataset_bad_root_missing():

The name test_load_dataset_bad_root_missing does not conform to the function naming conventions ((([a-z][a-z0-9_]{2,30})|(_[a-z0-9_]*))$).

    """ Test that :func:`lib.util.load_dataset` raises a ``FileNotFoundError`` for a non-existent directory `root` """

This line is too long as per the coding-style (118/100).

    with pytest.raises(FileNotFoundError):
        load_dataset("i_dont_exist", "primes")


def test_load_dataset_bad_dataset_type_float():

The name test_load_dataset_bad_dataset_type_float does not conform to the function naming conventions ((([a-z][a-z0-9_]{2,30})|(_[a-z0-9_]*))$).

    """ Test that :func:`lib.util.load_dataset` raises a ``TypeError`` for a non-``str`` value for `dataset` (``float``)

This line is too long as per the coding-style (120/100).

    """
    with pytest.raises(TypeError):
        load_dataset("general", 3.14)


def test_load_dataset_bad_dataset_missing():

The name test_load_dataset_bad_dataset_missing does not conform to the function naming conventions ((([a-z][a-z0-9_]{2,30})|(_[a-z0-9_]*))$).

    """ Test that :func:`lib.util.load_dataset` raises a ``FileNotFoundError`` for a non-existent file `dataset` """

This line is too long as per the coding-style (116/100).

    with pytest.raises(FileNotFoundError):
        load_dataset("general", "3.14")


def test_load_dataset_bad_separator_type_float():

The name test_load_dataset_bad_separator_type_float does not conform to the function naming conventions ((([a-z][a-z0-9_]{2,30})|(_[a-z0-9_]*))$).

    """ Test that :func:`lib.util.load_dataset` raises a ``TypeError`` for a non-``str`` value for `separator`

This line is too long as per the coding-style (110/100).

        (``float``)
    """
    with pytest.raises(TypeError):
        load_dataset("general", "primes", separator=12.34)


def test_load_dataset_bad_data_type():
    """ Test that :func:`lib.util.load_dataset` raises a ``TypeError`` for a non-``type`` value for `data_type`

This line is too long as per the coding-style (111/100).

        (``int``)
    """
    with pytest.raises(TypeError):
        load_dataset("general", "primes", data_type=7)