tasks-toolkit 0.1.3__py3-none-any.whl

scripts/test_sprint_auto_preflight.py

@@ -0,0 +1,143 @@
+"""Tests for scripts/sprint_auto_preflight.py.
+
+Run: PYTHONPATH=scripts python3 -m unittest test_sprint_auto_preflight
+"""
+from __future__ import annotations
+
+import json
+import os
+import subprocess
+import sys
+import tempfile
+import unittest
+from pathlib import Path
+
+sys.path.insert(0, str(Path(__file__).resolve().parent))
+import sprint_auto_preflight as sap
+
+
+class TestCollectPreflight(unittest.TestCase):
+
+    def setUp(self):
+        self.tmp = Path(tempfile.mkdtemp())
+        (self.tmp / "tasks").mkdir()
+        self.root = self.tmp
+
+    def tearDown(self):
+        import shutil
+        shutil.rmtree(self.tmp, ignore_errors=True)
+
+    def test_unreviewed_goal_returns_question(self):
+        result = sap.collect_preflight(self.root, {"goal": "test"}, {})
+        ids = [q["id"] for q in result["questions"]]
+        self.assertIn("goal_review", ids)
+
+    def test_missing_answers_exits_2_probe(self):
+        proc = subprocess.run(
+            [sys.executable, "-B", str(Path(__file__).resolve().parent / "sprint_auto_preflight.py"),
+             "preflight-probe", "--goal", "Inspect hashing behavior"],
+            capture_output=True, text=True, cwd=str(Path(__file__).resolve().parent.parent),
+        )
+        self.assertEqual(proc.returncode, 2)
+        data = json.loads(proc.stdout)
+        self.assertTrue(len(data["questions"]) > 0)
+        # no writes: stdout contains the full unresolved batch
+        self.assertIn("goal_review", [q["id"] for q in data["questions"]])
+
+    def test_forbidden_env_spec_lint_off(self):
+        os.environ["SPEC_LINT"] = "off"
+        try:
+            result = sap.collect_preflight(self.root, {"goal": "g"}, {})
+            self.assertTrue(any("SPEC_LINT" in b for b in result["blockers"]))
+        finally:
+            del os.environ["SPEC_LINT"]
+
+    def test_forbidden_env_accept_checks(self):
+        os.environ["ACCEPT_CHECKS_CMD"] = "exit 0"
+        try:
+            result = sap.collect_preflight(self.root, {"goal": "g"}, {})
+            self.assertTrue(any("ACCEPT_CHECKS_CMD" in b for b in result["blockers"]))
+        finally:
+            del os.environ["ACCEPT_CHECKS_CMD"]
+
+    def test_forbidden_env_verify_cmds(self):
+        for var in ("JUNIE_VERIFY_CMD", "KILO_VERIFY_CMD", "CODEX_VERIFY_CMD"):
+            os.environ[var] = "true"
+            try:
+                result = sap.collect_preflight(self.root, {"goal": "g"}, {})
+                self.assertTrue(any(var in b for b in result["blockers"]), var)
+            finally:
+                del os.environ[var]
+
+    def test_allowed_scopes_empty_returns_question(self):
+        result = sap.collect_preflight(self.root, {"goal": "g"}, {"goal_reviewed": True})
+        ids = [q["id"] for q in result["questions"]]
+        self.assertIn("allowed_scopes", ids)
+
+    def test_invalid_scope_blocker(self):
+        result = sap.collect_preflight(self.root, {"goal": "g"}, {
+            "goal_reviewed": True,
+            "allowed_scopes": ["../escape", "/abs"],
+        })
+        self.assertTrue(any("invalid scope" in b for b in result["blockers"]))
+
+    def test_delegated_default(self):
+        answers = {
+            "goal_reviewed": True,
+            "allowed_scopes": ["src/"],
+            "decisions": [{"id": "runner", "delegated": True, "safe_default": "junie", "rationale": "default"}],
+        }
+        result = sap.collect_preflight(self.root, {"goal": "g"}, answers)
+        self.assertTrue(any(d["id"] == "runner" for d in result["delegated_defaults"]))
+
+    def test_missing_policy_returns_questions(self):
+        result = sap.collect_preflight(self.root, {"goal": "g"}, {
+            "goal_reviewed": True,
+            "allowed_scopes": ["src/"],
+        })
+        ids = [q["id"] for q in result["questions"]]
+        self.assertIn("runner", ids)
+
+    def test_approval_scope_structure(self):
+        result = sap.collect_preflight(self.root, {"goal": "my goal"}, {
+            "goal_reviewed": True,
+            "allowed_scopes": ["src/"],
+            "policy": {"runner": "junie", "serial": True, "push": False},
+        })
+        scope = result["approval_scope"]
+        self.assertEqual(scope["goal"], "my goal")
+        self.assertTrue(scope["goal_reviewed"])
+        self.assertEqual(scope["allowed_scopes"], ["src/"])
+
+    def test_no_writes_to_root(self):
+        before = set(self.root.rglob("*"))
+        sap.collect_preflight(self.root, {"goal": "g"}, {})
+        after = set(self.root.rglob("*"))
+        self.assertEqual(before, after)
+
+    def test_git_staged_generated_blocker(self):
+        # create a git repo with staged generated file
+        subprocess.run(["git", "init", "-q", "-b", "main"], cwd=self.root, check=True)
+        subprocess.run(["git", "config", "user.email", "t@t.com"], cwd=self.root, check=True)
+        subprocess.run(["git", "config", "user.name", "t"], cwd=self.root, check=True)
+        (self.root / "tasks").mkdir(exist_ok=True)
+        (self.root / "tasks" / "tasks.snapshot.json").write_text("{}")
+        subprocess.run(["git", "add", "tasks/tasks.snapshot.json"], cwd=self.root, check=True)
+        result = sap.collect_preflight(self.root, {"goal": "g"}, {})
+        self.assertTrue(any("staged generated" in b for b in result["blockers"]))
+
+    def test_sqlite_ro_mode(self):
+        db = self.root / "tasks" / "tasks.db"
+        db.parent.mkdir(exist_ok=True)
+        import sqlite3
+        conn = sqlite3.connect(str(db))
+        conn.execute("CREATE TABLE nodes (id TEXT)")
+        conn.commit()
+        conn.close()
+        # should not raise
+        result = sap.collect_preflight(self.root, {"goal": "g"}, {})
+        self.assertIsInstance(result, dict)
+
+
+if __name__ == "__main__":
+    unittest.main()

