test_esipp_network.py

        # directed arcs cannot end on an import node: A -> I

        error_triggered = False
        try:
            net.add_directed_arc(node_key_a="A", node_key_b="I", arcs=lossless_arcs)
        except ValueError:
            error_triggered = True
        assert error_triggered

        # import-export nodes cannot have static losses

        error_triggered = False
        try:
            net.add_directed_arc(node_key_a="I", node_key_b="E", arcs=lossy_arcs)
        except ValueError:
            error_triggered = True
        assert error_triggered

        # undirected arcs cannot involve import nor export nodes

        error_triggered = False
        try:
            net.add_undirected_arc(node_key_a="I", node_key_b="A", arcs=lossless_arcs)
        except ValueError:
            error_triggered = True
        assert error_triggered

        # undirected arcs cannot involve import nor export nodes

        error_triggered = False
        try:
            net.add_undirected_arc(node_key_a="B", node_key_b="E", arcs=lossless_arcs)
        except ValueError:
            error_triggered = True
        assert error_triggered

        # *********************************************************************
        # *********************************************************************

        # trigger errors using non-identified nodes

        # *********************************************************************

        # create a new export node

        net.add_export_node(node_key="E1", prices={(0, 0, 0): resource_price})

        # create an arc starting in that export node

        error_triggered = False
        try:
            net.add_directed_arc(node_key_a="E1", node_key_b="B", arcs=lossless_arcs)
            net.identify_node_types()
        except ValueError:
            error_triggered = True
        assert error_triggered

        # remove the troublesome arc

        net.remove_edge(u="E1", v="B")

        # *********************************************************************

        # create a new import node

        net.add_import_node(node_key="I1", prices={(0, 0, 0): resource_price})

        # create an arc ending in that import node

        error_triggered = False
        try:
            net.add_directed_arc(node_key_a="A", node_key_b="I1", arcs=lossless_arcs)
            net.identify_node_types()
        except ValueError:
            error_triggered = True
        assert error_triggered

        # remove the troublesome arc

        net.remove_edge(u="A", v="I1")

        # *********************************************************************

        # check non-existent arc

        net.arc_is_undirected(("X", "Y", 1))
        
    # *************************************************************************
    # *************************************************************************
            
    def test_undirected_arc_import_error(self):
        
        # network    
        mynet = Network()
    
        # import node    
        imp_node_key = generate_pseudo_unique_key(mynet.nodes())    
        mynet.add_import_node(
            node_key=imp_node_key,
            prices={
                (0, 0, 0): ResourcePrice(prices=1+0.05, volumes=None)
            },
        )
    
        # other nodes
        node_A = generate_pseudo_unique_key(mynet.nodes())
        mynet.add_source_sink_node(
            node_key=node_A,
            # base_flow=[1, -1, 0.5, -0.5]
            base_flow={(0, 0): 1, (0, 1): -1, (0, 2): 0.5, (0, 3): -0.5},
        )
        node_B = generate_pseudo_unique_key(mynet.nodes())
        mynet.add_source_sink_node(
            node_key=node_B,
            # base_flow=[-1, 1, -0.5, 0.5]
            base_flow={(0, 0): -1, (0, 1): 1, (0, 2): -0.5, (0, 3): 0.5},
        )
    
        # add arcs
    
        # import arc
        arc_tech_IA = Arcs(
            name="any",
            # efficiency=[1, 1, 1, 1],
            efficiency={(0, 0): 1, (0, 1): 1, (0, 2): 1, (0, 3): 1},
            capacity=[0.5, 0.75, 1.0, 1.25, 1.5, 2.0],
            minimum_cost=[10, 10.1, 10.2, 10.3, 10.4, 10.5],
            specific_capacity_cost=1,
            capacity_is_instantaneous=False,
            efficiency_reverse=None,
            static_loss=None,
            validate=False,
        )
        mynet.add_undirected_arc(
            node_key_a=imp_node_key, node_key_b=node_A, arcs=arc_tech_IA
        )
    
        error_raised = False
        try:
            # identify node types
            mynet.identify_node_types()
        except ValueError:
            error_raised = True
        assert error_raised
    
        # *********************************************************************
        # *********************************************************************
        
    # *************************************************************************
    # *************************************************************************
            
    def test_undirected_arc_export_error(self):
            
        # 4 nodes: one import, one export, two supply/demand nodes
        mynet = Network()
    
        # export node
        exp_node_key = generate_pseudo_unique_key(mynet.nodes())
        mynet.add_export_node(
            node_key=exp_node_key,
            prices={
                (0, 0, 0): ResourcePrice(prices=0.1+0.05, volumes=None)
            },
        )
    
        # other nodes
        node_B = generate_pseudo_unique_key(mynet.nodes())
        mynet.add_source_sink_node(
            node_key=node_B,
            # base_flow=[-1, 1, -0.5, 0.5]
            base_flow={(0, 0): -1, (0, 1): 1, (0, 2): -0.5, (0, 3): 0.5},
        )    
        # export arc
        arc_tech_BE = Arcs(
            name="any",
            # efficiency=[1, 1, 1, 1],
            efficiency={(0, 0): 1, (0, 1): 1, (0, 2): 1, (0, 3): 1},
            capacity=[0.5, 0.75, 1.0, 1.25, 1.5, 2.0],
            minimum_cost=[10, 10.1, 10.2, 10.3, 10.4, 10.5],
            specific_capacity_cost=1,
            capacity_is_instantaneous=False,
            efficiency_reverse=None,
            static_loss=None,
            validate=False,
        )
        mynet.add_undirected_arc(
            node_key_a=node_B, node_key_b=exp_node_key, arcs=arc_tech_BE
        )
        
        error_raised = False
        try:
            # identify node types
            mynet.identify_node_types()
        except ValueError:
            error_raised = True
        assert error_raised

    # *************************************************************************
    # *************************************************************************

    def test_pseudo_unique_key_generation(self):
        # create network

        network = Network()

        # add node A

        network.add_waypoint_node(node_key="A")

        # add node B

        network.add_waypoint_node(node_key="B")

        # identify nodes

        network.identify_node_types()

        # add arcs

        key_list = [
            "3e225573-4e78-48c8-bb08-efbeeb795c22",
            "f6d30428-15d1-41e9-a952-0742eaaa5a31",
            "8c29b906-2518-41c5-ada8-07b83508b5b8",
            "f9a72a39-1422-4a02-af97-906ce79c32a3",
            "b6941a48-10cc-465d-bf53-178bd2939bd1",
        ]

        for key in key_list:
            network.add_edge(
                u_for_edge="A",
                v_for_edge="B",
                key=key,
                **{network.KEY_ARC_UND: False, network.KEY_ARC_TECH: None}
            )

        # use a seed number to trigger more iterations

        import uuid

        rand = random.Random()
        rand.seed(360)
        uuid.uuid4 = lambda: uuid.UUID(int=rand.getrandbits(128), version=4)

        error_triggered = False
        try:
            _ = network.get_pseudo_unique_arc_key(
                node_key_start="A", node_key_end="B", max_iterations=len(key_list) - 1
            )
        except Exception:
            error_triggered = True
        assert error_triggered

# *****************************************************************************
# *****************************************************************************