Remove warnings

misago/admin/tests/test_admin_form_templatetags.py

@@ -1,6 +1,6 @@
+import pytest
 from django import forms
 from django.template import Context, Template, TemplateSyntaxError
-from django.test import TestCase
 
 from misago.admin.templatetags.misago_admin_form import (
     is_radio_select_field,
@@ -13,7 +13,7 @@ from misago.admin.templatetags.misago_admin_form import (
 from misago.admin.forms import YesNoSwitch
 
 
-class TestForm(forms.Form):
+class Form(forms.Form):
     text_field = forms.CharField(
         label="Hello!", max_length=255, help_text="I am a help text."
     )
@@ -34,174 +34,192 @@ class TestForm(forms.Form):
     yesno_field = YesNoSwitch(label="Switch")
 
 
+@pytest.fixture
+def form():
+    return Form()
+
+
 def render(template_str):
     base_template = "{%% load misago_admin_form %%} %s"
-    context = Context({"form": TestForm()})
+    context = Context({"form": Form()})
     template = Template(base_template % template_str)
     return template.render(context).strip()
 
 
-class FormRowTagTests(TestCase):
-    def test_row_with_field_input_is_rendered(self):
-        html = render("{% form_row form.text_field %}")
-        self.assertIn("id_text_field", html)
+def test_row_with_field_input_is_rendered():
+    html = render("{% form_row form.text_field %}")
+    assert "id_text_field" in html
+
+
+def test_row_with_field_input_and_label_css_class_is_rendered():
+    html = render('{% form_row form.text_field label_class="col-md-3" %}')
+    assert "id_text_field" in html
+    assert "col-md-3" in html
+
+
+def test_row_with_field_input_and_field_css_class_is_rendered():
+    html = render('{% form_row form.text_field field_class="col-md-9" %}')
+    assert "id_text_field" in html
+    assert "col-md-9" in html
+
+
+def test_row_with_field_input_and_label_andfield_css_classes_is_rendered():
+    html = render('{% form_row form.text_field "col-md-3" "col-md-9" %}')
+    assert "id_text_field" in html
+    assert "col-md-3" in html
+    assert "col-md-9" in html
+
+
+def test_tag_without_field_raises_exception():
+    with pytest.raises(TemplateSyntaxError):
+        render("{% form_row %}")
+
+
+def test_field_label_is_rendered():
+    html = render("{% form_row form.text_field %}")
+    assert "Hello!" in html
+
+
+def test_field_help_text_is_rendered():
+    html = render("{% form_row form.text_field %}")
+    assert "I am a help text." in html
+
+
+def test_for_field_with_radio_select_widget_filter_returns_true(form):
+    assert is_radio_select_field(form["yesno_field"])
+
+
+def test_for_field_without_radio_select_widget_filter_returns_false(form):
+    assert not is_radio_select_field(form["text_field"])
+
+
+def test_for_field_with_select_widget_filter_returns_true(form):
+    assert is_select_field(form["select_field"])
+
+
+def teste_for_field_without_select_widget_filter_returns_false(form):
+    assert not is_select_field(form["text_field"])
+
+
+def test_for_field_with_checkbox_select_widget_filter_returns_true(form):
+    assert is_multiple_choice_field(form["checkbox_select_field"])
+
+
+def test_for_field_without_checkbox_select_widget_filter_returns_false(form):
+    assert not is_multiple_choice_field(form["text_field"])
+
+
+def test_for_field_with_multiple_select_widget_filter_returns_true(form):
+    assert is_multiple_choice_field(form["multiple_select_field"])
+
+
+def test_for_field_without_multiple_select_widget_filter_returns_false(form):
+    assert not is_multiple_choice_field(form["text_field"])
+
+
+def test_for_field_with_textarea_widget_filter_returns_true(form):
+    assert is_textarea_field(form["textarea_field"])
 
-    def test_row_with_field_input_and_label_css_class_is_rendered(self):
-        html = render('{% form_row form.text_field label_class="col-md-3" %}')
-        self.assertIn("id_text_field", html)
-        self.assertIn("col-md-3", html)
 
-    def test_row_with_field_input_and_field_css_class_is_rendered(self):
-        html = render('{% form_row form.text_field field_class="col-md-9" %}')
-        self.assertIn("id_text_field", html)
-        self.assertIn("col-md-9", html)
+def test_for_field_without_textarea_widget_filter_returns_false(form):
+    assert not is_textarea_field(form["text_field"])
 
-    def test_row_with_field_input_and_label_andfield_css_classes_is_rendered(self):
-        html = render('{% form_row form.text_field "col-md-3" "col-md-9" %}')
-        self.assertIn("id_text_field", html)
-        self.assertIn("col-md-3", html)
-        self.assertIn("col-md-9", html)
 
-    def test_tag_without_field_raises_exception(self):
-        with self.assertRaises(TemplateSyntaxError):
-            render("{% form_row %}")
+def test_specified_class_name_is_rendered():
+    result = render_attrs({"attrs": {}}, class_name="form-control")
+    assert result == 'class="form-control"'
 
-    def test_field_label_is_rendered(self):
-        html = render("{% form_row form.text_field %}")
-        self.assertIn("Hello!", html)
 
-    def test_field_help_text_is_rendered(self):
-        html = render("{% form_row form.text_field %}")
-        self.assertIn("I am a help text.", html)
+def test_specified_class_name_overrided_by_class_attr():
+    result = render_attrs({"attrs": {"class": "custom"}}, class_name="form-control")
+    assert result == 'class="custom"'
 
 
-class IsRadioSelectFieldFilterTests(TestCase):
-    def test_for_field_with_radio_select_widget_filter_returns_true(self):
-        form = TestForm()
-        self.assertTrue(is_radio_select_field(form["yesno_field"]))
+def test_attr_with_string_value_is_rendered():
+    result = render_attrs({"attrs": {"name": "lorem"}})
+    assert result == 'name="lorem"'
 
-    def test_for_field_without_radio_select_widget_filter_returns_false(self):
-        form = TestForm()
-        self.assertFalse(is_radio_select_field(form["text_field"]))
 
+def test_attr_with_int_value_is_rendered():
+    result = render_attrs({"attrs": {"cols": 5}})
+    assert result == 'cols="5"'
 
-class IsSelectFieldFilerTests(TestCase):
-    def test_for_field_with_select_widget_filter_returns_true(self):
-        form = TestForm()
-        self.assertTrue(is_select_field(form["select_field"]))
 
-    def teste_for_field_without_select_widget_filter_returns_false(self):
-        form = TestForm()
-        self.assertFalse(is_select_field(form["text_field"]))
+def test_attr_with_boolean_true_value_is_not_rendered():
+    result = render_attrs({"attrs": {"selected": True}})
+    assert result == ""
 
 
-class IsMultipleChoiceFieldFilerTests(TestCase):
-    def test_for_field_with_checkbox_select_widget_filter_returns_true(self):
-        form = TestForm()
-        self.assertTrue(is_multiple_choice_field(form["checkbox_select_field"]))
+def test_attr_with_boolean_false_value_is_not_rendered():
+    result = render_attrs({"attrs": {"selected": False}})
+    assert result == ""
 
-    def test_for_field_without_checkbox_select_widget_filter_returns_false(self):
-        form = TestForm()
-        self.assertFalse(is_multiple_choice_field(form["text_field"]))
 
-    def test_for_field_with_multiple_select_widget_filter_returns_true(self):
-        form = TestForm()
-        self.assertTrue(is_multiple_choice_field(form["multiple_select_field"]))
+def test_attr_with_none_value_is_not_rendered():
+    result = render_attrs({"attrs": {"selected": None}})
+    assert result == ""
 
-    def test_for_field_without_multiple_select_widget_filter_returns_false(self):
-        form = TestForm()
-        self.assertFalse(is_multiple_choice_field(form["text_field"]))
 
+def test_attr_name_is_escaped():
+    result = render_attrs({"attrs": {'"': "test"}})
+    assert result == '"="test"'
 
-class IsTextareaFieldFilterTests(TestCase):
-    def test_for_field_with_textarea_widget_filter_returns_true(self):
-        form = TestForm()
-        self.assertTrue(is_textarea_field(form["textarea_field"]))
 
-    def test_for_field_without_textarea_widget_filter_returns_false(self):
-        form = TestForm()
-        self.assertFalse(is_textarea_field(form["text_field"]))
+def test_attr_value_is_escaped():
+    result = render_attrs({"attrs": {"name": '"'}})
+    assert result == 'name="""'
 
 
-class RenderAttrsTagTests(TestCase):
-    def test_specified_class_name_is_rendered(self):
-        result = render_attrs({"attrs": {}}, class_name="form-control")
-        self.assertEqual(result, 'class="form-control"')
+def test_multiple_valid_attrs_are_rendered():
+    result = render_attrs({"attrs": {"name": "lorem", "cols": 5}})
+    assert result == 'name="lorem" cols="5"'
 
-    def test_specified_class_name_overrided_by_class_attr(self):
-        result = render_attrs({"attrs": {"class": "custom"}}, class_name="form-control")
-        self.assertEqual(result, 'class="custom"')
 
-    def test_attr_with_string_value_is_rendered(self):
-        result = render_attrs({"attrs": {"name": "lorem"}})
-        self.assertEqual(result, 'name="lorem"')
+def test_empty_attr_dict_is_not_rendered():
+    result = render_attrs({"attrs": {}})
+    assert result == ""
 
-    def test_attr_with_int_value_is_rendered(self):
-        result = render_attrs({"attrs": {"cols": 5}})
-        self.assertEqual(result, 'cols="5"')
 
-    def test_attr_with_boolean_true_value_is_not_rendered(self):
-        result = render_attrs({"attrs": {"selected": True}})
-        self.assertEqual(result, "")
+def test_attr_with_boolean_true_value_is_rendered():
+    result = render_bool_attrs({"bool": True})
+    assert result == "bool"
 
-    def test_attr_with_boolean_false_value_is_not_rendered(self):
-        result = render_attrs({"attrs": {"selected": False}})
-        self.assertEqual(result, "")
 
-    def test_attr_with_none_value_is_not_rendered(self):
-        result = render_attrs({"attrs": {"selected": None}})
-        self.assertEqual(result, "")
+def test_attr_with_string_value_is_not_rendered():
+    result = render_bool_attrs({"name": "hello"})
+    assert result == ""
 
-    def test_attr_name_is_escaped(self):
-        result = render_attrs({"attrs": {'"': "test"}})
-        self.assertEqual(result, '"="test"')
 
-    def test_attr_value_is_escaped(self):
-        result = render_attrs({"attrs": {"name": '"'}})
-        self.assertEqual(result, 'name="""')
+def test_attr_with_int_value_is_not_rendered():
+    result = render_bool_attrs({"col": 13})
+    assert result == ""
 
-    def test_multiple_valid_attrs_are_rendered(self):
-        result = render_attrs({"attrs": {"name": "lorem", "cols": 5}})
-        self.assertEqual(result, 'name="lorem" cols="5"')
 
-    def test_empty_attr_dict_is_not_rendered(self):
-        result = render_attrs({"attrs": {}})
-        self.assertEqual(result, "")
+def test_attr_with_boolean_false_value_is_not_rendered():
+    result = render_bool_attrs({"selected": False})
+    assert result == ""
 
 
-class RenderBoolAttrsTagTests(TestCase):
-    def test_attr_with_boolean_true_value_is_rendered(self):
-        result = render_bool_attrs({"bool": True})
-        self.assertEqual(result, "bool")
+def test_attr_with_none_value_is_not_rendered():
+    result = render_bool_attrs({"selected": None})
+    assert result == ""
 
-    def test_attr_with_string_value_is_not_rendered(self):
-        result = render_bool_attrs({"name": "hello"})
-        self.assertEqual(result, "")
 
-    def test_attr_with_int_value_is_not_rendered(self):
-        result = render_bool_attrs({"col": 13})
-        self.assertEqual(result, "")
+def test_attr_with_false_int_value_is_not_rendered():
+    result = render_bool_attrs({"selected": 0})
+    assert result == ""
 
-    def test_attr_with_boolean_false_value_is_not_rendered(self):
-        result = render_bool_attrs({"selected": False})
-        self.assertEqual(result, "")
 
-    def test_attr_with_none_value_is_not_rendered(self):
-        result = render_bool_attrs({"selected": None})
-        self.assertEqual(result, "")
+def test_multiple_attrs_with_boolean_true_value_are_rendered():
+    result = render_bool_attrs({"selected": True, "required": True})
+    assert result == "selected required"
 
-    def test_attr_with_false_int_value_is_not_rendered(self):
-        result = render_bool_attrs({"selected": 0})
-        self.assertEqual(result, "")
 
-    def test_multiple_attrs_with_boolean_true_value_are_rendered(self):
-        result = render_bool_attrs({"selected": True, "required": True})
-        self.assertEqual(result, "selected required")
+def test_only_attrs_with_boolean_true_value_are_rendered():
+    result = render_bool_attrs({"bool": True, "string": "hello", "int": 123})
+    assert result == "bool"
 
-    def test_only_attrs_with_boolean_true_value_are_rendered(self):
-        result = render_bool_attrs({"bool": True, "string": "hello", "int": 123})
-        self.assertEqual(result, "bool")
 
-    def test_empty_attr_dict_is_not_rendered(self):
-        result = render_bool_attrs({})
-        self.assertEqual(result, "")
+def test_empty_attr_dict_is_not_rendered():
+    result = render_bool_attrs({})
+    assert result == ""

misago/core/tests/test_serializers.py

@@ -8,6 +8,28 @@ from misago.threads import testutils
 from misago.threads.models import Thread
 
 
+class Serializer(serializers.ModelSerializer, MutableFields):
+    url = serializers.SerializerMethodField()
+
+    class Meta:
+        model = Thread
+        fields = [
+            "id",
+            "title",
+            "replies",
+            "has_unapproved_posts",
+            "started_on",
+            "last_post_on",
+            "last_post_is_event",
+            "last_post",
+            "last_poster_name",
+            "is_unapproved",
+            "is_hidden",
+            "is_closed",
+            "weight",
+        ]
+
+
 class MutableFieldsSerializerTests(TestCase):
     def test_subset_fields(self):
         """classmethod subset_fields creates new serializer"""
@@ -16,9 +38,9 @@ class MutableFieldsSerializerTests(TestCase):
 
         fields = ["id", "title", "replies", "last_poster_name"]
 
-        serializer = TestSerializer.subset_fields(*fields)
+        serializer = Serializer.subset_fields(*fields)
         self.assertEqual(
-            serializer.__name__, "TestSerializerIdTitleRepliesLastPosterNameSubset"
+            serializer.__name__, "SerializerIdTitleRepliesLastPosterNameSubset"
         )
         self.assertEqual(serializer.Meta.fields, fields)
 
@@ -33,7 +55,7 @@ class MutableFieldsSerializerTests(TestCase):
             },
         )
 