scripts/test_sprint_auto_prepare.py

@@ -0,0 +1,150 @@
+"""Tests for scripts/sprint_auto_prepare.py.
+
+Run: PYTHONPATH=scripts python3 -m unittest test_sprint_auto_prepare
+"""
+from __future__ import annotations
+
+import json
+import os
+import subprocess
+import sys
+import tempfile
+import unittest
+from pathlib import Path
+
+sys.path.insert(0, str(Path(__file__).resolve().parent))
+import sprint_auto_prepare as sap
+import tasks
+import tasks_storage
+import tasks_plan_import as tpi
+
+
+class PrepareTests(unittest.TestCase):
+
+    def setUp(self):
+        self.tmp = Path(tempfile.mkdtemp())
+        os.environ["VIBE_TASKS_ROOT"] = str(self.tmp)
+        subprocess.run(
+            [sys.executable, str(Path(__file__).resolve().parent / "tasks_init.py"),
+             "--path", str(self.tmp / "tasks" / "tasks.db"), "--project", "T"],
+            check=True, capture_output=True,
+        )
+        # init git repo
+        subprocess.run(["git", "init", "-q", "-b", "main"], cwd=self.tmp, check=True)
+        subprocess.run(["git", "config", "user.email", "t@t.com"], cwd=self.tmp, check=True)
+        subprocess.run(["git", "config", "user.name", "t"], cwd=self.tmp, check=True)
+        (self.tmp / "README.md").write_text("init")
+        (self.tmp / ".gitignore").write_text("tmp/\ntasks/*.db\ntasks/.lock\ntasks/removed/\n")
+        # copy worktree.sh for branch creation
+        scripts_dir = self.tmp / "scripts"
+        scripts_dir.mkdir(parents=True, exist_ok=True)
+        import shutil
+        shutil.copy(str(Path(__file__).resolve().parent.parent / "scripts" / "worktree.sh"), str(scripts_dir / "worktree.sh"))
+        shutil.copy(str(Path(__file__).resolve().parent.parent / "scripts" / "needs-dotnet-checks.sh"), str(scripts_dir / "needs-dotnet-checks.sh"))
+        subprocess.run(["git", "add", "-A"], cwd=self.tmp, check=True)
+        subprocess.run(["git", "commit", "-q", "-m", "init"], cwd=self.tmp, check=True)
+        self.root = self.tmp
+        self.answers = {
+            "goal_reviewed": True,
+            "allowed_scopes": ["scripts/"],
+            "policy": {"runner": "codex", "serial": True, "push": False,
+                       "fallback": "none", "retries": 0, "accept_flags": False,
+                       "reset": False, "clean": False},
+        }
+        self.plan = {
+            "sprint": {"slug": "test-prep", "title": "Test prep sprint", "goal": "Test"},
+            "tasks": [
+                {"key": "a", "title": "Add a", "description": "first",
+                 "depends_on": [], "scope": ["scripts/a.sh"],
+                 "spec_name": "test-a",
+                 "spec": "# Task: a\n\n## Goal\nDo a.\n\n## Files\n- EDIT: scripts/a.sh\n\n## Tests\nscripts/test_a.sh\n\n## Acceptance\n`bash scripts/test_a.sh`\n\n## Live check\n`bash scripts/a.sh`\n"},
+            ],
+        }
+        self.plan_path = self.tmp / "tmp" / "plan.json"
+        self.plan_path.parent.mkdir(parents=True, exist_ok=True)
+        self.plan_path.write_text(json.dumps(self.plan))
+
+    def tearDown(self):
+        import shutil
+        if "VIBE_TASKS_ROOT" in os.environ:
+            del os.environ["VIBE_TASKS_ROOT"]
+        shutil.rmtree(self.tmp, ignore_errors=True)
+
+    def _run_prepare(self, run_name="run-1", plan_path=None, goal="Test goal"):
+        pp = plan_path or self.plan_path
+        ans_path = self.tmp / "tmp" / "answers.json"
+        ans_path.parent.mkdir(parents=True, exist_ok=True)
+        ans_path.write_text(json.dumps(self.answers))
+        return subprocess.run(
+            [sys.executable, str(Path(__file__).resolve().parent / "sprint_auto_prepare.py"),
+             "--root", str(self.tmp), "--run-name", run_name, "--goal", goal,
+             "--answers", str(ans_path), "--plan", str(pp)],
+            capture_output=True, text=True,
+            cwd=str(Path(__file__).resolve().parent.parent),
+        )
+
+    def test_valid_prepare(self):
+        proc = self._run_prepare()
+        self.assertEqual(proc.returncode, 0, proc.stderr)
+        result = json.loads(proc.stdout)
+        self.assertEqual(result["status"], "prepared")
+        self.assertIn("import_receipt", result)
+        self.assertFalse(result["import_receipt"]["replay"])
+
+    def test_resume_after_import_before_branch(self):
+        # First prepare creates sprint + branch
+        proc = self._run_prepare()
+        self.assertEqual(proc.returncode, 0, proc.stderr)
+        result1 = json.loads(proc.stdout)
+        sprint_id = result1["import_receipt"]["sprint_id"]
+        # Verify tracker has the sprint
+        tasks.DATA_FILE = self.tmp / "tasks" / "tasks.db"
+        tasks_storage.DATA_FILE = tasks.DATA_FILE
+        conn = tasks.connect()
+        node = conn.execute("SELECT id, title FROM nodes WHERE id=?", (sprint_id,)).fetchone()
+        self.assertIsNotNone(node)
+        conn.close()
+
+    def test_invalid_plan_missing_title(self):
+        bad_plan = json.loads(self.plan_path.read_text())
+        bad_plan["sprint"]["title"] = ""
+        bad_path = self.tmp / "tmp" / "bad_plan.json"
+        bad_path.parent.mkdir(parents=True, exist_ok=True)
+        bad_path.write_text(json.dumps(bad_plan))
+        proc = self._run_prepare(plan_path=bad_path)
+        self.assertNotEqual(proc.returncode, 0)
+        result = json.loads(proc.stdout)
+        self.assertEqual(result["status"], "invalid_plan")
+
+    def test_scope_violation(self):
+        bad_plan = json.loads(self.plan_path.read_text())
+        bad_plan["tasks"][0]["scope"] = ["/etc/passwd"]
+        bad_path = self.tmp / "tmp" / "bad_scope.json"
+        bad_path.parent.mkdir(parents=True, exist_ok=True)
+        bad_path.write_text(json.dumps(bad_plan))
+        proc = self._run_prepare(plan_path=bad_path)
+        # scope violation should be caught (path validation in preflight or scope check)
+        # The scope /etc/passwd starts with / which is invalid
+        self.assertNotEqual(proc.returncode, 0)
+
+    def test_missing_answers(self):
+        self.answers = {}  # no goal_reviewed
+        proc = self._run_prepare()
+        self.assertNotEqual(proc.returncode, 0)
+        result = json.loads(proc.stdout)
+        self.assertIn("needs_answers", result["status"])
+
+    def test_no_plan(self):
+        proc = subprocess.run(
+            [sys.executable, str(Path(__file__).resolve().parent / "sprint_auto_prepare.py"),
+             "--root", str(self.tmp), "--run-name", "run-x", "--goal", "g",
+             "--answers", str(self.tmp / "answers.json")],
+            capture_output=True, text=True,
+            cwd=str(Path(__file__).resolve().parent.parent),
+        )
+        # no --plan and no existing plan file → needs_plan
+        self.assertNotEqual(proc.returncode, 0)
+
+
+if __name__ == "__main__":
+    unittest.main()

