Exercise8

README.md

@@ -33,4 +33,53 @@ Dalam exercise kali ini saya membuat mutant yang bertujuan untuk membuat functio
 
 Dalam exercise kali ini mempelajari tentang ```Spiking```. ```Spiking``` adalah sebuah aktivitas explore program ketika membuat sebuah fitur tanpa membuat TDD functional dan unittest. Pada exercise kali ini spiking diterapkan ketika membuat fitur *auth* tanpa tanpa menggunakan passworrd.
 
-Sedangkan De-```Spiking``` adalah menghapus keseluruhan implementasi spiking lalu memulai membuat implementasi fitur barusan, dari awal lagi hanya saja lengkap dengan TDD nya.
\ No newline at end of file
+Sedangkan De-```Spiking``` adalah menghapus keseluruhan implementasi spiking lalu memulai membuat implementasi fitur barusan, dari awal lagi hanya saja lengkap dengan TDD nya.
+
+# Exercise 8
+
+Mocking adalah sebuah cara untuk melakukan testing dengan membuat fungsi `fake` yang menerima input dan mengeluarkan hasil yang sama seperti fungsi yang ingin di test dengan tujuan untuk menghindari pemanggilan fungsi yang berlebihan dan untuk menghindari fungsi lain terpengaruh oleh fungsi yang tadi dipanggil
+
+Pada exercise ini dipelajari 2 cara melakukan mocking yaitu `manual mocking` dan mocking dengan `library`.
+
+Pada manual mocking dilakukan dengan mengganti fungsi `send_mail` dengan versi fake nya yang bernama `fake_send_mail` :
+
+```
+def test_sends_mail_to_address_from_post(self):
+        self.send_mail_called = False
+        
+        def fake_send_mail(subject, body, from_email, to_list):
+            self.send_mail_called = True
+            self.subject = subject
+            self.body = body
+            self.from_email = from_email
+            self.to_list = to_list
+        
+        accounts.views.send_mail = fake_send_mail
+
+        self.client.post('/accounts/send_login_email', data={
+            'email': 'edith@example.com'
+        })
+        
+        self.assertTrue(self.send_mail_called)
+        self.assertEqual(self.subject, 'Your login link for Superlists')
+        self.assertEqual(self.from_email, 'noreply@superlists')
+        self.assertEqual(self.to_list, ['edith@example.com'])   
+```
+
+
+Sedangkan mocking dengan `library`, dilakukan dengan menggunakan library dari Python yang sudah tersedia bernama `Mock`. Library tersebut menyediakan decorator bernama `patch` yang digunakan pada fungsi yang membutuhkan mock
+
+```
+@patch('accounts.views.send_mail')
+    def test_sends_mail_to_address_from_post(self, mock_send_mail):
+        self.client.post('/accounts/send_login_email', data={
+        'email': 'edith@example.com'
+        })
+        self.assertEqual(mock_send_mail.called, True)
+        (subject, body, from_email, to_list), kwargs = mock_send_mail.call_args
+        self.assertEqual(subject, 'Your login link for Superlists')
+        self.assertEqual(from_email, 'noreply@superlists')
+        self.assertEqual(to_list, ['edith@example.com'])
+```
+
+Dengan memberikan anotasi `@Patch` fungsi yang berada dibawahnya akan secara otomatis dibuatkan versi Mock-nya oleh library tersebut.
\ No newline at end of file

accounts/authentication.py

 import sys
 from accounts.models import ListUser, Token
+from accounts.models import User, Token
 
 
 class PasswordlessAuthenticationBackend(object):
     def authenticate(self, uid):
-        print('uid', uid, file=sys.stderr)
-        if not Token.objects.filter(uid=uid).exists():
-            print('no token found', file=sys.stderr)
-        return None
-        token = Token.objects.get(uid=uid)
-        print('got token', file=sys.stderr)
         try:
-            user = ListUser.objects.get(email=token.email)
-            print('got user', file=sys.stderr)
-            return user
-        except ListUser.DoesNotExist:
-            print('new user', file=sys.stderr)
-            return ListUser.objects.create(email=token.email)
+            token = Token.objects.get(uid=uid)
+            return User.objects.get(email=token.email)
+        except User.DoesNotExist:
+            return User.objects.create(email=token.email)
+        except Token.DoesNotExist:
+            return None
 
     def get_user(self, email):
-        return ListUser.objects.get(email=email)
\ No newline at end of file
+        try:
+            return User.objects.get(email=email)
+        except User.DoesNotExist:
+            return None

accounts/models.py

 from django.db import models
 import uuid