-        self.assertFalse(TestSerializer.Meta.fields == serializer.Meta.fields)
+        self.assertFalse(Serializer.Meta.fields == serializer.Meta.fields)
 
     def test_exclude_fields(self):
         """classmethod exclude_fields creates new serializer"""
@@ -41,10 +63,10 @@ class MutableFieldsSerializerTests(TestCase):
         thread = testutils.post_thread(category=category)
 
         kept_fields = ["id", "title", "weight"]
-        removed_fields = list(set(TestSerializer.Meta.fields) - set(kept_fields))
+        removed_fields = list(set(Serializer.Meta.fields) - set(kept_fields))
 
-        serializer = TestSerializer.exclude_fields(*removed_fields)
-        self.assertEqual(serializer.__name__, "TestSerializerIdTitleWeightSubset")
+        serializer = Serializer.exclude_fields(*removed_fields)
+        self.assertEqual(serializer.__name__, "SerializerIdTitleWeightSubset")
         self.assertEqual(serializer.Meta.fields, kept_fields)
 
         serialized_thread = serializer(thread).data
@@ -53,36 +75,14 @@ class MutableFieldsSerializerTests(TestCase):
             {"id": thread.id, "title": thread.title, "weight": thread.weight},
         )
 
-        self.assertFalse(TestSerializer.Meta.fields == serializer.Meta.fields)
+        self.assertFalse(Serializer.Meta.fields == serializer.Meta.fields)
 
     def test_extend_fields(self):
         """classmethod extend_fields creates new serializer"""
         category = Category.objects.get(slug="first-category")
         thread = testutils.post_thread(category=category)
 
