Sign upLogin

kiwitcms/Kiwi

View on GitHub
Star

Showing 145 of 405 total issues

Function save_model has a Cognitive Complexity of 8 (exceeds 5 allowed). Consider refactoring.
Open

    def save_model(self, request, obj, form, change):
        super().save_model(request, obj, form, change)
        # try health check
        bug_url = form.cleaned_data["hc_bug_url"]
        if bug_url:
Severity: Minor
Found in tcms/testcases/admin.py - About 45 mins to fix

Cognitive Complexity

Cognitive Complexity is a measure of how difficult a unit of code is to intuitively understand. Unlike Cyclomatic Complexity, which determines how difficult your code will be to test, Cognitive Complexity tells you how difficult your code will be to read and comprehend.

A method's cognitive complexity is based on a few simple rules:

  • Code is not considered more complex when it uses shorthand that the language provides for collapsing multiple statements into one
  • Code is considered more complex for each "break in the linear flow of the code"
  • Code is considered more complex when "flow breaking structures are nested"

Further reading

Function post has a Cognitive Complexity of 8 (exceeds 5 allowed). Consider refactoring.
Open

    def post(self, request):
        form = NewRunForm(data=request.POST)
        form.populate(request.POST.get("plan"))

        if form.is_valid():
Severity: Minor
Found in tcms/testruns/views.py - About 45 mins to fix

Cognitive Complexity

Cognitive Complexity is a measure of how difficult a unit of code is to intuitively understand. Unlike Cyclomatic Complexity, which determines how difficult your code will be to test, Cognitive Complexity tells you how difficult your code will be to read and comprehend.

A method's cognitive complexity is based on a few simple rules:

  • Code is not considered more complex when it uses shorthand that the language provides for collapsing multiple statements into one
  • Code is considered more complex for each "break in the linear flow of the code"
  • Code is considered more complex when "flow breaking structures are nested"

Further reading

Function mailto has 6 arguments (exceeds 4 allowed). Consider refactoring.
Open

