Uploaded image for project: 'Rules Repository'
  1. Rules Repository
  2. RSPEC-5914

Assertions should not fail or succeed unconditionally

    XMLWordPrintable

    Details

    • Message:
      Hide
      for assertTrue/assertFalse
      * Replace this expression; its boolean value is constant.

      for assertIsNone, assertIsNotNone
      * Remove this identity assertion; it will always fail.

      for assertIs, assertIsNot
      * Primary: Replace this "assertIs" call with an "assertEqual" call.
      * Secondary: This expression creates a new object every time.
      Show
      for assertTrue/assertFalse * Replace this expression; its boolean value is constant. for assertIsNone, assertIsNotNone * Remove this identity assertion; it will always fail. for assertIs, assertIsNot * Primary: Replace this "assertIs" call with an "assertEqual" call. * Secondary: This expression creates a new object every time.
    • Highlighting:
      Hide

      for assertTrue/assertFalse: the argument

      for assertIsNone, assertIsNotNone: the whole assertion

      for assertIs, assertIsNot:

      • primary: the assertion method
      • secondary: the expression creating a new object every time
      Show
      for assertTrue/assertFalse: the argument for assertIsNone, assertIsNotNone: the whole assertion for assertIs, assertIsNot: primary: the assertion method secondary: the expression creating a new object every time
    • Default Severity:
      Major
    • Impact:
      Low
    • Likelihood:
      High
    • Default Quality Profiles:
      Sonar way
    • Targeted languages:
      Python
    • Remediation Function:
      Constant/Issue
    • Constant Cost:
      5min
    • Analysis Level:
      Control-flow Analysis
    • Analysis Scope:
      Test Sources

      Description

      Assertions are meant to detect when code behaves as expected. An assertion which fails or succeeds all the time should be fixed.

      This rule raises an issue when an assertion method is given parameters which will make it succeed or fail all the time. It covers three cases:

      • an assert statement or a unittest's assertTrue or assertFalse method is called with a value which will be always True or always False.
      • a unittest's assertIsNotNone or assertIsNone method is called with a value which will be always None or never None.
      • a unittest's assertIsNot or assertIs method is called with a literal expression creating a new object every time (ex: [1, 2, 3]).

      Noncompliant Code Example

      import unittest
      
      class MyTestCase(unittest.TestCase):
          def expect_fail1(self):
              assert False
      
          def expect_fail2(self):
              self.assertTrue(False)  # Noncompliant. This assertion always fails.
      
          def expect_not_none(self):
              self.assertIsNotNone(round(1.5))  # Noncompliant. This assertion always succeeds because "round" returns a number, not None.
      
          def helper_compare(param):
              self.assertIs(param, [1, 2, 3])  # Noncompliant. This assertion always fails because [1, 2, 3] creates a new object.
      

      Compliant Solution

      import unittest
      
      class MyTestCase(unittest.TestCase):
          def expect_fail(self):
              self.fail("This is expected")
      
          def expect_not_none(self):
              self.assertNotEqual(round(1.5), 0)
      
          def helper_compare(param):
              self.assertEqual(param, [1, 2, 3])
      

      See

        Attachments

          Issue Links

            Activity

              People

              Assignee:
              Unassigned Unassigned
              Reporter:
              nicolas.harraudeau Nicolas Harraudeau (Inactive)
              Votes:
              0 Vote for this issue
              Watchers:
              1 Start watching this issue

                Dates

                Created:
                Updated: