content: from django.test import TestCase
  
  from circuits.models import *
  from dcim.choices import LinkStatusChoices
  from dcim.models import *
  from dcim.svg import CableTraceSVG
  from dcim.utils import object_to_path_node
  from utilities.exceptions import AbortRequest
  
  
  class CablePathTestCase(TestCase):
      """
      Test NetBox's ability to trace and retrace CablePaths in response to data model changes. Tests are numbered
      as follows:
  
          1XX: Test direct connections between different endpoint types
          2XX: Test different cable topologies
          3XX: Test responses to changes in existing objects
          4XX: Test to exclude specific cable topologies
      """
      @classmethod
      def setUpTestData(cls):
  
          # Create a single device that will hold all components
          cls.site = Site.objects.create(name='Site', slug='site')
  
          manufacturer = Manufacturer.objects.create(name='Generic', slug='generic')
          device_type = DeviceType.objects.create(manufacturer=manufacturer, model='Test Device')
          role = DeviceRole.objects.create(name='Device Role', slug='device-role')
          cls.device = Device.objects.create(site=cls.site, device_type=device_type, role=role, name='Test Device')
  
          cls.powerpanel = PowerPanel.objects.create(site=cls.site, name='Power Panel')
  
          provider = Provider.objects.create(name='Provider', slug='provider')
          circuit_type = CircuitType.objects.create(name='Circuit Type', slug='circuit-type')
          cls.circuit = Circuit.objects.create(provider=provider, type=circuit_type, cid='Circuit 1')
  
      def _get_cablepath(self, nodes, **kwargs):
          """
          Return a given cable path
  
          :param nodes: Iterable of steps, with each step being either a single node or a list of nodes
  
          :return: The matching CablePath (if any)
          """
          path = []
          for step in nodes:
              if type(step) in (list, tuple):
                  path.append([object_to_path_node(node) for node in step])
              else:
                  path.append([object_to_path_node(step)])
          return CablePath.objects.filter(path=path, **kwargs).first()
  
      def assertPathExists(self, nodes, **kwargs):
          """
          Assert that a CablePath from origin to destination with a specific intermediate path exists. Returns the
          first matching CablePath, if found.
  
          :param nodes: Iterable of steps, with each step being either a single node or a list of nodes
          """
          cablepath = self._get_cablepath(nodes, **kwargs)
          self.assertIsNotNone(cablepath, msg='CablePath not found')
  
          return cablepath
  
      def assertPathDoesNotExist(self, nodes, **kwargs):
          """
          Assert that a specific CablePath does *not* exist.
  
          :param nodes: Iterable of steps, with each step being either a single node or a list of nodes
          """
          cablepath = self._get_cablepath(nodes, **kwargs)
          self.assertIsNone(cablepath, msg='Unexpected CablePath found')
  
      def assertPathIsSet(self, origin, cablepath, msg=None):
          """
          Assert that a specific CablePath instance is set as the path on the origin.
  
          :param origin: The originating path endpoint
          :param cablepath: The CablePath instance originating from this endpoint
          :param msg: Custom failure message (optional)
          """
          if msg is None:
              msg = f"Path #{cablepath.pk} not set on originating endpoint {origin}"
          self.assertEqual(origin._path_id, cablepath.pk, msg=msg)
  
      def assertPathIsNotSet(self, origin, msg=None):
          """
          Assert that a specific CablePath instance is set as the path on the origin.
  
          :param origin: The originating path endpoint
          :param msg: Custom failure message (optional)
          """
          if msg is None:
              msg = f"Path #{origin._path_id} set as origin on {origin}; should be None!"
          self.assertIsNone(origin._path_id, msg=msg)
  
      def test_101_interface_to_interface(self):
          """
          [IF1] --C1-- [IF2]
          """
          interface1 = Interface.objects.create(device=self.device, name='Interface 1')
          interface2 = Interface.objects.create(device=self.device, name='Interface 2')
  
          # Create cable 1
          cable1 = Cable(
              a_terminations=[interface1],
              b_terminations=[interface2]
          )
          cable1.save()
  
          path1 = self.assertPathExists(
              (interface1, cable1, interface2),
              is_complete=True,
              is_active=True
          )
          path2 = self.assertPathExists(
              (interface2, cable1, interface1),
              is_complete=True,
              is_active=True
          )
          self.assertEqual(CablePath.objects.count(), 2)
          interface1.refresh_from_db()
          interface2.refresh_from_db()
          self.assertPathIsSet(interface1, path1)
          self.assertPathIsSet(interface2, path2)
  
          # Test SVG generation
          CableTraceSVG(interface1).render()
  
          # Delete cable 1
          cable1.delete()
  
          # Check that all CablePaths have been deleted
          self.assertEqual(CablePath.objects.count(), 0)
  
      def test_102_consoleport_to_consoleserverport(self):
          """
          [CP1] --C1-- [CSP1]
          """
          consoleport1 = ConsolePort.objects.create(device=self.device, name='Console Port 1')
          consoleserverport1 = ConsoleServerPort.objects.create(device=self.device, name='Console Server Port 1')
  
          # Create cable 1
          cable1 = Cable(
              a_terminations=[consoleport1],
              b_terminations=[consoleserverport1]
          )
          cable1.save()
  
          path1 = self.assertPathExists(
              (consoleport1, cable1, consoleserverport1),
              is_complete=True,
              is_active=True
          )
          path2 = self.assertPathExists(
              (consoleserverport1, cable1, consoleport1),
              is_complete=True,
              is_active=True
          )
          self.assertEqual(CablePath.objects.count(), 2)
          consoleport1.refresh_from_db()
          consoleserverport1.refresh_from_db()
          self.assertPathIsSet(consoleport1, path1)
          self.assertPathIsSet(consoleserverport1, path2)
  
          # Test SVG generation
          CableTraceSVG(consoleport1).render()
  
          # Delete cable 1
          cable1.delete()
  
          # Check that all CablePaths have been deleted
          self.assertEqual(CablePath.objects.count(), 0)
  
      def test_103_powerport_to_poweroutlet(self):
          """
          [PP1] --C1-- [PO1]
          """
          powerport1 = PowerPort.objects.create(device=self.device, name='Power Port 1')
          poweroutlet1 = PowerOutlet.objects.create(device=self.device, name='Power Outlet 1')
  
          # Create cable 1
          cable1 = Cable(
              a_terminations=[powerport1],
              b_terminations=[poweroutlet1]
          )
          cable1.save()
  
          path1 = self.assertPathExists(
              (powerport1, cable1, poweroutlet1),
              is_complete=True,
              is_active=True
          )
          path2 = self.assertPathExists(
              (poweroutlet1, cable1, powerport1),
              is_complete=True,
              is_active=True
          )
          self.assertEqual(CablePath.objects.count(), 2)
          powerport1.refresh_from_db()
          poweroutlet1.refresh_from_db()
          self.assertPathIsSet(powerport1, path1)
          self.assertPathIsSet(poweroutlet1, path2)
  
          # Test SVG generation
          CableTraceSVG(powerport1).render()
  
          # Delete cable 1
          cable1.delete()
  
          # Check that all CablePaths have been deleted
          self.assertEqual(CablePath.objects.count(), 0)
  
      def test_104_powerport_to_powerfeed(self):
          """
          [PP1] --C1-- [PF1]
          """
          powerport1 = PowerPort.objects.create(device=self.device, name='Power Port 1')
          powerfeed1 = PowerFeed.objects.create(power_panel=self.powerpanel, name='Power Feed 1')
  
          # Create cable 1
          cable1 = Cable(
              a_terminations=[powerport1],
              b_terminations=[powerfeed1]
          )
          cable1.save()
  
          path1 = self.assertPathExists(
              (powerport1, cable1, powerfeed1),
              is_complete=True,
              is_active=True
          )
          path2 = self.assertPathExists(
              (powerfeed1, cable1, powerport1),
              is_complete=True,
              is_active=True
          )
          self.assertEqual(CablePath.objects.count(), 2)
          powerport1.refresh_from_db()
          powerfeed1.refresh_from_db()
          self.assertPathIsSet(powerport1, path1)
          self.assertPathIsSet(powerfeed1, path2)
  
          # Test SVG generation
          CableTraceSVG(powerport1).render()
  
          # Delete cable 1
          cable1.delete()
  
          # Check that all CablePaths have been deleted
          self.assertEqual(CablePath.objects.count(), 0)
  
      def test_120_single_interface_to_multi_interface(self):
          """
          [IF1] --C1-- [IF2]
                       [IF3]
          """
          interface1 = Interface.objects.create(device=self.device, name='Interface 1')
          interface2 = Interface.objects.create(device=self.device, name='Interface 2')
          interface3 = Interface.objects.create(device=self.device, name='Interface 3')
  
          # Create cable 1
          cable1 = Cable(
              a_terminations=[interface1],
              b_terminations=[interface2, interface3]
          )
          cable1.save()
  
          path1 = self.assertPathExists(
              (interface1, cable1, (interface2, interface3)),
              is_complete=True,
              is_active=True
          )
          path2 = self.assertPathExists(
              ((interface2, interface3), cable1, interface1),
              is_complete=True,
              is_active=True
          )
          self.assertEqual(CablePath.objects.count(), 2)
          interface1.refresh_from_db()
          interface2.refresh_from_db()
          interface3.refresh_from_db()
          self.assertPathIsSet(interface1, path1)
          self.assertPathIsSet(interface2, path2)
          self.assertPathIsSet(interface3, path2)
  
          # Test SVG generation
          CableTraceSVG(interface1).render()
  
          # Delete cable 1
          cable1.delete()
  
          # Check that all CablePaths have been deleted
          self.assertEqual(CablePath.objects.count(), 0)
          interface1.refresh_from_db()
          interface2.refresh_from_db()
          interface3.refresh_from_db()
          self.assertPathIsNotSet(interface1)
          self.assertPathIsNotSet(interface2)
          self.assertPathIsNotSet(interface3)
  
      def test_121_multi_interface_to_multi_interface(self):
          """
          [IF1] --C1-- [IF3]
          [IF2]        [IF4]
          """
          interface1 = Interface.objects.create(device=self.device, name='Interface 1')
          interface2 = Interface.objects.create(device=self.device, name='Interface 2')
          interface3 = Interface.objects.create(device=self.device, name='Interface 3')
          interface4 = Interface.objects.create(device=self.device, name='Interface 4')
  
          # Create cable 1
          cable1 = Cable(
              a_terminations=[interface1, interface2],
              b_terminations=[interface3, interface4]
          )
          cable1.save()
  
          path1 = self.assertPathExists(
              ((interface1, interface2), cable1, (interface3, interface4)),
              is_complete=True,
              is_active=True
          )
          path2 = self.assertPathExists(
              ((interface3, interface4), cable1, (interface1, interface2)),
              is_complete=True,
              is_active=True
          )
          self.assertEqual(CablePath.objects.count(), 2)
          interface1.refresh_from_db()
          interface2.refresh_from_db()
          interface3.refresh_from_db()
          interface4.refresh_from_db()
          self.assertPathIsSet(interface1, path1)
          self.assertPathIsSet(interface2, path1)
          self.assertPathIsSet(interface3, path2)
          self.assertPathIsSet(interface4, path2)
  
          # Test SVG generation
          CableTraceSVG(interface1).render()
  
          # Delete cable 1
          cable1.delete()
  
          # Check that all CablePaths have been deleted
          self.assertEqual(CablePath.objects.count(), 0)
          interface1.refresh_from_db()
          interface2.refresh_from_db()
          interface3.refresh_from_db()
          interface4.refresh_from_db()
          self.assertPathIsNotSet(interface1)
          self.assertPathIsNotSet(interface2)
          self.assertPathIsNotSet(interface3)
          self.assertPathIsNotSet(interface4)
  
      def test_201_single_path_via_pass_through(self):
          """
          [IF1] --C1-- [FP1] [RP1] --C2-- [IF2]
          """
          interface1 = Interface.objects.create(device=self.device, name='Interface 1')
          interface2 = Interface.objects.create(device=self.device, name='Interface 2')
          rearport1 = RearPort.objects.create(device=self.device, name='Rear Port 1', positions=1)
          frontport1 = FrontPort.objects.create(
              device=self.device, name='Front Port 1', rear_port=rearport1, rear_port_position=1
          )
  
          # Create cable 1
          cable1 = Cable(
              a_terminations=[interface1],
              b_terminations=[frontport1]
          )
          cable1.save()
          self.assertPathExists(
              (interface1, cable1, frontport1, rearport1),
              is_complete=False
          )
          self.assertEqual(CablePath.objects.count(), 1)
  
          # Create cable 2
          cable2 = Cable(
              a_terminations=[rearport1],
              b_terminations=[interface2]
          )
          cable2.save()
          self.assertPathExists(
              (interface1, cable1, frontport1, rearport1, cable2, interface2),
              is_complete=True,
              is_active=True
          )
          self.assertPathExists(
              (interface2, cable2, rearport1, frontport1, cable1, interface1),
              is_complete=True,
              is_active=True
          )
          self.assertEqual(CablePath.objects.count(), 2)
  
          # Test SVG generation
          CableTraceSVG(interface1).render()
  
          # Delete cable 2
          cable2.delete()
          path1 = self.assertPathExists(
              (interface1, cable1, frontport1, rearport1),
              is_complete=False
          )
          self.assertEqual(CablePath.objects.count(), 1)
          interface1.refresh_from_db()
          interface2.refresh_from_db()
          self.assertPathIsSet(interface1, path1)
          self.assertPathIsNotSet(interface2)
  
      def test_202_single_path_via_pass_through_with_breakouts(self):
          """
          [IF1] --C1-- [FP1] [RP1] --C2-- [IF3]
          [IF2]                           [IF4]
          """
          interface1 = Interface.objects.create(device=self.device, name='Interface 1')
          interface2 = Interface.objects.create(device=self.device, name='Interface 2')
          interface3 = Interface.objects.create(device=self.device, name='Interface 3')
          interface4 = Interface.objects.create(device=self.device, name='Interface 4')
          rearport1 = RearPort.objects.create(device=self.device, name='Rear Port 1', positions=1)
          frontport1 = FrontPort.objects.create(
              device=self.device, name='Front Port 1', rear_port=rearport1, rear_port_position=1
          )
  
          # Create cable 1
          cable1 = Cable(
              a_terminations=[interface1, interface2],
              b_terminations=[frontport1]
          )
          cable1.save()
          self.assertPathExists(
              ([interface1, interface2], cable1, frontport1, rearport1),
              is_complete=False
          )
          self.assertEqual(CablePath.objects.count(), 1)
  
          # Create cable 2
          cable2 = Cable(
              a_terminations=[rearport1],
              b_terminations=[interface3, interface4]
          )
          cable2.save()
          self.assertPathExists(
              ([interface1, interface2], cable1, frontport1, rearport1, cable2, [interface3, interface4]),
              is_complete=True,
              is_active=True
          )
          self.assertPathExists(
              ([interface3, interface4], cable2, rearport1, frontport1, cable1, [interface1, interface2]),
              is_complete=True,
              is_active=True
          )
          self.assertEqual(CablePath.objects.count(), 2)
  
          # Test SVG generation
          CableTraceSVG(interface1).render()
  
          # Delete cable 2
          cable2.delete()
          path1 = self.assertPathExists(
              ([interface1, interface2], cable1, frontport1, rearport1),
              is_complete=False
          )
          self.assertEqual(CablePath.objects.count(), 1)
          interface1.refresh_from_db()
          interface2.refresh_from_db()
          self.assertPathIsSet(interface1, path1)
          self.assertPathIsSet(interface2, path1)
          self.assertPathIsNotSet(interface3)
          self.assertPathIsNotSet(interface4)
  
      def test_203_multiple_paths_via_pass_through(self):
          """
          [IF1] --C1-- [FP1:1] [RP1] --C3-- [RP2] [FP2:1] --C4-- [IF3]
          [IF2] --C2-- [FP1:2]                    [FP2:2] --C5-- [IF4]
          """
          interface1 = Interface.objects.create(device=self.device, name='Interface 1')
          interface2 = Interface.objects.create(device=self.device, name='Interface 2')
          interface3 = Interface.objects.create(device=self.device, name='Interface 3')
          interface4 = Interface.objects.create(device=self.device, name='Interface 4')
          rearport1 = RearPort.objects.create(device=self.device, name='Rear Port 1', positions=4)
          rearport2 = RearPort.objects.create(device=self.device, name='Rear Port 2', positions=4)
          frontport1_1 = FrontPort.objects.create(
              device=self.device, name='Front Port 1:1', rear_port=rearport1, rear_port_position=1
          )
          frontport1_2 = FrontPort.objects.create(
              device=self.device, name='Front Port 1:2', rear_port=rearport1, rear_port_position=2
          )
          frontport2_1 = FrontPort.objects.create(
              device=self.device, name='Front Port 2:1', rear_port=rearport2, rear_port_position=1
          )
          frontport2_2 = FrontPort.objects.create(
              device=self.device, name='Front Port 2:2', rear_port=rearport2, rear_port_position=2
          )
  
          # Create cables 1-2
          cable1 = Cable(
              a_terminations=[interface1],
              b_terminations=[frontport1_1]
          )
          cable1.save()
          cable2 = Cable(
              a_terminations=[interface2],
              b_terminations=[frontport1_2]
          )
          cable2.save()
          self.assertPathExists(
              (interface1, cable1, frontport1_1, rearport1),
              is_complete=False
          )
          self.assertPathExists(
              (interface2, cable2, frontport1_2, rearport1),
              is_complete=False
          )
          self.assertEqual(CablePath.objects.count(), 2)
  
          # Create cable 3
          cable3 = Cable(
              a_terminations=[rearport1],
              b_terminations=[rearport2]
          )
          cable3.save()
          self.assertPathExists(
              (interface1, cable1, frontport1_1, rearport1, cable3, rearport2, frontport2_1),
              is_complete=False
          )
          self.assertPathExists(
              (interface2, cable2, frontport1_2, rearport1, cable3, rearport2, frontport2_2),
              is_complete=False
          )
          self.assertEqual(CablePath.objects.count(), 2)
  
          # Create cables 4-5
          cable4 = Cable(
              a_terminations=[frontport2_1],
              b_terminations=[interface3]
          )
          cable4.save()
          cable5 = Cable(
              a_terminations=[frontport2_2],
              b_terminations=[interface4]
          )
          cable5.save()
          path1 = self.assertPathExists(
              (interface1, cable1, frontport1_1, rearport1, cable3, rearport2, frontport2_1, cable4, interface3),
              is_complete=True,
              is_active=True
          )
          path2 = self.assertPathExists(
              (interface2, cable2, frontport1_2, rearport1, cable3, rearport2, frontport2_2, cable5, interface4),
              is_complete=True,
              is_active=True
          )
          path3 = self.assertPathExists(
              (interface3, cable4, frontport2_1, rearport2, cable3, rearport1, frontport1_1, cable1, interface1),
              is_complete=True,
              is_active=True
          )
          path4 = self.assertPathExists(
              (interface4, cable5, frontport2_2, rearport2, cable3, rearport1, frontport1_2, cable2, interface2),
              is_complete=True,
              is_active=True
          )
          self.assertEqual(CablePath.objects.count(), 4)
  
          # Test SVG generation
          CableTraceSVG(interface1).render()
  
          # Delete cable 3
          cable3.delete()
  
          # Check for four partial paths; one from each interface
          self.assertEqual(CablePath.objects.filter(is_complete=False).count(), 4)
          self.assertEqual(CablePath.objects.filter(is_complete=True).count(), 0)
          interface1.refresh_from_db()
          interface2.refresh_from_db()
          interface3.refresh_from_db()
          interface4.refresh_from_db()
          self.assertPathIsSet(interface1, path1)
          self.assertPathIsSet(interface2, path2)
          self.assertPathIsSet(interface3, path3)
          self.assertPathIsSet(interface4, path4)
  
      def test_204_multiple_paths_via_pass_through_with_breakouts(self):
          """
          [IF1] --C1-- [FP1:1] [RP1] --C3-- [RP2] [FP2:1] --C4-- [IF4]
          [IF2]                                                  [IF5]
          [IF3] --C2-- [FP1:2]                    [FP2:2] --C5-- [IF6]
          [IF4]                                                  [IF7]
          """
          interface1 = Interface.objects.create(device=self.device, name='Interface 1')
          interface2 = Interface.objects.create(device=self.device, name='Interface 2')
          interface3 = Interface.objects.create(device=self.device, name='Interface 3')
          interface4 = Interface.objects.create(device=self.device, name='Interface 4')
          interface5 = Interface.objects.create(device=self.device, name='Interface 5')
          interface6 = Interface.objects.create(device=self.device, name='Interface 6')
          interface7 = Interface.objects.create(device=self.device, name='Interface 7')
          interface8 = Interface.objects.create(device=self.device, name='Interface 8')
          rearport1 = RearPort.objects.create(device=self.device, name='Rear Port 1', positions=4)
          rearport2 = RearPort.objects.create(device=self.device, name='Rear Port 2', positions=4)
          frontport1_1 = FrontPort.objects.create(
              device=self.device, name='Front Port 1:1', rear_port=rearport1, rear_port_position=1
          )
          frontport1_2 = FrontPort.objects.create(
              device=self.device, name='Front Port 1:2', rear_port=rearport1, rear_port_position=2
          )
          frontport2_1 = FrontPort.objects.create(
              device=self.device, name='Front Port 2:1', rear_port=rearport2, rear_port_position=1
          )
          frontport2_2 = FrontPort.objects.create(
              device=self.device, name='Front Port 2:2', rear_port=rearport2, rear_port_position=2
          )
  
          # Create cables 1-2
          cable1 = Cable(
              a_terminations=[interface1, interface2],
              b_terminations=[frontport1_1]
          )
          cable1.save()
          cable2 = Cable(
              a_terminations=[interface3, interface4],
              b_terminations=[frontport1_2]
          )
          cable2.save()
          self.assertPathExists(
              ([interface1, interface2], cable1, frontport1_1, rearport1),
              is_complete=False
          )
          self.assertPathExists(
              ([interface3, interface4], cable2, frontport1_2, rearport1),
              is_complete=False
          )
          self.assertEqual(CablePath.objects.count(), 2)
  
          # Create cable 3
          cable3 = Cable(
              a_terminations=[rearport1],
              b_terminations=[rearport2]
          )
          cable3.save()
          self.assertPathExists(
              ([interface1, interface2], cable1, frontport1_1, rearport1, cable3, rearport2, frontport2_1),
              is_complete=False
          )
          self.assertPathExists(
              ([interface3, interface4], cable2, frontport1_2, rearport1, cable3, rearport2, frontport2_2),
              is_complete=False
          )
          self.assertEqual(CablePath.objects.count(), 2)
  
          # Create cables 4-5
          cable4 = Cable(
              a_terminations=[frontport2_1],
              b_terminations=[interface5, interface6]
          )
          cable4.save()
          cable5 = Cable(
              a_terminations=[frontport2_2],
              b_terminations=[interface7, interface8]
          )
          cable5.save()
          path1 = self.assertPathExists(
              (
                  [interface1, interface2],
                  cable1,
                  frontport1_1,
                  rearport1,
                  cable3,
                  rearport2,
                  frontport2_1,
                  cable4,
                  [interface5, interface6],
              ),
              is_complete=True,
              is_active=True,
          )
          path2 = self.assertPathExists(
              (
                  [interface3, interface4],
                  cable2,
                  frontport1_2,
                  rearport1,
                  cable3,
                  rearport2,
                  frontport2_2,
                  cable5,
                  [interface7, interface8],
              ),
              is_complete=True,
              is_active=True,
          )
          path3 = self.assertPathExists(
              (
                  [interface5, interface6],
                  cable4,
                  frontport2_1,
                  rearport2,
                  cable3,
                  rearport1,
                  frontport1_1,
                  cable1,
                  [interface1, interface2],
              ),
              is_complete=True,
              is_active=True,
          )
          path4 = self.assertPathExists(
              (
                  [interface7, interface8],
                  cable5,
                  frontport2_2,
                  rearport2,
                  cable3,
                  rearport1,
                  frontport1_2,
                  cable2,
                  [interface3, interface4],
              ),
              is_complete=True,
              is_active=True,
          )
          self.assertEqual(CablePath.objects.count(), 4)
  
          # Test SVG generation
          CableTraceSVG(interface1).render()
  
          # Delete cable 3
          cable3.delete()
  
          # Check for four partial paths; one from each interface
          self.assertEqual(CablePath.objects.filter(is_complete=False).count(), 4)
          self.assertEqual(CablePath.objects.filter(is_complete=True).count(), 0)
          interface1.refresh_from_db()
          interface2.refresh_from_db()
          interface3.refresh_from_db()
          interface4.refresh_from_db()
          interface5.refresh_from_db()
          interface6.refresh_from_db()
          interface7.refresh_from_db()
          interface8.refresh_from_db()
          self.assertPathIsSet(interface1, path1)
          self.assertPathIsSet(interface2, path1)
          self.assertPathIsSet(interface3, path2)
          self.assertPathIsSet(interface4, path2)
          self.assertPathIsSet(interface5, path3)
          self.assertPathIsSet(interface6, path3)
          self.assertPathIsSet(interface7, path4)
          self.assertPathIsSet(interface8, path4)
  
      def test_205_multiple_paths_via_nested_pass_throughs(self):
          """
          [IF1] --C1-- [FP1:1] [RP1] --C3-- [FP2] [RP2] --C4-- [RP3] [FP3] --C5-- [RP4] [FP4:1] --C6-- [IF3]
          [IF2] --C2-- [FP1:2]                                                          [FP4:2] --C7-- [IF4]
          """
          interface1 = Interface.objects.create(device=self.device, name='Interface 1')
          interface2 = Interface.objects.create(device=self.device, name='Interface 2')
          interface3 = Interface.objects.create(device=self.device, name='Interface 3')
          interface4 = Interface.objects.create(device=self.device, name='Interface 4')
          rearport1 = RearPort.objects.create(device=self.device, name='Rear Port 1', positions=4)
          rearport2 = RearPort.objects.create(device=self.device, name='Rear Port 2', positions=1)
          rearport3 = RearPort.objects.create(device=self.device, name='Rear Port 3', positions=1)
          rearport4 = RearPort.objects.create(device=self.device, name='Rear Port 4', positions=4)
          frontport1_1 = FrontPort.objects.create(
              device=self.device, name='Front Port 1:1', rear_port=rearport1, rear_port_position=1
          )
          frontport1_2 = FrontPort.objects.create(
              device=self.device, name='Front Port 1:2', rear_port=rearport1, rear_port_position=2
          )
          frontport2 = FrontPort.objects.create(
              device=self.device, name='Front Port 2', rear_port=rearport2, rear_port_position=1
          )
          frontport3 = FrontPort.objects.create(
              device=self.device, name='Front Port 3', rear_port=rearport3, rear_port_position=1
          )
          frontport4_1 = FrontPort.objects.create(
              device=self.device, name='Front Port 4:1', rear_port=rearport4, rear_port_position=1
          )
          frontport4_2 = FrontPort.objects.create(
              device=self.device, name='Front Port 4:2', rear_port=rearport4, rear_port_position=2
          )
  
          # Create cables 1-2, 6-7
          cable1 = Cable(
              a_terminations=[interface1],
              b_terminations=[frontport1_1]
          )
          cable1.save()
          cable2 = Cable(
              a_terminations=[interface2],
              b_terminations=[frontport1_2]
          )
          cable2.save()
          cable6 = Cable(
              a_terminations=[interface3],
              b_terminations=[frontport4_1]
          )
          cable6.save()
          cable7 = Cable(
              a_terminations=[interface4],
              b_terminations=[frontport4_2]
          )
          cable7.save()
          self.assertEqual(CablePath.objects.count(), 4)  # Four partial paths; one from each interface
  
          # Create cables 3 and 5
          cable3 = Cable(
              a_terminations=[rearport1],
              b_terminations=[frontport2]
          )
          cable3.save()
          cable5 = Cable(
              a_terminations=[rearport4],
              b_terminations=[frontport3]
          )
          cable5.save()
          self.assertEqual(CablePath.objects.count(), 4)  # Four (longer) partial paths; one from each interface
  
          # Create cable 4
          cable4 = Cable(
              a_terminations=[rearport2],
              b_terminations=[rearport3]
          )
          cable4.save()
          self.assertPathExists(
              (
                  interface1, cable1, frontport1_1, rearport1, cable3, frontport2, rearport2, cable4, rearport3,
                  frontport3, cable5, rearport4, frontport4_1, cable6, interface3,
              ),
              is_complete=True,
              is_active=True
          )
          self.assertPathExists(
              (
                  interface2, cable2, frontport1_2, rearport1, cable3, frontport2, rearport2, cable4, rearport3,
                  frontport3, cable5, rearport4, frontport4_2, cable7, interface4,
              ),
              is_complete=True,
              is_active=True
          )
          self.assertPathExists(
              (
                  interface3, cable6, frontport4_1, rearport4, cable5, frontport3, rearport3, cable4, rearport2,
                  frontport2, cable3, rearport1, frontport1_1, cable1, interface1,
              ),
              is_complete=True,
              is_active=True
          )
          self.assertPathExists(
              (
                  interface4, cable7, frontport4_2, rearport4, cable5, frontport3, rearport3, cable4, rearport2,
                  frontport2, cable3, rearport1, frontport1_2, cable2, interface2,
              ),
              is_complete=True,
              is_active=True
          )
          self.assertEqual(CablePath.objects.count(), 4)
  
          # Test SVG generation
          CableTraceSVG(interface1).render()
  
          # Delete cable 3
          cable3.delete()
  
          # Check for four partial paths; one from each interface
          self.assertEqual(CablePath.objects.filter(is_complete=False).count(), 4)
          self.assertEqual(CablePath.objects.filter(is_complete=True).count(), 0)
  
      def test_206_multiple_paths_via_multiple_pass_throughs(self):
          """
          [IF1] --C1-- [FP1:1] [RP1] --C3-- [RP2] [FP2:1] --C4-- [FP3:1] [RP3] --C6-- [RP4] [FP4:1] --C7-- [IF3]
          [IF2] --C2-- [FP1:2]                    [FP2:1] --C5-- [FP3:1]                    [FP4:2] --C8-- [IF4]
          """
  