aa-bulletin-board 1.10.0__py3-none-any.whl → 1.11.0__py3-none-any.whl

aa_bulletin_board/tests/test_bulletins.py

@@ -25,22 +25,26 @@ class TestGetSentinelUser(TestCase):
     Tests for the sentinel user
     """
 
-    def test_should_create_user_when_it_does_not_exist(self):
+    def test_should_create_user_when_it_does_not_exist(self) -> None:
         """
-        Test should create sentinel user when it doesn't exist
+        Test should create a sentinel user when it doesn't exist
+
         :return:
+        :rtype:
         """
 
         # when
         user = get_sentinel_user()
 
         # then
-        self.assertEqual(user.username, "deleted")
+        self.assertEqual(first=user.username, second="deleted")
 
-    def test_should_return_user_when_it_does(self):
+    def test_should_return_user_when_it_does(self) -> None:
         """
         Test should return sentinel user when it exists
+
         :return:
+        :rtype:
         """
 
         # given
@@ -50,7 +54,7 @@ class TestGetSentinelUser(TestCase):
         user = get_sentinel_user()
 
         # then
-        self.assertEqual(user.username, "deleted")
+        self.assertEqual(first=user.username, second="deleted")
 
 
 class TestBulletins(TestCase):
@@ -62,32 +66,40 @@ class TestBulletins(TestCase):
     def setUpClass(cls) -> None:
         """
         Set up groups and users
+
+        :return:
+        :rtype:
         """
 
         super().setUpClass()
         cls.group = Group.objects.create(name="Superhero")
 
         # User cannot access bulletins
-        cls.user_1001 = create_fake_user(1001, "Peter Parker")
+        cls.user_1001 = create_fake_user(
+            character_id=1001, character_name="Peter Parker"
+        )
 
         # User can access bulletins
         cls.user_1002 = create_fake_user(
-            1002, "Bruce Wayne", permissions=["aa_bulletin_board.basic_access"]
+            character_id=1002,
+            character_name="Bruce Wayne",
+            permissions=["aa_bulletin_board.basic_access"],
         )
 
         # User can manage bulletins
         cls.user_1003 = create_fake_user(
-            1003,
-            "Clark Kent",
+            character_id=1003,
+            character_name="Clark Kent",
             permissions=[
                 "aa_bulletin_board.basic_access",
                 "aa_bulletin_board.manage_bulletins",
             ],
         )
 
-    def test_should_remove_bulletin(self):
+    def test_should_remove_bulletin(self) -> None:
         """
         Test if a bulletin should be removed
+
         :return:
         :rtype:
         """
@@ -100,22 +112,29 @@ class TestBulletins(TestCase):
             created_by=self.user_1001,
         )
 
-        self.client.force_login(self.user_1003)
+        self.client.force_login(user=self.user_1003)
 
         # when
         response = self.client.get(
-            reverse("aa_bulletin_board:remove_bulletin", args=[bulletin.slug])
+            path=reverse(
+                viewname="aa_bulletin_board:remove_bulletin", args=[bulletin.slug]
+            )
         )
-        messages = list(get_messages(response.wsgi_request))
+        messages = list(get_messages(request=response.wsgi_request))
 
         # then
-        self.assertRedirects(response, "/bulletin-board/")
-        self.assertEqual(len(messages), 1)
-        self.assertEqual(str(messages[0]), f'Bulletin "{bulletin_title}" deleted.')
+        self.assertRedirects(response=response, expected_url="/bulletin-board/")
+        self.assertEqual(first=len(messages), second=1)
+        self.assertEqual(
+            first=str(messages[0]), second=f'Bulletin "{bulletin_title}" deleted.'
+        )
 
-    def test_should_raise_does_not_exist_exception_when_delete_bulletin_not_found(self):
+    def test_should_raise_does_not_exist_exception_when_delete_bulletin_not_found(
+        self,
+    ) -> None:
         """
         Test if a bulletin that doesn't exist should be removed
