Split tests into files

Add scripts to restart dataabase and to run tests with coverage
Add coverage configuraton
Add models tests

KawowyDzienniczek/.coveragerc

+# .coveragerc to control coverage.py
+[run]
+branch = True
+omit =
+    */test*
+    */apps*
+    */migrations/*
+    *__init__.py*
+    */settings/*
+    *wsgi.py*
+    *admin.py*
+    *manage.py*
+
+[report]
+# Regexes for lines to exclude from consideration
+exclude_lines =
+    # Have to re-enable the standard pragma
+    pragma: no cover
+
+    # Don't complain about missing debug-only code:
+    def __repr__
+    if self\.debug
+
+    # Don't complain if tests don't hit defensive assertion code:
+    raise AssertionError
+    raise NotImplementedError
+
+    # Don't complain if non-runnable code isn't run:
+    if 0:
+    if __name__ == .__main__.:
+ignore_errors = True

KawowyDzienniczek/App/loyaltyMe/admin.py

 # Register your models here.
+from django.contrib import admin
+
+from App.loyaltyMe.models import Task
+
+admin.site.register(Task)
\ No newline at end of file

KawowyDzienniczek/App/loyaltyMe/management/commands/init_tasks.py

 import datetime
 
 from django.core.management.base import BaseCommand
-from django.forms import DateField
 
 from App.loyaltyMe.models import Task
 
@@ -13,11 +12,11 @@ class Command(BaseCommand):
         tasks = [
             # 'name',products
             ['Bądź u nas 10 godzin', datetime.datetime.now(), 'description', 'TM', datetime.timedelta(seconds=15),
-             datetime.timedelta(seconds=15), datetime.timedelta(seconds=15), datetime.timedelta(seconds=15)],
+             15, 15, datetime.timedelta(seconds=15)],
             ['Przyjdz 10 razy', datetime.datetime.now(), 'description', 'PR', datetime.timedelta(seconds=15),
-             datetime.timedelta(seconds=15), datetime.timedelta(seconds=15), datetime.timedelta(seconds=15)],
+             15, 15, datetime.timedelta(seconds=15)],
         ]
-        print("Creating Offers")
+        print("Creating Tasks")
         for task in tasks:
             print('Create {0}'.format(task[0]))
 

KawowyDzienniczek/App/loyaltyMe/models.py

@@ -25,13 +25,13 @@ class Task(models.Model):
     )
 
     type = models.CharField(max_length=2, choices=TYPE_CHOICES, default=PRESENCE)
-    update_delay = models.DateField()
+    update_delay = models.DurationField()  # raz na dzień? Tego nie widzi usera
     description = models.CharField(max_length=50)
     name = models.CharField(max_length=50)
-    counter_target = models.DurationField()
-    beacon_counter_target = models.DurationField()
-    counter_incrementation = models.DurationField()
-    beacon_signal_delay = models.DurationField()
+    counter_target = models.IntegerField() #badz 10 razy #badz przez m # To widzi  user #cel koncowy
+    counter_incrementation = models.IntegerField() # o  1   # Tego nie widzi user
+    beacon_counter_target = models.IntegerField() # 3x # 1x # tego nie widiz user
+    beacon_signal_delay = models.DurationField() # przez 5minut # co 5 minut #tego nie widzi user
 
 
 

KawowyDzienniczek/App/loyaltyMe/test_models.py

 # Create your tests here.
-import datetime
-from unittest import TestCase
+from datetime import datetime, timedelta
 
-from App.loyaltyMe.models import Task, UserTask
+from django.contrib.auth.models import User
+from django.test import TestCase
+
+from App.loyaltyMe.models import Task
+from App.user.models import UserTask
+
+
+class TaskTestCase(TestCase):
+    def setUp(self):
+        Task.objects.get_or_create(type="TM", update_delay=timedelta(seconds=10),
+                                   description="Test_description", name="test_name", counter_target=5,
+                                   beacon_counter_target=5, counter_incrementation=1,
+                                   beacon_signal_delay=timedelta(seconds=10))
 
 
 class UserTaskTestCase(TestCase):
     def setUp(self):
-        self.task = Task(beacon_signal_delay=10)
-        self.beacon_signal_last_update = datetime.datetime.now() - datetime.timedelta(seconds=15)
-        self.user_task = UserTask(task=self.task, beacon_signal_last_update=self.beacon_signal_last_update)
+        self.user = User.objects.get_or_create()[0]
+        self.task = Task.objects.get_or_create(type="TM", update_delay=timedelta(seconds=10),
+                                               description="Test_description", name="test_name", counter_target=1,
+                                               beacon_counter_target=2, counter_incrementation=1,
+                                               beacon_signal_delay=timedelta(seconds=15))[0]
+        beacon_signal_last_update = datetime.now() - timedelta(seconds=15)
+        self.user_task = UserTask.objects.get_or_create(task=self.task, user=self.user, done=False,
+                                                        last_update=datetime.now(),
+                                                        counter=0, beacon_counter=0,
+                                                        beacon_signal_last_update=beacon_signal_last_update)[0]
+
+    def set_data_beacon_singal_passed(self):
+        self.user_task.task.beacon_signal_delay = timedelta(seconds=15)
+        self.user_task.beacon_signal_last_update = datetime.now() - timedelta(seconds=15)
+
+    def set_data_task_signal_passed(self):
+        self.user_task.update_delay= timedelta(seconds=15)
+        self.user_task.last_update=datetime.now() - timedelta(seconds=20)
+
+
+    def test_delay_passed(self):
+        signal_last_update = datetime.now() - timedelta(seconds=16)
+        signal_delay = timedelta(seconds=15)
+        result = self.user_task.delay_passed(signal_last_update, signal_delay)
+        self.assertTrue(result)
+
+    def test_delay_passed_limit_value(self):
+        signal_last_update = timedelta(seconds=15)
+        signal_delay = datetime.now() - timedelta(seconds=15)
+        result = self.user_task.delay_passed(signal_last_update, signal_delay)
+        self.assertTrue(result)
+
+    def test_delay_not_passed(self):
+        signal_last_update = timedelta(seconds=15)
+        signal_delay = datetime.now() - timedelta(seconds=14)
+        result = self.user_task.delay_passed(signal_last_update, signal_delay)
+        self.assertFalse(result)
+
+    def test_ready_to_update_beacon_counter_increase(self):
+        self.set_data_beacon_singal_passed()
+        self.user_task.beacon_counter = 0
+        result = self.user_task.ready_to_update()
+        self.assertEqual(self.user_task.beacon_counter, 1)
+        self.assertFalse(result)
+
+    def test_ready_to_update_beacon_counter_not_increase(self):
+        self.user_task.task.beacon_signal_delay = timedelta(seconds=15)
+        self.user_task.beacon_signal_last_update = datetime.now() - timedelta(seconds=14)
+        self.user_task.beacon_counter = 0
+        self.user_task.task.beacon_counter_target = 2
+        result = self.user_task.ready_to_update()
+        self.assertEqual(self.user_task.beacon_counter, 0)
+        self.assertFalse(result)
+
+    def test_ready_to_update_beacon_counter_reset(self):
+        self.set_data_beacon_singal_passed()
+        self.user_task.beacon_counter = 0
+        self.user_task.task.beacon_counter_target = 1
+        result = self.user_task.ready_to_update()
+        self.assertEqual(self.user_task.beacon_counter, 0)
+        self.assertTrue(result)
+
+    def test_update_counter_increase(self):
+        self.set_data_task_signal_passed()
+        self.set_data_beacon_singal_passed()
+        self.user_task.beacon_counter = 0
+        self.user_task.task.beacon_counter_target = 1
+        self.user_task.counter = 0
+        self.user_task.task.counter_target = 2
+        result = self.user_task.update()
+        self.assertEqual(self.user_task.counter, 1)
+        self.assertFalse(result)
+
+    def test_update_counter_not_increase(self):
+        self.set_data_beacon_singal_passed()
+
+        self.user_task.update_delay= timedelta(seconds=15)
+        self.user_task.last_update= datetime.now()
+
+        self.user_task.beacon_counter = 0
+        self.user_task.task.beacon_counter_target = 1
+        self.user_task.counter = 0
+        self.user_task.task.counter_target = 2
+
+        result = self.user_task.update()
+        self.assertEqual(self.user_task.counter, 0)
+        self.assertFalse(result)
+
+    def test_update_task_done(self):
+        self.set_data_task_signal_passed()
+        self.set_data_beacon_singal_passed()
+        self.user_task.beacon_counter = 0
+        self.user_task.task.beacon_counter_target = 1
+
+        self.user_task.counter = 0
+        self.user_task.task.counter_target = 1
 
-    def test_lol(self):
-        self.user_task.update()
+        result = self.user_task.update()
+        self.assertTrue(self.user_task.done)
+        self.assertTrue(result)

KawowyDzienniczek/App/user/models.py

-from django.db import models
+from datetime import timedelta, datetime
+
 from django.contrib.auth.models import User
+from django.db import models
 from django.db.models.signals import post_save
 from django.dispatch import receiver
-from django.utils import timezone
 from rest_framework.authtoken.models import Token
-from datetime import timedelta
-
+from django.test import TestCase
 # Create your models here.
 from App.loyaltyMe.models import Place, Promotion, Task
 
@@ -38,28 +38,38 @@ class UserTask(models.Model):
                              blank=False, null=False, default=None)
     done = models.BooleanField(default=False)
     last_update = models.DateField()
-    counter = models.DurationField()
-    beacon_counter = models.DurationField()
-    beacon_signal_last_update = models.DateField()
+    counter = models.IntegerField()  #akutalnie bylem 3 razy # aktualny status uzytkwonika w zadaniu
+    beacon_counter = models.IntegerField()  #  juz 10 minut, jeszcze raz i bedzie hyvka # status czy zaliczyc z beaconow taska
+    beacon_signal_last_update = models.DateField()  #ostatnio 23 h temu # last update
 
     def update(self):
-        if not self.beacon_delay_passed():
-            return
+        if not self.ready_to_update():
+            return False
         if self.done:
-            return
+            return False
+        if self.task_delay_passed():
+            self.counter += self.task.counter_incrementation
         if self.counter == self.task.counter_target:
             self.done = True
-            return
-        actual_time = timezone.now()
-        if actual_time + self.task.update_delay > self.last_update:
-            self.counter += self.task.counter_incrementation
+            return True
+        return False
 
-    def beacon_delay_passed(self):
-        actual_time = timezone.now()
-        if actual_time + timedelta(seconds = self.task.beacon_signal_delay) > self.beacon_signal_last_update:
+    def ready_to_update(self):
+        if self.beacon_delay_passed():
             self.beacon_counter = +1
-            self.beacon_signal_last_update = actual_time
+            self.beacon_signal_last_update = datetime.now()
         if self.beacon_counter == self.task.beacon_counter_target:
             self.beacon_counter = 0
             return True
         return False
+
+    def beacon_delay_passed(self):
+        return self.delay_passed(self.beacon_signal_last_update, self.task.beacon_signal_delay)
+
+    def task_delay_passed(self):
+        return self.delay_passed(self.last_update, self.task.update_delay)
+
+    def delay_passed(self, last_update, signal_delay):
+        actual_time = datetime.now()
+        time_difference = actual_time - last_update
+        return time_difference > signal_delay
\ No newline at end of file

KawowyDzienniczek/scripts/database_restart.sh

+sudo su postgres
+dropdb kawowydzienniczek
+createdb kawowydzienniczek -e utf8
+psql
+CREATE USER kawowydzienniczek;
+ALTER USER kawowydzienniczek PASSWORD 'kawowydzienniczek7913';
+ALTER DATABASE kawowydzienniczek OWNER TO kawowydzienniczek;
\ No newline at end of file

KawowyDzienniczek/scripts/test.sh

+coverage erase
+coverage run --source='.' manage.py test
+coverage report -m | tail -n 2
\ No newline at end of file

requirements.txt

@@ -9,3 +9,4 @@ pycodestyle==2.0.0
 pyflakes==1.2.3
 psycopg2
 drfdocs
+coverage