def mailto(  # pylint: disable=invalid-name
Severity: Minor
Found in tcms/core/utils/mailto.py - About 45 mins to fix

    Function create_permissions has 6 arguments (exceeds 4 allowed). Consider refactoring.
    Open

    def create_permissions(
    Severity: Minor
    Found in tcms/bugs/management.py - About 45 mins to fix

      Function advancedSearchAndAddTestCases has a Cognitive Complexity of 8 (exceeds 5 allowed). Consider refactoring.
      Open

      export function advancedSearchAndAddTestCases (objId, rpcMethod, href, errorMessage) {
    window.addTestCases = function (testCaseIDs, sender) {
        let rpcErrors = 0

        // close the popup
      Severity: Minor
      Found in tcms/static/js/utils.js - About 45 mins to fix

      Cognitive Complexity

      Cognitive Complexity is a measure of how difficult a unit of code is to intuitively understand. Unlike Cyclomatic Complexity, which determines how difficult your code will be to test, Cognitive Complexity tells you how difficult your code will be to read and comprehend.

      A method's cognitive complexity is based on a few simple rules:

      • Code is not considered more complex when it uses shorthand that the language provides for collapsing multiple statements into one
      • Code is considered more complex for each "break in the linear flow of the code"
      • Code is considered more complex when "flow breaking structures are nested"

      Further reading

      Function update has a Cognitive Complexity of 8 (exceeds 5 allowed). Consider refactoring.
      Open

      def update(execution_id, values, **kwargs):
    """
    .. function:: RPC TestExecution.update(execution_id, values)

        Update the selected TestExecution
      Severity: Minor
      Found in tcms/rpc/api/testexecution.py - About 45 mins to fix

      Cognitive Complexity

      Cognitive Complexity is a measure of how difficult a unit of code is to intuitively understand. Unlike Cyclomatic Complexity, which determines how difficult your code will be to test, Cognitive Complexity tells you how difficult your code will be to read and comprehend.

      A method's cognitive complexity is based on a few simple rules:

      • Code is not considered more complex when it uses shorthand that the language provides for collapsing multiple statements into one
      • Code is considered more complex for each "break in the linear flow of the code"
      • Code is considered more complex when "flow breaking structures are nested"

      Further reading

      Function post has a Cognitive Complexity of 8 (exceeds 5 allowed). Consider refactoring.
      Open

          def post(self, request):
        if not self._is_request_data_valid(request):
            return HttpResponseRedirect(request.META.get("HTTP_REFERER", "/"))

        # Do the clone action
      Severity: Minor
      Found in tcms/testcases/views.py - About 45 mins to fix

      Cognitive Complexity

      Cognitive Complexity is a measure of how difficult a unit of code is to intuitively understand. Unlike Cyclomatic Complexity, which determines how difficult your code will be to test, Cognitive Complexity tells you how difficult your code will be to read and comprehend.

      A method's cognitive complexity is based on a few simple rules:

      • Code is not considered more complex when it uses shorthand that the language provides for collapsing multiple statements into one
      • Code is considered more complex for each "break in the linear flow of the code"
      • Code is considered more complex when "flow breaking structures are nested"

      Further reading

      Function initAddPlan has a Cognitive Complexity of 8 (exceeds 5 allowed). Consider refactoring.
      Open

      function initAddPlan (caseId, plansTable) {
    // + button
    $('#btn-add-plan').click(function () {
        addTestPlanToTestCase(caseId, plansTable)
    })
      Severity: Minor
      Found in tcms/testcases/static/testcases/js/get.js - About 45 mins to fix

      Cognitive Complexity

      Cognitive Complexity is a measure of how difficult a unit of code is to intuitively understand. Unlike Cyclomatic Complexity, which determines how difficult your code will be to test, Cognitive Complexity tells you how difficult your code will be to read and comprehend.

      A method's cognitive complexity is based on a few simple rules:

      • Code is not considered more complex when it uses shorthand that the language provides for collapsing multiple statements into one
      • Code is considered more complex for each "break in the linear flow of the code"
      • Code is considered more complex when "flow breaking structures are nested"

      Further reading

      Function create_execution has 6 arguments (exceeds 4 allowed). Consider refactoring.
      Open

          def create_execution(  # pylint: disable=too-many-arguments
      Severity: Minor
      Found in tcms/testruns/models.py - About 45 mins to fix

        Function _url_view_mapping has a Cognitive Complexity of 8 (exceeds 5 allowed). Consider refactoring.
        Open

            def _url_view_mapping(cls, root_urlpatterns):
        def flatten(urlpatterns, prefix="^", result=None):
            """
            Flattens the url graph
        Severity: Minor
        Found in kiwi_lint/views.py - About 45 mins to fix

        Cognitive Complexity

        Cognitive Complexity is a measure of how difficult a unit of code is to intuitively understand. Unlike Cyclomatic Complexity, which determines how difficult your code will be to test, Cognitive Complexity tells you how difficult your code will be to read and comprehend.

        A method's cognitive complexity is based on a few simple rules:

        • Code is not considered more complex when it uses shorthand that the language provides for collapsing multiple statements into one
        • Code is considered more complex for each "break in the linear flow of the code"
        • Code is considered more complex when "flow breaking structures are nested"

        Further reading

        Function quickSearchAndAddTestCase has a Cognitive Complexity of 8 (exceeds 5 allowed). Consider refactoring.
        Open

        export function quickSearchAndAddTestCase (objId, pageCallback, cache, initialQuery = {}) {
    // + button
    $('#btn-add-case').click(function () {
        pageCallback(objId)
        Severity: Minor
        Found in tcms/static/js/utils.js - About 45 mins to fix

        Cognitive Complexity

        Cognitive Complexity is a measure of how difficult a unit of code is to intuitively understand. Unlike Cyclomatic Complexity, which determines how difficult your code will be to test, Cognitive Complexity tells you how difficult your code will be to read and comprehend.

        A method's cognitive complexity is based on a few simple rules:

        • Code is not considered more complex when it uses shorthand that the language provides for collapsing multiple statements into one
        • Code is considered more complex for each "break in the linear flow of the code"
        • Code is considered more complex when "flow breaking structures are nested"

        Further reading

        Function addPropertyValue has 5 arguments (exceeds 4 allowed). Consider refactoring.
        Open

        export function addPropertyValue (objectId, objectAttrName, viewMethod, addMethod, removeMethod) {
        Severity: Minor
        Found in tcms/static/js/properties.js - About 35 mins to fix

          Function updateSelect has 5 arguments (exceeds 4 allowed). Consider refactoring.
          Open

          export function updateSelect (data, selector, idAttr, valueAttr, groupAttr) {
          Severity: Minor
          Found in tcms/static/js/utils.js - About 35 mins to fix

            Function assign_default_group_permissions has 5 arguments (exceeds 4 allowed). Consider refactoring.
            Open

            def assign_default_group_permissions(
            Severity: Minor
            Found in tcms/utils/permissions.py - About 35 mins to fix

              Function renderCommentsForObject has 5 arguments (exceeds 4 allowed). Consider refactoring.
              Open

              export function renderCommentsForObject (objId, getMethod, deleteMethod, canDelete, parentNode) {
              Severity: Minor
              Found in tcms/static/js/utils.js - About 35 mins to fix

                Function propertiesCard has 5 arguments (exceeds 4 allowed). Consider refactoring.
                Open

                export function propertiesCard (objectId, objectAttrName, viewMethod, addMethod, removeMethod) {
                Severity: Minor
                Found in tcms/static/js/properties.js - About 35 mins to fix

                  Function add_attachment has 5 arguments (exceeds 4 allowed). Consider refactoring.
                  Open

                  def add_attachment(obj_id, app_model, user, filename, b64content):
                  Severity: Minor
                  Found in tcms/rpc/utils.py - About 35 mins to fix

                    Function diff_objects has a Cognitive Complexity of 7 (exceeds 5 allowed). Consider refactoring.
                    Open

                    def diff_objects(old_instance, new_instance, fields):
    """
    Diff two objects by examining the given fields and
    return a string.
    """
                    Severity: Minor
                    Found in tcms/core/history.py - About 35 mins to fix

                    Cognitive Complexity

                    Cognitive Complexity is a measure of how difficult a unit of code is to intuitively understand. Unlike Cyclomatic Complexity, which determines how difficult your code will be to test, Cognitive Complexity tells you how difficult your code will be to read and comprehend.

                    A method's cognitive complexity is based on a few simple rules:

                    • Code is not considered more complex when it uses shorthand that the language provides for collapsing multiple statements into one
                    • Code is considered more complex for each "break in the linear flow of the code"
                    • Code is considered more complex when "flow breaking structures are nested"

                    Further reading

                    Function visit_attribute has a Cognitive Complexity of 7 (exceeds 5 allowed). Consider refactoring.
                    Open

                        def visit_attribute(self, node):
        # looking for .extra(select={}) patterns
        if node.attrname == "extra" and isinstance(node.parent, astroid.Call):
            for keyword in node.parent.keywords:
                if keyword.arg in [
                    Severity: Minor
                    Found in kiwi_lint/raw_sql.py - About 35 mins to fix

                    Cognitive Complexity

                    Cognitive Complexity is a measure of how difficult a unit of code is to intuitively understand. Unlike Cyclomatic Complexity, which determines how difficult your code will be to test, Cognitive Complexity tells you how difficult your code will be to read and comprehend.

                    A method's cognitive complexity is based on a few simple rules:

                    • Code is not considered more complex when it uses shorthand that the language provides for collapsing multiple statements into one
                    • Code is considered more complex for each "break in the linear flow of the code"
                    • Code is considered more complex when "flow breaking structures are nested"

                    Further reading

                    Function drawChart has a Cognitive Complexity of 7 (exceeds 5 allowed). Consider refactoring.
                    Open

                    export function drawChart () {
    const query = {}

    const productIds = $('#id_product').val()
    if (productIds.length) {
                    Severity: Minor
                    Found in tcms/telemetry/static/telemetry/js/testing/execution-trends.js - About 35 mins to fix

                    Cognitive Complexity

                    Cognitive Complexity is a measure of how difficult a unit of code is to intuitively understand. Unlike Cyclomatic Complexity, which determines how difficult your code will be to test, Cognitive Complexity tells you how difficult your code will be to read and comprehend.

                    A method's cognitive complexity is based on a few simple rules:

                    • Code is not considered more complex when it uses shorthand that the language provides for collapsing multiple statements into one
                    • Code is considered more complex for each "break in the linear flow of the code"
                    • Code is considered more complex when "flow breaking structures are nested"

                    Further reading

                    Severity
                    Category
                    Status
                    Source
                    Language