+
         :return:
         :rtype:
         """
@@ -126,24 +145,60 @@ class TestBulletins(TestCase):
             content=f"<p>{fake.sentence()}</p>",
             created_by=self.user_1001,
         )
-        self.client.force_login(self.user_1003)
+        self.client.force_login(user=self.user_1003)
 
         # when
         response = self.client.get(
-            reverse("aa_bulletin_board:remove_bulletin", args=["foobarsson"])
+            path=reverse(
+                viewname="aa_bulletin_board:remove_bulletin", args=["foobarsson"]
+            )
         )
         messages = list(get_messages(response.wsgi_request))
 
-        self.assertRaises(bulletin.DoesNotExist)
-        self.assertEqual(len(messages), 1)
+        self.assertRaises(expected_exception=bulletin.DoesNotExist)
+        self.assertEqual(first=len(messages), second=1)
         self.assertEqual(
-            str(messages[0]),
-            "The bulletin you are trying to delete for does not exist.",
+            first=str(messages[0]),
+            second="The bulletin you are trying to delete does not exist.",
         )
 
-    def test_should_translate_russian_letters_in_slug(self):
+    def test_should_raise_does_not_exist_exception_when_edit_bulletin_not_found(
+        self,
+    ) -> None:
+        """
+        Test if a bulletin that doesn't exist should be edited
+
+        :return:
+        :rtype:
+        """
+
+        # given
+        bulletin = Bulletin.objects.create(
+            title=fake.sentence(),
+            content=f"<p>{fake.sentence()}</p>",
+            created_by=self.user_1001,
+        )
+        self.client.force_login(user=self.user_1003)
+
+        # when
+        response = self.client.get(
+            path=reverse(
+                viewname="aa_bulletin_board:edit_bulletin", args=["foobarsson"]
+            )
+        )
+        messages = list(get_messages(request=response.wsgi_request))
+
+        self.assertRaises(expected_exception=bulletin.DoesNotExist)
+        self.assertEqual(first=len(messages), second=1)
+        self.assertEqual(
+            first=str(messages[0]),
+            second="The bulletin you are trying to edit does not exist.",
+        )
+
+    def test_should_translate_russian_letters_in_slug(self) -> None:
         """
         Test that russian letters in a slug are translated
+
         :return:
         :rtype:
         """
@@ -154,12 +209,15 @@ class TestBulletins(TestCase):
             created_by=self.user_1001,
         )
 
-        self.assertEqual(bulletin.slug, "drifterke-rorki-v-dok")
+        self.assertEqual(first=bulletin.slug, second="drifterke-rorki-v-dok")
 
-    def test_should_return_cleaned_message_string_on_bulletin_creation(self):
+    def test_should_return_cleaned_message_string_on_bulletin_creation(self) -> None:
         """
-        Test should return a clean/sanitized message string when new bulletin is created
+        Test should return a clean/sanitized message string
+        when a new bulletin is created
+
         :return:
+        :rtype:
         """
 
         # given
@@ -168,18 +226,19 @@ class TestBulletins(TestCase):
             "'test')</script>and this is style test. <style>.MathJax, "
             ".MathJax_Message, .MathJax_Preview{display: none}</style>end tests."
         )
-        cleaned_message = string_cleanup(dirty_message)
+        cleaned_message = string_cleanup(string=dirty_message)
         bulletin = Bulletin.objects.create(
             title="Foobar",
             content=dirty_message,
             created_by=self.user_1001,
         )
 
-        self.assertEqual(bulletin.content, cleaned_message)
+        self.assertEqual(first=bulletin.content, second=cleaned_message)
 
-    def test_bulletin_slug_creation(self):
+    def test_bulletin_slug_creation(self) -> None:
         """
         Test slug creation
