fix: lint issues for bootprocess

Author: sharad-sharma

Makefile

@@ -70,7 +70,7 @@ test: setup_mounts ensure_web_container_for_test
 lint: export APPUID = $(APP_UID)
 lint: setup_mounts ensure_web_container_for_test
 	@docker exec dev python -m pylama --version
-	@docker exec dev python -m pylama Access/accessrequest_helper.py scripts
+	@docker exec dev python -m pylama Access/accessrequest_helper.py scripts bootprocess
 	@if [ "$$?" -ne 0 ]; then \
 		echo "Linter checks failed"; \
 		exit 1; \

bootprocess/admin.py

@@ -1 +0,0 @@
-from django.contrib import admin

bootprocess/apps.py

@@ -1,6 +1,8 @@
+""" apps file for bootprocess """
 from django.apps import AppConfig
 
 
 class BootprocessConfig(AppConfig):
+    """ Config for bootprocess """
     default_auto_field = "django.db.models.BigAutoField"
     name = "bootprocess"

bootprocess/general.py

@@ -1,22 +1,25 @@
+""" file contains general methods for bootprocess """
+import logging
 from django.core import mail
 from django.core.mail import BadHeaderError
-import logging
 from EnigmaAutomation.settings import EMAIL_BACKEND, DEFAULT_FROM_EMAIL
 logger = logging.getLogger(__name__)
 
-def emailSES(destination, subject, body):
+
+def emailSES(destination, subject, body):   # noqa: C0103
+    """ method to send email to destination with given subject and body """
     if destination and subject and body:
         with mail.get_connection(backend=EMAIL_BACKEND) as connection:
             try:
                 email = mail.EmailMessage(subject=subject, body=body,
-                                        from_email=DEFAULT_FROM_EMAIL, to=destination,
-                                        connection=connection)
+                                          from_email=DEFAULT_FROM_EMAIL, to=destination,
+                                          connection=connection)
                 email.content_subtype = "html"
                 response = email.send(fail_silently=False)
                 if response != 1:
                     raise Exception('Message not delivered. Contact Admin for more details.')
-            except BadHeaderError:
-                raise Exception("Invalid header found.")
+            except BadHeaderError as exc:
+                raise Exception("Invalid header found.") from exc
     else:
         raise Exception('Make sure all fields are entered and valid.')
 

bootprocess/tests/test_views_helper.py

@@ -1,17 +1,20 @@
+""" test file for views_helper """
+import threading
 import pytest
 from bootprocess import views_helper
 from Access import models
-import threading
 from EnigmaAutomation.settings import DEFAULT_ACCESS_GROUP
 
 
 class MockAuthUser:
+    """ mocking AuthUser """
     def __init__(self, username="", user=""):
         self.user = user
         self.username = username
 
 
 class MockRequest:
+    """ mocking Request """
     def __init__(self, username=""):
         self.user = MockAuthUser(username)
 
@@ -28,57 +31,64 @@ def __init__(self, username=""):
         ("UserInDefaultGroup", False, 40),
     ],
 )
-def test_getDashboardData(
-    monkeypatch,
-    testName,
-    userIsInDefaultAccessGroup,
-    groupCount,
-):
+def test_getDashboardData(monkeypatch, testName, userIsInDefaultAccessGroup, groupCount):  # noqa: C901
     class MockUserModelobj:
+        """ mocking method UserModelobj """
         def __init__(self, user="", gitusername="", name=""):
             self.user = user
             self.gitusername = gitusername
             self.name = name
 
         def get(self, user__username=""):
+            """ mocked method get """
             self.user = user__username
             return MockUserModelobj(user="username", gitusername="username")
 
     class MockGitAccessModelobj:
-        def __init__(self, requestInfo={"": ""}):
+        """ mocking GitAccessModelobj """
+        def __init__(self, request_info=None):
+            del request_info
             self.user = ""
-            self.requestInfo = requestInfo
 
         def filter(self, requester="", status=""):
+            """ mocked method filter """
+            del requester
             if status == "Approved":
                 return [MockGitAccessModelobj()]
             return MockGitAccessModelobj()
 
     class MockGroupV2:
+        """ mocking class GroupV2 """
         def filter(self, name="", status=""):
+            """ mocked method filter """
+            del name
             if status == "Approved":
                 return [MockGroupV2()]
             return MockGitAccessModelobj()
 
     class MockUserAccessMapping:
+        """ mocking UserAccessMapping """
         def filter(self, user="", status="", access__access_tag=""):
+            """ mocked method filter """
+            del user, status
             if access__access_tag == "other":
                 return []
-            elif access__access_tag == "github_access":
+            if access__access_tag == "github_access":
                 return []
-            elif access__access_tag == "ssh":
+            if access__access_tag == "ssh":
                 return []
-            else:
-                group = []
-                for i in range(groupCount):
-                    group.append(i)
-                return group
+            group = []
+            for i in range(groupCount):
+                group.append(i)
+            return group
 
     class Group:
+        """ class Group """
         def __init__(self):
             self.name = ""
 
     class MockMembershipV2:
