Cleanup and add travis

Conflicts:
	python/py_vapid/__init__.py

Author: jrconlin

.travis.yml

@@ -0,0 +1,12 @@
+language: python
+python:
+- "2.7"
+install:
+- cd python
+- pip install -r requirements.txt
+- pip install -r test-requirements.txt
+script:
+- nosetests
+- flake8 pywebpush
+after_success:
+    - coverage report --omit py_vapid/main.py

python/.coveragerc

@@ -0,0 +1,3 @@
+[report]
+omit = *noseplugin*
+show_missing = true

python/py_vapid/__init__.py

@@ -25,10 +25,13 @@ class Vapid(object):
 
     def __init__(self, private_key_file=None, private_key=None):
         """Initialize VAPID using an optional file containing a private key
-        in PEM format.
+        in PEM format, or a string containing the PEM formatted private key.
+
+        :param private_key_file: Name of the file containing the private key
+        :type private_key_file: str
+        :param private_key: A private key in PEM format
+        :type private_key: str
 
-        :param private_key_file: The name of the file containing the
-        private key
         """
         if private_key_file:
             if not os.path.isfile(private_key_file):
@@ -50,31 +53,46 @@ def __init__(self, private_key_file=None, private_key=None):
 
     @property
     def private_key(self):
-        """Return the private key."""
+        """The VAPID private ECDSA key"""
         if not self._private_key:
             raise VapidException(
                 "No private key defined. Please import or generate a key.")
         return self._private_key
 
     @private_key.setter
     def private_key(self, value):
-        """Set the private key."""
+        """Set the VAPID private ECDSA key
+
+        :param value: the byte array containing the private ECDSA key data
+        :type value: bytes
+
+        """
         self._private_key = value
 
     @property
     def public_key(self):
-        """Return the public key."""
+        """The VAPID public ECDSA key
+
+        The public key is currently read only. Set it via the `.private_key`
+        method.
+
+        """
         if not self._public_key:
             self._public_key = self.private_key.get_verifying_key()
         return self._public_key
 
     def generate_keys(self):
         """Generate a valid ECDSA Key Pair."""
         self.private_key = ecdsa.SigningKey.generate(curve=ecdsa.NIST256p)
-        self.public_key
+        self._public_key = self.private_key.get_verifying_key()
 
     def save_key(self, key_file):
-        """Save the private key to a PEM file."""
+        """Save the private key to a PEM file.
+
+        :param key_file: The file path to save the private key data
+        :type key_file: str
+
+        """
         file = open(key_file, "wb")
         if not self._private_key:
             self.generate_keys()
@@ -84,30 +102,52 @@ def save_key(self, key_file):
     def save_public_key(self, key_file):
         """Save the public key to a PEM file.
         :param key_file: The name of the file to save the public key
+        :type key_file: str
+
         """
         with open(key_file, "wb") as file:
             file.write(self.public_key.to_pem())
             file.close()
 
-    def validate(self, token):
-        """Sign a Valdiation token from the dashboard"""
-        sig = self.private_key.sign(token, hashfunc=self._hasher)
-        token = base64.urlsafe_b64encode(sig)
-        return token
+    def validate(self, validation_token):
+        """Sign a Valdiation token from the dashboard
+
+        :param validation_token: Short validation token from the dev dashboard
+        :type validation_token: str
+        :returns: corresponding token for key verification
+        :rtype: str
+
+        """
+        sig = self.private_key.sign(validation_token, hashfunc=self._hasher)
+        verification_token = base64.urlsafe_b64encode(sig)
+        return verification_token
 