+
         :return:
         :rtype:
         """
@@ -202,13 +261,14 @@ class TestBulletins(TestCase):
             created_by=self.user_1001,
         )
 
-        self.assertEqual(bulletin.slug, "this-is-a-bulletin")
-        self.assertEqual(bulletin_2.slug, "this-is-a-bulletin-1")
-        self.assertEqual(bulletin_3.slug, "this-is-a-bulletin-2")
+        self.assertEqual(first=bulletin.slug, second="this-is-a-bulletin")
+        self.assertEqual(first=bulletin_2.slug, second="this-is-a-bulletin-1")
+        self.assertEqual(first=bulletin_3.slug, second="this-is-a-bulletin-2")
 
-    def test_should_return_bulletin_title_as_model_object_string_name(self):
+    def test_should_return_bulletin_title_as_model_object_string_name(self) -> None:
         """
-        Test should return the objects string name
+        Test should return the object's string name
+
         :return:
         :rtype:
         """
@@ -219,11 +279,12 @@ class TestBulletins(TestCase):
             created_by=self.user_1001,
         )
 
-        self.assertEqual(str(bulletin), "This is a bulletin")
+        self.assertEqual(first=str(bulletin), second="This is a bulletin")
 
-    def test_form_clean_content_method(self):
+    def test_form_clean_content_method(self) -> None:
         """
         Test the clean_ method of the form
+
         :return:
         :rtype:
         """
@@ -233,10 +294,10 @@ class TestBulletins(TestCase):
             "'test')</script>and this is style test. <style>.MathJax, "
             ".MathJax_Message, .MathJax_Preview{display: none}</style>end tests."
         )
-        cleaned_message = string_cleanup(dirty_message)
+        cleaned_message = string_cleanup(string=dirty_message)
         data = {"title": "This is a title", "content": dirty_message}
 
-        form = BulletinForm(data)
+        form = BulletinForm(data=data)
 
-        self.assertTrue(form.is_valid())
-        self.assertEqual(form.cleaned_data["content"], cleaned_message)
+        self.assertTrue(expr=form.is_valid())
+        self.assertEqual(first=form.cleaned_data["content"], second=cleaned_message)

aa_bulletin_board/tests/test_templatetags.py

@@ -15,22 +15,25 @@ class TestVersionedStatic(TestCase):
     Test aa_bulletin_board_versioned_static template tag
     """
 
-    def test_versioned_static(self):
+    def test_versioned_static(self) -> None:
         """
         Test versioned static template tag
+
         :return:
         :rtype:
         """
 
         context = Context({"version": __version__})
         template_to_render = Template(
-            "{% load aa_bulletin_board_versioned_static %}"
-            "{% aa_bulletin_board_static 'aa_bulletin_board/css/aa-bulletin-board.min.css' %}"
+            template_string=(
+                "{% load aa_bulletin_board_versioned_static %}"
+                "{% aa_bulletin_board_static 'aa_bulletin_board/css/aa-bulletin-board.min.css' %}"  # pylint: disable=line-too-long
+            )
         )
 
-        rendered_template = template_to_render.render(context)
+        rendered_template = template_to_render.render(context=context)
 
         self.assertInHTML(
-            f'/static/aa_bulletin_board/css/aa-bulletin-board.min.css?v={context["version"]}',
-            rendered_template,
+            needle=f'/static/aa_bulletin_board/css/aa-bulletin-board.min.css?v={context["version"]}',  # pylint: disable=line-too-long
+            haystack=rendered_template,
         )

aa_bulletin_board/tests/test_user_interface.py

@@ -24,35 +24,43 @@ class TestBulletinUI(WebTest):
     """
 
     @classmethod
-    def setUpClass(cls):
+    def setUpClass(cls) -> None:
         """
         Set up groups and users
