import pytest
from tjnetwork import *

class TestApi:
    def enter(self, p):
        if is_project_open(p):
            close_project(p)

        if have_project(p):
            delete_project(p)

        create_project(p)
        open_project(p)


    def leave(self, p):
        close_project(p)
        delete_project(p)


    def test_project(self):
        p = 'test_project'

        assert not have_project(p)
        assert not is_project_open(p)
        assert get_project_open_count(p) == 0

        create_project(p)

        assert have_project(p)
        assert not is_project_open(p)
        assert get_project_open_count(p) == 0

        open_project(p)

        assert have_project(p)
        assert is_project_open(p)
        assert get_project_open_count(p) == 1

        open_project(p)

        assert have_project(p)
        assert is_project_open(p)
        assert get_project_open_count(p) == 2

        close_project(p)

        assert have_project(p)
        assert is_project_open(p)
        assert get_project_open_count(p) == 1

        close_project(p)
        
        assert have_project(p)
        assert not is_project_open(p)
        assert get_project_open_count(p) == 0

        delete_project(p)

        assert not have_project(p)
        assert not is_project_open(p)
        assert get_project_open_count(p) == 0


    def test_title(self):
        p = 'test_title'
        self.enter(p)

        assert get_title(p)['value'] == ''

        change = set_title(p, ChangeSet({'value': 'title'})).operations[0]
        assert change['operation'] == 'update'
        assert change['type'] == 'title'
        assert get_title(p)['value'] == 'title'

        set_title(p, ChangeSet({'value': 'test'}))
        assert get_title(p)['value'] == 'test'

        self.leave(p)


    def test_title_op(self):
        p = 'test_title_op'
        self.enter(p)

        assert get_title(p)['value'] == ''

        cs = set_title(p, ChangeSet({'value': 'title'})).operations[0]
        assert cs['operation'] == 'update'
        assert cs['type'] == 'title'
        assert cs['value'] == 'title'
        assert get_title(p)['value'] == 'title'

        cs = execute_undo(p).operations[0]
        assert cs['operation'] == 'update'
        assert cs['type'] == 'title'
        assert cs['value'] == ''
        assert get_title(p)['value'] == ''

        cs = execute_redo(p).operations[0]
        assert cs['operation'] == 'update'
        assert cs['type'] == 'title'
        assert cs['value'] == 'title'
        assert get_title(p)['value'] == 'title'

        cs = execute_undo(p, True).operations[0]
        assert cs['operation'] == 'update'
        assert cs['type'] == 'title'
        assert cs['value'] == ''
        assert get_title(p)['value'] == ''

        cs = execute_redo(p)
        assert len(cs.operations) == 0
        assert get_title(p)['value'] == ''

        self.leave(p)


    def test_junction(self):
        p = 'test_junction'
        self.enter(p)

        add_junction(p, ChangeSet({'id': 'j0', 'x': 0.0, 'y': 10.0, 'elevation': 20.0}))
        j0 = get_junction(p, 'j0')
        assert j0['x'] == 0.0
        assert j0['y'] == 10.0
        assert j0['elevation'] == 20.0
        assert j0['demand'] == None
        assert j0['pattern'] == None
        assert j0['links'] == []

        set_junction(p, ChangeSet({'id': 'j0', 'x': 100.0, 'y': 200.0}))
        j0 = get_junction(p, 'j0')
        assert j0['x'] == 100.0
        assert j0['y'] == 200.0

        set_junction(p, ChangeSet({'id': 'j0', 'elevation': 100.0}))
        j0 = get_junction(p, 'j0')
        assert j0['elevation'] == 100.0

        set_junction(p, ChangeSet({'id': 'j0', 'demand': 100.0}))
        j0 = get_junction(p, 'j0')
        assert j0['demand'] == 100.0

        # TODO: pattern

        add_junction(p, ChangeSet({'id': 'j1', 'x': 0.0, 'y': 10.0, 'elevation': 20.0}))
        nodes = get_nodes(p)
        assert len(nodes) == 2
        assert nodes[0] == 'j0'
        assert nodes[1] == 'j1'
        assert is_junction(p, 'j0')
        assert is_junction(p, 'j1')

        delete_junction(p, ChangeSet({'id': 'j1'}))
        nodes = get_nodes(p)
        assert len(nodes) == 1
        assert nodes[0] == 'j0'

        delete_junction(p, ChangeSet({'id': 'j0'}))
        nodes = get_nodes(p)
        assert len(nodes) == 0

        add_junction(p, ChangeSet({'id': 'j1', 'x': 0.0, 'y': 10.0, 'elevation': 20.0}))
        add_junction(p, ChangeSet({'id': 'j2', 'x': 0.0, 'y': 10.0, 'elevation': 20.0}))
        add_junction(p, ChangeSet({'id': 'j3', 'x': 0.0, 'y': 10.0, 'elevation': 20.0}))
        add_pipe(p, ChangeSet({'id': 'p1', 'node1': 'j1', 'node2': 'j2', 'length': 100.0, 'diameter': 10.0, 'roughness': 0.1, 'minor_loss': 0.5, 'status': PIPE_STATUS_OPEN }))
        add_pump(p, ChangeSet({'id': 'p2', 'node1': 'j1', 'node2': 'j2'}))
        add_valve(p, ChangeSet({'id': 'v1', 'node1': 'j2', 'node2': 'j3', 'diameter': 10.0, 'v_type': VALVES_TYPE_FCV, 'setting': 0.1, 'minor_loss': 0.5 }))
        assert get_junction(p, 'j1')['links'] == ['p1', 'p2']
        assert get_junction(p, 'j2')['links'] == ['p1', 'p2', 'v1']
        assert get_junction(p, 'j3')['links'] == ['v1']

        self.leave(p)

    
    def test_junction_op(self):
        p = 'test_junction_op'
        self.enter(p)

        cs = add_junction(p, ChangeSet({'id': 'j0', 'x': 0.0, 'y': 10.0, 'elevation': 20.0})).operations[0]
        assert cs['operation'] == 'add'
        assert cs['type'] == JUNCTION
        assert cs['id'] == 'j0'
        assert cs['x'] == 0.0
        assert cs['y'] == 10.0
        assert cs['elevation'] == 20.0
        assert cs['demand'] == None
        assert cs['pattern'] == None

        cs = execute_undo(p).operations[0]
        assert cs['operation'] == 'delete'
        assert cs['type'] == JUNCTION
        assert cs['id'] == 'j0'

        cs = execute_redo(p).operations[0]
        assert cs['operation'] == 'add'
        assert cs['type'] == JUNCTION
        assert cs['id'] == 'j0'
        assert cs['x'] == 0.0
        assert cs['y'] == 10.0
        assert cs['elevation'] == 20.0
        assert cs['demand'] == None
        assert cs['pattern'] == None

        cs = execute_undo(p, True).operations[0]
        assert cs['operation'] == 'delete'
        assert cs['type'] == JUNCTION
        assert cs['id'] == 'j0'

        cs = execute_redo(p)
        assert len(cs.operations) == 0

        nodes = get_nodes(p)
        assert len(nodes) == 0

        add_junction(p, ChangeSet({'id': 'j0', 'x': 0.0, 'y': 10.0, 'elevation': 20.0, 'demand': 100.0}))

        nodes = get_nodes(p)
        assert len(nodes) == 1

        cs = delete_junction(p, ChangeSet({'id': 'j0'})).operations[0]
        assert cs['operation'] == 'delete'
        assert cs['type'] == JUNCTION
        assert cs['id'] == 'j0'

        cs = execute_undo(p).operations[0]
        assert cs['operation'] == 'add'
        assert cs['type'] == JUNCTION
        assert cs['id'] == 'j0'
        assert cs['x'] == 0.0
        assert cs['y'] == 10.0
        assert cs['elevation'] == 20.0
        assert cs['demand'] == 100.0
        assert cs['pattern'] == None

        cs = execute_redo(p).operations[0]
        assert cs['operation'] == 'delete'
        assert cs['type'] == JUNCTION
        assert cs['id'] == 'j0'

        cs = execute_undo(p, True).operations[0]
        assert cs['operation'] == 'add'
        assert cs['type'] == JUNCTION
        assert cs['id'] == 'j0'
        assert cs['x'] == 0.0
        assert cs['y'] == 10.0
        assert cs['elevation'] == 20.0
        assert cs['demand'] == 100.0
        assert cs['pattern'] == None

        cs = execute_redo(p)
        assert len(cs.operations) == 0

        nodes = get_nodes(p)
        assert len(nodes) == 1

        cs = set_junction(p, ChangeSet({'id': 'j0', 'x': 100.0, 'y': 200.0})).operations[0]
        assert cs['operation'] == 'update'
        assert cs['type'] == JUNCTION
        assert cs['id'] == 'j0'
        assert cs['x'] == 100.0
        assert cs['y'] == 200.0
        assert cs['elevation'] == 20.0
        assert cs['demand'] == 100.0
        assert cs['pattern'] == None

        cs = execute_undo(p).operations[0]
        assert cs['operation'] == 'update'
        assert cs['type'] == JUNCTION
        assert cs['id'] == 'j0'
        assert cs['x'] == 0.0
        assert cs['y'] == 10.0
        assert cs['elevation'] == 20.0
        assert cs['demand'] == 100.0
        assert cs['pattern'] == None

        self.leave(p)


    def test_reservoir(self):
        p = 'test_reservoir'
        self.enter(p)

        add_reservoir(p, ChangeSet({'id': 'r0', 'x': 0.0, 'y': 10.0, 'head': 20.0}))
        r0 = get_reservoir(p, 'r0')
        assert r0['x'] == 0.0
        assert r0['y'] == 10.0
        assert r0['head'] == 20.0
        assert r0['pattern'] == None
        assert r0['links'] == []

        set_reservoir(p, ChangeSet({'id': 'r0', 'x': 100.0, 'y': 200.0}))
        r0 = get_reservoir(p, 'r0')
        assert r0['x'] == 100.0
        assert r0['y'] == 200.0

        set_reservoir(p, ChangeSet({'id': 'r0', 'head': 100.0}))
        r0 = get_reservoir(p, 'r0')
        assert r0['head'] == 100.0

        # TODO: pattern

        add_reservoir(p, ChangeSet({'id': 'r1', 'x': 0.0, 'y': 10.0, 'head': 20.0}))
        nodes = get_nodes(p)
        assert len(nodes) == 2
        assert nodes[0] == 'r0'
        assert nodes[1] == 'r1'
        assert is_reservoir(p, 'r0')
        assert is_reservoir(p, 'r1')

        delete_reservoir(p, ChangeSet({'id': 'r1'}))
        nodes = get_nodes(p)
        assert len(nodes) == 1
        assert nodes[0] == 'r0'

        delete_reservoir(p, ChangeSet({'id': 'r0'}))
        nodes = get_nodes(p)
        assert len(nodes) == 0

        add_reservoir(p, ChangeSet({'id': 'r1', 'x': 0.0, 'y': 10.0, 'head': 20.0}))
        add_reservoir(p, ChangeSet({'id': 'r2', 'x': 0.0, 'y': 10.0, 'head': 20.0}))
        add_reservoir(p, ChangeSet({'id': 'r3', 'x': 0.0, 'y': 10.0, 'head': 20.0}))
        add_pipe(p, ChangeSet({'id': 'p1', 'node1': 'r1', 'node2': 'r2', 'length': 100.0, 'diameter': 10.0, 'roughness': 0.1, 'minor_loss': 0.5, 'status': PIPE_STATUS_OPEN }))
        add_pump(p, ChangeSet({'id': 'p2', 'node1': 'r1', 'node2': 'r2'}))
        add_valve(p, ChangeSet({'id': 'v1', 'node1': 'r2', 'node2': 'r3', 'diameter': 10.0, 'v_type': VALVES_TYPE_FCV, 'setting': 0.1, 'minor_loss': 0.5 }))
        assert get_reservoir(p, 'r1')['links'] == ['p1', 'p2']
        assert get_reservoir(p, 'r2')['links'] == ['p1', 'p2', 'v1']
        assert get_reservoir(p, 'r3')['links'] == ['v1']

        self.leave(p)


    def test_reservoir_op(self):
        p = 'test_reservoir_op'
        self.enter(p)

        cs = add_reservoir(p, ChangeSet({'id': 'r0', 'x': 0.0, 'y': 10.0, 'head': 20.0})).operations[0]
        assert cs['operation'] == 'add'
        assert cs['type'] == RESERVOIR
        assert cs['id'] == 'r0'
        assert cs['x'] == 0.0
        assert cs['y'] == 10.0
        assert cs['head'] == 20.0
        assert cs['pattern'] == None

        cs = execute_undo(p).operations[0]
        assert cs['operation'] == 'delete'
        assert cs['type'] == RESERVOIR
        assert cs['id'] == 'r0'

        cs = execute_redo(p).operations[0]
        assert cs['operation'] == 'add'
        assert cs['type'] == RESERVOIR
        assert cs['id'] == 'r0'
        assert cs['x'] == 0.0
        assert cs['y'] == 10.0
        assert cs['head'] == 20.0
        assert cs['pattern'] == None

        cs = execute_undo(p, True).operations[0]
        assert cs['operation'] == 'delete'
        assert cs['type'] == RESERVOIR
        assert cs['id'] == 'r0'

        cs = execute_redo(p)
        assert len(cs.operations) == 0

        nodes = get_nodes(p)
        assert len(nodes) == 0

        add_reservoir(p, ChangeSet({'id': 'r0', 'x': 0.0, 'y': 10.0, 'head': 20.0}))

        nodes = get_nodes(p)
        assert len(nodes) == 1

        cs = delete_reservoir(p, ChangeSet({'id': 'r0'})).operations[0]
        assert cs['operation'] == 'delete'
        assert cs['type'] == RESERVOIR
        assert cs['id'] == 'r0'

        cs = execute_undo(p).operations[0]
        assert cs['operation'] == 'add'
        assert cs['type'] == RESERVOIR
        assert cs['id'] == 'r0'
        assert cs['x'] == 0.0
        assert cs['y'] == 10.0
        assert cs['head'] == 20.0
        assert cs['pattern'] == None

        cs = execute_redo(p).operations[0]
        assert cs['operation'] == 'delete'
        assert cs['type'] == RESERVOIR
        assert cs['id'] == 'r0'

        cs = execute_undo(p, True).operations[0]
        assert cs['operation'] == 'add'
        assert cs['type'] == RESERVOIR
        assert cs['id'] == 'r0'
        assert cs['x'] == 0.0
        assert cs['y'] == 10.0
        assert cs['head'] == 20.0
        assert cs['pattern'] == None

        cs = execute_redo(p)
        assert len(cs.operations) == 0

        nodes = get_nodes(p)
        assert len(nodes) == 1

        cs = set_reservoir(p, ChangeSet({'id': 'r0', 'x': 100.0, 'y': 200.0})).operations[0]
        assert cs['operation'] == 'update'
        assert cs['type'] == RESERVOIR
        assert cs['id'] == 'r0'
        assert cs['x'] == 100.0
        assert cs['y'] == 200.0
        assert cs['head'] == 20.0
        assert cs['pattern'] == None

        cs = execute_undo(p).operations[0]
        assert cs['operation'] == 'update'
        assert cs['type'] == RESERVOIR
        assert cs['id'] == 'r0'
        assert cs['x'] == 0.0
        assert cs['y'] == 10.0
        assert cs['head'] == 20.0
        assert cs['pattern'] == None

        self.leave(p)


    def test_tank(self):
        p = 'test_tank'
        self.enter(p)

        add_tank(p, ChangeSet({'id': 't0', 'x': 0.0, 'y': 10.0, 'elevation': 20.0, 'init_level': 1.0, 'min_level': 0.0, 'max_level': 2.0, 'diameter': 10.0, 'min_vol': 100.0, 'vol_curve': None, 'overflow': OVERFLOW_NO}))
        t0 = get_tank(p, 't0')
        assert t0['x'] == 0.0
        assert t0['y'] == 10.0
        assert t0['elevation'] == 20.0
        assert t0['init_level'] == 1.0
        assert t0['min_level'] == 0.0
        assert t0['max_level'] == 2.0
        assert t0['diameter'] == 10.0
        assert t0['min_vol'] == 100.0
        assert t0['vol_curve'] == None
        assert t0['overflow'] == OVERFLOW_NO
        assert t0['links'] == []

        set_tank(p, ChangeSet({'id': 't0', 'x': 100.0, 'y': 200.0}))
        t0 = get_tank(p, 't0')
        assert t0['x'] == 100.0
        assert t0['y'] == 200.0

        set_tank(p, ChangeSet({'id': 't0', 'elevation': 100.0}))
        t0 = get_tank(p, 't0')
        assert t0['elevation'] == 100.0

        set_tank(p, ChangeSet({'id': 't0', 'init_level': 100.0, 'min_level': 50.0, 'max_level': 200.0}))
        t0 = get_tank(p, 't0')
        assert t0['init_level'] == 100.0
        assert t0['min_level'] == 50.0
        assert t0['max_level'] == 200.0

        set_tank(p, ChangeSet({'id': 't0', 'diameter': 100.0}))
        t0 = get_tank(p, 't0')
        assert t0['diameter'] == 100.0

        set_tank(p, ChangeSet({'id': 't0', 'min_vol': 200.0}))
        t0 = get_tank(p, 't0')
        assert t0['min_vol'] == 200.0

        # TODO: vol_curve

        set_tank(p, ChangeSet({'id': 't0', 'overflow': OVERFLOW_YES}))
        t0 = get_tank(p, 't0')
        assert t0['overflow'] == OVERFLOW_YES

        add_tank(p, ChangeSet({'id': 't1', 'x': 0.0, 'y': 10.0, 'elevation': 20.0, 'init_level': 1.0, 'min_level': 0.0, 'max_level': 2.0, 'diameter': 10.0, 'min_vol': 100.0, 'vol_curve': None, 'overflow': OVERFLOW_NO}))
        nodes = get_nodes(p)
        assert len(nodes) == 2
        assert nodes[0] == 't0'
        assert nodes[1] == 't1'
        assert is_tank(p, 't0')
        assert is_tank(p, 't1')

        delete_tank(p, ChangeSet({'id': 't1'}))
        nodes = get_nodes(p)
        assert len(nodes) == 1
        assert nodes[0] == 't0'

        delete_tank(p, ChangeSet({'id': 't0'}))
        nodes = get_nodes(p)
        assert len(nodes) == 0

        add_tank(p, ChangeSet({'id': 't1', 'x': 0.0, 'y': 10.0, 'elevation': 20.0, 'init_level': 1.0, 'min_level': 0.0, 'max_level': 2.0, 'diameter': 10.0, 'min_vol': 100.0, 'vol_curve': None, 'overflow': OVERFLOW_NO}))
        add_tank(p, ChangeSet({'id': 't2', 'x': 0.0, 'y': 10.0, 'elevation': 20.0, 'init_level': 1.0, 'min_level': 0.0, 'max_level': 2.0, 'diameter': 10.0, 'min_vol': 100.0, 'vol_curve': None, 'overflow': OVERFLOW_NO}))
        add_tank(p, ChangeSet({'id': 't3', 'x': 0.0, 'y': 10.0, 'elevation': 20.0, 'init_level': 1.0, 'min_level': 0.0, 'max_level': 2.0, 'diameter': 10.0, 'min_vol': 100.0, 'vol_curve': None, 'overflow': OVERFLOW_NO}))
        add_pipe(p, ChangeSet({'id': 'p1', 'node1': 't1', 'node2': 't2', 'length': 100.0, 'diameter': 10.0, 'roughness': 0.1, 'minor_loss': 0.5, 'status': PIPE_STATUS_OPEN }))
        add_pump(p, ChangeSet({'id': 'p2', 'node1': 't1', 'node2': 't2'}))
        add_valve(p, ChangeSet({'id': 'v1', 'node1': 't2', 'node2': 't3', 'diameter': 10.0, 'v_type': VALVES_TYPE_FCV, 'setting': 0.1, 'minor_loss': 0.5 }))
        assert get_tank(p, 't1')['links'] == ['p1', 'p2']
        assert get_tank(p, 't2')['links'] == ['p1', 'p2', 'v1']
        assert get_tank(p, 't3')['links'] == ['v1']

        self.leave(p)


    def test_tank_op(self):
        p = 'test_tank_op'
        self.enter(p)

        cs = add_tank(p, ChangeSet({'id': 't0', 'x': 0.0, 'y': 10.0, 'elevation': 20.0, 'init_level': 1.0, 'min_level': 0.0, 'max_level': 2.0, 'diameter': 10.0, 'min_vol': 100.0, 'vol_curve': None, 'overflow': OVERFLOW_NO})).operations[0]
        assert cs['operation'] == 'add'
        assert cs['type'] == TANK
        assert cs['id'] == 't0'
        assert cs['x'] == 0.0
        assert cs['y'] == 10.0
        assert cs['elevation'] == 20.0
        assert cs['init_level'] == 1.0
        assert cs['min_level'] == 0.0
        assert cs['max_level'] == 2.0
        assert cs['diameter'] == 10.0
        assert cs['min_vol'] == 100.0
        assert cs['vol_curve'] == None
        assert cs['overflow'] == OVERFLOW_NO

        cs = execute_undo(p).operations[0]
        assert cs['operation'] == 'delete'
        assert cs['type'] == TANK
        assert cs['id'] == 't0'

        cs = execute_redo(p).operations[0]
        assert cs['operation'] == 'add'
        assert cs['type'] == TANK
        assert cs['id'] == 't0'
        assert cs['x'] == 0.0
        assert cs['y'] == 10.0
        assert cs['elevation'] == 20.0
        assert cs['init_level'] == 1.0
        assert cs['min_level'] == 0.0
        assert cs['max_level'] == 2.0
        assert cs['diameter'] == 10.0
        assert cs['min_vol'] == 100.0
        assert cs['vol_curve'] == None
        assert cs['overflow'] == OVERFLOW_NO

        cs = execute_undo(p, True).operations[0]
        assert cs['operation'] == 'delete'
        assert cs['type'] == TANK
        assert cs['id'] == 't0'

        cs = execute_redo(p)
        assert len(cs.operations) == 0

        nodes = get_nodes(p)
        assert len(nodes) == 0

        add_tank(p, ChangeSet({'id': 't0', 'x': 0.0, 'y': 10.0, 'elevation': 20.0, 'init_level': 1.0, 'min_level': 0.0, 'max_level': 2.0, 'diameter': 10.0, 'min_vol': 100.0, 'vol_curve': None, 'overflow': OVERFLOW_NO}))

        nodes = get_nodes(p)
        assert len(nodes) == 1

        cs = delete_tank(p, ChangeSet({'id': 't0'})).operations[0]
        assert cs['operation'] == 'delete'
        assert cs['type'] == TANK
        assert cs['id'] == 't0'

        cs = execute_undo(p).operations[0]
        assert cs['operation'] == 'add'
        assert cs['type'] == TANK
        assert cs['id'] == 't0'
        assert cs['x'] == 0.0
        assert cs['y'] == 10.0
        assert cs['elevation'] == 20.0
        assert cs['init_level'] == 1.0
        assert cs['min_level'] == 0.0
        assert cs['max_level'] == 2.0
        assert cs['diameter'] == 10.0
        assert cs['min_vol'] == 100.0
        assert cs['vol_curve'] == None
        assert cs['overflow'] == OVERFLOW_NO

        cs = execute_redo(p).operations[0]
        assert cs['operation'] == 'delete'
        assert cs['type'] == TANK
        assert cs['id'] == 't0'

        cs = execute_undo(p, True).operations[0]
        assert cs['operation'] == 'add'
        assert cs['type'] == TANK
        assert cs['id'] == 't0'
        assert cs['x'] == 0.0
        assert cs['y'] == 10.0
        assert cs['elevation'] == 20.0
        assert cs['init_level'] == 1.0
        assert cs['min_level'] == 0.0
        assert cs['max_level'] == 2.0
        assert cs['diameter'] == 10.0
        assert cs['min_vol'] == 100.0
        assert cs['vol_curve'] == None
        assert cs['overflow'] == OVERFLOW_NO

        cs = execute_redo(p)
        assert len(cs.operations) == 0

        nodes = get_nodes(p)
        assert len(nodes) == 1

        cs = set_tank(p, ChangeSet({'id': 't0', 'x': 100.0, 'y': 200.0})).operations[0]
        assert cs['operation'] == 'update'
        assert cs['type'] == TANK
        assert cs['id'] == 't0'
        assert cs['x'] == 100.0
        assert cs['y'] == 200.0
        assert cs['elevation'] == 20.0
        assert cs['init_level'] == 1.0
        assert cs['min_level'] == 0.0
        assert cs['max_level'] == 2.0
        assert cs['diameter'] == 10.0
        assert cs['min_vol'] == 100.0
        assert cs['vol_curve'] == None
        assert cs['overflow'] == OVERFLOW_NO

        cs = execute_undo(p).operations[0]
        assert cs['operation'] == 'update'
        assert cs['type'] == TANK
        assert cs['id'] == 't0'
        assert cs['x'] == 0.0
        assert cs['y'] == 10.0
        assert cs['elevation'] == 20.0
        assert cs['init_level'] == 1.0
        assert cs['min_level'] == 0.0
        assert cs['max_level'] == 2.0
        assert cs['diameter'] == 10.0
        assert cs['min_vol'] == 100.0
        assert cs['vol_curve'] == None
        assert cs['overflow'] == OVERFLOW_NO

        self.leave(p)


    def test_pipe(self):
        p = 'test_pipe'
        self.enter(p)

        add_junction(p, ChangeSet({'id': 'j1', 'x': 0.0, 'y': 10.0, 'elevation': 20.0}))
        add_junction(p, ChangeSet({'id': 'j2', 'x': 0.0, 'y': 10.0, 'elevation': 20.0}))
        add_junction(p, ChangeSet({'id': 'j3', 'x': 0.0, 'y': 10.0, 'elevation': 20.0}))
        add_junction(p, ChangeSet({'id': 'j4', 'x': 0.0, 'y': 10.0, 'elevation': 20.0}))
        assert is_junction(p, 'j1')
        assert is_junction(p, 'j2')
        assert is_junction(p, 'j3')
        assert is_junction(p, 'j4')

        add_pipe(p, ChangeSet({'id': 'p0', 'node1': 'j1', 'node2': 'j2', 'length': 100.0, 'diameter': 10.0, 'roughness': 0.1, 'minor_loss': 0.5, 'status': PIPE_STATUS_OPEN }))
        p0 = get_pipe(p, 'p0')
        assert p0['node1'] == 'j1'
        assert p0['node2'] == 'j2'
        assert p0['length'] == 100.0
        assert p0['diameter'] == 10.0
        assert p0['roughness'] == 0.1
        assert p0['minor_loss'] == 0.5
        assert p0['status'] == PIPE_STATUS_OPEN

        set_pipe(p, ChangeSet({'id': 'p0', 'node1': 'j3', 'node2': 'j4'}))
        p0 = get_pipe(p, 'p0')
        assert p0['node1'] == 'j3'
        assert p0['node2'] == 'j4'

        set_pipe(p, ChangeSet({'id': 'p0', 'length': 200.0}))
        p0 = get_pipe(p, 'p0')
        assert p0['length'] == 200.0

        set_pipe(p, ChangeSet({'id': 'p0', 'diameter': 100.0}))
        p0 = get_pipe(p, 'p0')
        assert p0['diameter'] == 100.0

        set_pipe(p, ChangeSet({'id': 'p0', 'roughness': 0.2}))
        p0 = get_pipe(p, 'p0')
        assert p0['roughness'] == 0.2

        set_pipe(p, ChangeSet({'id': 'p0', 'minor_loss': 0.1}))
        p0 = get_pipe(p, 'p0')
        assert p0['minor_loss'] == 0.1

        set_pipe(p, ChangeSet({'id': 'p0', 'status': PIPE_STATUS_CLOSED}))
        p0 = get_pipe(p, 'p0')
        assert p0['status'] == PIPE_STATUS_CLOSED

        add_pipe(p, ChangeSet({'id': 'p1', 'node1': 'j1', 'node2': 'j2', 'length': 100.0, 'diameter': 10.0, 'roughness': 0.1, 'minor_loss': 0.5, 'status': PIPE_STATUS_OPEN }))
        links = get_links(p)
        assert len(links) == 2
        assert links[0] == 'p0'
        assert links[1] == 'p1'
        assert is_pipe(p, 'p0')
        assert is_pipe(p, 'p1')

        delete_pipe(p, ChangeSet({'id': 'p1'}))
        links = get_links(p)
        assert len(links) == 1
        assert links[0] == 'p0'

        delete_pipe(p, ChangeSet({'id': 'p0'}))
        links = get_links(p)
        assert len(links) == 0

        self.leave(p)


    def test_pipe_op(self):
        p = 'test_pipe_op'
        self.enter(p)

        add_junction(p, ChangeSet({'id': 'j1', 'x': 0.0, 'y': 10.0, 'elevation': 20.0}))
        add_junction(p, ChangeSet({'id': 'j2', 'x': 0.0, 'y': 10.0, 'elevation': 20.0}))
        add_junction(p, ChangeSet({'id': 'j3', 'x': 0.0, 'y': 10.0, 'elevation': 20.0}))
        add_junction(p, ChangeSet({'id': 'j4', 'x': 0.0, 'y': 10.0, 'elevation': 20.0}))
        assert is_junction(p, 'j1')
        assert is_junction(p, 'j2')
        assert is_junction(p, 'j3')
        assert is_junction(p, 'j4')

        cs = add_pipe(p, ChangeSet({'id': 'p0', 'node1': 'j1', 'node2': 'j2', 'length': 100.0, 'diameter': 10.0, 'roughness': 0.1, 'minor_loss': 0.5, 'status': PIPE_STATUS_OPEN })).operations[0]
        assert cs['operation'] == 'add'
        assert cs['type'] == PIPE
        assert cs['id'] == 'p0'
        assert cs['node1'] == 'j1'
        assert cs['node2'] == 'j2'
        assert cs['length'] == 100.0
        assert cs['diameter'] == 10.0
        assert cs['roughness'] == 0.1
        assert cs['minor_loss'] == 0.5
        assert cs['status'] == PIPE_STATUS_OPEN

        cs = execute_undo(p).operations[0]
        assert cs['operation'] == 'delete'
        assert cs['type'] == PIPE
        assert cs['id'] == 'p0'

        cs = execute_redo(p).operations[0]
        assert cs['operation'] == 'add'
        assert cs['type'] == PIPE
        assert cs['id'] == 'p0'
        assert cs['node1'] == 'j1'
        assert cs['node2'] == 'j2'
        assert cs['length'] == 100.0
        assert cs['diameter'] == 10.0
        assert cs['roughness'] == 0.1
        assert cs['minor_loss'] == 0.5
        assert cs['status'] == PIPE_STATUS_OPEN

        cs = execute_undo(p, True).operations[0]
        assert cs['operation'] == 'delete'
        assert cs['type'] == PIPE
        assert cs['id'] == 'p0'

        cs = execute_redo(p)
        assert len(cs.operations) == 0

        links = get_links(p)
        assert len(links) == 0

        add_pipe(p, ChangeSet({'id': 'p0', 'node1': 'j1', 'node2': 'j2', 'length': 100.0, 'diameter': 10.0, 'roughness': 0.1, 'minor_loss': 0.5, 'status': PIPE_STATUS_OPEN }))

        links = get_links(p)
        assert len(links) == 1

        cs = delete_pipe(p, ChangeSet({'id': 'p0'})).operations[0]
        assert cs['operation'] == 'delete'
        assert cs['type'] == PIPE
        assert cs['id'] == 'p0'

        cs = execute_undo(p).operations[0]
        assert cs['operation'] == 'add'
        assert cs['type'] == PIPE
        assert cs['id'] == 'p0'
        assert cs['node1'] == 'j1'
        assert cs['node2'] == 'j2'
        assert cs['length'] == 100.0
        assert cs['diameter'] == 10.0
        assert cs['roughness'] == 0.1
        assert cs['minor_loss'] == 0.5
        assert cs['status'] == PIPE_STATUS_OPEN

        cs = execute_redo(p).operations[0]
        assert cs['operation'] == 'delete'
        assert cs['type'] == PIPE
        assert cs['id'] == 'p0'

        cs = execute_undo(p, True).operations[0]
        assert cs['operation'] == 'add'
        assert cs['type'] == PIPE
        assert cs['id'] == 'p0'
        assert cs['node1'] == 'j1'
        assert cs['node2'] == 'j2'
        assert cs['length'] == 100.0
        assert cs['diameter'] == 10.0
        assert cs['roughness'] == 0.1
        assert cs['minor_loss'] == 0.5
        assert cs['status'] == PIPE_STATUS_OPEN

        cs = execute_redo(p)
        assert len(cs.operations) == 0

        links = get_links(p)
        assert len(links) == 1

        cs = set_pipe(p, ChangeSet({'id': 'p0', 'node1': 'j3', 'node2': 'j4'})).operations[0]
        assert cs['operation'] == 'update'
        assert cs['type'] == PIPE
        assert cs['id'] == 'p0'
        assert cs['node1'] == 'j3'
        assert cs['node2'] == 'j4'
        assert cs['length'] == 100.0
        assert cs['diameter'] == 10.0
        assert cs['roughness'] == 0.1
        assert cs['minor_loss'] == 0.5
        assert cs['status'] == PIPE_STATUS_OPEN

        cs = execute_undo(p).operations[0]
        assert cs['operation'] == 'update'
        assert cs['type'] == PIPE
        assert cs['id'] == 'p0'
        assert cs['node1'] == 'j1'
        assert cs['node2'] == 'j2'
        assert cs['length'] == 100.0
        assert cs['diameter'] == 10.0
        assert cs['roughness'] == 0.1
        assert cs['minor_loss'] == 0.5
        assert cs['status'] == PIPE_STATUS_OPEN

        self.leave(p)


    def test_pump(self):
        p = 'test_pump'
        self.enter(p)

        add_junction(p, ChangeSet({'id': 'j1', 'x': 0.0, 'y': 10.0, 'elevation': 20.0}))
        add_junction(p, ChangeSet({'id': 'j2', 'x': 0.0, 'y': 10.0, 'elevation': 20.0}))
        add_junction(p, ChangeSet({'id': 'j3', 'x': 0.0, 'y': 10.0, 'elevation': 20.0}))
        add_junction(p, ChangeSet({'id': 'j4', 'x': 0.0, 'y': 10.0, 'elevation': 20.0}))
        assert is_junction(p, 'j1')
        assert is_junction(p, 'j2')
        assert is_junction(p, 'j3')
        assert is_junction(p, 'j4')

        add_pump(p, ChangeSet({'id': 'p0', 'node1': 'j1', 'node2': 'j2'}))
        p0 = get_pump(p, 'p0')
        assert p0['node1'] == 'j1'
        assert p0['node2'] == 'j2'

        set_pump(p, ChangeSet({'id': 'p0', 'node1': 'j3', 'node2': 'j4'}))
        p0 = get_pump(p, 'p0')
        assert p0['node1'] == 'j3'
        assert p0['node2'] == 'j4'

        add_pump(p, ChangeSet({'id': 'p1', 'node1': 'j1', 'node2': 'j2'}))
        links = get_links(p)
        assert len(links) == 2
        assert links[0] == 'p0'
        assert links[1] == 'p1'
        assert is_pump(p, 'p0')
        assert is_pump(p, 'p1')

        delete_pump(p, ChangeSet({'id': 'p1'}))
        links = get_links(p)
        assert len(links) == 1
        assert links[0] == 'p0'

        delete_pump(p, ChangeSet({'id': 'p0'}))
        links = get_links(p)
        assert len(links) == 0

        self.leave(p)


    def test_pump_op(self):
        p = 'test_pump_op'
        self.enter(p)

        add_junction(p, ChangeSet({'id': 'j1', 'x': 0.0, 'y': 10.0, 'elevation': 20.0}))
        add_junction(p, ChangeSet({'id': 'j2', 'x': 0.0, 'y': 10.0, 'elevation': 20.0}))
        add_junction(p, ChangeSet({'id': 'j3', 'x': 0.0, 'y': 10.0, 'elevation': 20.0}))
        add_junction(p, ChangeSet({'id': 'j4', 'x': 0.0, 'y': 10.0, 'elevation': 20.0}))
        assert is_junction(p, 'j1')
        assert is_junction(p, 'j2')
        assert is_junction(p, 'j3')
        assert is_junction(p, 'j4')

        cs = add_pump(p, ChangeSet({'id': 'p0', 'node1': 'j1', 'node2': 'j2'})).operations[0]
        assert cs['operation'] == 'add'
        assert cs['type'] == PUMP
        assert cs['id'] == 'p0'
        assert cs['node1'] == 'j1'
        assert cs['node2'] == 'j2'

        cs = execute_undo(p).operations[0]
        assert cs['operation'] == 'delete'
        assert cs['type'] == PUMP
        assert cs['id'] == 'p0'

        cs = execute_redo(p).operations[0]
        assert cs['operation'] == 'add'
        assert cs['type'] == PUMP
        assert cs['id'] == 'p0'
        assert cs['node1'] == 'j1'
        assert cs['node2'] == 'j2'

        cs = execute_undo(p, True).operations[0]
        assert cs['operation'] == 'delete'
        assert cs['type'] == PUMP
        assert cs['id'] == 'p0'

        cs = execute_redo(p)
        assert len(cs.operations) == 0

        links = get_links(p)
        assert len(links) == 0

        add_pump(p, ChangeSet({'id': 'p0', 'node1': 'j1', 'node2': 'j2'}))

        links = get_links(p)
        assert len(links) == 1

        cs = delete_pump(p, ChangeSet({'id': 'p0'})).operations[0]
        assert cs['operation'] == 'delete'
        assert cs['type'] == PUMP
        assert cs['id'] == 'p0'

        cs = execute_undo(p).operations[0]
        assert cs['operation'] == 'add'
        assert cs['type'] == PUMP
        assert cs['id'] == 'p0'
        assert cs['node1'] == 'j1'
        assert cs['node2'] == 'j2'

        cs = execute_redo(p).operations[0]
        assert cs['operation'] == 'delete'
        assert cs['type'] == PUMP
        assert cs['id'] == 'p0'

        cs = execute_undo(p, True).operations[0]
        assert cs['operation'] == 'add'
        assert cs['type'] == PUMP
        assert cs['id'] == 'p0'
        assert cs['node1'] == 'j1'
        assert cs['node2'] == 'j2'

        cs = execute_redo(p)
        assert len(cs.operations) == 0

        links = get_links(p)
        assert len(links) == 1

        cs = set_pump(p, ChangeSet({'id': 'p0', 'node1': 'j3', 'node2': 'j4'})).operations[0]
        assert cs['operation'] == 'update'
        assert cs['type'] == PUMP
        assert cs['id'] == 'p0'
        assert cs['node1'] == 'j3'
        assert cs['node2'] == 'j4'

        cs = execute_undo(p).operations[0]
        assert cs['operation'] == 'update'
        assert cs['type'] == PUMP
        assert cs['id'] == 'p0'
        assert cs['node1'] == 'j1'
        assert cs['node2'] == 'j2'

        self.leave(p)


    def test_valve(self):
        p = 'test_valve'
        self.enter(p)

        add_junction(p, ChangeSet({'id': 'j1', 'x': 0.0, 'y': 10.0, 'elevation': 20.0}))
        add_junction(p, ChangeSet({'id': 'j2', 'x': 0.0, 'y': 10.0, 'elevation': 20.0}))
        add_junction(p, ChangeSet({'id': 'j3', 'x': 0.0, 'y': 10.0, 'elevation': 20.0}))
        add_junction(p, ChangeSet({'id': 'j4', 'x': 0.0, 'y': 10.0, 'elevation': 20.0}))
        assert is_junction(p, 'j1')
        assert is_junction(p, 'j2')
        assert is_junction(p, 'j3')
        assert is_junction(p, 'j4')

        add_valve(p, ChangeSet({'id': 'v0', 'node1': 'j1', 'node2': 'j2', 'diameter': 10.0, 'v_type': VALVES_TYPE_FCV, 'setting': 0.1, 'minor_loss': 0.5 }))
        v0 = get_valve(p, 'v0')
        assert v0['node1'] == 'j1'
        assert v0['node2'] == 'j2'
        assert v0['diameter'] == 10.0
        assert v0['v_type'] == VALVES_TYPE_FCV
        assert v0['setting'] == 0.1
        assert v0['minor_loss'] == 0.5

        set_valve(p, ChangeSet({'id': 'v0', 'node1': 'j3', 'node2': 'j4'}))
        v0 = get_valve(p, 'v0')
        assert v0['node1'] == 'j3'
        assert v0['node2'] == 'j4'

        set_valve(p, ChangeSet({'id': 'v0', 'diameter': 100.0}))
        v0 = get_valve(p, 'v0')
        assert v0['diameter'] == 100.0

        set_valve(p, ChangeSet({'id': 'v0', 'v_type': VALVES_TYPE_GPV}))
        v0 = get_valve(p, 'v0')
        assert v0['v_type'] == VALVES_TYPE_GPV

        set_valve(p, ChangeSet({'id': 'v0', 'setting': 0.2}))
        v0 = get_valve(p, 'v0')
        assert v0['setting'] == 0.2

        set_valve(p, ChangeSet({'id': 'v0', 'minor_loss': 0.1}))
        v0 = get_valve(p, 'v0')
        assert v0['minor_loss'] == 0.1

        add_valve(p, ChangeSet({'id': 'v1', 'node1': 'j1', 'node2': 'j2', 'diameter': 10.0, 'v_type': VALVES_TYPE_FCV, 'setting': 0.1, 'minor_loss': 0.5 }))
        links = get_links(p)
        assert len(links) == 2
        assert links[0] == 'v0'
        assert links[1] == 'v1'
        assert is_valve(p, 'v0')
        assert is_valve(p, 'v1')

        delete_valve(p, ChangeSet({'id': 'v1'}))
        links = get_links(p)
        assert len(links) == 1
        assert links[0] == 'v0'

        delete_valve(p, ChangeSet({'id': 'v0'}))
        links = get_links(p)
        assert len(links) == 0

        self.leave(p)


    def test_valve_op(self):
        p = 'test_valve_op'
        self.enter(p)

        add_junction(p, ChangeSet({'id': 'j1', 'x': 0.0, 'y': 10.0, 'elevation': 20.0}))
        add_junction(p, ChangeSet({'id': 'j2', 'x': 0.0, 'y': 10.0, 'elevation': 20.0}))
        add_junction(p, ChangeSet({'id': 'j3', 'x': 0.0, 'y': 10.0, 'elevation': 20.0}))
        add_junction(p, ChangeSet({'id': 'j4', 'x': 0.0, 'y': 10.0, 'elevation': 20.0}))
        assert is_junction(p, 'j1')
        assert is_junction(p, 'j2')
        assert is_junction(p, 'j3')
        assert is_junction(p, 'j4')

        cs = add_valve(p, ChangeSet({'id': 'v0', 'node1': 'j1', 'node2': 'j2', 'diameter': 10.0, 'v_type': VALVES_TYPE_FCV, 'setting': 0.1, 'minor_loss': 0.5 })).operations[0]
        assert cs['operation'] == 'add'
        assert cs['type'] == VALVE
        assert cs['id'] == 'v0'
        assert cs['node1'] == 'j1'
        assert cs['node2'] == 'j2'
        assert cs['diameter'] == 10.0
        assert cs['v_type'] == VALVES_TYPE_FCV
        assert cs['setting'] == 0.1
        assert cs['minor_loss'] == 0.5

        cs = execute_undo(p).operations[0]
        assert cs['operation'] == 'delete'
        assert cs['type'] == VALVE
        assert cs['id'] == 'v0'

        cs = execute_redo(p).operations[0]
        assert cs['operation'] == 'add'
        assert cs['type'] == VALVE
        assert cs['id'] == 'v0'
        assert cs['node1'] == 'j1'
        assert cs['node2'] == 'j2'
        assert cs['diameter'] == 10.0
        assert cs['v_type'] == VALVES_TYPE_FCV
        assert cs['setting'] == 0.1
        assert cs['minor_loss'] == 0.5

        cs = execute_undo(p, True).operations[0]
        assert cs['operation'] == 'delete'
        assert cs['type'] == VALVE
        assert cs['id'] == 'v0'

        cs = execute_redo(p)
        assert len(cs.operations) == 0

        links = get_links(p)
        assert len(links) == 0

        add_valve(p, ChangeSet({'id': 'v0', 'node1': 'j1', 'node2': 'j2', 'diameter': 10.0, 'v_type': VALVES_TYPE_FCV, 'setting': 0.1, 'minor_loss': 0.5 }))

        links = get_links(p)
        assert len(links) == 1

        cs = delete_valve(p, ChangeSet({'id': 'v0'})).operations[0]
        assert cs['operation'] == 'delete'
        assert cs['type'] == VALVE
        assert cs['id'] == 'v0'

        cs = execute_undo(p).operations[0]
        assert cs['operation'] == 'add'
        assert cs['type'] == VALVE
        assert cs['id'] == 'v0'
        assert cs['node1'] == 'j1'
        assert cs['node2'] == 'j2'
        assert cs['diameter'] == 10.0
        assert cs['v_type'] == VALVES_TYPE_FCV
        assert cs['setting'] == 0.1
        assert cs['minor_loss'] == 0.5

        cs = execute_redo(p).operations[0]
        assert cs['operation'] == 'delete'
        assert cs['type'] == VALVE
        assert cs['id'] == 'v0'

        cs = execute_undo(p, True).operations[0]
        assert cs['operation'] == 'add'
        assert cs['type'] == VALVE
        assert cs['id'] == 'v0'
        assert cs['node1'] == 'j1'
        assert cs['node2'] == 'j2'
        assert cs['diameter'] == 10.0
        assert cs['v_type'] == VALVES_TYPE_FCV
        assert cs['setting'] == 0.1
        assert cs['minor_loss'] == 0.5

        cs = execute_redo(p)
        assert len(cs.operations) == 0

        links = get_links(p)
        assert len(links) == 1

        cs = set_valve(p, ChangeSet({'id': 'v0', 'node1': 'j3', 'node2': 'j4'})).operations[0]
        assert cs['operation'] == 'update'
        assert cs['type'] == VALVE
        assert cs['id'] == 'v0'
        assert cs['node1'] == 'j3'
        assert cs['node2'] == 'j4'
        assert cs['diameter'] == 10.0
        assert cs['v_type'] == VALVES_TYPE_FCV
        assert cs['setting'] == 0.1
        assert cs['minor_loss'] == 0.5

        cs = execute_undo(p).operations[0]
        assert cs['operation'] == 'update'
        assert cs['type'] == VALVE
        assert cs['id'] == 'v0'
        assert cs['node1'] == 'j1'
        assert cs['node2'] == 'j2'
        assert cs['diameter'] == 10.0
        assert cs['v_type'] == VALVES_TYPE_FCV
        assert cs['setting'] == 0.1
        assert cs['minor_loss'] == 0.5

        self.leave(p)


    def test_batch_commands(self):
        p = 'test_valve_op'
        self.enter(p)

        cs = ChangeSet()
        cs.add({'type': JUNCTION, 'id': 'j1', 'x': 0.0, 'y': 10.0, 'elevation': 20.0})
        cs.add({'type': JUNCTION, 'id': 'j2', 'x': 0.0, 'y': 10.0, 'elevation': 20.0})
        cs.add({'type': JUNCTION, 'id': 'j2', 'x': 0.0, 'y': 10.0, 'elevation': 20.0}) # fail

        cs = execute_batch_commands(p, cs)
        assert len(cs.operations) == 2

        self.leave(p)


if __name__ == '__main__':
    pytest.main()