update tests

src/surykatka/http.py

@@ -110,10 +110,10 @@ def calculateSpeedRange(total_seconds):
     if total_seconds == 0:
         # error cases
         return "BAD"
-    elif 0.5 < total_seconds:
-        return "MODERATE"
-    elif 0.2 < total_seconds:
+    elif total_seconds < 0.2:
         return "FAST"
+    elif total_seconds < 0.5:
+        return "MODERATE"
     else:
         return "SLOW"
 

tests/test_db.py

@@ -19,6 +19,42 @@
 
 import unittest
 from surykatka.db import LogDB
+from playhouse.migrate import migrate, SqliteMigrator
+from collections import namedtuple
+from playhouse.reflection import Introspector
+
+ValidationResult = namedtuple(
+    "ValidationResult",
+    ("valid", "table_exists", "add_fields", "remove_fields", "change_fields"),
+)
+
+
+def validate_schema(model):
+    db = model._meta.database
+    table = model._meta.table_name
+    if not db.table_exists(table):
+        return ValidationResult(False, False, None, None, None)
+
+    introspector = Introspector.from_database(db)
+    db_model = introspector.generate_models(table_names=[table])[table]
+
+    columns = set(model._meta.columns)
+    db_columns = set(db_model._meta.columns)
+
+    to_remove = [model._meta.columns[c] for c in columns - db_columns]
+    to_add = [db_model._meta.columns[c] for c in db_columns - columns]
+    to_change = []
+    intersect = columns & db_columns  # Take intersection and remove matches.
+    for column in intersect:
+        field = model._meta.columns[column]
+        db_field = db_model._meta.columns[column]
+        if (field.field_type != db_field.field_type) and (
+            not (field.field_type == "BIGINT")
+        ):
+            to_change.append((field, db_field))
+
+    is_valid = not any((to_remove, to_add, to_change))
+    return ValidationResult(is_valid, True, to_add, to_remove, to_change)
 
 
 class SurykatkaDBTestCase(unittest.TestCase):
@@ -28,7 +64,7 @@ class SurykatkaDBTestCase(unittest.TestCase):
     def test_createTable(self):
         assert self.db._db.pragma("user_version") == 0
         self.db.createTables()
-        assert self.db._db.pragma("user_version") == 2
+        assert self.db._db.pragma("user_version") == 3
 
     def test_downgrade(self):
         assert self.db._db.pragma("user_version") == 0
@@ -56,10 +92,47 @@ class SurykatkaDBTestCase(unittest.TestCase):
                     self.db.DnsChange,
                 ]
             )
+            migrate(
+                SqliteMigrator(self.db._db).drop_column(
+                    "HttpCodeChange", "total_seconds"
+                ),
+            )
             self.db._db.pragma("user_version", 1)
 
         self.db.createTables()
-        assert self.db._db.pragma("user_version") == 2
+        assert self.db._db.pragma("user_version") == 3
+        assert validate_schema(self.db.SslChange).valid, validate_schema(
+            self.db.SslChange
+        )
+
+    def test_migrationFromVersion2(self):
+        assert self.db._db.pragma("user_version") == 0
+        # Recreate version 2
+        with self.db._db.transaction():
+
+            self.db._db.create_tables(
+                [
+                    self.db.Status,
+                    self.db.ConfigurationChange,
+                    self.db.HttpCodeChange,
+                    self.db.NetworkChange,
+                    self.db.PlatformChange,
+                    self.db.DnsChange,
+                    self.db.SslChange,
+                ]
+            )
+            migrate(
+                SqliteMigrator(self.db._db).drop_column(
+                    "HttpCodeChange", "total_seconds"
+                ),
+            )
+            self.db._db.pragma("user_version", 2)
+
+        self.db.createTables()
+        assert self.db._db.pragma("user_version") == 3
+        assert validate_schema(self.db.HttpCodeChange).valid, validate_schema(
+            self.db.HttpCodeChange
+        )
 
 
 def suite():