FreeCAD

1
# -*- coding: utf-8 -*-
2
# ***************************************************************************
3
# *   Copyright (c) 2016 sliptonic <shopinthewoods@gmail.com>               *
4
# *                                                                         *
5
# *   This program is free software; you can redistribute it and/or modify  *
6
# *   it under the terms of the GNU Lesser General Public License (LGPL)    *
7
# *   as published by the Free Software Foundation; either version 2 of     *
8
# *   the License, or (at your option) any later version.                   *
9
# *   for detail see the LICENCE text file.                                 *
10
# *                                                                         *
11
# *   This program is distributed in the hope that it will be useful,       *
12
# *   but WITHOUT ANY WARRANTY; without even the implied warranty of        *
13
# *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the         *
14
# *   GNU Library General Public License for more details.                  *
15
# *                                                                         *
16
# *   You should have received a copy of the GNU Library General Public     *
17
# *   License along with this program; if not, write to the Free Software   *
18
# *   Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  *
19
# *   USA                                                                   *
20
# *                                                                         *
21
# ***************************************************************************
22

23
import Path
24
import unittest
25

26

27
class TestPathLog(unittest.TestCase):
28
    """Some basic tests for the logging framework."""
29

30
    MODULE = "TestPathLog"  # file name without extension
31

32
    def setUp(self):
33
        Path.Log.setLevel(Path.Log.Level.RESET)
34
        Path.Log.untrackAllModules()
35

36
    def callerFile(self):
37
        return Path.Log._caller()[0]
38

39
    def callerLine(self):
40
        return Path.Log._caller()[1]
41

42
    def callerFunc(self):
43
        return Path.Log._caller()[2]
44

45
    def test00(self):
46
        """Check for proper module extraction."""
47
        self.assertEqual(self.callerFile(), self.MODULE)
48

49
    def test01(self):
50
        """Check for proper function extraction."""
51
        self.assertEqual(self.callerFunc(), "test01")
52

53
    def test10(self):
54
        """Verify default log levels is NOTICE."""
55
        self.assertEqual(Path.Log.getLevel(), Path.Log.Level.NOTICE)
56
        self.assertEqual(Path.Log.getLevel(self.MODULE), Path.Log.Level.NOTICE)
57

58
    def test11(self):
59
        """Verify setting global log level."""
60
        Path.Log.setLevel(Path.Log.Level.DEBUG)
61

62
        self.assertEqual(Path.Log.getLevel(), Path.Log.Level.DEBUG)
63
        self.assertEqual(Path.Log.getLevel(self.MODULE), Path.Log.Level.DEBUG)
64

65
    def test12(self):
66
        """Verify setting module log level."""
67
        Path.Log.setLevel(Path.Log.Level.DEBUG, self.MODULE)
68

69
        self.assertEqual(Path.Log.getLevel(), Path.Log.Level.NOTICE)
70
        self.assertEqual(Path.Log.getLevel(self.MODULE), Path.Log.Level.DEBUG)
71

72
    def test13(self):
73
        """Verify setting other modul's log level doesn't change this one's."""
74
        # if this test fails then most likely the global RESET is broken
75
        Path.Log.setLevel(Path.Log.Level.DEBUG, "SomeOtherModule")
76

77
        self.assertEqual(Path.Log.getLevel(), Path.Log.Level.NOTICE)
78
        self.assertEqual(Path.Log.getLevel(self.MODULE), Path.Log.Level.NOTICE)
79

80
    def test14(self):
81
        """Verify resetting log level for module falls back to global level."""
82
        Path.Log.setLevel(Path.Log.Level.DEBUG, self.MODULE)
83
        self.assertEqual(Path.Log.getLevel(self.MODULE), Path.Log.Level.DEBUG)
84
        # changing global log level does not affect module
85
        Path.Log.setLevel(Path.Log.Level.ERROR)
86
        self.assertEqual(Path.Log.getLevel(self.MODULE), Path.Log.Level.DEBUG)
87
        # resetting module log level restores global log level for module
88
        Path.Log.setLevel(Path.Log.Level.RESET, self.MODULE)
89
        self.assertEqual(Path.Log.getLevel(self.MODULE), Path.Log.Level.ERROR)
90
        # changing the global log level will also change the module log level
91
        Path.Log.setLevel(Path.Log.Level.DEBUG)
92
        self.assertEqual(Path.Log.getLevel(self.MODULE), Path.Log.Level.DEBUG)
93

94
    def test20(self):
95
        """Verify debug logs aren't logged by default."""
96
        self.assertIsNone(Path.Log.debug("this"))
97

98
    def test21(self):
99
        """Verify debug logs are logged if log level is set to DEBUG."""
100
        Path.Log.setLevel(Path.Log.Level.DEBUG)