+import uuid
+from django.contrib import auth
+from django.db import models
+auth.signals.user_logged_in.disconnect(auth.models.update_last_login)
 from django.contrib.auth.models import (
 AbstractBaseUser, BaseUserManager, PermissionsMixin
 )
@@ -33,4 +37,4 @@ class User(models.Model):
     REQUIRED_FIELDS = []
     USERNAME_FIELD = 'email'
     is_anonymous = False
-    is_authenticated = True
\ No newline at end of file
+    is_authenticated = True

accounts/tests/test_authentication.py

+from django.test import TestCase
+from django.contrib.auth import get_user_model
+from accounts.authentication import PasswordlessAuthenticationBackend
+from accounts.models import Token
+User = get_user_model()
+
+class AuthenticateTest(TestCase):
+    def test_returns_None_if_no_such_token(self):
+        result = PasswordlessAuthenticationBackend().authenticate(
+        'no-such-token'
+        )
+        self.assertIsNone(result)
+
+    def test_returns_new_user_with_correct_email_if_token_exists(self):
+        email = 'edith@example.com'
+        token = Token.objects.create(email=email)
+        user = PasswordlessAuthenticationBackend().authenticate(token.uid)
+        new_user = User.objects.get(email=email)
+        self.assertEqual(user, new_user)
+
+    def test_returns_existing_user_with_correct_email_if_token_exists(self):
+        email = 'edith@example.com'
+        existing_user = User.objects.create(email=email)
+        token = Token.objects.create(email=email)
+        user = PasswordlessAuthenticationBackend().authenticate(token.uid)
+        self.assertEqual(user, existing_user)
+
+class GetUserTest(TestCase):
+    def test_gets_user_by_email(self):
+        User.objects.create(email='another@example.com')
+        desired_user = User.objects.create(email='edith@example.com')
+        found_user = PasswordlessAuthenticationBackend().get_user(
+            'edith@example.com'
+        )
+        self.assertEqual(found_user, desired_user)
+
+    def test_returns_None_if_no_user_with_that_email(self):
+        self.assertIsNone(
+            PasswordlessAuthenticationBackend().get_user('edith@example.com')
+        )

accounts/tests/test_views.py

+from django.test import TestCase
+from unittest.mock import patch, call
+import accounts.views
+from accounts.models import Token
+from django.test import TestCase
+from unittest.mock import patch
+class SendLoginEmailViewTest(TestCase):
+    def test_redirects_to_home_page(self):
+        response = self.client.post('/accounts/send_login_email', data={
+        'email': 'edith@example.com'
+        })
+        self.assertRedirects(response, '/')
+
+    def test_sends_mail_to_address_from_post(self):
+        self.send_mail_called = False
+        
+        def fake_send_mail(subject, body, from_email, to_list):
+            self.send_mail_called = True
+            self.subject = subject
+            self.body = body
+            self.from_email = from_email
+            self.to_list = to_list
+        
+        accounts.views.send_mail = fake_send_mail
+
+        self.client.post('/accounts/send_login_email', data={
+            'email': 'edith@example.com'
+        })
+        
+        self.assertTrue(self.send_mail_called)
+        self.assertEqual(self.subject, 'Your login link for Superlists')
+        self.assertEqual(self.from_email, 'noreply@superlists')
+        self.assertEqual(self.to_list, ['edith@example.com'])   
+    
+    @patch('accounts.views.send_mail')
+    def test_sends_mail_to_address_from_post(self, mock_send_mail):
+        self.client.post('/accounts/send_login_email', data={
+        'email': 'edith@example.com'
+        })
+        self.assertEqual(mock_send_mail.called, True)
+        (subject, body, from_email, to_list), kwargs = mock_send_mail.call_args
+        self.assertEqual(subject, 'Your login link for Superlists')
+        self.assertEqual(from_email, 'noreply@superlists')
+        self.assertEqual(to_list, ['edith@example.com'])
+        self.assertEqual(to_list, ['schmedith@example.com'])
+
+    @patch('accounts.views.send_mail')
+    def test_sends_mail_to_address_from_post(self, mock_send_mail):
+        self.client.post('/accounts/send_login_email', data={
+        'email': 'edith@example.com'
+        })
+        self.assertEqual(mock_send_mail.called, True)
+        (subject, body, from_email, to_list), kwargs = mock_send_mail.call_args
+        self.assertEqual(subject, 'Your login link for Superlists')
+        self.assertEqual(from_email, 'noreply@superlists')
+        self.assertEqual(to_list, ['edith@example.com'])
+
+    def test_adds_success_message(self):
+        response = self.client.post('/accounts/send_login_email', data={
+        'email': 'edith@example.com'
+        }, follow=True)
+        message = list(response.context['messages'])[0]
+        self.assertEqual(
+        message.message,
+        "Check your email, we've sent you a link you can use to log in."
+        )
+        self.assertEqual(message.tags, "success")
+
+    def test_creates_token_associated_with_email(self):
+        self.client.post('/accounts/send_login_email', data={
+        'email': 'edith@example.com'
+        })
+        token = Token.objects.first()
+        self.assertEqual(token.email, 'edith@example.com')
+
+    @patch('accounts.views.send_mail')
+    def test_sends_link_to_login_using_token_uid(self, mock_send_mail):
+        self.client.post('/accounts/send_login_email', data={
+        'email': 'edith@example.com'
+        })
+        token = Token.objects.first()
+        expected_url = f'http://testserver/accounts/login?token={token.uid}'
+        (subject, body, from_email, to_list), kwargs = mock_send_mail.call_args
+        self.assertIn(expected_url, body)
+
+    @patch('accounts.views.auth')
+    def test_calls_authenticate_with_uid_from_get_request(self, mock_auth):
+        self.client.get('/accounts/login?token=abcd123')
+        self.assertEqual(
+        mock_auth.authenticate.call_args,
+        call(uid='abcd123')
+        )
+    @patch('accounts.views.auth')
+    def test_calls_auth_login_with_user_if_there_is_one(self, mock_auth):
+        response = self.client.get('/accounts/login?token=abcd123')
+        self.assertEqual(
+            mock_auth.login.call_args,
+            call(response.wsgi_request, mock_auth.authenticate.return_value)
+        )
+
+class LoginViewTest(TestCase):
+    def test_redirects_to_home_page(self):
+        response = self.client.get('/accounts/login?token=abcd123')
+        self.assertRedirects(response, '/')
+
+    def test_does_not_login_if_user_is_not_authenticated(self, mock_auth):
+        mock_auth.authenticate.return_value = None
+        self.client.get('/accounts/login?token=abcd123')
+        self.assertEqual(mock_auth.login.called, False)

