TestPBS.test_str() - Code Metrics - SMART-Lab/smartdispatch - Measure and Improve Code Quality continuously with Scrutinizer

TestPBS.test_str() A
last analyzed 2017-06-22 19:40 UTC

↳ Parent: TestPBS

Complexity

Conditions

Size

Total Lines

Duplication

Lines	0
Ratio	0 %

Importance

Changes

Metric	Value
cc	1
c	0
b	0
f	0
dl	0
loc	62
rs	9.4743

How to fix Long Method

from nose.tools import assert_true, assert_equal, assert_raises
from numpy.testing import assert_array_equal


from smartdispatch.pbs import PBS
import unittest
import tempfile
import shutil
import os


class TestPBS(unittest.TestCase):

    def setUp(self):
        self.testing_dir = tempfile.mkdtemp()
        self.queue_name = "qtest@cluster"
        self.walltime = "10:42"
        self.pbs = PBS(self.queue_name, self.walltime)

    def tearDown(self):
        shutil.rmtree(self.testing_dir)

    def test_constructor(self):
        assert_raises(ValueError, PBS, self.queue_name, None)
        assert_raises(ValueError, PBS, None, self.walltime)
        assert_raises(ValueError, PBS, "", self.walltime)
        assert_raises(ValueError, PBS, self.queue_name, "Wrong walltime format")

    def test_add_options(self):
        # Default options
        assert_equal(len(self.pbs.options), 2)
        assert_true('-V' in self.pbs.options.keys())
        assert_equal(self.pbs.options['-q'], self.queue_name)

        self.pbs.add_options(A="option1")
        assert_equal(self.pbs.options["-A"], "option1")
        self.pbs.add_options(A="option2", B="option3")
        assert_equal(self.pbs.options["-A"], "option2")
        assert_equal(self.pbs.options["-B"], "option3")

    def test_add_resources(self):
        assert_equal(len(self.pbs.resources), 1)
        assert_equal(self.pbs.resources["walltime"], self.walltime)

        self.pbs.add_resources(nodes="23:ppn=2")
        assert_equal(self.pbs.resources["nodes"], "23:ppn=2")

        self.pbs.add_resources(pmem=123, walltime="42:42")
        assert_equal(self.pbs.resources["pmem"], 123)
        assert_equal(self.pbs.resources["walltime"], "42:42")

    def test_add_modules_to_load(self):
        assert_equal(self.pbs.modules, [])

        modules = ["cuda", "gcc", "python/2.7"]
        self.pbs.add_modules_to_load(modules[0], modules[1])
        assert_array_equal(self.pbs.modules, modules[:2])

        self.pbs.add_modules_to_load(modules[-1])
        assert_array_equal(self.pbs.modules, modules)

    def test_add_commands(self):
        assert_equal(self.pbs.commands, [])

        commands = ["python my_script.py", "echo 1234", "git push origin master"]
        self.pbs.add_commands(commands[0])
        assert_array_equal(self.pbs.commands, commands[0])

        self.pbs.add_commands(*commands[1:])
        assert_array_equal(self.pbs.commands, commands)

    def test_str(self):
        # Create simple PBS file
        expected = """#!/bin/bash
#PBS -q qtest@mp2
#PBS -V
#PBS -l walltime=01:00:00

# Modules #

# Prolog #

# Commands #

# Epilog #"""
        pbs = PBS(queue_name="qtest@mp2", walltime="01:00:00")
        assert_equal(str(pbs), expected)

        # Create a more complex PBS file
        prolog = ['echo "This is prolog1"',
                  'echo "This is prolog2"']
        commands = ["cd $HOME; echo 1 2 3 1>> cmd1.o 2>> cmd1.e",
                    "cd $HOME; echo 3 2 1 1>> cmd1.o 2>> cmd1.e"]
        epilog = ['echo "This is epilog1"',
                  'echo "This is epilog2"']
        modules = ["CUDA_Toolkit/6.0", "python2.7"]

        expected = """\
#!/bin/bash
#PBS -q qtest@mp2
#PBS -V
#PBS -A xyz-123-ab
#PBS -l walltime=01:00:00
#PBS -l nodes=2:ppn=3:gpus=1

# Modules #
module load CUDA_Toolkit/6.0
module load python2.7

# Prolog #
{prolog1}
{prolog2}

# Commands #
{command1}
{command2}

# Epilog #
{epilog1}
{epilog2}""".format(
            prolog1=prolog[0], prolog2=prolog[1],
            command1=commands[0], command2=commands[1],
            epilog1=epilog[0], epilog2=epilog[1])

        pbs = PBS(queue_name="qtest@mp2", walltime="01:00:00")
        pbs.add_resources(nodes="2:ppn=3:gpus=1")
        pbs.add_options(A="xyz-123-ab")
        pbs.add_modules_to_load(*modules)
        pbs.add_to_prolog(*prolog)
        pbs.add_commands(*commands)
        pbs.add_to_epilog(*epilog)

        assert_equal(str(pbs), expected)

    def test_save(self):
        pbs_filename = os.path.join(self.testing_dir, "pbs.sh")
        self.pbs.save(pbs_filename)
        assert_equal(str(self.pbs), open(pbs_filename).read())


