def test_find_demand_with(self): from next.model.models import Scenario from next.views import find_demand_with, create_edges sc1 = self.session.query(Scenario).filter(Scenario.name == "Test").first() request = testing.DummyRequest() params = {'id': sc1.id, 'phase_id': 2} request.matchdict = params #create the edges create_edges(request) request.json_body = {'d': 1000} response = find_demand_with(request) total = simplejson.loads(response.body) self.assertEqual(0, total['total'])
def test_create_supply_nodes(self): from next.model.models import Scenario from next.views import create_supply_nodes, create_edges sc1 = self.session.query(Scenario).filter(Scenario.name == "Test").first() request = testing.DummyRequest() params = {'id': sc1.id, 'phase_id': 2} request.matchdict = params #create the edges create_edges(request) request.json_body = {'d': 1000, 'n': 10} response = create_supply_nodes(request) #ensure that we have two new supply nodes demand_nodes = self.helper_get_phase_nodes(sc1.id, 3, "supply") self.assertEqual(4, len(demand_nodes['features']))
def test_graph_phase_cumul(self): from next.model.models import Scenario from next.views import graph_phase_cumul, create_edges sc1 = self.session.query(Scenario).filter(Scenario.name == "Test").first() request = testing.DummyRequest() params = {'id': sc1.id, 'phase_id': 2} request.matchdict = params #create the edges create_edges(request) response = graph_phase_cumul(request) pairs = simplejson.loads(response.body) #TODO Elaborate this test (add data and check calc) # import pdb; pdb.set_trace() pair = pairs[0] self.assertTrue(pair[1] < 1) self.assertEqual(1, len(pairs))
def test_show_phase_nodes(self): from next.model.models import Scenario from next.views import show_cumulative_phase_nodes, create_edges sc1 = self.session.query(Scenario).filter(Scenario.name == "Test").first() params = {'id': sc1.id, 'phase_id': 2} #test getting all nodes request = testing.DummyRequest() request.matchdict = params response = show_cumulative_phase_nodes(request) feature_coll = simplejson.loads(response.body) features = feature_coll['features'] self.assertEqual(4, len(features)) #test getting the demand nodes #need to create_edges first to generate edges response = create_edges(request) get_params = {'type': "demand"} request = testing.DummyRequest(params=get_params) request.matchdict = params response = show_cumulative_phase_nodes(request) feature_coll = simplejson.loads(response.body) features = feature_coll['features'] self.assertEqual(2, len(features)) feature = features[0] coords = feature['geometry']['coordinates'] self.assertTrue(([1, 1] == coords) or ([-2, -2] == coords)) self.assertEqual("demand", feature['properties']['type'])
def test_create_edges(self): """ Test whether demands are associated with the appropriate supply nodes based on proximity """ from next.model.models import Scenario, Node, Edge from next.views import create_edges sc1 = self.session.query(Scenario).filter(Scenario.name == "Test").first() params = {'id': sc1.id, 'phase_id': 2} request = testing.DummyRequest() request.matchdict = params response = create_edges(request) demand1 = self.session.query(Node).filter(func.ST_X(Node.point) == 1.0).first() demand2 = self.session.query(Node).filter(func.ST_X(Node.point) == -2.0).first() supply1 = self.session.query(Node).\ filter(Edge.to_node_id == Node.id).\ filter(Edge.from_node_id == demand1.id).first() supply2 = self.session.query(Node).\ filter(Edge.to_node_id == Node.id).\ filter(Edge.from_node_id == demand2.id).first() supply1_coords = to_shape(supply1.point).coords[0] #(self.session) supply2_coords = to_shape(supply2.point).coords[0] #(self.session) self.assertTrue(supply1_coords[0] == 0.0 and supply1_coords[1] == 0.0) self.assertTrue(supply2_coords[0] == -1.0 and supply2_coords[1] == -1.0)
def test_delete_phase(self): """ This test is pretty comprehensive (may get promoted to top level test) 1. Add 1 new phase with 100 nodes 2. To this add another phase via "create_supply_nodes" 3. delete the phase created in step 1 4. Test whether it and its child are deleted """ from next.model.models import Scenario, Phase, Node, Edge, PhaseAncestor from next.views import create_edges, create_supply_nodes, remove_phase scen1 = self.session.query(Scenario).filter(Scenario.name == "Test").first() phase1 = self.session.query(Phase).filter(Phase.scenario_id == scen1.id).first() parent_phase = Phase(scen1, phase1) self.session.add_all([scen1, parent_phase]) demand_nodes = nodes_along_latitude(100, parent_phase, self.session, node_type='demand', y_val=0.0, x_origin=0.0, x_spacing=0.1) supply_nodes = nodes_along_latitude(5, parent_phase, self.session, node_type='supply', y_val=0.0, x_origin=0.0, x_spacing=2.0) self.session.add_all(demand_nodes) self.session.add_all(supply_nodes) # flush to assign ids self.session.flush() # add the edges for the parent phase request = testing.DummyRequest() params = {'id': scen1.id, 'phase_id': parent_phase.id} request.matchdict = params #create the edges create_edges(request) # build the request to auto create_supply_nodes # NOTE: this uses the previously set matchdict with # scenario_id/phase_id params request.json_body = {'d': 1000, 'n': 10} response = create_supply_nodes(request) # Get the new phase (to test that it was created) # TODO: QUERY HERE child_phase = parent_phase.get_descendents_query().filter( Phase.id != parent_phase.id).order_by(Phase.id).first() descendent_ids = [p.id for p in parent_phase.get_descendents_query()] self.assertTrue(len(descendent_ids) == 2) self.assertTrue(child_phase.id > parent_phase.id) self.assertTrue(child_phase.get_nodes_query().count() == 10) # remove the parent phase (params remain the same) response = remove_phase(request) # Check whether all nodes, edges, phases, ancestors associated with # both phases have been deleted self.assertTrue(self.session.query(Node).filter((Node.scenario_id == scen1.id) & (Node.phase_id.in_(descendent_ids))).count() == 0) self.assertTrue(self.session.query(Edge).filter((Edge.scenario_id == scen1.id) & (Edge.phase_id.in_(descendent_ids))).count() == 0) self.assertTrue(self.session.query(Phase).filter((Phase.scenario_id == scen1.id) & (Phase.id.in_(descendent_ids))).count() == 0) self.assertTrue(self.session.query(PhaseAncestor).filter((PhaseAncestor.scenario_id == scen1.id) & (PhaseAncestor.phase_id.in_(descendent_ids))).count() == 0) # ensure that no phases reference these deleted phases too self.assertTrue(self.session.query(PhaseAncestor).filter((PhaseAncestor.scenario_id == scen1.id) & (PhaseAncestor.ancestor_phase_id.in_(descendent_ids))).count() == 0)