accounts/tests/tests_models.py

 from django.test import TestCase
 from django.contrib.auth import get_user_model
 from accounts.models import Token
-
+from django.test import TestCase
+from django.contrib import auth
+from accounts.models import Token
+User = auth.get_user_model()
 User = get_user_model()
 
 class TokenModelTest(TestCase):
@@ -13,4 +16,10 @@ class TokenModelTest(TestCase):
 class UserModelTest(TestCase):
     def test_email_is_primary_key(self):
         user = User(email='a@b.com')
-        self.assertEqual(user.pk, 'a@b.com')
\ No newline at end of file
+        self.assertEqual(user.pk, 'a@b.com')
+
+    def test_no_problem_with_auth_login(self):
+        user = User.objects.create(email='edith@example.com')
+        user.backend = ''
+        request = self.client.request().wsgi_request
+        auth.login(request, user)

accounts/urls.py

 from django.conf.urls import url
 from accounts import views
+from django.contrib.auth.views import logout
 
 urlpatterns = [
-url(r'^send_email$', views.send_login_email, name='send_login_email'),
+url(r'^send_login_email$', views.send_login_email, name='send_login_email'),
 url(r'^login$', views.login, name='login'),
-url(r'^logout$', views.logout, name='logout'),
-]
\ No newline at end of file
+url(r'^logout$', logout, {'next_page': '/'}, name='logout'),
+]

accounts/views.py

 import uuid
 import sys
+from django.contrib import messages
+from django.contrib import auth, messages
 from accounts.models import Token
 from django.contrib.auth import authenticate
 from django.contrib.auth import login as auth_login
 from django.core.mail import send_mail
 from django.shortcuts import redirect, render
 from django.contrib.auth import login as auth_login, logout as auth_logout
+from django.core.mail import send_mail
+from django.shortcuts import redirect
+
+# def send_login_email(request):
+#     email = request.POST['email']
+#     uid = str(uuid.uuid4())
+#     Token.objects.create(email=email, uid=uid)
+#     print('saving uid', uid, 'for email', email, file=sys.stderr)
+#     url = request.build_absolute_uri(f'/accounts/login?uid={uid}')
+#     send_mail(
+#     'Your login link for Superlists',
+#     f'Use this link to log in:\n\n{url}',
+#     'noreply@superlists',
+#     [email],
+#     )
+#     return render(request, 'login_email_sent.html')
 
 def send_login_email(request):
     email = request.POST['email']