1			from nose.tools import assert_true, assert_equal, assert_raises
2			from numpy.testing import assert_array_equal
3
4
5			from smartdispatch.pbs import PBS
6			import unittest
7			import tempfile
8			import shutil
9			import os
10
11
12			class TestPBS(unittest.TestCase):
13
14			def setUp(self):
15			self.testing_dir = tempfile.mkdtemp()
16			self.queue_name = "qtest@cluster"
17			self.walltime = "10:42"
18			self.pbs = PBS(self.queue_name, self.walltime)
19
20			def tearDown(self):
21			shutil.rmtree(self.testing_dir)
22
23			def test_constructor(self):
24			assert_raises(ValueError, PBS, self.queue_name, None)
25			assert_raises(ValueError, PBS, None, self.walltime)
26			assert_raises(ValueError, PBS, "", self.walltime)
27			assert_raises(ValueError, PBS, self.queue_name, "Wrong walltime format")
28
29			def test_add_options(self):
30			# Default options
31			assert_equal(len(self.pbs.options), 2)
32			assert_true('-V' in self.pbs.options.keys())
33			assert_equal(self.pbs.options['-q'], self.queue_name)
34
35			self.pbs.add_options(A="option1")
36			assert_equal(self.pbs.options["-A"], "option1")
37			self.pbs.add_options(A="option2", B="option3")
38			assert_equal(self.pbs.options["-A"], "option2")
39			assert_equal(self.pbs.options["-B"], "option3")
40
41			def test_add_resources(self):
42			assert_equal(len(self.pbs.resources), 1)
43			assert_equal(self.pbs.resources["walltime"], self.walltime)
44
45			self.pbs.add_resources(nodes="23:ppn=2")
46			assert_equal(self.pbs.resources["nodes"], "23:ppn=2")
47
48			self.pbs.add_resources(pmem=123, walltime="42:42")
49			assert_equal(self.pbs.resources["pmem"], 123)
50			assert_equal(self.pbs.resources["walltime"], "42:42")
51
52			def test_add_modules_to_load(self):
53			assert_equal(self.pbs.modules, [])
54
55			modules = ["cuda", "gcc", "python/2.7"]
56			self.pbs.add_modules_to_load(modules[0], modules[1])
57			assert_array_equal(self.pbs.modules, modules[:2])
58
59			self.pbs.add_modules_to_load(modules[-1])
60			assert_array_equal(self.pbs.modules, modules)
61
62			def test_add_commands(self):
63			assert_equal(self.pbs.commands, [])
64
65			commands = ["python my_script.py", "echo 1234", "git push origin master"]
66			self.pbs.add_commands(commands[0])
67			assert_array_equal(self.pbs.commands, commands[0])
68
69			self.pbs.add_commands(*commands[1:])
70			assert_array_equal(self.pbs.commands, commands)
71
72			def test_str(self):
73			# Create simple PBS file
74			expected = """#!/bin/bash
75			#PBS -q qtest@mp2
76			#PBS -V
77			#PBS -l walltime=01:00:00
78
79			# Modules #
80
81			# Prolog #
82
83			# Commands #
84
85			# Epilog #"""
86			pbs = PBS(queue_name="qtest@mp2", walltime="01:00:00")
87			assert_equal(str(pbs), expected)
88
89			# Create a more complex PBS file
90			prolog = ['echo "This is prolog1"',
91			'echo "This is prolog2"']
92			commands = ["cd $HOME; echo 1 2 3 1>> cmd1.o 2>> cmd1.e",
93			"cd $HOME; echo 3 2 1 1>> cmd1.o 2>> cmd1.e"]
94			epilog = ['echo "This is epilog1"',
95			'echo "This is epilog2"']
96			modules = ["CUDA_Toolkit/6.0", "python2.7"]
97
98			expected = """\
99			#!/bin/bash
100			#PBS -q qtest@mp2
101			#PBS -V
102			#PBS -A xyz-123-ab
103			#PBS -l walltime=01:00:00
104			#PBS -l nodes=2:ppn=3:gpus=1
105
106			# Modules #
107			module load CUDA_Toolkit/6.0
108			module load python2.7
109
110			# Prolog #
111			{prolog1}
112			{prolog2}
113
114			# Commands #
115			{command1}
116			{command2}
117
118			# Epilog #
119			{epilog1}
120			{epilog2}""".format(
121			prolog1=prolog[0], prolog2=prolog[1],
122			command1=commands[0], command2=commands[1],
123			epilog1=epilog[0], epilog2=epilog[1])
124
125			pbs = PBS(queue_name="qtest@mp2", walltime="01:00:00")
126			pbs.add_resources(nodes="2:ppn=3:gpus=1")
127			pbs.add_options(A="xyz-123-ab")
128			pbs.add_modules_to_load(*modules)
129			pbs.add_to_prolog(*prolog)
130			pbs.add_commands(*commands)
131			pbs.add_to_epilog(*epilog)
132
133			assert_equal(str(pbs), expected)
134
135			def test_save(self):
136			pbs_filename = os.path.join(self.testing_dir, "pbs.sh")
137			self.pbs.save(pbs_filename)
138			assert_equal(str(self.pbs), open(pbs_filename).read())
139

SMART-Lab / smartdispatch

TestPBS.test_str() A last analyzed 2017-06-22 19:40 UTC

Complexity

Size

Duplication

Importance

How to fix Long Method

Long Method

Duplication Side-by-Side

Filter issues like

TestPBS.test_str() A
last analyzed 2017-06-22 19:40 UTC