scripts/test_sprint_auto_resume.py

@@ -0,0 +1,104 @@
+"""Tests for scripts/sprint_auto_resume.py.
+
+Run: PYTHONPATH=scripts python3 -m unittest test_sprint_auto_resume
+"""
+from __future__ import annotations
+
+import json
+import os
+import subprocess
+import sys
+import tempfile
+import unittest
+from pathlib import Path
+
+sys.path.insert(0, str(Path(__file__).resolve().parent))
+import sprint_auto_resume as sar
+import sprint_auto_state as sas
+
+
+class ResumeTests(unittest.TestCase):
+
+    def setUp(self):
+        self.tmp = Path(tempfile.mkdtemp())
+
+    def tearDown(self):
+        import shutil
+        shutil.rmtree(self.tmp, ignore_errors=True)
+
+    def test_reconcile_no_checkpoint(self):
+        result = sar.reconcile_checkpoint(self.tmp, "nonexistent")
+        self.assertEqual(result["status"], "no_checkpoint")
+
+    def test_reconcile_basic(self):
+        state = sas.RunState(run_name="r1", operation_intent="execute_task:a")
+        sas.write_checkpoint(self.tmp / "state.json", state)
+        # Need state at the right path
+        sp = sas.state_path(self.tmp, "r1")
+        sp.parent.mkdir(parents=True, exist_ok=True)
+        sas.write_checkpoint(sp, state)
+        result = sar.reconcile_checkpoint(self.tmp, "r1")
+        self.assertEqual(result["status"], "reconciled")
+        self.assertIn("resume task execution", result["actions"][0] if result["actions"] else "")
+
+    def test_reconcile_child_running(self):
+        import time
+        proc = subprocess.Popen(["sleep", "30"], start_new_session=True)
+        state = sas.RunState(run_name="r2", child_pid=proc.pid)
+        sp = sas.state_path(self.tmp, "r2")
+        sp.parent.mkdir(parents=True, exist_ok=True)
+        sas.write_checkpoint(sp, state)
+        result = sar.reconcile_checkpoint(self.tmp, "r2")
+        self.assertEqual(result["status"], "child_running")
+        self.assertTrue(result["child_alive"])
+        proc.kill()
+        proc.wait()
+
+    def test_finish_guard_ok(self):
+        ok, reason = sar.finish_guard(self.tmp, "r1", "", "")
+        self.assertTrue(ok)
+
+    def test_recognize_existing_merge_no_branch(self):
+        # No git repo → False
+        self.assertFalse(sar.recognize_existing_merge(self.tmp, "nonexistent"))
+
+    def test_recognize_existing_merge_with_git(self):
+        subprocess.run(["git", "init", "-q", "-b", "main"], cwd=self.tmp, check=True)
+        subprocess.run(["git", "config", "user.email", "t@t.com"], cwd=self.tmp, check=True)
+        subprocess.run(["git", "config", "user.name", "t"], cwd=self.tmp, check=True)
+        (self.tmp / "f.txt").write_text("x")
+        subprocess.run(["git", "add", "-A"], cwd=self.tmp, check=True)
+        subprocess.run(["git", "commit", "-q", "-m", "init"], cwd=self.tmp, check=True)
+        # Create and merge a branch
+        subprocess.run(["git", "checkout", "-q", "-b", "sprint/1-test"], cwd=self.tmp, check=True)
+        (self.tmp / "s.txt").write_text("sprint")
+        subprocess.run(["git", "add", "-A"], cwd=self.tmp, check=True)
+        subprocess.run(["git", "commit", "-q", "-m", "sprint work"], cwd=self.tmp, check=True)
+        subprocess.run(["git", "checkout", "-q", "main"], cwd=self.tmp, check=True)
+        subprocess.run(["git", "merge", "--no-ff", "sprint/1-test", "-m", "merge"], cwd=self.tmp, check=True)
+        self.assertTrue(sar.recognize_existing_merge(self.tmp, "sprint/1-test"))
+
+    def test_reconcile_merge_exists(self):
+        subprocess.run(["git", "init", "-q", "-b", "main"], cwd=self.tmp, check=True)
+        subprocess.run(["git", "config", "user.email", "t@t.com"], cwd=self.tmp, check=True)
+        subprocess.run(["git", "config", "user.name", "t"], cwd=self.tmp, check=True)
+        (self.tmp / "f.txt").write_text("x")
+        subprocess.run(["git", "add", "-A"], cwd=self.tmp, check=True)
+        subprocess.run(["git", "commit", "-q", "-m", "init"], cwd=self.tmp, check=True)
+        subprocess.run(["git", "checkout", "-q", "-b", "sprint/1-test"], cwd=self.tmp, check=True)
+        (self.tmp / "s.txt").write_text("sprint")
+        subprocess.run(["git", "add", "-A"], cwd=self.tmp, check=True)
+        subprocess.run(["git", "commit", "-q", "-m", "sprint work"], cwd=self.tmp, check=True)
+        subprocess.run(["git", "checkout", "-q", "main"], cwd=self.tmp, check=True)
+        subprocess.run(["git", "merge", "--no-ff", "sprint/1-test", "-m", "merge"], cwd=self.tmp, check=True)
+        state = sas.RunState(run_name="r3", operation_intent="finish", expected_refs={"sprint_branch": "sprint/1-test"})
+        sp = sas.state_path(self.tmp, "r3")
+        sp.parent.mkdir(parents=True, exist_ok=True)
+        sas.write_checkpoint(sp, state)
+        result = sar.reconcile_checkpoint(self.tmp, "r3")
+        self.assertTrue(result["merge_exists"])
+        self.assertIn("post-merge verification", " ".join(result["actions"]))
+
+
+if __name__ == "__main__":
+    unittest.main()

