namespace_trie: ported to pytest (#4060)

lib/spack/spack/test/namespace_trie.py

@@ -22,88 +22,92 @@
 # License along with this program; if not, write to the Free Software
 # Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
 ##############################################################################
-import unittest
+import pytest
 
-from spack.util.naming import NamespaceTrie
+import spack.util.naming
 
 
-class NamespaceTrieTest(unittest.TestCase):
+@pytest.fixture()
+def trie():
+    return spack.util.naming.NamespaceTrie()
 
-    def setUp(self):
-        self.trie = NamespaceTrie()
 
-    def test_add_single(self):
+def test_add_single(trie):
-        self.trie['foo'] = 'bar'
+    trie['foo'] = 'bar'
 
-        self.assertTrue(self.trie.is_prefix('foo'))
+    assert trie.is_prefix('foo')
-        self.assertTrue(self.trie.has_value('foo'))
+    assert trie.has_value('foo')
-        self.assertEqual(self.trie['foo'], 'bar')
+    assert trie['foo'] == 'bar'
 
-    def test_add_multiple(self):
-        self.trie['foo.bar'] = 'baz'
 
-        self.assertFalse(self.trie.has_value('foo'))
+def test_add_multiple(trie):
-        self.assertTrue(self.trie.is_prefix('foo'))
+    trie['foo.bar'] = 'baz'
 
-        self.assertTrue(self.trie.is_prefix('foo.bar'))
+    assert not trie.has_value('foo')
-        self.assertTrue(self.trie.has_value('foo.bar'))
+    assert trie.is_prefix('foo')
-        self.assertEqual(self.trie['foo.bar'], 'baz')
 
-        self.assertFalse(self.trie.is_prefix('foo.bar.baz'))
+    assert trie.is_prefix('foo.bar')
-        self.assertFalse(self.trie.has_value('foo.bar.baz'))
+    assert trie.has_value('foo.bar')
+    assert trie['foo.bar'] == 'baz'
 
-    def test_add_three(self):
+    assert not trie.is_prefix('foo.bar.baz')
-        # add a three-level namespace
+    assert not trie.has_value('foo.bar.baz')
-        self.trie['foo.bar.baz'] = 'quux'
 
-        self.assertTrue(self.trie.is_prefix('foo'))
-        self.assertFalse(self.trie.has_value('foo'))
 
-        self.assertTrue(self.trie.is_prefix('foo.bar'))
+def test_add_three(trie):
-        self.assertFalse(self.trie.has_value('foo.bar'))
+    # add a three-level namespace
+    trie['foo.bar.baz'] = 'quux'
 
-        self.assertTrue(self.trie.is_prefix('foo.bar.baz'))
+    assert trie.is_prefix('foo')
-        self.assertTrue(self.trie.has_value('foo.bar.baz'))
+    assert not trie.has_value('foo')
-        self.assertEqual(self.trie['foo.bar.baz'], 'quux')
 
-        self.assertFalse(self.trie.is_prefix('foo.bar.baz.quux'))
+    assert trie.is_prefix('foo.bar')
-        self.assertFalse(self.trie.has_value('foo.bar.baz.quux'))
+    assert not trie.has_value('foo.bar')
 
-        # Try to add a second element in a prefix namespace
+    assert trie.is_prefix('foo.bar.baz')
-        self.trie['foo.bar'] = 'blah'
+    assert trie.has_value('foo.bar.baz')
+    assert trie['foo.bar.baz'] == 'quux'
 
-        self.assertTrue(self.trie.is_prefix('foo'))
+    assert not trie.is_prefix('foo.bar.baz.quux')
-        self.assertFalse(self.trie.has_value('foo'))
+    assert not trie.has_value('foo.bar.baz.quux')
 
-        self.assertTrue(self.trie.is_prefix('foo.bar'))
+    # Try to add a second element in a prefix namespace
-        self.assertTrue(self.trie.has_value('foo.bar'))
+    trie['foo.bar'] = 'blah'
-        self.assertEqual(self.trie['foo.bar'], 'blah')
 
-        self.assertTrue(self.trie.is_prefix('foo.bar.baz'))
+    assert trie.is_prefix('foo')
-        self.assertTrue(self.trie.has_value('foo.bar.baz'))
+    assert not trie.has_value('foo')
-        self.assertEqual(self.trie['foo.bar.baz'], 'quux')
 
-        self.assertFalse(self.trie.is_prefix('foo.bar.baz.quux'))
+    assert trie.is_prefix('foo.bar')
-        self.assertFalse(self.trie.has_value('foo.bar.baz.quux'))
+    assert trie.has_value('foo.bar')
+    assert trie['foo.bar'] == 'blah'
 
-    def test_add_none_single(self):
+    assert trie.is_prefix('foo.bar.baz')
-        self.trie['foo'] = None
+    assert trie.has_value('foo.bar.baz')
-        self.assertTrue(self.trie.is_prefix('foo'))
+    assert trie['foo.bar.baz'] == 'quux'
-        self.assertTrue(self.trie.has_value('foo'))
-        self.assertEqual(self.trie['foo'], None)
 
-        self.assertFalse(self.trie.is_prefix('foo.bar'))
+    assert not trie.is_prefix('foo.bar.baz.quux')
-        self.assertFalse(self.trie.has_value('foo.bar'))
+    assert not trie.has_value('foo.bar.baz.quux')
 
-    def test_add_none_multiple(self):
-        self.trie['foo.bar'] = None
 
-        self.assertTrue(self.trie.is_prefix('foo'))
+def test_add_none_single(trie):
-        self.assertFalse(self.trie.has_value('foo'))
+    trie['foo'] = None
+    assert trie.is_prefix('foo')
+    assert trie.has_value('foo')
+    assert trie['foo'] is None
 
-        self.assertTrue(self.trie.is_prefix('foo.bar'))
+    assert not trie.is_prefix('foo.bar')
-        self.assertTrue(self.trie.has_value('foo.bar'))
+    assert not trie.has_value('foo.bar')
-        self.assertEqual(self.trie['foo.bar'], None)
 
-        self.assertFalse(self.trie.is_prefix('foo.bar.baz'))
+
-        self.assertFalse(self.trie.has_value('foo.bar.baz'))
+def test_add_none_multiple(trie):
+    trie['foo.bar'] = None
+
+    assert trie.is_prefix('foo')
+    assert not trie.has_value('foo')
+
+    assert trie.is_prefix('foo.bar')
+    assert trie.has_value('foo.bar')
+    assert trie['foo.bar'] is None
+
+    assert not trie.is_prefix('foo.bar.baz')
+    assert not trie.has_value('foo.bar.baz')