add tests

.coveragerc

@@ -0,0 +1,3 @@
+[run]
+omit = test/*
+source = feeds

feeds/notification_level.py

@@ -15,7 +15,7 @@ def register(level):
         ))
 
     if level.name is None:
-        raise ValueError("A level must have an name form")
+        raise ValueError("A level must have a name")
     elif level.name.lower() in _level_register:
         raise ValueError("The level '{}' is already registered!".format(level.name))
 
@@ -28,7 +28,7 @@ def register(level):
 def get_level(key):
     key = str(key)
     if key.lower() in _level_register:
-        return _level_register[key]
+        return _level_register[key]()
     else:
         raise MissingLevelError('Level "{}" not found.'.format(key))
 
@@ -42,7 +42,7 @@ def translate_level(level):
     """
     if isinstance(level, str):
         return get_level(level)
-    elif issubclass(level, Level):
+    elif isinstance(level, Level):
         return get_level(level.name)
     else:
         raise TypeError("Must be either a subclass of Level or a string.")

feeds/verbs.py

@@ -41,7 +41,7 @@ def translate_verb(verb):
     """
     if isinstance(verb, str):
         return get_verb(verb)
-    elif issubclass(verb, Verb):
+    elif isinstance(verb, Verb):
         return get_verb(verb.infinitive)
     else:
         raise TypeError("Must be either a subclass of Verb or a string.")

test/test_notification_level.py

@@ -0,0 +1,88 @@
+import pytest
+import feeds.notification_level as level
+from feeds.exceptions import (
+    MissingLevelError
+)
+
+def test_register_level_ok():
+    class TestLevel(level.Level):
+        id=666
+        name="test"
+    level.register(TestLevel)
+    assert '666' in level._level_register
+    assert level._level_register['666'] == TestLevel
+    assert 'test' in level._level_register
+    assert level._level_register['test'] == TestLevel
+
+def test_register_level_bad():
+    class NoId(level.Level):
+        id=None
+        name="noid"
+
+    with pytest.raises(ValueError) as e:
+        level.register(NoId)
+    assert "A level must have an id" in str(e.value)
+
+    class NoName(level.Level):
+        id=667
+
+    with pytest.raises(ValueError) as e:
+        level.register(NoName)
+    assert "A level must have a name" in str(e.value)
+
+    class DuplicateId(level.Level):
+        id='1'
+        name='duplicate'
+
+    with pytest.raises(ValueError) as e:
+        level.register(DuplicateId)
+    assert "The level id '1' is already taken by alert" in str(e.value)
+
+    class DuplicateName(level.Level):
+        id=668
+        name="warning"
+
+    with pytest.raises(ValueError) as e:
+        level.register(DuplicateName)
+    assert "The level 'warning' is already registered" in str(e.value)
+
+    with pytest.raises(TypeError) as e:
+        level.register(str)
+    assert "Can only register Level subclasses" in str(e.value)
+
+    with pytest.raises(ValueError) as e:
+        level.register(level.Alert)
+    assert "The level id '1' is already taken by alert" in str(e.value)
+
+
+def test_get_level():
+    l = level.get_level('warning')
+    assert isinstance(l, level.Warning)
+    assert l.id == level.Warning.id
+    assert l.name == level.Warning.name
+
+    missing = "not_a_real_level"
+    with pytest.raises(MissingLevelError) as e:
+        level.get_level(missing)
+    assert 'Level "{}" not found'.format(missing) in str(e.value)
+
+
+def test_translate_level():
+    l = level.Alert()
+    l_trans = level.translate_level(l)
+    assert isinstance(l_trans, level.Alert)
+
+    l = level.translate_level('1')
+    assert isinstance(l, level.Alert)
+    assert l.name == 'alert'
+
+    l = level.translate_level('alert')
+    assert isinstance(l, level.Alert)
+
+    with pytest.raises(MissingLevelError) as e:
+        level.translate_level('foo')
+    assert 'Level "foo" not found' in str(e.value)
+
+    with pytest.raises(TypeError) as e:
+        level.translate_level([])
+    assert 'Must be either a subclass of Level or a string' in str(e.value)

test/test_verbs.py

@@ -85,4 +85,24 @@ def test_get_verb_fail():
 
 def test_serialize():
     v = verbs.get_verb('invite')
-    assert v.serialize() == 1
+    assert v.serialize() == 1
+
+def test_translate_verb():
+    v = verbs.Request()
+    v_trans = verbs.translate_verb(v)
+    assert isinstance(v_trans, verbs.Request)
+
+    v = verbs.translate_verb('1')
+    assert isinstance(v, verbs.Invite)
+    assert v.infinitive == 'invite'
+
+    l = verbs.translate_verb('invite')
+    assert isinstance(l, verbs.Invite)
+
+    with pytest.raises(MissingVerbError) as e:
+        verbs.translate_verb('foo')
+    assert 'Verb "foo" not found' in str(e.value)
+
+    with pytest.raises(TypeError) as e:
+        verbs.translate_verb([])
+    assert 'Must be either a subclass of Verb or a string' in str(e.value)