default to KEY_TYPE_NORMAL to ensure backwards compatibility

also cleaned up tests around api_keys - fixed imports, reduced fixture usage
and added an additional (temporary) test for default test type

app/schemas.py

@@ -165,7 +165,7 @@ class NotificationsStatisticsSchema(BaseSchema):
 class ApiKeySchema(BaseSchema):
 
     created_by = field_for(models.ApiKey, 'created_by', required=True)
-    key_type = field_for(models.ApiKey, 'key_type', required=True)
+    key_type = field_for(models.ApiKey, 'key_type', required=True, missing=models.KEY_TYPE_NORMAL)
 
     class Meta:
         model = models.ApiKey

tests/app/dao/test_api_key_dao.py

@@ -1,6 +1,7 @@
 from datetime import datetime
 
-from pytest import fail
+import pytest
+from sqlalchemy.exc import IntegrityError
 from sqlalchemy.orm.exc import NoResultFound
 
 from app.dao.api_key_dao import (save_model_api_key,
@@ -20,10 +21,7 @@ def test_secret_is_signed_and_can_be_read_again(notify_api, mocker):
         assert signed_secret != 'some_uuid'
 
 
-def test_save_api_key_should_create_new_api_key_and_history(notify_api,
+def test_save_api_key_should_create_new_api_key_and_history(sample_service):
-                                                            notify_db,
-                                                            notify_db_session,
-                                                            sample_service):
     api_key = ApiKey(**{'service': sample_service,
                         'name': sample_service.name,
                         'created_by': sample_service.created_by,
@@ -42,8 +40,6 @@ def test_save_api_key_should_create_new_api_key_and_history(notify_api,
 
 
 def test_expire_api_key_should_update_the_api_key_and_create_history_record(notify_api,
-                                                                            notify_db,
-                                                                            notify_db_session,
                                                                             sample_api_key):
     expire_api_key(service_id=sample_api_key.service_id, api_key_id=sample_api_key.id)
     all_api_keys = get_model_api_keys(service_id=sample_api_key.service_id)
@@ -62,16 +58,9 @@ def test_expire_api_key_should_update_the_api_key_and_create_history_record(noti
     sorted_all_history[1].version = 2
 
 
-def test_get_api_key_should_raise_exception_when_api_key_does_not_exist(notify_api,
+def test_get_api_key_should_raise_exception_when_api_key_does_not_exist(sample_service, fake_uuid):
-                                                                        notify_db,
+    with pytest.raises(NoResultFound):
-                                                                        notify_db_session,
-                                                                        sample_service,
-                                                                        fake_uuid):
-    try:
         get_model_api_keys(sample_service.id, id=fake_uuid)
-        fail("Should have thrown a NoResultFound exception")
-    except NoResultFound:
-        pass
 
 
 def test_should_return_api_key_for_service(notify_api, notify_db, notify_db_session, sample_api_key):
@@ -79,44 +68,30 @@ def test_should_return_api_key_for_service(notify_api, notify_db, notify_db_sess
     assert api_key == sample_api_key
 
 
-def test_should_return_unsigned_api_keys_for_service_id(notify_api,
+def test_should_return_unsigned_api_keys_for_service_id(sample_api_key):
-                                                        notify_db,
-                                                        notify_db_session,
-                                                        sample_api_key):
     unsigned_api_key = get_unsigned_secrets(sample_api_key.service_id)
     assert len(unsigned_api_key) == 1
     assert sample_api_key.secret != unsigned_api_key[0]
     assert unsigned_api_key[0] == _get_secret(sample_api_key.secret)
 
 
-def test_get_unsigned_secret_returns_key(notify_api,
+def test_get_unsigned_secret_returns_key(sample_api_key):
-                                         notify_db,
-                                         notify_db_session,
-                                         sample_api_key):
     unsigned_api_key = get_unsigned_secret(sample_api_key.id)
     assert sample_api_key.secret != unsigned_api_key
     assert unsigned_api_key == _get_secret(sample_api_key.secret)
 
 
-def test_should_not_allow_duplicate_key_names_per_service(notify_api,
+def test_should_not_allow_duplicate_key_names_per_service(sample_api_key, fake_uuid):
-                                                          notify_db,
-                                                          notify_db_session,
-                                                          sample_api_key,
-                                                          fake_uuid):
     api_key = ApiKey(**{'id': fake_uuid,
                         'service': sample_api_key.service,
                         'name': sample_api_key.name,
                         'created_by': sample_api_key.created_by,
                         'key_type': KEY_TYPE_NORMAL})
-    try:
+    with pytest.raises(IntegrityError):
         save_model_api_key(api_key)
-        fail("should throw IntegrityError")
-    except:
-        pass
 
 
-def test_save_api_key_should_not_create_new_service_history(notify_api, notify_db, notify_db_session, sample_service):
+def test_save_api_key_should_not_create_new_service_history(sample_service):
-
     from app.models import Service
 
     assert Service.query.count() == 1

tests/app/service/test_api_key_endpoints.py

@@ -1,7 +1,7 @@
 import json
-from datetime import datetime
 
 from flask import url_for
+
 from app.models import ApiKey, KEY_TYPE_NORMAL
 from app.dao.api_key_dao import expire_api_key
 from tests import create_authorization_header
@@ -10,9 +10,7 @@ from tests.app.conftest import sample_service as create_sample_service
 from tests.app.conftest import sample_user as create_user
 
 
-def test_api_key_should_create_new_api_key_for_service(notify_api, notify_db,
+def test_api_key_should_create_new_api_key_for_service(notify_api, sample_service):
-                                                       notify_db_session,
-                                                       sample_service):
     with notify_api.test_request_context():
         with notify_api.test_client() as client:
             data = {
@@ -31,8 +29,7 @@ def test_api_key_should_create_new_api_key_for_service(notify_api, notify_db,
             assert saved_api_key.name == 'some secret name'
 
 
-def test_api_key_should_return_error_when_service_does_not_exist(notify_api, notify_db, notify_db_session,
+def test_api_key_should_return_error_when_service_does_not_exist(notify_api, sample_service):
-                                                                 sample_service):
     with notify_api.test_request_context():
         with notify_api.test_client() as client:
             import uuid
@@ -43,8 +40,21 @@ def test_api_key_should_return_error_when_service_does_not_exist(notify_api, not
             assert response.status_code == 404
 
 
-def test_revoke_should_expire_api_key_for_service(notify_api, notify_db, notify_db_session,
+def test_create_api_key_should_set_default_key_type_of_normal(notify_api, sample_service):
-                                                  sample_api_key):
+    with notify_api.test_request_context(), notify_api.test_client() as client:
+        data = {
+            'name': 'some secret name',
+            'created_by': str(sample_service.created_by.id)
+        }
+        auth_header = create_authorization_header()
+        response = client.post(url_for('service.create_api_key', service_id=sample_service.id),
+                               data=json.dumps(data),
+                               headers=[('Content-Type', 'application/json'), auth_header])
+        assert response.status_code == 201
+        assert ApiKey.query.one().key_type == KEY_TYPE_NORMAL
+
+
+def test_revoke_should_expire_api_key_for_service(notify_api, sample_api_key):
     with notify_api.test_request_context():
         with notify_api.test_client() as client:
             assert ApiKey.query.count() == 1
@@ -58,9 +68,7 @@ def test_revoke_should_expire_api_key_for_service(notify_api, notify_db, notify_
             assert api_keys_for_service.expiry_date is not None
 
 
-def test_api_key_should_create_multiple_new_api_key_for_service(notify_api, notify_db,
+def test_api_key_should_create_multiple_new_api_key_for_service(notify_api, sample_service):
-                                                                notify_db_session,
-                                                                sample_service):
     with notify_api.test_request_context():
         with notify_api.test_client() as client:
             assert ApiKey.query.count() == 0
@@ -119,9 +127,7 @@ def test_get_api_keys_should_return_all_keys_for_service(notify_api, notify_db,
             assert len(json_resp['apiKeys']) == 3
 
 
-def test_get_api_keys_should_return_one_key_for_service(notify_api, notify_db,
+def test_get_api_keys_should_return_one_key_for_service(notify_api, sample_api_key):
-                                                        notify_db_session,
-                                                        sample_api_key):
     with notify_api.test_request_context():
         with notify_api.test_client() as client:
             auth_header = create_authorization_header()