Ejemplo n.º 1
0
 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'])
Ejemplo n.º 2
0
    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']))
Ejemplo n.º 3
0
 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))
Ejemplo n.º 4
0
    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'])
Ejemplo n.º 5
0
    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)
Ejemplo n.º 6
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)