mirror of
https://github.com/GothenburgBitFactory/timewarrior.git
synced 2025-06-26 10:54:28 +02:00
Python refactoring
- Optimize imports - Adjust coding style to PEP8 - Remove obsolete comments
This commit is contained in:
Thomas Lauf
parent
311c8c2c83
commit
dd42f844c6
28 changed files with 74 additions and 467 deletions
|
|
@ -26,30 +26,15 @@
|
|||
#
|
||||
###############################################################################
|
||||
|
||||
import sys
|
||||
import os
|
||||
import sys
|
||||
import unittest
|
||||
from datetime import datetime
|
||||
|
||||
# Ensure python finds the local simpletap module
|
||||
sys.path.append(os.path.dirname(os.path.abspath(__file__)))
|
||||
|
||||
from basetest import Timew, TestCase
|
||||
|
||||
# Test methods available:
|
||||
# self.assertEqual(a, b)
|
||||
# self.assertNotEqual(a, b)
|
||||
# self.assertTrue(x)
|
||||
# self.assertFalse(x)
|
||||
# self.assertIs(a, b)
|
||||
# self.assertIsNot(substring, text)
|
||||
# self.assertIsNone(x)
|
||||
# self.assertIsNotNone(x)
|
||||
# self.assertIn(substring, text)
|
||||
# self.assertNotIn(substring, text
|
||||
# self.assertRaises(e)
|
||||
# self.assertRegexpMatches(text, pattern)
|
||||
# self.assertNotRegexpMatches(text, pattern)
|
||||
# self.tap("")
|
||||
|
||||
class TestCancel(TestCase):
|
||||
def setUp(self):
|
||||
|
|
|
|||
21
test/chart.t
21
test/chart.t
|
|
@ -26,31 +26,15 @@
|
|||
#
|
||||
###############################################################################
|
||||
|
||||
import sys
|
||||
import os
|
||||
import sys
|
||||
import unittest
|
||||
from datetime import datetime
|
||||
|
||||
# Ensure python finds the local simpletap module
|
||||
sys.path.append(os.path.dirname(os.path.abspath(__file__)))
|
||||
|
||||
from basetest import Timew, TestCase
|
||||
|
||||
# Test methods available:
|
||||
# self.assertEqual(a, b)
|
||||
# self.assertNotEqual(a, b)
|
||||
# self.assertTrue(x)
|
||||
# self.assertFalse(x)
|
||||
# self.assertIs(a, b)
|
||||
# self.assertIsNot(substring, text)
|
||||
# self.assertIsNone(x)
|
||||
# self.assertIsNotNone(x)
|
||||
# self.assertIn(substring, text)
|
||||
# self.assertNotIn(substring, text
|
||||
# self.assertRaises(e)
|
||||
# self.assertRegexpMatches(text, pattern)
|
||||
# self.assertNotRegexpMatches(text, pattern)
|
||||
# self.tap("")
|
||||
|
||||
|
||||
class TestChart(TestCase):
|
||||
def setUp(self):
|
||||
|
|
@ -199,6 +183,7 @@ class TestChart(TestCase):
|
|||
|
||||
""", out)
|
||||
|
||||
|
||||
if __name__ == "__main__":
|
||||
from simpletap import TAPTestRunner
|
||||
unittest.main(testRunner=TAPTestRunner())
|
||||
|
|
|
|||
34
test/cli.t
34
test/cli.t
|
|
@ -26,32 +26,16 @@
|
|||
#
|
||||
###############################################################################
|
||||
|
||||
import sys
|
||||
import os
|
||||
import shutil
|
||||
import sys
|
||||
import unittest
|
||||
from datetime import datetime
|
||||
|
||||
# Ensure python finds the local simpletap module
|
||||
sys.path.append(os.path.dirname(os.path.abspath(__file__)))
|
||||
|
||||
from basetest import Timew, TestCase
|
||||
|
||||
# Test methods available:
|
||||
# self.assertEqual(a, b)
|
||||
# self.assertNotEqual(a, b)
|
||||
# self.assertTrue(x)
|
||||
# self.assertFalse(x)
|
||||
# self.assertIs(a, b)
|
||||
# self.assertIsNot(substring, text)
|
||||
# self.assertIsNone(x)
|
||||
# self.assertIsNotNone(x)
|
||||
# self.assertIn(substring, text)
|
||||
# self.assertNotIn(substring, text
|
||||
# self.assertRaises(e)
|
||||
# self.assertRegexpMatches(text, pattern)
|
||||
# self.assertNotRegexpMatches(text, pattern)
|
||||
# self.tap("")
|
||||
|
||||
|
||||
class TestCLI(TestCase):
|
||||
def setUp(self):
|
||||
|
|
@ -59,15 +43,15 @@ class TestCLI(TestCase):
|
|||
self.t = Timew()
|
||||
|
||||
def test_initial_call_of_timew(self):
|
||||
"""Verify that calling 'timew' the first time returns exit code 0"""
|
||||
self.t.reset_env()
|
||||
shutil.rmtree(self.t.env["TIMEWARRIORDB"])
|
||||
"""Verify that calling 'timew' the first time returns exit code 0"""
|
||||
self.t.reset_env()
|
||||
shutil.rmtree(self.t.env["TIMEWARRIORDB"])
|
||||
|
||||
code, out, err = self.t.runSuccess(":yes")
|
||||
self.assertIn("Welcome to Timewarrior.\n", out)
|
||||
code, out, err = self.t.runSuccess(":yes")
|
||||
self.assertIn("Welcome to Timewarrior.\n", out)
|
||||
|
||||
assert os.path.isdir(self.t.env["TIMEWARRIORDB"])
|
||||
assert os.path.exists(self.t.env["TIMEWARRIORDB"])
|
||||
assert os.path.isdir(self.t.env["TIMEWARRIORDB"])
|
||||
assert os.path.exists(self.t.env["TIMEWARRIORDB"])
|
||||
|
||||
def test_TimeWarrior_without_command_without_active_time_tracking(self):
|
||||
"""Call 'timew' without active time tracking"""
|
||||
|
|
|
|||
19
test/clock.t
19
test/clock.t
|
|
@ -26,30 +26,15 @@
|
|||
#
|
||||
###############################################################################
|
||||
|
||||
import sys
|
||||
import os
|
||||
import sys
|
||||
import unittest
|
||||
from datetime import datetime
|
||||
|
||||
# Ensure python finds the local simpletap module
|
||||
sys.path.append(os.path.dirname(os.path.abspath(__file__)))
|
||||
|
||||
from basetest import Timew, TestCase
|
||||
|
||||
# Test methods available:
|
||||
# self.assertEqual(a, b)
|
||||
# self.assertNotEqual(a, b)
|
||||
# self.assertTrue(x)
|
||||
# self.assertFalse(x)
|
||||
# self.assertIs(a, b)
|
||||
# self.assertIsNot(substring, text)
|
||||
# self.assertIsNone(x)
|
||||
# self.assertIsNotNone(x)
|
||||
# self.assertIn(substring, text)
|
||||
# self.assertNotIn(substring, text
|
||||
# self.assertRaises(e)
|
||||
# self.assertRegexpMatches(text, pattern)
|
||||
# self.assertNotRegexpMatches(text, pattern)
|
||||
# self.tap("")
|
||||
|
||||
class TestClock(TestCase):
|
||||
def setUp(self):
|
||||
|
|
|
|||
|
|
@ -26,8 +26,8 @@
|
|||
#
|
||||
###############################################################################
|
||||
|
||||
import sys
|
||||
import os
|
||||
import sys
|
||||
import unittest
|
||||
|
||||
# Ensure python finds the local simpletap module
|
||||
|
|
@ -35,21 +35,6 @@ sys.path.append(os.path.dirname(os.path.abspath(__file__)))
|
|||
|
||||
from basetest import Timew, TestCase
|
||||
|
||||
# Test methods available:
|
||||
# self.assertEqual(a, b)
|
||||
# self.assertNotEqual(a, b)
|
||||
# self.assertTrue(x)
|
||||
# self.assertFalse(x)
|
||||
# self.assertIs(a, b)
|
||||
# self.assertIsNot(substring, text)
|
||||
# self.assertIsNone(x)
|
||||
# self.assertIsNotNone(x)
|
||||
# self.assertIn(substring, text)
|
||||
# self.assertNotIn(substring, text
|
||||
# self.assertRaises(e)
|
||||
# self.assertRegexpMatches(text, pattern)
|
||||
# self.assertNotRegexpMatches(text, pattern)
|
||||
# self.tap("")
|
||||
|
||||
class TestConfig(TestCase):
|
||||
def setUp(self):
|
||||
|
|
@ -229,6 +214,7 @@ class TestConfig(TestCase):
|
|||
code, out, err = self.t("config number 5", input="yes\n")
|
||||
self.assertIn(" with a value of '5'?", out)
|
||||
|
||||
|
||||
if __name__ == "__main__":
|
||||
from simpletap import TAPTestRunner
|
||||
unittest.main(testRunner=TAPTestRunner())
|
||||
|
|
|
|||
|
|
@ -26,9 +26,10 @@
|
|||
#
|
||||
###############################################################################
|
||||
|
||||
import sys
|
||||
import os
|
||||
import sys
|
||||
import unittest
|
||||
|
||||
from datetime import datetime, timedelta
|
||||
|
||||
# Ensure python finds the local simpletap module
|
||||
|
|
@ -36,21 +37,6 @@ sys.path.append(os.path.dirname(os.path.abspath(__file__)))
|
|||
|
||||
from basetest import Timew, TestCase
|
||||
|
||||
# Test methods available:
|
||||
# self.assertEqual(a, b)
|
||||
# self.assertNotEqual(a, b)
|
||||
# self.assertTrue(x)
|
||||
# self.assertFalse(x)
|
||||
# self.assertIs(a, b)
|
||||
# self.assertIsNot(substring, text)
|
||||
# self.assertIsNone(x)
|
||||
# self.assertIsNotNone(x)
|
||||
# self.assertIn(substring, text)
|
||||
# self.assertNotIn(substring, text
|
||||
# self.assertRaises(e)
|
||||
# self.assertRegexpMatches(text, pattern)
|
||||
# self.assertNotRegexpMatches(text, pattern)
|
||||
# self.tap("")
|
||||
|
||||
class TestContinue(TestCase):
|
||||
def setUp(self):
|
||||
|
|
@ -232,6 +218,7 @@ class TestContinue(TestCase):
|
|||
self.assertTrue('tags' in j[2])
|
||||
self.assertEqual(j[2]['tags'], ['FOO'])
|
||||
|
||||
|
||||
if __name__ == "__main__":
|
||||
from simpletap import TAPTestRunner
|
||||
unittest.main(testRunner=TAPTestRunner())
|
||||
|
|
|
|||
|
|
@ -26,30 +26,15 @@
|
|||
#
|
||||
###############################################################################
|
||||
|
||||
import sys
|
||||
import os
|
||||
import sys
|
||||
import unittest
|
||||
from datetime import datetime
|
||||
|
||||
# Ensure python finds the local simpletap module
|
||||
sys.path.append(os.path.dirname(os.path.abspath(__file__)))
|
||||
|
||||
from basetest import Timew, TestCase
|
||||
|
||||
# Test methods available:
|
||||
# self.assertEqual(a, b)
|
||||
# self.assertNotEqual(a, b)
|
||||
# self.assertTrue(x)
|
||||
# self.assertFalse(x)
|
||||
# self.assertIs(a, b)
|
||||
# self.assertIsNot(substring, text)
|
||||
# self.assertIsNone(x)
|
||||
# self.assertIsNotNone(x)
|
||||
# self.assertIn(substring, text)
|
||||
# self.assertNotIn(substring, text
|
||||
# self.assertRaises(e)
|
||||
# self.assertRegexpMatches(text, pattern)
|
||||
# self.assertNotRegexpMatches(text, pattern)
|
||||
# self.tap("")
|
||||
|
||||
class TestDelete(TestCase):
|
||||
def setUp(self):
|
||||
|
|
@ -96,7 +81,6 @@ class TestDelete(TestCase):
|
|||
j = self.t.export()
|
||||
self.assertEqual(len(j), 0)
|
||||
|
||||
# TI-58
|
||||
def test_delete_open_interval_straddling_lunch(self):
|
||||
"""Delete a single open interval that straddles lunch, verify that is is gone"""
|
||||
self.t.config("exclusions.monday", "12:00-13:00")
|
||||
|
|
|
|||
22
test/dom.t
22
test/dom.t
|
|
@ -26,30 +26,15 @@
|
|||
#
|
||||
###############################################################################
|
||||
|
||||
import sys
|
||||
import os
|
||||
import sys
|
||||
import unittest
|
||||
from datetime import datetime
|
||||
|
||||
# Ensure python finds the local simpletap module
|
||||
sys.path.append(os.path.dirname(os.path.abspath(__file__)))
|
||||
|
||||
from basetest import Timew, TestCase
|
||||
|
||||
# Test methods available:
|
||||
# self.assertEqual(a, b)
|
||||
# self.assertNotEqual(a, b)
|
||||
# self.assertTrue(x)
|
||||
# self.assertFalse(x)
|
||||
# self.assertIs(a, b)
|
||||
# self.assertIsNot(substring, text)
|
||||
# self.assertIsNone(x)
|
||||
# self.assertIsNotNone(x)
|
||||
# self.assertIn(substring, text)
|
||||
# self.assertNotIn(substring, text
|
||||
# self.assertRaises(e)
|
||||
# self.assertRegexpMatches(text, pattern)
|
||||
# self.assertNotRegexpMatches(text, pattern)
|
||||
# self.tap("")
|
||||
|
||||
class TestDOM(TestCase):
|
||||
def setUp(self):
|
||||
|
|
@ -166,6 +151,7 @@ class TestDOM(TestCase):
|
|||
code, out, err = self.t("get dom.tracked.count")
|
||||
self.assertEqual('0\n', out)
|
||||
|
||||
|
||||
class TestDOMTracked(TestCase):
|
||||
@classmethod
|
||||
def setUpClass(cls):
|
||||
|
|
@ -247,6 +233,7 @@ class TestDOMTracked(TestCase):
|
|||
code, out, err = self.t("get dom.tracked.1.json")
|
||||
self.assertRegexpMatches(out, r'{"start":"\d{8}T\d{6}Z"}')
|
||||
|
||||
|
||||
class TestDOMRC(TestCase):
|
||||
def setUp(self):
|
||||
"""Executed before each test in the class"""
|
||||
|
|
@ -260,6 +247,7 @@ class TestDOMRC(TestCase):
|
|||
"""Test dom.rc.debug"""
|
||||
code, out, err = self.t("get dom.rc.debug")
|
||||
|
||||
|
||||
if __name__ == "__main__":
|
||||
from simpletap import TAPTestRunner
|
||||
unittest.main(testRunner=TAPTestRunner())
|
||||
|
|
|
|||
|
|
@ -37,22 +37,6 @@ sys.path.append(os.path.dirname(os.path.abspath(__file__)))
|
|||
|
||||
from basetest import Timew, TestCase
|
||||
|
||||
# Test methods available:
|
||||
# self.assertEqual(a, b)
|
||||
# self.assertNotEqual(a, b)
|
||||
# self.assertTrue(x)
|
||||
# self.assertFalse(x)
|
||||
# self.assertIs(a, b)
|
||||
# self.assertIsNot(substring, text)
|
||||
# self.assertIsNone(x)
|
||||
# self.assertIsNotNone(x)
|
||||
# self.assertIn(substring, text)
|
||||
# self.assertNotIn(substring, text
|
||||
# self.assertRaises(e)
|
||||
# self.assertRegexpMatches(text, pattern)
|
||||
# self.assertNotRegexpMatches(text, pattern)
|
||||
# self.tap("")
|
||||
|
||||
|
||||
class TestExport(TestCase):
|
||||
def setUp(self):
|
||||
|
|
|
|||
|
|
@ -26,32 +26,15 @@
|
|||
#
|
||||
###############################################################################
|
||||
|
||||
import sys
|
||||
import os
|
||||
import sys
|
||||
import unittest
|
||||
from datetime import datetime
|
||||
from basetest.utils import DEFAULT_EXTENSION_PATH
|
||||
import shutil
|
||||
|
||||
# Ensure python finds the local simpletap module
|
||||
sys.path.append(os.path.dirname(os.path.abspath(__file__)))
|
||||
|
||||
from basetest import Timew, TestCase
|
||||
|
||||
# Test methods available:
|
||||
# self.assertEqual(a, b)
|
||||
# self.assertNotEqual(a, b)
|
||||
# self.assertTrue(x)
|
||||
# self.assertFalse(x)
|
||||
# self.assertIs(a, b)
|
||||
# self.assertIsNot(substring, text)
|
||||
# self.assertIsNone(x)
|
||||
# self.assertIsNotNone(x)
|
||||
# self.assertIn(substring, text)
|
||||
# self.assertNotIn(substring, text
|
||||
# self.assertRaises(e)
|
||||
# self.assertRegexpMatches(text, pattern)
|
||||
# self.assertNotRegexpMatches(text, pattern)
|
||||
# self.tap("")
|
||||
|
||||
class TestExtensions(TestCase):
|
||||
def setUp(self):
|
||||
|
|
@ -73,6 +56,7 @@ class TestExtensions(TestCase):
|
|||
code, out, err = self.t('report ext')
|
||||
self.assertIn('test works', out)
|
||||
|
||||
|
||||
if __name__ == "__main__":
|
||||
from simpletap import TAPTestRunner
|
||||
unittest.main(testRunner=TAPTestRunner())
|
||||
|
|
|
|||
21
test/fill.t
21
test/fill.t
|
|
@ -26,30 +26,15 @@
|
|||
#
|
||||
###############################################################################
|
||||
|
||||
import sys
|
||||
import os
|
||||
import sys
|
||||
import unittest
|
||||
from datetime import datetime
|
||||
|
||||
# Ensure python finds the local simpletap module
|
||||
sys.path.append(os.path.dirname(os.path.abspath(__file__)))
|
||||
|
||||
from basetest import Timew, TestCase
|
||||
|
||||
# Test methods available:
|
||||
# self.assertEqual(a, b)
|
||||
# self.assertNotEqual(a, b)
|
||||
# self.assertTrue(x)
|
||||
# self.assertFalse(x)
|
||||
# self.assertIs(a, b)
|
||||
# self.assertIsNot(substring, text)
|
||||
# self.assertIsNone(x)
|
||||
# self.assertIsNotNone(x)
|
||||
# self.assertIn(substring, text)
|
||||
# self.assertNotIn(substring, text
|
||||
# self.assertRaises(e)
|
||||
# self.assertRegexpMatches(text, pattern)
|
||||
# self.assertNotRegexpMatches(text, pattern)
|
||||
# self.tap("")
|
||||
|
||||
class TestFillHint(TestCase):
|
||||
def setUp(self):
|
||||
|
|
@ -112,6 +97,7 @@ class TestFillHint(TestCase):
|
|||
self.assertTrue('end' not in j[1])
|
||||
self.assertEqual(j[1]['tags'][0], 'two')
|
||||
|
||||
|
||||
class TestFillCommand(TestCase):
|
||||
def setUp(self):
|
||||
"""Executed before each test in the class"""
|
||||
|
|
@ -144,6 +130,7 @@ class TestFillCommand(TestCase):
|
|||
self.tap(out)
|
||||
self.tap(err)
|
||||
|
||||
|
||||
if __name__ == "__main__":
|
||||
from simpletap import TAPTestRunner
|
||||
unittest.main(testRunner=TAPTestRunner())
|
||||
|
|
|
|||
20
test/gaps.t
20
test/gaps.t
|
|
@ -26,30 +26,15 @@
|
|||
#
|
||||
###############################################################################
|
||||
|
||||
import sys
|
||||
import os
|
||||
import sys
|
||||
import unittest
|
||||
from datetime import datetime
|
||||
|
||||
# Ensure python finds the local simpletap module
|
||||
sys.path.append(os.path.dirname(os.path.abspath(__file__)))
|
||||
|
||||
from basetest import Timew, TestCase
|
||||
|
||||
# Test methods available:
|
||||
# self.assertEqual(a, b)
|
||||
# self.assertNotEqual(a, b)
|
||||
# self.assertTrue(x)
|
||||
# self.assertFalse(x)
|
||||
# self.assertIs(a, b)
|
||||
# self.assertIsNot(substring, text)
|
||||
# self.assertIsNone(x)
|
||||
# self.assertIsNotNone(x)
|
||||
# self.assertIn(substring, text)
|
||||
# self.assertNotIn(substring, text
|
||||
# self.assertRaises(e)
|
||||
# self.assertRegexpMatches(text, pattern)
|
||||
# self.assertNotRegexpMatches(text, pattern)
|
||||
# self.tap("")
|
||||
|
||||
class TestGaps(TestCase):
|
||||
def setUp(self):
|
||||
|
|
@ -82,6 +67,7 @@ class TestGaps(TestCase):
|
|||
code, out, err = self.t("gaps 2016-05-27 - 2016-05-28")
|
||||
self.assertRegexpMatches(out, r'\s{30}5:00:00')
|
||||
|
||||
|
||||
if __name__ == "__main__":
|
||||
from simpletap import TAPTestRunner
|
||||
unittest.main(testRunner=TAPTestRunner())
|
||||
|
|
|
|||
16
test/ids.t
16
test/ids.t
|
|
@ -35,22 +35,6 @@ sys.path.append(os.path.dirname(os.path.abspath(__file__)))
|
|||
|
||||
from basetest import Timew, TestCase
|
||||
|
||||
# Test methods available:
|
||||
# self.assertEqual(a, b)
|
||||
# self.assertNotEqual(a, b)
|
||||
# self.assertTrue(x)
|
||||
# self.assertFalse(x)
|
||||
# self.assertIs(a, b)
|
||||
# self.assertIsNot(substring, text)
|
||||
# self.assertIsNone(x)
|
||||
# self.assertIsNotNone(x)
|
||||
# self.assertIn(substring, text)
|
||||
# self.assertNotIn(substring, text
|
||||
# self.assertRaises(e)
|
||||
# self.assertRegexpMatches(text, pattern)
|
||||
# self.assertNotRegexpMatches(text, pattern)
|
||||
# self.tap("")
|
||||
|
||||
|
||||
class TestIds(TestCase):
|
||||
def setUp(self):
|
||||
|
|
|
|||
20
test/join.t
20
test/join.t
|
|
@ -26,30 +26,15 @@
|
|||
#
|
||||
###############################################################################
|
||||
|
||||
import sys
|
||||
import os
|
||||
import sys
|
||||
import unittest
|
||||
from datetime import datetime
|
||||
|
||||
# Ensure python finds the local simpletap module
|
||||
sys.path.append(os.path.dirname(os.path.abspath(__file__)))
|
||||
|
||||
from basetest import Timew, TestCase
|
||||
|
||||
# Test methods available:
|
||||
# self.assertEqual(a, b)
|
||||
# self.assertNotEqual(a, b)
|
||||
# self.assertTrue(x)
|
||||
# self.assertFalse(x)
|
||||
# self.assertIs(a, b)
|
||||
# self.assertIsNot(substring, text)
|
||||
# self.assertIsNone(x)
|
||||
# self.assertIsNotNone(x)
|
||||
# self.assertIn(substring, text)
|
||||
# self.assertNotIn(substring, text
|
||||
# self.assertRaises(e)
|
||||
# self.assertRegexpMatches(text, pattern)
|
||||
# self.assertNotRegexpMatches(text, pattern)
|
||||
# self.tap("")
|
||||
|
||||
class TestJoin(TestCase):
|
||||
def setUp(self):
|
||||
|
|
@ -72,6 +57,7 @@ class TestJoin(TestCase):
|
|||
|
||||
# TODO Add :adjust tests.
|
||||
|
||||
|
||||
if __name__ == "__main__":
|
||||
from simpletap import TAPTestRunner
|
||||
unittest.main(testRunner=TAPTestRunner())
|
||||
|
|
|
|||
|
|
@ -26,30 +26,17 @@
|
|||
#
|
||||
###############################################################################
|
||||
|
||||
import sys
|
||||
import os
|
||||
import sys
|
||||
import unittest
|
||||
|
||||
from datetime import datetime, timedelta
|
||||
|
||||
# Ensure python finds the local simpletap module
|
||||
sys.path.append(os.path.dirname(os.path.abspath(__file__)))
|
||||
|
||||
from basetest import Timew, TestCase
|
||||
|
||||
# Test methods available:
|
||||
# self.assertEqual(a, b)
|
||||
# self.assertNotEqual(a, b)
|
||||
# self.assertTrue(x)
|
||||
# self.assertFalse(x)
|
||||
# self.assertIs(a, b)
|
||||
# self.assertIsNot(substring, text)
|
||||
# self.assertIsNone(x)
|
||||
# self.assertIsNotNone(x)
|
||||
# self.assertIn(substring, text)
|
||||
# self.assertNotIn(substring, text
|
||||
# self.assertRaises(e)
|
||||
# self.assertRegexpMatches(text, pattern)
|
||||
# self.assertNotRegexpMatches(text, pattern)
|
||||
# self.tap("")
|
||||
|
||||
class TestLengthen(TestCase):
|
||||
def setUp(self):
|
||||
|
|
|
|||
21
test/move.t
21
test/move.t
|
|
@ -26,31 +26,17 @@
|
|||
#
|
||||
###############################################################################
|
||||
|
||||
import sys
|
||||
import os
|
||||
import sys
|
||||
import unittest
|
||||
|
||||
from datetime import datetime, timedelta
|
||||
|
||||
# Ensure python finds the local simpletap module
|
||||
sys.path.append(os.path.dirname(os.path.abspath(__file__)))
|
||||
|
||||
from basetest import Timew, TestCase
|
||||
|
||||
# Test methods available:
|
||||
# self.assertEqual(a, b)
|
||||
# self.assertNotEqual(a, b)
|
||||
# self.assertTrue(x)
|
||||
# self.assertFalse(x)
|
||||
# self.assertIs(a, b)
|
||||
# self.assertIsNot(substring, text)
|
||||
# self.assertIsNone(x)
|
||||
# self.assertIsNotNone(x)
|
||||
# self.assertIn(substring, text)
|
||||
# self.assertNotIn(substring, text
|
||||
# self.assertRaises(e)
|
||||
# self.assertRegexpMatches(text, pattern)
|
||||
# self.assertNotRegexpMatches(text, pattern)
|
||||
# self.tap("")
|
||||
|
||||
|
||||
class TestMove(TestCase):
|
||||
def setUp(self):
|
||||
|
|
@ -225,6 +211,7 @@ class TestMove(TestCase):
|
|||
|
||||
# TODO Add :adjust tests.
|
||||
|
||||
|
||||
if __name__ == "__main__":
|
||||
from simpletap import TAPTestRunner
|
||||
unittest.main(testRunner=TAPTestRunner())
|
||||
|
|
|
|||
19
test/quiet.t
19
test/quiet.t
|
|
@ -26,30 +26,15 @@
|
|||
#
|
||||
###############################################################################
|
||||
|
||||
import sys
|
||||
import os
|
||||
import sys
|
||||
import unittest
|
||||
from datetime import datetime
|
||||
|
||||
# Ensure python finds the local simpletap module
|
||||
sys.path.append(os.path.dirname(os.path.abspath(__file__)))
|
||||
|
||||
from basetest import Timew, TestCase
|
||||
|
||||
# Test methods available:
|
||||
# self.assertEqual(a, b)
|
||||
# self.assertNotEqual(a, b)
|
||||
# self.assertTrue(x)
|
||||
# self.assertFalse(x)
|
||||
# self.assertIs(a, b)
|
||||
# self.assertIsNot(substring, text)
|
||||
# self.assertIsNone(x)
|
||||
# self.assertIsNotNone(x)
|
||||
# self.assertIn(substring, text)
|
||||
# self.assertNotIn(substring, text
|
||||
# self.assertRaises(e)
|
||||
# self.assertRegexpMatches(text, pattern)
|
||||
# self.assertNotRegexpMatches(text, pattern)
|
||||
# self.tap("")
|
||||
|
||||
class TestQuietMode(TestCase):
|
||||
def setUp(self):
|
||||
|
|
|
|||
|
|
@ -26,30 +26,15 @@
|
|||
#
|
||||
###############################################################################
|
||||
|
||||
import sys
|
||||
import os
|
||||
import sys
|
||||
import unittest
|
||||
from datetime import datetime
|
||||
|
||||
# Ensure python finds the local simpletap module
|
||||
sys.path.append(os.path.dirname(os.path.abspath(__file__)))
|
||||
|
||||
from basetest import Timew, TestCase
|
||||
|
||||
# Test methods available:
|
||||
# self.assertEqual(a, b)
|
||||
# self.assertNotEqual(a, b)
|
||||
# self.assertTrue(x)
|
||||
# self.assertFalse(x)
|
||||
# self.assertIs(a, b)
|
||||
# self.assertIsNot(substring, text)
|
||||
# self.assertIsNone(x)
|
||||
# self.assertIsNotNone(x)
|
||||
# self.assertIn(substring, text)
|
||||
# self.assertNotIn(substring, text
|
||||
# self.assertRaises(e)
|
||||
# self.assertRegexpMatches(text, pattern)
|
||||
# self.assertNotRegexpMatches(text, pattern)
|
||||
# self.tap("")
|
||||
|
||||
class TestResize(TestCase):
|
||||
def setUp(self):
|
||||
|
|
@ -68,6 +53,7 @@ class TestResize(TestCase):
|
|||
code, out, err = self.t.runError("resize @1 10mins")
|
||||
self.assertIn('Cannot resize open interval @1', err)
|
||||
|
||||
|
||||
if __name__ == "__main__":
|
||||
from simpletap import TAPTestRunner
|
||||
unittest.main(testRunner=TAPTestRunner())
|
||||
|
|
|
|||
|
|
@ -26,30 +26,17 @@
|
|||
#
|
||||
###############################################################################
|
||||
|
||||
import sys
|
||||
import os
|
||||
import sys
|
||||
import unittest
|
||||
|
||||
from datetime import datetime, timedelta
|
||||
|
||||
# Ensure python finds the local simpletap module
|
||||
sys.path.append(os.path.dirname(os.path.abspath(__file__)))
|
||||
|
||||
from basetest import Timew, TestCase
|
||||
|
||||
# Test methods available:
|
||||
# self.assertEqual(a, b)
|
||||
# self.assertNotEqual(a, b)
|
||||
# self.assertTrue(x)
|
||||
# self.assertFalse(x)
|
||||
# self.assertIs(a, b)
|
||||
# self.assertIsNot(substring, text)
|
||||
# self.assertIsNone(x)
|
||||
# self.assertIsNotNone(x)
|
||||
# self.assertIn(substring, text)
|
||||
# self.assertNotIn(substring, text
|
||||
# self.assertRaises(e)
|
||||
# self.assertRegexpMatches(text, pattern)
|
||||
# self.assertNotRegexpMatches(text, pattern)
|
||||
# self.tap("")
|
||||
|
||||
class TestShorten(TestCase):
|
||||
def setUp(self):
|
||||
|
|
@ -140,6 +127,7 @@ class TestBug6(TestCase):
|
|||
code, out, err = self.t.runError("shorten @1 10mins")
|
||||
self.assertIn('Cannot shorten interval @1 by 0:10:00 because it is only 0:05:00 in length.', err)
|
||||
|
||||
|
||||
if __name__ == "__main__":
|
||||
from simpletap import TAPTestRunner
|
||||
unittest.main(testRunner=TAPTestRunner())
|
||||
|
|
|
|||
20
test/split.t
20
test/split.t
|
|
@ -26,30 +26,15 @@
|
|||
#
|
||||
###############################################################################
|
||||
|
||||
import sys
|
||||
import os
|
||||
import sys
|
||||
import unittest
|
||||
from datetime import datetime
|
||||
|
||||
# Ensure python finds the local simpletap module
|
||||
sys.path.append(os.path.dirname(os.path.abspath(__file__)))
|
||||
|
||||
from basetest import Timew, TestCase
|
||||
|
||||
# Test methods available:
|
||||
# self.assertEqual(a, b)
|
||||
# self.assertNotEqual(a, b)
|
||||
# self.assertTrue(x)
|
||||
# self.assertFalse(x)
|
||||
# self.assertIs(a, b)
|
||||
# self.assertIsNot(substring, text)
|
||||
# self.assertIsNone(x)
|
||||
# self.assertIsNotNone(x)
|
||||
# self.assertIn(substring, text)
|
||||
# self.assertNotIn(substring, text
|
||||
# self.assertRaises(e)
|
||||
# self.assertRegexpMatches(text, pattern)
|
||||
# self.assertNotRegexpMatches(text, pattern)
|
||||
# self.tap("")
|
||||
|
||||
class TestSplit(TestCase):
|
||||
def setUp(self):
|
||||
|
|
@ -98,6 +83,7 @@ class TestSplit(TestCase):
|
|||
|
||||
# TODO Add :adjust tests.
|
||||
|
||||
|
||||
if __name__ == "__main__":
|
||||
from simpletap import TAPTestRunner
|
||||
unittest.main(testRunner=TAPTestRunner())
|
||||
|
|
|
|||
17
test/start.t
17
test/start.t
|
|
@ -35,22 +35,6 @@ sys.path.append(os.path.dirname(os.path.abspath(__file__)))
|
|||
|
||||
from basetest import Timew, TestCase
|
||||
|
||||
# Test methods available:
|
||||
# self.assertEqual(a, b)
|
||||
# self.assertNotEqual(a, b)
|
||||
# self.assertTrue(x)
|
||||
# self.assertFalse(x)
|
||||
# self.assertIs(a, b)
|
||||
# self.assertIsNot(substring, text)
|
||||
# self.assertIsNone(x)
|
||||
# self.assertIsNotNone(x)
|
||||
# self.assertIn(substring, text)
|
||||
# self.assertNotIn(substring, text
|
||||
# self.assertRaises(e)
|
||||
# self.assertRegexpMatches(text, pattern)
|
||||
# self.assertNotRegexpMatches(text, pattern)
|
||||
# self.tap("")
|
||||
|
||||
|
||||
class TestStart(TestCase):
|
||||
def setUp(self):
|
||||
|
|
@ -114,7 +98,6 @@ class TestStart(TestCase):
|
|||
code, out, err = self.t("start foo bar")
|
||||
self.assertNotIn("Recorded bar foo", out)
|
||||
|
||||
|
||||
def test_single_interval_enclosing_exclusion(self):
|
||||
"""Add one interval that encloseѕ an exclusion, and is therefore flattened"""
|
||||
self.t.config("exclusions.monday", "<9:11:50 12:22:44-13:32:23 >18:05:11")
|
||||
|
|
|
|||
16
test/stop.t
16
test/stop.t
|
|
@ -35,22 +35,6 @@ sys.path.append(os.path.dirname(os.path.abspath(__file__)))
|
|||
|
||||
from basetest import Timew, TestCase
|
||||
|
||||
# Test methods available:
|
||||
# self.assertEqual(a, b)
|
||||
# self.assertNotEqual(a, b)
|
||||
# self.assertTrue(x)
|
||||
# self.assertFalse(x)
|
||||
# self.assertIs(a, b)
|
||||
# self.assertIsNot(substring, text)
|
||||
# self.assertIsNone(x)
|
||||
# self.assertIsNotNone(x)
|
||||
# self.assertIn(substring, text)
|
||||
# self.assertNotIn(substring, text
|
||||
# self.assertRaises(e)
|
||||
# self.assertRegexpMatches(text, pattern)
|
||||
# self.assertNotRegexpMatches(text, pattern)
|
||||
# self.tap("")
|
||||
|
||||
|
||||
class TestStop(TestCase):
|
||||
def setUp(self):
|
||||
|
|
|
|||
|
|
@ -30,30 +30,13 @@ import os
|
|||
import sys
|
||||
import unittest
|
||||
|
||||
from datetime import datetime, timedelta
|
||||
|
||||
# Ensure python finds the local simpletap module
|
||||
sys.path.append(os.path.dirname(os.path.abspath(__file__)))
|
||||
|
||||
from basetest import Timew, TestCase
|
||||
|
||||
from datetime import datetime, timedelta
|
||||
|
||||
|
||||
# Test methods available:
|
||||
# self.assertEqual(a, b)
|
||||
# self.assertNotEqual(a, b)
|
||||
# self.assertTrue(x)
|
||||
# self.assertFalse(x)
|
||||
# self.assertIs(a, b)
|
||||
# self.assertIsNot(substring, text)
|
||||
# self.assertIsNone(x)
|
||||
# self.assertIsNotNone(x)
|
||||
# self.assertIn(substring, text)
|
||||
# self.assertNotIn(substring, text
|
||||
# self.assertRaises(e)
|
||||
# self.assertRegexpMatches(text, pattern)
|
||||
# self.assertNotRegexpMatches(text, pattern)
|
||||
# self.tap("")
|
||||
|
||||
|
||||
class TestSummary(TestCase):
|
||||
def setUp(self):
|
||||
|
|
|
|||
20
test/tag.t
20
test/tag.t
|
|
@ -26,30 +26,17 @@
|
|||
#
|
||||
###############################################################################
|
||||
|
||||
import sys
|
||||
import os
|
||||
import sys
|
||||
import unittest
|
||||
|
||||
from datetime import datetime, timedelta
|
||||
|
||||
# Ensure python finds the local simpletap module
|
||||
sys.path.append(os.path.dirname(os.path.abspath(__file__)))
|
||||
|
||||
from basetest import Timew, TestCase
|
||||
|
||||
# Test methods available:
|
||||
# self.assertEqual(a, b)
|
||||
# self.assertNotEqual(a, b)
|
||||
# self.assertTrue(x)
|
||||
# self.assertFalse(x)
|
||||
# self.assertIs(a, b)
|
||||
# self.assertIsNot(substring, text)
|
||||
# self.assertIsNone(x)
|
||||
# self.assertIsNotNone(x)
|
||||
# self.assertIn(substring, text)
|
||||
# self.assertNotIn(substring, text
|
||||
# self.assertRaises(e)
|
||||
# self.assertRegexpMatches(text, pattern)
|
||||
# self.assertNotRegexpMatches(text, pattern)
|
||||
# self.tap("")
|
||||
|
||||
class TestTag(TestCase):
|
||||
def setUp(self):
|
||||
|
|
@ -136,7 +123,6 @@ class TestTag(TestCase):
|
|||
self.assertEqual(j[1]['tags'], ['foo'], 'tags of unmodified interval do not match')
|
||||
|
||||
|
||||
|
||||
class TestUntag(TestCase):
|
||||
def setUp(self):
|
||||
"""Executed before each test in the class"""
|
||||
|
|
|
|||
20
test/tags.t
20
test/tags.t
|
|
@ -26,30 +26,15 @@
|
|||
#
|
||||
###############################################################################
|
||||
|
||||
import sys
|
||||
import os
|
||||
import sys
|
||||
import unittest
|
||||
from datetime import datetime
|
||||
|
||||
# Ensure python finds the local simpletap module
|
||||
sys.path.append(os.path.dirname(os.path.abspath(__file__)))
|
||||
|
||||
from basetest import Timew, TestCase
|
||||
|
||||
# Test methods available:
|
||||
# self.assertEqual(a, b)
|
||||
# self.assertNotEqual(a, b)
|
||||
# self.assertTrue(x)
|
||||
# self.assertFalse(x)
|
||||
# self.assertIs(a, b)
|
||||
# self.assertIsNot(substring, text)
|
||||
# self.assertIsNone(x)
|
||||
# self.assertIsNotNone(x)
|
||||
# self.assertIn(substring, text)
|
||||
# self.assertNotIn(substring, text
|
||||
# self.assertRaises(e)
|
||||
# self.assertRegexpMatches(text, pattern)
|
||||
# self.assertNotRegexpMatches(text, pattern)
|
||||
# self.tap("")
|
||||
|
||||
class TestTags(TestCase):
|
||||
def setUp(self):
|
||||
|
|
@ -110,6 +95,7 @@ class TestTags(TestCase):
|
|||
# self.assertNotIn("Note: 'foo' is a new tag.", out)
|
||||
# self.assertNotIn("Note: 'bar' is a new tag.", out)
|
||||
|
||||
|
||||
if __name__ == "__main__":
|
||||
from simpletap import TAPTestRunner
|
||||
unittest.main(testRunner=TAPTestRunner())
|
||||
|
|
|
|||
|
|
@ -26,10 +26,12 @@
|
|||
#
|
||||
###############################################################################
|
||||
|
||||
import sys
|
||||
import os
|
||||
import sys
|
||||
import unittest
|
||||
|
||||
from datetime import datetime
|
||||
|
||||
# Ensure python finds the local simpletap module
|
||||
sys.path.append(os.path.dirname(os.path.abspath(__file__)))
|
||||
|
||||
|
|
@ -51,6 +53,7 @@ from basetest import Timew, TestCase
|
|||
# self.assertNotRegexpMatches(text, pattern)
|
||||
# self.tap("")
|
||||
|
||||
|
||||
class TestBugNumber(TestCase):
|
||||
@classmethod
|
||||
def setUpClass(cls):
|
||||
|
|
|
|||
16
test/track.t
16
test/track.t
|
|
@ -37,22 +37,6 @@ sys.path.append(os.path.dirname(os.path.abspath(__file__)))
|
|||
|
||||
from basetest import Timew, TestCase
|
||||
|
||||
# Test methods available:
|
||||
# self.assertEqual(a, b)
|
||||
# self.assertNotEqual(a, b)
|
||||
# self.assertTrue(x)
|
||||
# self.assertFalse(x)
|
||||
# self.assertIs(a, b)
|
||||
# self.assertIsNot(substring, text)
|
||||
# self.assertIsNone(x)
|
||||
# self.assertIsNotNone(x)
|
||||
# self.assertIn(substring, text)
|
||||
# self.assertNotIn(substring, text
|
||||
# self.assertRaises(e)
|
||||
# self.assertRegexpMatches(text, pattern)
|
||||
# self.assertNotRegexpMatches(text, pattern)
|
||||
# self.tap("")
|
||||
|
||||
|
||||
class TestTrack(TestCase):
|
||||
def setUp(self):
|
||||
|
|
|
|||
|
|
@ -26,31 +26,15 @@
|
|||
#
|
||||
###############################################################################
|
||||
|
||||
import sys
|
||||
import os
|
||||
import sys
|
||||
import unittest
|
||||
import re
|
||||
|
||||
# Ensure python finds the local simpletap module
|
||||
sys.path.append(os.path.dirname(os.path.abspath(__file__)))
|
||||
|
||||
from basetest import Timew, TestCase
|
||||
from basetest.utils import run_cmd_wait
|
||||
|
||||
# Test methods available:
|
||||
# self.assertEqual(a, b)
|
||||
# self.assertNotEqual(a, b)
|
||||
# self.assertTrue(x)
|
||||
# self.assertFalse(x)
|
||||
# self.assertIs(a, b)
|
||||
# self.assertIsNot(substring, text)
|
||||
# self.assertIsNone(x)
|
||||
# self.assertIsNotNone(x)
|
||||
# self.assertIn(substring, text)
|
||||
# self.assertNotIn(substring, text
|
||||
# self.assertRaises(e)
|
||||
# self.assertRegexpMatches(text, pattern)
|
||||
# self.assertNotRegexpMatches(text, pattern)
|
||||
# self.tap("")
|
||||
|
||||
class TestVersion(TestCase):
|
||||
def setUp(self):
|
||||
|
|
|
|||
Loading…
Add table
Add a link
Reference in a new issue