scripts/test_sprint_auto_state.py

@@ -0,0 +1,157 @@
+"""Tests for scripts/sprint_auto_state.py.
+
+Run: PYTHONPATH=scripts python3 -m unittest test_sprint_auto_state
+"""
+from __future__ import annotations
+
+import json
+import os
+import signal
+import subprocess
+import sys
+import tempfile
+import time
+import unittest
+from pathlib import Path
+
+sys.path.insert(0, str(Path(__file__).resolve().parent))
+import sprint_auto_state as sas
+
+
+class StateTests(unittest.TestCase):
+
+    def setUp(self):
+        self.tmp = Path(tempfile.mkdtemp())
+
+    def tearDown(self):
+        import shutil
+        shutil.rmtree(self.tmp, ignore_errors=True)
+
+    def test_write_read_roundtrip(self):
+        st = sas.RunState(run_name="r1", goal="g")
+        p = self.tmp / "state.json"
+        sas.write_checkpoint(p, st)
+        loaded = sas.read_checkpoint(p)
+        self.assertIsNotNone(loaded)
+        self.assertEqual(loaded.run_name, "r1")
+        self.assertEqual(loaded.goal, "g")
+
+    def test_atomic_replacement(self):
+        p = self.tmp / "state.json"
+        sas.write_checkpoint(p, sas.RunState(run_name="v1"))
+        # interrupt mid-write by writing partial then replacing
+        sas.write_checkpoint(p, sas.RunState(run_name="v2"))
+        loaded = sas.read_checkpoint(p)
+        self.assertEqual(loaded.run_name, "v2")
+
+    def test_truncated_state_returns_none(self):
+        p = self.tmp / "state.json"
+        p.write_text("{truncated")
+        self.assertIsNone(sas.read_checkpoint(p))
+
+    def test_unknown_version_returns_none(self):
+        p = self.tmp / "state.json"
+        p.write_text(json.dumps({"version": 999, "run_name": "x"}))
+        self.assertIsNone(sas.read_checkpoint(p))
+
+    def test_symlink_state_refused(self):
+        target = self.tmp / "real.json"
+        target.write_text("{}")
+        link = self.tmp / "link.json"
+        link.symlink_to(target)
+        with self.assertRaises(ValueError):
+            sas.write_checkpoint(link, sas.RunState())
+
+    def test_symlink_lock_refused(self):
+        target = self.tmp / "real.lock"
+        target.write_text("")
+        link = self.tmp / "link.lock"
+        link.symlink_to(target)
+        with self.assertRaises(ValueError):
+            with sas.StateLock(link):
+                pass
+
+    def test_exclusive_lock(self):
+        lock = self.tmp / "test.lock"
+        with sas.StateLock(lock):
+            # second acquire should block; use non-blocking
+            fh = open(lock, "w")
+            try:
+                fcntl_import = __import__("fcntl")
+                with self.assertRaises((BlockingIOError, OSError)):
+                    fcntl_import.flock(fh, fcntl_import.LOCK_EX | fcntl_import.LOCK_NB)
+            finally:
+                fh.close()
+
+    def test_child_alive_false_no_pid(self):
+        st = sas.RunState(child_pid=0)
+        self.assertFalse(sas.is_child_alive(st))
+
+    def test_child_alive_true(self):
+        proc = subprocess.Popen(["sleep", "10"])
+        st = sas.RunState(child_pid=proc.pid)
+        self.assertTrue(sas.is_child_alive(st))
+        proc.kill()
+        proc.wait()
+
+    def test_supervised_run_success(self):
+        code, out = sas.supervised_run(["echo", "hello"], self.tmp, 10)
+        self.assertEqual(code, 0)
+        self.assertIn("hello", out)
+
+    def test_supervised_run_timeout(self):
+        code, out = sas.supervised_run(["sleep", "60"], self.tmp, 1)
+        self.assertNotEqual(code, 0)
+
+    def test_import_no_write(self):
+        # importing module should not create files
+        before = set(self.tmp.rglob("*"))
+        # re-import
+        import importlib
+        importlib.reload(sas)
+        after = set(self.tmp.rglob("*"))
+        self.assertEqual(before, after)
+
+    def test_parent_interruption_preserves_exclusive_child_ownership(self):
+        # spawn a child that holds a lock and sleeps
+        lock = self.tmp / "child.lock"
+        script = self.tmp / "child.py"
+        script.write_text(
+            "import fcntl, time, sys\n"
+            "fh = open(sys.argv[1], 'w')\n"
+            "fcntl.flock(fh, fcntl.LOCK_EX)\n"
+            "time.sleep(30)\n"
+        )
+        proc = subprocess.Popen(
+            [sys.executable, str(script), str(lock)],
+            start_new_session=True,
+        )
+        time.sleep(0.5)
+        # child should be alive and holding lock
+        self.assertTrue(sas.is_child_alive(sas.RunState(child_pid=proc.pid)))
+        # try to acquire lock non-blocking -> should fail
+        fh = open(lock, "w")
+        import fcntl
+        try:
+            fcntl.flock(fh, fcntl.LOCK_EX | fcntl.LOCK_NB)
+            self.fail("lock not held by child")
+        except (BlockingIOError, OSError):
+            pass
+        finally:
+            fh.close()
+        proc.kill()
+        proc.wait()
+
+    def test_bind_state(self):
+        st = sas.bind_state(
+            self.tmp, self.tmp, "run1", "goal", "fp", ["src/"], "abc123",
+            "junie", "model", 120,
+        )
+        self.assertEqual(st.run_name, "run1")
+        self.assertEqual(st.initial_main_sha, "abc123")
+        self.assertEqual(st.allowed_scopes, ["src/"])
+        self.assertEqual(st.version, sas.STATE_VERSION)
+
+
+if __name__ == "__main__":
+    unittest.main()