+        """ mocking class MembershipV2 """
         def __init__(self, is_owner=False, approver="", status="", user=""):
             self.is_owner = is_owner
             self.approver = approver
@@ -87,47 +97,53 @@ def __init__(self, is_owner=False, approver="", status="", user=""):
             self.group = Group()
 
         def filter(self, user="", status="", group="", is_owner=False):
+            """ mocked method filter """
+            del user, status, group
             if is_owner:
                 return [MockMembershipV2()]
             return MockMembershipV2()
 
-        def only(self, filter):
+        def only(self, _filter):
+            """ mocked method only """
             return MockMembershipV2()
 
-        def create(*args, **kwargs):
+        def create(self, *_, **__):
+            """ mocked method create """
             return MockMembershipV2()
 
         def save(self):
+            """ mocked method save """
             return ""
 
         def __str__(self):
             if userIsInDefaultAccessGroup:
                 return DEFAULT_ACCESS_GROUP
-            else:
-                return ""
+            return ""
 
         def __len__(self):
             return groupCount
 
     class MockThread:
+        """ class for mocking Thread """
         def start(self):
+            """ method to mock start method of Thread """
             return True
 
-    def mockgenerateUserMappings(*args, **kwargs):
+    def mockgenerate_user_mappings(*_, **__):
         return []
 
-    views_helper.generate_user_mappings = mockgenerateUserMappings
+    views_helper.generate_user_mappings = mockgenerate_user_mappings
 
-    def mock_Thread(*args, **kwargs):
+    def mock_thread(*_, **__):
         return MockThread()
 
-    monkeypatch.setattr(threading, "Thread", mock_Thread)
+    monkeypatch.setattr(threading, "Thread", mock_thread)
 
     models.MembershipV2.objects = MockMembershipV2()
     models.User.objects = MockUserModelobj()
     models.UserAccessMapping.objects = MockUserAccessMapping()
     models.GroupV2.objects = MockGroupV2()
     request = MockRequest(username="username1")
-    context = views_helper.getDashboardData(request)
+    context = views_helper.get_dashboard_data(request)
     assert context["regions"] == ["eu-central-1"]
     assert context["groupCount"] == groupCount

bootprocess/views.py

@@ -1,24 +1,24 @@
+""" views for bootprocess """
+import logging
 from django.contrib.auth import logout
 from django.contrib.auth.decorators import login_required
 from django.shortcuts import render
-import logging
-from .views_helper import getDashboardData
+from .views_helper import get_dashboard_data
 
 logger = logging.getLogger(__name__)
-# Create your views here.
 
 
 @login_required
 def logout_view(request):
     """Logout View runs when logout url call"""
     logout(request)
-    logger.debug("User: {0} is logging out".format(request.user.username))
+    logger.debug("User: %s is logging out", request.user.username)
     return render(request, "registration/login.html")
 
 
 @login_required
 def dashboard(request):
     """Loaded dashboard"""
-    context = getDashboardData(request)
+    context = get_dashboard_data(request)
     logger.info("Dashboard load for user %s", request.user.username)
     return render(request, "EnigmaOps/dashboard.html", context)

bootprocess/views_helper.py

@@ -1,19 +1,20 @@
+""" helper for views of bootprocess """
 import logging
+import json
+import datetime
 from Access.models import (
     User as access_user,
     MembershipV2,
     GroupV2,
-    UserAccessMapping,
 )
-from EnigmaAutomation.settings import DEFAULT_ACCESS_GROUP
 from Access.views_helper import generate_user_mappings, execute_group_access
-import json
-import datetime
+from EnigmaAutomation.settings import DEFAULT_ACCESS_GROUP
 
 logger = logging.getLogger(__name__)
 
 
-def getDashboardData(request):
+def get_dashboard_data(request):
+    """ helper to get dashboard data """
     user = access_user.objects.get(user__username=request.user)
 
     # Add users to DEFAULT_ACCESS_GROUP if the user is not already on the group
@@ -31,7 +32,7 @@ def getDashboardData(request):
                 .filter(status="Approved")
                 .only("user")
             )
-            group_owner = [member for member in group_members.filter(is_owner=True)]
+            group_owner = list(group_members.filter(is_owner=True))
             membership_id = (
                 user.name
                 + "-"
@@ -61,17 +62,17 @@ def getDashboardData(request):
                 + request.user.username
             )
 
-    with open("instanceTypes.json") as data_file:
+    with open("instanceTypes.json", encoding="utf-8") as data_file:
         data = json.load(data_file)
     ec2_regions = list(data.keys())
 
     context = {}
 
-    groupCount = len(
+    group_count = len(
         MembershipV2.objects.filter(user=request.user.user, status="Approved")
     )
 
     context["regions"] = ec2_regions
-    context["groupCount"] = groupCount
+    context["groupCount"] = group_count
 
     return context

pylama.ini

@@ -14,6 +14,9 @@ ignore = W0718,W0719,E1101
 [pylama:Access/accessrequest_helper.py]
 ignore = W1202,R901,R0911,C0302,R0914
 
+[pylama:bootprocess/tests/test_views_helper.py]
+ignore = R0903
+
 [pylama:vulture]
 min-confidence = 100