More Testing

km3buu/__version__.py

@@ -17,6 +17,6 @@ version = "unknown version"
 
 try:
     version = get_version(root="..", relative_to=__file__)
-except LookupError:
+except LookupError:  # pragma: no cover
     with open(join(realpath(dirname(__file__)), "version.txt"), "r") as fobj:
         version = fobj.read()

km3buu/geometry.py

@@ -35,7 +35,7 @@ class DetectorVolume(ABC):
         self._solid_angle = 1
 
     @abstractmethod
-    def random_dir(self, n=1):
+    def random_dir(self, n=1):  # pragma: no cover
         """
         Generate a random direction for the interaction
 
@@ -51,7 +51,7 @@ class DetectorVolume(ABC):
         pass
 
     @abstractmethod
-    def random_pos(self, n=1):
+    def random_pos(self, n=1):  # pragma: no cover
         """
         Generate a random position in the detector volume based on a uniform
         event distribution
@@ -87,7 +87,7 @@ class DetectorVolume(ABC):
         return self.random_pos(), self.random_dir(), 1.0, None
 
     @abstractmethod
-    def header_entries(self):
+    def header_entries(self):  # pragma: no cover
         """
         Returns the header information for the detector volume geometry
 
@@ -283,13 +283,14 @@ class CANVolume(DetectorVolume):
     def header_entries(self, nevents=0):
         retdct = dict()
         key = "genvol"
-        value = "{} {} {} {} {}".format(self._zmin, self._zmax, self._radius,
-                                        self._volume, nevents)
+        value = "{:.3f} {:.3f} {:.3f} {:.3f} {:d}".format(
+            self._zmin, self._zmax, self._radius, self._volume, nevents)
         retdct[key] = value
         key = "fixedcan"
-        value = "{} {} {} {} {}".format(self._detector_center[0],
-                                        self._detector_center[1], self._zmin,
-                                        self._zmax, self._radius)
+        value = "{:.3f} {:.3f} {:.3f} {:.3f} {:.3f}".format(
+            self._detector_center[0], self._detector_center[1], self._zmin,
+            self._zmax, self._radius)
+        retdct[key] = value
         return retdct
 
     def distribute_event(self, evt):
@@ -419,14 +420,15 @@ class CylindricalVolume(DetectorVolume):
     def header_entries(self, nevents=0):
         retdct = dict()
         key = "genvol"
-        value = "{} {} {} {} {}".format(-self._rock_height, self._water_height,
-                                        self._radius, self._volume, nevents)
+        value = "{:.3f} {:.3f} {:.3f} {:.3f} {:d}".format(
+            -self._rock_height, self._water_height, self._radius, self._volume,
+            nevents)
         retdct[key] = value
         key = "fixedcan"
-        value = "{} {} {} {} {}".format(self._detector_center[0],
-                                        self._detector_center[1],
-                                        self._canzmin, self._canzmax,
-                                        self._canradius)
+        value = "{:.3f} {:.3f} {:.3f} {:.3f} {:.3f}".format(
+            self._detector_center[0], self._detector_center[1], self._canzmin,
+            self._canzmax, self._canradius)
+        retdct[key] = value
         return retdct
 
     def make_proposal_geometries(self):

km3buu/tests/test_ctrl.py

@@ -11,8 +11,10 @@ __email__ = "jschumann@km3net.de"
 __status__ = "Development"
 
 import csv
+import re
 import pytest
 import unittest
+from unittest import mock
 import numpy as np
 from km3buu.jobcard import *
 from km3buu.ctrl import run_jobcard
@@ -27,6 +29,28 @@ TESTDATA_DIR = data_path("gibuu")
 GIBUU_INSTALL_AVAILABLE = environ.get("CONTAINER_GIBUU_EXEC") is not None
 
 
+def subprocess_mock_function(*args, **kwargs):
+    assert re.match("abc < (.+)/tmp.job", args[0])
+    assert kwargs["shell"]
+    assert kwargs["cwd"] == "/tmp"
+    return mock.Mock()
+
+
+class TestRunJobcard(unittest.TestCase):
+
+    def setUp(self):
+        self.filename = join(TESTDATA_DIR, "km3net_testdata.job")
+        self.jobcard = read_jobcard(self.filename)
+        self.flux_file = NamedTemporaryFile(suffix='.dat')
+        self.jobcard["neutrino_induced"]["FileNameFlux"] = self.flux_file.name
+
+    @mock.patch.dict(environ, {"CONTAINER_GIBUU_EXEC": "abc"})
+    @mock.patch("subprocess.Popen", side_effect=subprocess_mock_function)
+    def test_inside_container(self, mock):
+        run_jobcard(self.jobcard, "/tmp")
+        assert mock.called
+
+
 @pytest.mark.skipif(not GIBUU_INSTALL_AVAILABLE, reason="GiBUU not installed")
 class TestCTRLbyJobcardFile(unittest.TestCase):
 

km3buu/tests/test_geometry.py

@@ -23,6 +23,25 @@ class TestGeneralGeometry(unittest.TestCase):
             d = DetectorVolume()
 
 
+class TestNoVolume(unittest.TestCase):
+
+    def setUp(self):
+        self.detector_geometry = NoVolume()
+
+    def test_volume(self):
+        volume = self.detector_geometry.volume
+        self.assertAlmostEqual(volume, 1.0)
+
+    def test_random_pos(self):
+        pos = self.detector_geometry.random_pos()
+        np.testing.assert_array_almost_equal(pos, 0.0)
+
+    def test_random_dir(self):
+        direction = self.detector_geometry.random_dir()
+        assert direction[0] == 0.0
+        assert direction[1] == 1.0
+
+
 class TestSphere(unittest.TestCase):
 
     def setUp(self):
@@ -67,6 +86,15 @@ class TestCan(unittest.TestCase):
         volume = self.detector_geometry.volume
         self.assertAlmostEqual(volume, 243604084.28, 2)
 
+    def test_in_can(self):
+        assert ~self.detector_geometry.in_can((300, 300, 100))
+        assert self.detector_geometry.in_can((100, 100, 100))
+
+    def test_header(self):
+        header = self.detector_geometry.header_entries(1234)
+        assert header["genvol"] == "0.000 476.500 403.400 243604084.277 1234"
+        assert header["fixedcan"] == "0.000 0.000 0.000 476.500 403.400"
+
     def test_position(self):
         np.random.seed(1234)
         pos = self.detector_geometry.random_pos()
@@ -94,3 +122,47 @@ class TestCan(unittest.TestCase):
         geometry = CANVolume(zenith=(-0.3, -0.2))
         direction = geometry.random_dir()
         self.assertAlmostEqual(direction[1], -0.2727407394717358)
+
+
+class TestCylindricalVolume(unittest.TestCase):
+
+    def setUp(self):
+        np.random.seed(1234)
+        self.detector_geometry = CylindricalVolume()
+
+    def test_volume(self):
+        volume = self.detector_geometry.volume
+        self.assertAlmostEqual(volume, 589048622.55, 2)
+
+    def test_in_can(self):
+        assert ~self.detector_geometry.in_can((300, 300, 100))
+        assert self.detector_geometry.in_can((100, 100, 100))
+
+    def test_header(self):
+        header = self.detector_geometry.header_entries(1234)
+        assert header[
+            "genvol"] == "-100.000 650.000 500.000 589048622.548 1234"
+        assert header["fixedcan"] == "0.000 0.000 0.000 350.000 200.400"
+
+    def test_single_position(self):
+        pos = self.detector_geometry.random_pos()
+        np.testing.assert_array_almost_equal(
+            pos, [-157.510418, -151.889206, 228.295804])
+
+    def test_multiple_positions(self):
+        pos = self.detector_geometry.random_pos(10)
+        np.testing.assert_array_almost_equal(
+            pos[0, :], [-137.152421, 170.496557, 173.664488])
+        np.testing.assert_array_almost_equal(
+            pos[9, :], [346.394334, -314.633317, 326.073989])
+
+    def test_single_direction(self):
+        direction = self.detector_geometry.random_dir()
+        np.testing.assert_array_almost_equal(direction, [1.203352, 0.244218])
+
+    def test_multiple_directions(self):
+        directions = self.detector_geometry.random_dir(10)
+        np.testing.assert_array_almost_equal(directions[0, :],
+                                             [1.203352, -0.284365])
+        np.testing.assert_array_almost_equal(directions[9, :],
+                                             [5.503647, 0.765282])