-        serializer = TestSerializer.extend_fields("category")
+        serializer = Serializer.extend_fields("category")
 
         serialized_thread = serializer(thread).data
         self.assertEqual(serialized_thread["category"], category.pk)
-
-
-class TestSerializer(serializers.ModelSerializer, MutableFields):
-    url = serializers.SerializerMethodField()
-
-    class Meta:
-        model = Thread
-        fields = [
-            "id",
-            "title",
-            "replies",
-            "has_unapproved_posts",
-            "started_on",
-            "last_post_on",
-            "last_post_is_event",
-            "last_post",
-            "last_poster_name",
-            "is_unapproved",
-            "is_hidden",
-            "is_closed",
-            "weight",
-        ]

misago/threads/tests/test_thread_postlikes_api.py

@@ -23,7 +23,7 @@ class ThreadPostLikesApiTestCase(ThreadsApiTestCase):
         """api errors if user has no permission to see likes"""
         response = self.client.get(self.api_link)
         self.assertEqual(response.status_code, 403)
-        self.assertEquals(
+        self.assertEqual(
             response.json(), {"detail": "You can't see who liked this post."}
         )
 
@@ -32,7 +32,7 @@ class ThreadPostLikesApiTestCase(ThreadsApiTestCase):
         """api errors if user has no permission to see likes, but can see likes count"""
         response = self.client.get(self.api_link)
         self.assertEqual(response.status_code, 403)
-        self.assertEquals(
+        self.assertEqual(
             response.json(), {"detail": "You can't see who liked this post."}
         )