ResultTest

Complexity

Total Complexity

13

Size/Duplication

Total Lines	169
Duplicated Lines	0 %

Importance

Changes	3
Bugs	0	Features	0

10 Methods

Rating	Name	Duplication	Size	Complexity
A	test_origin()	0	9	1
B	test_add()	0	28	1
A	test_invalid_severity()	0	3	2
A	test_overlaps()	0	13	1
B	test_string_dict()	0	35	1
A	test_location_repr()	0	16	1
A	test_apply()	0	17	1
A	test_constructor()	0	11	1
A	test_json_diff()	0	21	1
A	test_invalid_confidence()	0	5	3

import unittest
import json
from os.path import abspath

from coalib.results.Diff import Diff
from coalib.results.Result import RESULT_SEVERITY, Result
from coalib.results.SourceRange import SourceRange
from coalib.output.JSONEncoder import create_json_encoder


class ResultTest(unittest.TestCase):

    def test_constructor(self):
        fl = ["1", "2", "3", "4"]
        list_diffs = [Diff(fl, filename="file"), Diff(fl, filename="file1")]
        dict_diffs = {"file": Diff(fl, filename="file")}

        uut = Result("origin", "msg", diffs=list_diffs)
        self.assertEqual(uut.diffs["file"].filename, "file")
        self.assertEqual(uut.diffs["file1"].filename, "file1")

        uut = Result("origin", "msg", diffs=dict_diffs)
        self.assertEqual(uut.diffs["file"], dict_diffs["file"])

    def test_origin(self):
        uut = Result("origin", "msg")
        self.assertEqual(uut.origin, "origin")

        uut = Result(self, "msg")
        self.assertEqual(uut.origin, "ResultTest")

        uut = Result(None, "msg")
        self.assertEqual(uut.origin, "")

    def test_invalid_severity(self):
        with self.assertRaises(ValueError):
            Result("o", "m", severity=-5)

    def test_invalid_confidence(self):
        with self.assertRaises(ValueError):
            Result("o", "m", confidence=-1)
        with self.assertRaises(ValueError):
            Result("o", "m", confidence=101)

    def test_string_dict(self):
        uut = Result(None, "")
        output = uut.to_string_dict()
        self.assertEqual(output, {"id": str(uut.id),
                                  "origin": "",
                                  "message": "",
                                  "file": "",
                                  "line_nr": "",
                                  "severity": "NORMAL",
                                  "debug_msg": "",
                                  "additional_info": "",
                                  "confidence": "100"})

        uut = Result.from_values(origin="origin",
                                 message="msg",
                                 file="file",
                                 line=2,
                                 severity=RESULT_SEVERITY.INFO,
                                 additional_info="hi!",
                                 debug_msg="dbg",
                                 confidence=50)
        output = uut.to_string_dict()
        self.assertEqual(output, {"id": str(uut.id),
                                  "origin": "origin",
                                  "message": "msg",
                                  "file": abspath("file"),
                                  "line_nr": "2",
                                  "severity": "INFO",
                                  "debug_msg": "dbg",
                                  "additional_info": "hi!",
                                  "confidence": "50"})

        uut = Result.from_values(origin="o", message="m", file="f", line=5)
        output = uut.to_string_dict()
        self.assertEqual(output["line_nr"], "5")

    def test_apply(self):
        file_dict = {
            "f_a": ["1", "2", "3"],
            "f_b": ["1", "2", "3"]
        }
        expected_file_dict = {
            "f_a": ["1", "3_changed"],
            "f_b": ["1", "2", "3"]
        }
        diff = Diff(file_dict['f_a'])
        diff.delete_line(2)
        diff.change_line(3, "3", "3_changed")

        uut = Result("origin", "msg", diffs={"f_a": diff})
        uut.apply(file_dict)

        self.assertEqual(file_dict, expected_file_dict)

    def test_add(self):
        file_dict = {
            "f_a": ["1", "2", "3"],
            "f_b": ["1", "2", "3"],
            "f_c": ["1", "2", "3"]
        }
        expected_file_dict = {
            "f_a": ["1", "3_changed"],
            "f_b": ["1", "2", "3_changed"],
            "f_c": ["1", "2", "3"]
        }

        diff = Diff(file_dict['f_a'])
        diff.delete_line(2)
        uut1 = Result("origin", "msg", diffs={"f_a": diff})

        diff = Diff(file_dict['f_a'])
        diff.change_line(3, "3", "3_changed")
        uut2 = Result("origin", "msg", diffs={"f_a": diff})

        diff = Diff(file_dict['f_b'])
        diff.change_line(3, "3", "3_changed")
        uut3 = Result("origin", "msg", diffs={"f_b": diff})

        uut1 += uut2 + uut3
        uut1.apply(file_dict)

        self.assertEqual(file_dict, expected_file_dict)

    def test_overlaps(self):
        overlapping_range = SourceRange.from_values("file1", 1, 1, 2, 2)
        nonoverlapping_range = SourceRange.from_values("file2", 1, 1, 2, 2)
        uut = Result.from_values("origin",
                                 "message",
                                 file="file1",
                                 line=1,
                                 column=1,
                                 end_line=2,
                                 end_column=2)
        self.assertTrue(uut.overlaps(overlapping_range))
        self.assertTrue(uut.overlaps([overlapping_range]))
        self.assertFalse(uut.overlaps(nonoverlapping_range))

    def test_location_repr(self):
        result_a = Result(origin="o", message="m")
        self.assertEqual(result_a.location_repr(), "the whole project")

        result_b = Result.from_values("o", "m", file="e")
        self.assertEqual(result_b.location_repr(), "'e'")

        affected_code = (SourceRange.from_values('f'),
                         SourceRange.from_values('g'))
        result_c = Result("o", "m", affected_code=affected_code)
        self.assertEqual(result_c.location_repr(), "'f', 'g'")

        affected_code = (SourceRange.from_values('f'),
                         SourceRange.from_values('f'))
        result_d = Result("o", "m", affected_code=affected_code)
        self.assertEqual(result_d.location_repr(), "'f'")

    def test_json_diff(self):
        file_dict = {
            "f_a": ["1", "2", "3"],
            "f_b": ["1", "2", "3"]
        }
        expected_file = {
            "f_a": ["1", "3_changed"],
            "f_b": ["1", "2", "3"]
        }
        diff = Diff(file_dict['f_a'])
        diff.delete_line(2)
        diff.change_line(3, "3", "3_changed")
        uut = Result("origin", "msg", diffs={"f_a": diff}).__json__(True)
        self.assertEqual(uut["diffs"]['f_a'].__json__(), "--- \n"
                                                         "+++ \n"
                                                         "@@ -1,3 +1,2 @@\n"
                                                         " 1-2-3+3_changed")
        JSONEncoder = create_json_encoder(use_relpath=True)
        json_dump = json.dumps(diff, cls=JSONEncoder, sort_keys=True)
        self.assertEqual(
            json_dump, '"--- \\n+++ \\n@@ -1,3 +1,2 @@\\n 1-2-3+3_changed"')