101
        self.assertIsNotNone(Path.Log.debug("this"))
102

103
    def test30(self):
104
        """Verify log level ERROR."""
105
        Path.Log.setLevel(Path.Log.Level.ERROR)
106
        self.assertIsNone(Path.Log.debug("something"))
107
        self.assertIsNone(Path.Log.info("something"))
108
        self.assertIsNone(Path.Log.notice("something"))
109
        self.assertIsNone(Path.Log.warning("something"))
110
        self.assertIsNotNone(Path.Log.error("something"))
111

112
    def test31(self):
113
        """Verify log level WARNING."""
114
        Path.Log.setLevel(Path.Log.Level.WARNING)
115
        self.assertIsNone(Path.Log.debug("something"))
116
        self.assertIsNone(Path.Log.info("something"))
117
        self.assertIsNone(Path.Log.notice("something"))
118
        self.assertIsNotNone(Path.Log.warning("something"))
119
        self.assertIsNotNone(Path.Log.error("something"))
120

121
    def test32(self):
122
        """Verify log level NOTICE."""
123
        Path.Log.setLevel(Path.Log.Level.NOTICE)
124
        self.assertIsNone(Path.Log.debug("something"))
125
        self.assertIsNone(Path.Log.info("something"))
126
        self.assertIsNotNone(Path.Log.notice("something"))
127
        self.assertIsNotNone(Path.Log.warning("something"))
128
        self.assertIsNotNone(Path.Log.error("something"))
129

130
    def test33(self):
131
        """Verify log level INFO."""
132
        Path.Log.setLevel(Path.Log.Level.INFO)
133
        self.assertIsNone(Path.Log.debug("something"))
134
        self.assertIsNotNone(Path.Log.info("something"))
135
        self.assertIsNotNone(Path.Log.notice("something"))
136
        self.assertIsNotNone(Path.Log.warning("something"))
137
        self.assertIsNotNone(Path.Log.error("something"))
138

139
    def test34(self):
140
        """Verify log level DEBUG."""
141
        Path.Log.setLevel(Path.Log.Level.DEBUG)
142
        self.assertIsNotNone(Path.Log.debug("something"))
143
        self.assertIsNotNone(Path.Log.info("something"))
144
        self.assertIsNotNone(Path.Log.notice("something"))
145
        self.assertIsNotNone(Path.Log.warning("something"))
146
        self.assertIsNotNone(Path.Log.error("something"))
147

148
    def test50(self):
149
        """Verify no tracking by default."""
150
        self.assertIsNone(Path.Log.track("this", "and", "that"))
151

152
    def test51(self):
153
        """Verify enabling tracking for module results in tracking."""
154
        Path.Log.trackModule()
155
        # Don't want to rely on the line number matching - still want some
156
        # indication that track does the right thing ....
157
        msg = Path.Log.track("this", "and", "that")
158
        self.assertTrue(msg.startswith(self.MODULE))
159
        self.assertTrue(msg.endswith("test51(this, and, that)"))
160

161
    def test52(self):
162
        """Verify untracking stops tracking."""
163
        Path.Log.trackModule()
164
        self.assertIsNotNone(Path.Log.track("this", "and", "that"))
165
        Path.Log.untrackModule()
166
        self.assertIsNone(Path.Log.track("this", "and", "that"))
167

168
    def test53(self):
169
        """Verify trackAllModules works correctly."""
170
        Path.Log.trackAllModules(True)
171
        self.assertIsNotNone(Path.Log.track("this", "and", "that"))
172
        Path.Log.trackAllModules(False)
173
        self.assertIsNone(Path.Log.track("this", "and", "that"))
174
        Path.Log.trackAllModules(True)
175
        Path.Log.trackModule()
176
        self.assertIsNotNone(Path.Log.track("this", "and", "that"))
177
        Path.Log.trackAllModules(False)
178
        self.assertIsNotNone(Path.Log.track("this", "and", "that"))
179

180
    def test60(self):
181
        """Verify track handles no argument."""
182
        Path.Log.trackModule()
183
        msg = Path.Log.track()
184
        self.assertTrue(msg.startswith(self.MODULE))
185
        self.assertTrue(msg.endswith("test60()"))
186

187
    def test61(self):
188
        """Verify track handles arbitrary argument types correctly."""
189
        Path.Log.trackModule()
190
        msg = Path.Log.track("this", None, 1, 18.25)
191
        self.assertTrue(msg.startswith(self.MODULE))
192
        self.assertTrue(msg.endswith("test61(this, None, 1, 18.25)"))
193

194
    def testzz(self):
195
        """Restoring environment after tests."""
196
        Path.Log.setLevel(Path.Log.Level.RESET)
197