+
+        :return:
+        :rtype:
         """
 
         super().setUpClass()
         cls.group = Group.objects.create(name="Superhero")
 
         # User cannot access bulletins
-        cls.user_1001 = create_fake_user(1001, "Peter Parker")
+        cls.user_1001 = create_fake_user(
+            character_id=1001, character_name="Peter Parker"
+        )
 
         # User can access bulletins
         cls.user_1002 = create_fake_user(
-            1002, "Bruce Wayne", permissions=["aa_bulletin_board.basic_access"]
+            character_id=1002,
+            character_name="Bruce Wayne",
+            permissions=["aa_bulletin_board.basic_access"],
         )
 
         # User can manage bulletins
         cls.user_1003 = create_fake_user(
-            1003,
-            "Clark Kent",
+            character_id=1003,
+            character_name="Clark Kent",
             permissions=[
                 "aa_bulletin_board.basic_access",
                 "aa_bulletin_board.manage_bulletins",
             ],
         )
 
-    def test_should_show_bulletin_page(self):
+    def test_should_show_bulletin_page(self) -> None:
         """
         Test if a bulletin is shown
+
         :return:
         :rtype:
         """
@@ -63,51 +71,64 @@ class TestBulletinUI(WebTest):
             content=f"<p>{fake.sentence()}</p>",
             created_by=self.user_1002,
         )
-        self.app.set_user(self.user_1002)
+        self.app.set_user(user=self.user_1002)
 
         # when
         page = self.app.get(
-            reverse("aa_bulletin_board:view_bulletin", args=[bulletin.slug])
+            url=reverse(
+                viewname="aa_bulletin_board:view_bulletin", args=[bulletin.slug]
+            )
         )
 
         # then
-        self.assertTemplateUsed(page, "aa_bulletin_board/bulletin.html")
+        self.assertTemplateUsed(
+            response=page, template_name="aa_bulletin_board/bulletin.html"
+        )
 
-    def test_should_redirect_to_bulletin_dashboard_when_bulletin_does_not_exist(self):
+    def test_should_redirect_to_bulletin_dashboard_when_bulletin_does_not_exist(
+        self,
+    ) -> None:
         """
         Test should redirect to bulletin dashboard when bulletin does not exist
+
         :return:
         :rtype:
         """
 
         # given
-        self.app.set_user(self.user_1002)
+        self.app.set_user(user=self.user_1002)
 
         # when
-        page = self.app.get(reverse("aa_bulletin_board:view_bulletin", args=["foobar"]))
+        page = self.app.get(
+            url=reverse(viewname="aa_bulletin_board:view_bulletin", args=["foobar"])
+        )
 
         # then
-        self.assertRedirects(page, "/bulletin-board/")
+        self.assertRedirects(response=page, expected_url="/bulletin-board/")
 
-    def test_should_show_create_bulletin_page(self):
+    def test_should_show_create_bulletin_page(self) -> None:
         """
         Test if create bulletin is shown
+
         :return:
         :rtype:
         """
 
         # given
-        self.app.set_user(self.user_1003)
+        self.app.set_user(user=self.user_1003)
 
         # when
-        page = self.app.get(reverse("aa_bulletin_board:create_bulletin"))
+        page = self.app.get(url=reverse(viewname="aa_bulletin_board:create_bulletin"))
 
         # then
-        self.assertTemplateUsed(page, "aa_bulletin_board/edit-bulletin.html")
+        self.assertTemplateUsed(
+            response=page, template_name="aa_bulletin_board/edit-bulletin.html"
+        )
 
-    def test_should_show_edit_bulletin_page(self):
+    def test_should_show_edit_bulletin_page(self) -> None:
         """
         Test if edit bulletin is shown
+
         :return:
         :rtype:
         """
@@ -118,49 +139,58 @@ class TestBulletinUI(WebTest):
             content=f"<p>{fake.sentence()}</p>",
             created_by=self.user_1002,
         )
-        self.app.set_user(self.user_1003)
+        self.app.set_user(user=self.user_1003)
 
         # when
         page = self.app.get(
-            reverse("aa_bulletin_board:edit_bulletin", args=[bulletin.slug])
+            url=reverse(
+                viewname="aa_bulletin_board:edit_bulletin", args=[bulletin.slug]
+            )
         )
 
         # then
-        self.assertTemplateUsed(page, "aa_bulletin_board/edit-bulletin.html")
+        self.assertTemplateUsed(
+            response=page, template_name="aa_bulletin_board/edit-bulletin.html"
+        )
 
     def test_should_redirect_to_bulletin_dashboard_when_edit_bulletin_does_not_exist(
         self,
-    ):
+    ) -> None:
         """
         Test should redirect to bulletin dashboard when bulletin to edit does not exist
