TestPlumdUtilsFilter

Complexity

Total Complexity

22

Size/Duplication

Total Lines	70
Duplicated Lines	0 %

Importance

Changes	3
Bugs	2	Features	1

5 Methods

Rating	Name	Duplication	Size	Complexity
B	test_filter_normal_nondigits()	0	12	6
A	test_filter_normal_digits()	0	11	4
A	test_filter_normal_empty()	0	11	2
B	test_filter_normal_noargs()	0	13	5
B	test_filter_normal_random()	0	12	5

import os
import sys
import random
PY3 = sys.version_info > (3,)

import string
import unittest

MAX_DIFF = 8192
FILE_PATH = os.path.realpath(__file__)
PATH = os.path.dirname(FILE_PATH)
sys.path.insert(0, os.path.realpath(os.path.join(PATH, "../../../")))
import plumd.util


class TestPlumdUtilsFilter(unittest.TestCase):


    def test_filter_normal_digits(self):
        """ensure filter properly filtering for digits"""
        # chars to keep - only digits
        kchars = string.digits
        # chars to test - all chars
        test = "".join(char for char in map(chr, range(256)))
        fobj = plumd.util.Filter(kchars)
        result = fobj.process(test)
        # any non-digits found?
        check = "".join(char for char in result if char not in kchars)
        self.assertEquals(check, "")


    def test_filter_normal_nondigits(self):
        """ensure filter properly filtering for digits"""
        # chars to keep - only non-digits
        kchars = "".join(char for char in map(chr, range(256)) \
                         if char not in string.digits)
        # chars to test - all chars
        test = "".join(char for char in map(chr, range(256)))
        fobj = plumd.util.Filter(kchars)
        result = fobj.process(test)
        # any non-digits found?
        check = "".join(char for char in result if char not in kchars)
        self.assertEquals(check, "")


    def test_filter_normal_noargs(self):
        """ensure filter properly filtering for defaults"""
        if PY3:
            kchars = string.ascii_letters + string.digits + "_-"
        else:
            kchars = string.letters + string.digits + "_-"

The Module string does not seem to have a member named letters.

        # chars to test - all chars
        test = "".join(char for char in map(chr, range(256)))
        fobj = plumd.util.Filter()
        result = fobj.process(test)
        # any non-digits found?
        check = "".join(char for char in result if char not in kchars)
        self.assertEquals(check, "")


    def test_filter_normal_empty(self):
        """ensure filter properly filtering for none values"""
        if PY3:
            kchars = string.ascii_letters + string.digits + "_-"

The variable kchars seems to be unused.

        else:
            kchars = string.letters + string.digits + "_-"

The Module string does not seem to have a member named letters.

        # chars to test - all chars
        test = ""
        fobj = plumd.util.Filter()
        result = fobj.process(test)
        self.assertEquals(result, "")


    def test_filter_normal_random(self):
        """ensure filter properly filtering for random characters"""
        kchars = ""
        while(len(kchars) < 128):

There is an unnecessary parenthesis after while.

            kchars += chr(random.randrange(0, 256))
        # chars to test - all chars
        test = "".join(char for char in map(chr, range(256)))
        fobj = plumd.util.Filter(kchars)
        result = fobj.process(test)
        # any non-digits found?
        check = "".join(char for char in result if char not in kchars)
        self.assertEquals(check, "")


if __name__ == '__main__':
    unittest.main()