Merge pull request #12 from passuf/feature/subtasks

Handle completed Subtasks fixes #10

wh_habitica/factories.py

@@ -1,10 +1,17 @@
 import factory
-from django.contrib.auth import get_user_model
 
+from django.utils.crypto import get_random_string
 
-class UserFactory(factory.django.DjangoModelFactory):
+from .models import Habitica
+from wunderhabit.factories import UserFactory
+
+
+class HabiticaFactory(factory.django.DjangoModelFactory):
     class Meta:
-        model = get_user_model()
+        model = Habitica
 
-    first_name = 'John'
-    last_name = 'Doe'
+    user_id = factory.Sequence(lambda n: "%d" % n)
+    name = 'John'
+    email = 'john@doe.com'
+    api_token = get_random_string(32)
+    owner = factory.SubFactory(UserFactory)

wh_habitica/test_forms.py → wh_habitica/tests/test_forms.py

@@ -3,9 +3,9 @@
 import pytest
 import responses
 
-import default
-from .factories import UserFactory
-from .forms import AuthForm
+from wh_habitica import default
+from wh_habitica.forms import AuthForm
+from wunderhabit.factories import UserFactory
 
 USER_DICT = dict(username='tester', email='foo@bar.com')
 

wunderhabit/factories.py

@@ -0,0 +1,11 @@
+import factory
+from django.contrib.auth import get_user_model
+
+
+class UserFactory(factory.django.DjangoModelFactory):
+    class Meta:
+        model = get_user_model()
+
+    username = factory.Sequence(lambda n: "user_%d" % n)
+    first_name = 'John'
+    last_name = 'Doe'

wunderlist/default.py

@@ -50,4 +50,5 @@
 OPERATION_UPDATE = 'update'
 
 SUBJECT_TASK = 'task'
+SUBJECT_SUBTASK = 'subtask'
 SUBJECT_LIST = 'list'

wunderlist/factories.py

@@ -0,0 +1,25 @@
+import factory
+
+from django.utils.crypto import get_random_string
+
+from .models import Connection, Wunderlist
+from wunderhabit.factories import UserFactory
+
+
+class WunderlistFactory(factory.django.DjangoModelFactory):
+    class Meta:
+        model = Wunderlist
+
+    user_id = factory.Sequence(lambda n: "%d" % n)
+    name = 'John'
+    email = 'john@doe.com'
+    api_token = get_random_string(32)
+    owner = factory.SubFactory(UserFactory)
+
+
+class ConnectionFactory(factory.django.DjangoModelFactory):
+    class Meta:
+        model = Connection
+
+    list_id = 42
+    token = get_random_string(32)

wunderlist/tests/test_views.py