+
         :return:
         :rtype:
         """
 
         # given
-        self.app.set_user(self.user_1003)
+        self.app.set_user(user=self.user_1003)
 
         # when
-        page = self.app.get(reverse("aa_bulletin_board:edit_bulletin", args=["foobar"]))
+        page = self.app.get(
+            url=reverse(viewname="aa_bulletin_board:edit_bulletin", args=["foobar"])
+        )
 
         # then
-        self.assertRedirects(page, "/bulletin-board/")
+        self.assertRedirects(response=page, expected_url="/bulletin-board/")
 
-    def test_should_return_cleaned_message_string_on_bulletin_creation(self):
+    def test_should_return_cleaned_message_string_on_bulletin_creation(self) -> None:
         """
-        Test should return a clean/sanitized message string when new bulletin is created
+        Test should return a clean/sanitized message string when a new bulletin is created
+
         :return:
+        :rtype:
         """
 
         # given
-        self.app.set_user(self.user_1003)
-        page = self.app.get(reverse("aa_bulletin_board:create_bulletin"))
+        self.app.set_user(user=self.user_1003)
+        page = self.app.get(url=reverse(viewname="aa_bulletin_board:create_bulletin"))
         dirty_message = (
             'this is a script test. <script type="text/javascript">alert('
             "'test')</script>and this is style test. <style>.MathJax, "
             ".MathJax_Message, .MathJax_Preview{display: none}</style>end tests."
         )
-        cleaned_message = string_cleanup(dirty_message)
+        cleaned_message = string_cleanup(string=dirty_message)
 
         # when
         form = page.forms["aa-bulletin-board-bulletin-form"]
@@ -170,12 +200,14 @@ class TestBulletinUI(WebTest):
 
         # then
         new_bulletin = Bulletin.objects.last()
-        self.assertEqual(new_bulletin.content, cleaned_message)
+        self.assertEqual(first=new_bulletin.content, second=cleaned_message)
 
-    def test_should_return_cleaned_message_string_on_bulletin_edit(self):
+    def test_should_return_cleaned_message_string_on_bulletin_edit(self) -> None:
         """
         Test should return a clean/sanitized message string when a bulletin is edited
+
         :return:
+        :rtype:
         """
 
         # given
@@ -184,18 +216,20 @@ class TestBulletinUI(WebTest):
             content=f"<p>{fake.sentence()}</p>",
             created_by=self.user_1002,
         )
-        self.app.set_user(self.user_1003)
+        self.app.set_user(user=self.user_1003)
 
         # when
         page = self.app.get(
-            reverse("aa_bulletin_board:edit_bulletin", args=[bulletin.slug])
+            url=reverse(
+                viewname="aa_bulletin_board:edit_bulletin", args=[bulletin.slug]
+            )
         )
         dirty_message = (
             'this is a script test. <script type="text/javascript">alert('
             "'test')</script>and this is style test. <style>.MathJax, "
             ".MathJax_Message, .MathJax_Preview{display: none}</style>end tests."
         )
-        cleaned_message = string_cleanup(dirty_message)
+        cleaned_message = string_cleanup(string=dirty_message)
 
         form = page.forms["aa-bulletin-board-bulletin-form"]
         form["title"] = "Message Cleanup Test"
@@ -204,20 +238,21 @@ class TestBulletinUI(WebTest):
 
         # then
         bulletin_edited = Bulletin.objects.get(pk=bulletin.pk)
-        self.assertEqual(bulletin_edited.content, cleaned_message)
+        self.assertEqual(first=bulletin_edited.content, second=cleaned_message)
 
     def test_should_return_to_edit_bulletin_form_for_invalid_form_submitted_on_create_bulletin(
         self,
-    ):
+    ) -> None:
         """