-    uid = str(uuid.uuid4())
-    Token.objects.create(email=email, uid=uid)
-    print('saving uid', uid, 'for email', email, file=sys.stderr)
-    url = request.build_absolute_uri(f'/accounts/login?uid={uid}')
+    token = Token.objects.create(email=email)
+    url = request.build_absolute_uri(
+        reverse('login') + '?token=' + str(token.uid)
+    )
+    message_body = f'Use this link to log in:\n\n{url}'
     send_mail(
-    'Your login link for Superlists',
-    f'Use this link to log in:\n\n{url}',
-    'noreply@superlists',
-    [email],
+        'Your login link for Superlists',
+        message_body,
+        'noreply@superlists',
+        [email]
     )
-    return render(request, 'login_email_sent.html')
+    messages.success( request,
+    "Check your email, we've sent you a link you can use to log in."
+    )
+    return redirect('/')
 
 def login(request):
-    print('login view', file=sys.stderr)
-    uid = request.GET.get('uid')
-    user = authenticate(uid=uid)
-    if user is not None:
-        auth_login(request, user)
+    user = auth.authenticate(uid=request.GET.get('token'))
+    if user:
+        auth.login(request, user)
     return redirect('/')
 
 def logout(request):
     auth_logout(request)
-    return redirect('/')
\ No newline at end of file
+    return redirect('/')

lists/templates/base.html

 <html>
+
 <head>
-<meta charset="utf-8">
-<meta http-equiv="X-UA-Compatible" content="IE=edge">
-<meta name="viewport" content="width=device-width, initial-scale=1">
-<title>To-Do</title>
-<link href="/static/bootstrap/css/bootstrap.min.css" rel="stylesheet">
-<link href="/static/base.css" rel="stylesheet">
+    <meta charset="utf-8">
+    <meta http-equiv="X-UA-Compatible" content="IE=edge">
+    <meta name="viewport" content="width=device-width, initial-scale=1">
+    <title>To-Do</title>
+    <link href="/static/bootstrap/css/bootstrap.min.css" rel="stylesheet">
+    <link href="/static/base.css" rel="stylesheet">
 </head>
+
 <body>
-        <div class="navbar">
-                {% if user.is_authenticated %}
-                <p>Logged in as {{ user.email}}</p>
-                <p><a id="id_logout" href="{% url 'logout' %}">Log out</a></p>
-                {% else %}
-                <form method="POST" action ="{% url 'send_login_email' %}">
-                Enter email to log in: <input name="email" type="text" />
-                {% csrf_token %}
-                </form>
-                {% endif %}
+    <nav class="navbar navbar-default" role="navigation">
+        <div class="container-fluid">
+            <a class="navbar-brand" href="/">Superlists</a> {% if user.email %}
+            <ul class="nav navbar-nav navbar-right">
+                <li class="navbar-text">Logged in as {{ user.email }}</li>
+                <li><a href="{% url 'logout' %}">Log out</a></li>
+            </ul>
+            {% else %}
+            <form class="navbar-form navbar-right" method="POST" action="{% url 'send_login_email' %}">
+                <span>Enter email to log in:</span>
+                <input class="form-control" name="email" type="text" /> {% csrf_token %}
+            </form>
+            {% endif %}
         </div>
+    </nav>
 
-        <div class="container">
-            <div class="row">
-                <div class="col-md-6 col-md-offset-3 jumbotron">
-                    <div class="text-center">
+    <div class="navbar">
+        {% if user.is_authenticated %}
+        <p>Logged in as {{ user.email}}</p>
+        <p><a id="id_logout" href="{% url 'logout' %}">Log out</a></p>
+        {% else %}
+        <form method="POST" action="{% url 'send_login_email' %}">
+            Enter email to log in:
+            <input name="email" type="text" /> {% csrf_token %}
+        </form>
+        {% endif %}
+    </div>
+
+    <div class="container">
+        <div class="row">
+            <div class="col-md-6 col-md-offset-3 jumbotron">
+                <div class="text-center">
                     <h1>{% block header_text %}{% endblock %}</h1>
-                        <form method="POST" action="{% block form_action %}{% endblock %}">
-                            <input name="item_text" id="id_new_item" class="form-control input-lg"
-                            placeholder="Enter a to-do item" />
-                            {% csrf_token %}
-                        </form>
-                    </div>
+                    <form method="POST" action="{% url 'send_login_email' %}">
+                        <input name="item_text" id="id_new_item" class="form-control input-lg" placeholder="Enter a to-do item" /> {% csrf_token %}
+                    </form>
                 </div>
             </div>
-                <div class="row">
-                    <div class="col-md-6 col-md-offset-3">
-                        {% block table %}
-                        {% endblock %}
-                    </div>
-                </div>
         </div>
+        <div class="row">
+            <div class="col-md-6 col-md-offset-3">
+                {% block table %} {% endblock %}
+            </div>
+        </div>
+    </div>
 </body>
-</html>
+
+</html>
\ No newline at end of file