@@ -0,0 +1,249 @@
+import json
+import pytest
+from requests import HTTPError
+from django.core.urlresolvers import reverse
+from django.http import Http404
+
+from wunderlist import default
+from wunderlist.factories import WunderlistFactory, ConnectionFactory
+from wunderlist.views import webhook
+from wh_habitica.factories import HabiticaFactory
+
+
+USER_DICT = dict(username='tester', email='foo@bar.com')
+INVALID_HOOK_TOKEN = '0000aUZ01eJYBhsIIVZotvc0dY9h0000'
+
+
+def get_user():
+    """
+    Returns a user which is connected with wunderlist and habitica.
+    """
+    wunderlist = WunderlistFactory.create()
+    habitica = HabiticaFactory.create()
+    habitica.owner = wunderlist.owner
+    habitica.save()
+    return wunderlist.owner
+
+
+def get_invalid_webhook_body():
+    return {
+        default.JSON_OPERATION: default.OPERATION_CREATE,
+        'no_user_id': -1,
+        default.JSON_SUBJECT: {
+            'no_type': 'type missing'
+        },
+    }
+
+
+def get_valid_webhook_body(
+        op=default.OPERATION_UPDATE,
+        user_id=-1,
+        subject_type=default.SUBJECT_TASK,
+        completed_before=False,
+        completed_after=True,
+):
+    return {
+        default.JSON_OPERATION: op,
+        default.JSON_USER_ID: user_id,
+        default.JSON_SUBJECT: {
+            default.JSON_TYPE: subject_type
+        },
+        default.JSON_BEFORE: {
+            default.JSON_COMPLETED: completed_before,
+        },
+        default.JSON_AFTER: {
+            default.JSON_COMPLETED: completed_after,
+        },
+    }
+
+
+@pytest.mark.django_db
+def test_webhook_invalid_token(rf):
+    request = rf.post(reverse('wunderlist:webhook', kwargs={'hook_id': INVALID_HOOK_TOKEN}))
+    with pytest.raises(Http404):
+        response = webhook(request, hook_id=INVALID_HOOK_TOKEN)
+
+
+@pytest.mark.django_db
+def test_webhook_invalid_request_type(rf):
+    connection = ConnectionFactory.create()
+    request = rf.get(reverse('wunderlist:webhook', kwargs={'hook_id': connection.token}))
+    response = webhook(request, hook_id=connection.token)
+    assert response.status_code == 400
+
+
+@pytest.mark.django_db
+def test_webhook_invalid_request_body(rf):
+    owner = get_user()
+    connection = ConnectionFactory.create()
+    connection.owner = owner
+    connection.save()
+
+    post_data = get_invalid_webhook_body()
+    request = rf.post(
+            reverse('wunderlist:webhook', kwargs={'hook_id': connection.token}),
+            json.dumps(post_data),
+            content_type="application/json",
+    )
+    response = webhook(request, hook_id=connection.token)
+    assert response.status_code == 400
+
+
+@pytest.mark.django_db
+def test_webhook_inactive_connection(rf):
+    owner = get_user()
+    connection = ConnectionFactory.create()
+    connection.owner = owner
+    connection.is_active = False
+    connection.save()
+
+    post_data = get_valid_webhook_body()
+    request = rf.post(
+            reverse('wunderlist:webhook', kwargs={'hook_id': connection.token}),
+            json.dumps(post_data),
+            content_type="application/json",
+    )
+    response = webhook(request, hook_id=connection.token)
+    assert response.status_code == 410
+
+
+@pytest.mark.django_db
+def test_webhook_invalid_wunderlist_user(rf):
+    owner = get_user()
+    connection = ConnectionFactory.create()
+    connection.owner = owner
+    connection.save()
+
+    post_data = get_valid_webhook_body(user_id=-1)
+    request = rf.post(
+            reverse('wunderlist:webhook', kwargs={'hook_id': connection.token}),
+            json.dumps(post_data),
+            content_type="application/json",
+    )
+    response = webhook(request, hook_id=connection.token)
+    assert response.status_code == 401
+
+
+@pytest.mark.django_db
+def test_webhook_wrong_user(rf):
+    owner = get_user()
+    wrong_user = get_user()
+    connection = ConnectionFactory.create()
+    connection.owner = wrong_user
+    connection.save()
+
+    post_data = get_valid_webhook_body(user_id=owner.wunderlist.user_id)
+    request = rf.post(
+            reverse('wunderlist:webhook', kwargs={'hook_id': connection.token}),
+            json.dumps(post_data),
+            content_type="application/json",
+    )
+    response = webhook(request, hook_id=connection.token)
+    assert response.status_code == 401
+
+
+@pytest.mark.django_db
+def test_webhook_inactive_user(rf):
+    owner = get_user()
+    connection = ConnectionFactory.create()
+    connection.owner = owner
+    connection.save()
+    owner.is_active = False
+    owner.save()
+
+    post_data = get_valid_webhook_body(user_id=owner.wunderlist.user_id)
+    request = rf.post(
+            reverse('wunderlist:webhook', kwargs={'hook_id': connection.token}),
+            json.dumps(post_data),
+            content_type="application/json",
+    )
+    response = webhook(request, hook_id=connection.token)
+    assert response.status_code == 403
+
+
+@pytest.mark.django_db
+def test_webhook_task_completed(rf):
+    owner = get_user()
+    connection = ConnectionFactory.create()
+    connection.owner = owner
+    connection.save()
+
+    post_data = get_valid_webhook_body(user_id=owner.wunderlist.user_id)
+    request = rf.post(
+            reverse('wunderlist:webhook', kwargs={'hook_id': connection.token}),
+            json.dumps(post_data),
+            content_type="application/json",
+    )
+    with pytest.raises(HTTPError) as error:
+        response = webhook(request, hook_id=connection.token)
+    assert 'Unauthorized' in str(error.value)
+
+
+@pytest.mark.django_db
+def test_webhook_subtask_completed(rf):
+    owner = get_user()
+    connection = ConnectionFactory.create()
+    connection.owner = owner
+    connection.save()
+
+    post_data = get_valid_webhook_body(user_id=owner.wunderlist.user_id, subject_type=default.SUBJECT_SUBTASK)
+    request = rf.post(
+            reverse('wunderlist:webhook', kwargs={'hook_id': connection.token}),
+            json.dumps(post_data),
+            content_type="application/json",
+    )
+    with pytest.raises(HTTPError) as error:
+        response = webhook(request, hook_id=connection.token)
+    assert 'Unauthorized' in str(error.value)
+
+
+@pytest.mark.django_db
+def test_webhook_invalid_task_body(rf):
+    owner = get_user()
+    connection = ConnectionFactory.create()
+    connection.owner = owner
+    connection.save()
+
+    post_data = get_valid_webhook_body(user_id=owner.wunderlist.user_id)
+    del post_data[default.JSON_AFTER]
+    request = rf.post(
+            reverse('wunderlist:webhook', kwargs={'hook_id': connection.token}),
+            json.dumps(post_data),
+            content_type="application/json",
+    )
+    response = webhook(request, hook_id=connection.token)
+    assert response.status_code == 400
+
+
+@pytest.mark.django_db
+def test_webhook_task_created(rf):
+    owner = get_user()
+    connection = ConnectionFactory.create()
+    connection.owner = owner
+    connection.save()
+
+    post_data = get_valid_webhook_body(user_id=owner.wunderlist.user_id, op=default.OPERATION_CREATE)
+    request = rf.post(
+            reverse('wunderlist:webhook', kwargs={'hook_id': connection.token}),
+            json.dumps(post_data),
+            content_type="application/json",
+    )
+    response = webhook(request, hook_id=connection.token)
+    assert response.status_code == 200
+
+
+@pytest.mark.django_db
+def test_webhook_unknown_operation(rf):
+    owner = get_user()
+    connection = ConnectionFactory.create()
+    connection.owner = owner
+    connection.save()
+
+    post_data = get_valid_webhook_body(user_id=owner.wunderlist.user_id, op='op_unknown')
+    request = rf.post(
+            reverse('wunderlist:webhook', kwargs={'hook_id': connection.token}),
+            json.dumps(post_data),
+            content_type="application/json",
+    )
+    response = webhook(request, hook_id=connection.token)
+    assert response.status_code == 400