-        Test should return to bulletin form, because submitted form is not valid
+        Test should return to the bulletin form, because the submitted form is not valid
         due to missing title
+
         :return:
         :rtype:
         """
 
-        self.app.set_user(self.user_1003)
-        page = self.app.get(reverse("aa_bulletin_board:create_bulletin"))
+        self.app.set_user(user=self.user_1003)
+        page = self.app.get(url=reverse(viewname="aa_bulletin_board:create_bulletin"))
 
         # when
         form = page.forms["aa-bulletin-board-bulletin-form"]
@@ -225,14 +260,17 @@ class TestBulletinUI(WebTest):
         page = form.submit()
 
         # then
-        self.assertTemplateUsed(page, "aa_bulletin_board/edit-bulletin.html")
+        self.assertTemplateUsed(
+            response=page, template_name="aa_bulletin_board/edit-bulletin.html"
+        )
 
     def test_should_return_to_edit_bulletin_form_for_invalid_form_submitted_on_edit_bulletin(
         self,
-    ):
+    ) -> None:
         """
-        Test should return to bulletin form, because submitted form is not valid
+        Test should return to the bulletin form, because the submitted form is not valid
         due to missing title
+
         :return:
         :rtype:
         """
@@ -242,11 +280,13 @@ class TestBulletinUI(WebTest):
             content=f"<p>{fake.sentence()}</p>",
             created_by=self.user_1002,
         )
-        self.app.set_user(self.user_1003)
+        self.app.set_user(user=self.user_1003)
 
         # when
         page = self.app.get(
-            reverse("aa_bulletin_board:edit_bulletin", args=[bulletin.slug])
+            url=reverse(
+                viewname="aa_bulletin_board:edit_bulletin", args=[bulletin.slug]
+            )
         )
 
         # when
@@ -256,4 +296,6 @@ class TestBulletinUI(WebTest):
         page = form.submit()
 
         # then
-        self.assertTemplateUsed(page, "aa_bulletin_board/edit-bulletin.html")
+        self.assertTemplateUsed(
+            response=page, template_name="aa_bulletin_board/edit-bulletin.html"
+        )

aa_bulletin_board/tests/utils.py

@@ -23,16 +23,41 @@ def create_fake_user(
     alliance_name: str = None,
     permissions: List[str] = None,
 ) -> User:
-    """Create a fake user incl. main character and (optional) permissions."""
-    username = re.sub(r"[^\w\d@\.\+-]", "_", character_name)
-    user = AuthUtils.create_user(username)
+    """
+    Create a fake user incl. Main character and (optional) permissions.
+
+    :param character_id:
+    :type character_id:
+    :param character_name:
+    :type character_name:
+    :param corporation_id:
+    :type corporation_id:
+    :param corporation_name:
+    :type corporation_name:
+    :param corporation_ticker:
+    :type corporation_ticker:
+    :param alliance_id:
+    :type alliance_id:
+    :param alliance_name:
+    :type alliance_name:
+    :param permissions:
+    :type permissions:
+    :return:
+    :rtype:
+    """
+
+    username = re.sub(pattern=r"[^\w\d@\.\+-]", repl="_", string=character_name)
+    user = AuthUtils.create_user(username=username)
+
     if not corporation_id:
         corporation_id = 2001
         corporation_name = "Wayne Technologies Inc."
         corporation_ticker = "WTE"
+
     if not alliance_id:
         alliance_id = 3001
         alliance_name = "Wayne Enterprises"
+
     AuthUtils.add_main_character_2(
         user=user,
         name=character_name,
@@ -43,7 +68,11 @@ def create_fake_user(
         alliance_id=alliance_id,
         alliance_name=alliance_name,
     )
+
     if permissions:
-        perm_objs = [AuthUtils.get_permission_by_name(perm) for perm in permissions]
+        perm_objs = [
+            AuthUtils.get_permission_by_name(perm=perm) for perm in permissions
+        ]
         user = AuthUtils.add_permissions_to_user(perms=perm_objs, user=user)
+
     return user