-    def verify_token(self, sig, token):
-        """Verify the signature against the token."""
-        hsig = base64.urlsafe_b64decode(sig)
-        return self.public_key.verify(hsig, token,
+    def verify_token(self, validation_token, verification_token):
+        """Internally used to verify the verification token is correct.
+
+        :param validation_token: Provided validation token string
+        :type validation_token: str
+        :param verification_token: Generated verification token
+        :type verification_token: str
+        :returns: Boolean indicating if verifictation token is valid.
+        :rtype: boolean
+
+        """
+        hsig = base64.urlsafe_b64decode(verification_token)
+        return self.public_key.verify(hsig, validation_token,
                                       hashfunc=self._hasher)
 
     def sign(self, claims, crypto_key=None):
         """Sign a set of claims.
         :param claims: JSON object containing the JWT claims to use.
+        :type claims: dict
         :param crypto_key: Optional existing crypto_key header content. The
             vapid public key will be appended to this data.
-        :returns result: a hash containing the header fields to use in
+        :type crypto_key: str
+        :returns: a hash containing the header fields to use in
             the subscription update.
+        :rtype: dict
+
         """
         if not claims.get('exp'):
             claims['exp'] = int(time.time()) + 86400

python/py_vapid/tests/test_vapid.py

@@ -9,12 +9,13 @@
 from jose import jws
 from py_vapid import Vapid, VapidException
 
-T_PRIVATE = """-----BEGIN EC PRIVATE KEY-----
+T_DER = """
 MHcCAQEEIPeN1iAipHbt8+/KZ2NIF8NeN24jqAmnMLFZEMocY8RboAoGCCqGSM49
 AwEHoUQDQgAEEJwJZq/GN8jJbo1GGpyU70hmP2hbWAUpQFKDByKB81yldJ9GTklB
 M5xqEwuPM7VuQcyiLDhvovthPIXx+gsQRQ==
------END EC PRIVATE KEY-----
 """
+T_PRIVATE = ("-----BEGIN EC PRIVATE KEY-----{}"
+             "-----END EC PRIVATE KEY-----\n").format(T_DER)
 
 T_PUBLIC = """-----BEGIN PUBLIC KEY-----
 MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEEJwJZq/GN8jJbo1GGpyU70hmP2hb
@@ -48,6 +49,13 @@ def test_init(self):
         v2 = Vapid(private_key=T_PRIVATE)
         eq_(v2.private_key.to_pem(), T_PRIVATE)
         eq_(v2.public_key.to_pem(), T_PUBLIC)
+        v3 = Vapid(private_key=T_DER)
+        eq_(v3.private_key.to_pem(), T_PRIVATE)
+        eq_(v3.public_key.to_pem(), T_PUBLIC)
+        no_exist = '/tmp/not_exist'
+        Vapid(private_key_file=no_exist)
+        ok_(os.path.isfile(no_exist))
+        os.unlink(no_exist)
 
     @patch("ecdsa.SigningKey.from_pem", side_effect=Exception)
     def test_init_bad_priv(self, mm):
@@ -57,19 +65,12 @@ def test_init_bad_priv(self, mm):
 
     def test_private(self):
         v = Vapid()
-
-        def getKey(v):
-            v.private_key
-
-        self.assertRaises(VapidException, getKey, v)
+        self.assertRaises(VapidException, lambda x=None: v.private_key)
 
     def test_public(self):
         v = Vapid()
 
-        def getKey(v):
-            v.public_key
-
-        self.assertRaises(VapidException, getKey, v)
+        self.assertRaises(VapidException, lambda x=None: v.public_key)
 
     def test_gen_key(self):
         v = Vapid()
@@ -95,6 +96,8 @@ def test_validate(self):
         ok_(v.public_key.verify(base64.urlsafe_b64decode(vtoken),
                                 msg,
                                 hashfunc=hashlib.sha256))
+        # test verify
+        ok_(v.verify_token(msg, vtoken))
 
     def test_sign(self):
         v = Vapid("/tmp/private")
@@ -103,7 +106,7 @@ def test_sign(self):
         eq_(result['Crypto-Key'],
             'id=previous,'
             'p256ecdsa=' + T_PUBLIC_RAW)
-        items = jws.verify(result['Authorization'][7:],
+        items = jws.verify(result['Authorization'].split(' ')[1],
                            v.public_key,
                            algorithms=["ES256"])
         eq_(json.loads(items), claims)
@@ -116,4 +119,3 @@ def test_bad_sign(self):
         self.assertRaises(VapidException,
                           v.sign,
                           {'aud': "p.example.com"})
-