active_road 0.0.2 → 0.0.3

data/spec/models/active_road/path_spec.rb

@@ -1,6 +1,6 @@
 require 'spec_helper'
 
-describe ActiveRoad::Path do
+describe ActiveRoad::Path, :type => :model do
 
 
 

data/spec/models/active_road/physical_road_conditionnal_cost_spec.rb

@@ -1,19 +1,19 @@
 require 'spec_helper'
 
-describe ActiveRoad::PhysicalRoadConditionnalCost do
+describe ActiveRoad::PhysicalRoadConditionnalCost, :type => :model do
 
   subject { create(:physical_road_conditionnal_cost) }
 
   it "should have tags" do
-    subject.should respond_to(:tags)
+    expect(subject).to respond_to(:tags)
   end
 
   it "should have a cost" do
-    subject.should respond_to(:cost)
+    expect(subject).to respond_to(:cost)
   end
 
   it "should have a physical road" do
-    subject.should respond_to(:physical_road_id)
+    expect(subject).to respond_to(:physical_road_id)
   end
 
 end

data/spec/models/active_road/physical_road_spec.rb

@@ -1,17 +1,28 @@
 require 'spec_helper'
 
-describe ActiveRoad::PhysicalRoad do
+describe ActiveRoad::PhysicalRoad, :type => :model do
 
   subject { create(:physical_road) }
 
   it "should validate objectid uniqueness" do
     other_road = build :physical_road, :objectid => subject.objectid 
-    other_road.should_not be_valid
+    expect(other_road).not_to be_valid
   end
 
   it "should be valid with a logical_road" do
     subject.logical_road = nil
-    subject.should be_valid
+    expect(subject).to be_valid
+  end
+
+  describe ".nearest_to" do 
+    let(:departure) { point(0, 0) }
+    let!(:ab) { create(:physical_road, :geometry => line_string( "0.0001 0.0001,1 1" ) ) }
+    let!(:ac) { create(:physical_road, :geometry => line_string( "-0.0001 -0.0001,-1 -1" ) )  }
+    let!(:ad) { create(:physical_road, :geometry => line_string( "-0.001 -0.001,-1 -1" ) )  }
+    
+    it "should return physical roads in an area ordered from closest to farthest from a departure" do
+      expect(ActiveRoad::PhysicalRoad.nearest_to(departure)).to eq([ab]) #[ab, ac]
+    end
   end
 
 end

data/spec/models/active_road/request_conditionnal_cost_linker_spec.rb

@@ -0,0 +1,65 @@
+require 'spec_helper'
+
+describe ActiveRoad::RequestConditionnalCostLinker, :type => :model do
+
+  let!(:physical_road) { create(:physical_road) }
+  let!(:conditionnal_costs) { [ create(:physical_road_conditionnal_cost, :tags => "bike", :cost => 0.1, :physical_road => physical_road), 
+                               create(:physical_road_conditionnal_cost, :tags => "pavement", :cost => 0.3, :physical_road => physical_road) ]
+  }
+  let(:physical_road_conditionnal_costs) { physical_road.physical_road_conditionnal_costs }
+
+  subject { ActiveRoad::RequestConditionnalCostLinker.new(["bike", "pavement", "~asphalt"]) }
+  
+  describe "#authorized_constraints_intersection_with" do
+
+    it "should return true if authorized constraints intersection" do
+      allow(subject).to receive_messages :authorized_constraints => ["bike"]
+      expect(subject.authorized_constraints_intersection_with?(["bike"])).to eq(true)
+    end
+    
+  end
+
+  describe "#unauthorized_constraints_intersection_with" do
+
+    it "should return true if unauthorized constraints intersection" do
+      allow(subject).to receive_messages :unauthorized_constraints => ["bike"]
+      expect(subject.unauthorized_constraints_intersection_with?(["bike"])).to eq(true)
+    end
+
+  end
+
+  describe "#linked?" do
+
+    it "should return true if tags in conditionnal costs and tag in constraints have common tags" do
+      rcc = ActiveRoad::RequestConditionnalCostLinker.new(["bike", "pavement"])
+      expect(rcc.linked?(["bike", "pavement"])).to eq(true)
+    end
+
+    it "should return true if tags in conditionnal costs and unauthorized constraints have common tags" do
+      rcc = ActiveRoad::RequestConditionnalCostLinker.new(["~asphalt"])
+      physical_road_conditionnal_costs << create(:physical_road_conditionnal_cost, :tags => "asphalt", :cost => 0.1)
+      expect(rcc.linked?(["bike", "pavement", "asphalt"])).to eq(true)
+    end
+    
+    it "should return false if tags in conditionnal costs have common tags with authorized or unauthorized constraints" do
+      rcc = ActiveRoad::RequestConditionnalCostLinker.new([])
+      expect(rcc.linked?(physical_road_conditionnal_costs)).to eq(false)
+    end
+    
+  end
+
+  describe "#conditionnal_costs_sum" do
+
+    it "should return the sum for conditionnal costs" do
+      expect(subject.conditionnal_costs_sum(physical_road_conditionnal_costs)).to eq(0.4)
+    end
+
+    it "should return infinity for conditionnal costs with an infinity value in it" do
+      rcc = ActiveRoad::RequestConditionnalCostLinker.new(["bike", "pavement", "test"])
+      physical_road_conditionnal_costs << create(:physical_road_conditionnal_cost, :tags => "test", :cost => Float::MAX)
+      expect(rcc.conditionnal_costs_sum(physical_road_conditionnal_costs)).to eq(Float::INFINITY)
+    end
+    
+  end
+
+end

data/spec/models/active_road/shared_examples/osm_pbf_importer_spec.rb

@@ -0,0 +1,148 @@
+shared_examples "an OsmPbfImporter module" do 
+
+  describe "#pedestrian?" do
+    it "should return true when tag key is highway and tag value is good" do
+      expect(importer.pedestrian?({"highway" => "pedestrian"})).to be_truthy
+      expect(importer.pedestrian?({"highway" => "path"})).to be_truthy
+    end
+
+    it "should return false when tag key is not highway or tag value is not good" do
+      expect(importer.pedestrian?({"highway" => "residential"})).to be_falsey
+    end    
+  end
+
+  describe "#bike?" do
+    it "should return true when tag key is highway and tag value is good" do
+      expect(importer.bike?({"highway" => "cycleway"})).to be_truthy
+      expect(importer.bike?({"cycleway:right" => "lane"})).to be_truthy
+      expect(importer.bike?({"cycleway:left" => "lane"})).to be_truthy
+      expect(importer.bike?({"cycleway" => "lane"})).to be_truthy
+    end
+
+    it "should return false when tag key is not highway or tag value is not good" do
+      expect(importer.bike?({"highway" => "residential"})).to be_falsey
+    end    
+  end
+
+  describe "#train?" do
+    it "should return true when tag key is railway and tag value is good" do
+      expect(importer.train?({"railway" => "rail"})).to be_truthy
+      expect(importer.train?({"railway" => "tram"})).to be_truthy
+    end
+
+    it "should return false when tag key is not railway or tag value is not good" do
+      expect(importer.train?({"highway" => "residential"})).to be_falsey
+    end    
+  end
+  
+  describe "#car?" do
+    it "should return true when tag key is highway and tag value is good" do
+      expect(importer.car?({"highway" => "motorway"})).to be_truthy
+      expect(importer.car?({"highway" => "secondary"})).to be_truthy
+    end
+
+    it "should return false when tag key is not highway or tag value is not good" do
+      expect(importer.car?({"highway" => "railway"})).to be_falsey
+    end    
+  end
+  
+  describe "#required_way?" do
+    it "should return true when tag key is highway or railway" do 
+      tags = {"highway" => "primary"} 
+      expect(importer.required_way?(ActiveRoad::OsmPbfImporter::way_required_tags_keys, tags)).to be_truthy
+    end
+
+    it "should return false when no tag key with highway or railway" do 
+      tags =  {"maxspeed" => "100", "bike" => "oneway"} 
+      expect(importer.required_way?(ActiveRoad::OsmPbfImporter::way_required_tags_keys, tags)).to  be_falsey
+    end
+  end
+
+  describe "#selected_tags" do
+    it "should return true when " do 
+      tags = {"highway" => "primary", "name" => "Rue montparnasse", "bridge" => "true", "other_tag" => "other_tag"} 
+      expect(importer.selected_tags(tags, ActiveRoad::OsmPbfImporter.way_selected_tags_keys)).to eq({"name" => "Rue montparnasse" })
+    end
+  end
+
+  describe "#required_relation?" do
+    it "should return true when tag key is boundary" do 
+      tags = {"boundary" => "administrative"} 
+      expect(importer.required_relation?(tags)).to be_truthy
+    end
+
+    it "should return false when no tag key with highway or railway" do 
+      tags =  {"other" => "100"} 
+      expect(importer.required_relation?(tags)).to  be_falsey
+    end
+  end
+
+  describe "#physical_road_conditionnal_costs" do
+    let(:physical_road) { create(:physical_road) }
+
+    it "should return conditionnal cost with pedestrian, bike and train to infinity when tag key is car" do
+      expect(importer.physical_road_conditionnal_costs( ActiveRoad::OsmPbfImporter::Way.new("", [], true) )).to eq([["pedestrian", Float::MAX], ["bike", Float::MAX], ["train", Float::MAX]])
+    end
+
+    it "should return conditionnal cost with pedestrian, bike, car and train to infinity when tag key is nothing" do   
+      expect(importer.physical_road_conditionnal_costs( ActiveRoad::OsmPbfImporter::Way.new("", []) )).to eq([ ["car", Float::MAX], ["pedestrian", Float::MAX], ["bike", Float::MAX], ["train", Float::MAX]])
+    end
+  end
+
+  describe "#extract_relation_polygon" do
+    let!(:first_way_geom) { line_string( "0 0,1 1" ) }
+    let!(:second_way_geom) { line_string( "1 1,2 2" ) }
+    let!(:third_way_geom) { line_string( "2 2,0 0" ) }
+
+    it "should return an exception if way geometries are not connected" do
+      second_way_geom_not_connected = line_string( "1 1,3 3" )
+      expect { importer.extract_relation_polygon([first_way_geom, second_way_geom_not_connected, third_way_geom]) }.to raise_error
+    end
+
+    it "should return polygon if way geometries are connected" do
+      expect(importer.extract_relation_polygon([first_way_geom, second_way_geom, third_way_geom])).to match_array( [ polygon(point(0.0,0.0), point(1.0,1.0), point(2.0,2.0)) ] )
+    end
+
+    it "should return polygon if way geometries are connected and some of them have points in the reverse order" do
+      second_way_geom_reversed = line_string( "2 2,1 1" ) 
+      expect(importer.extract_relation_polygon([first_way_geom, second_way_geom_reversed, third_way_geom])).to match_array( [ polygon(point(0.0,0.0), point(1.0,1.0), point(2.0,2.0)) ] )
+    end
+      
+  end
+
+  describe "#join_ways"
+
+  describe "#join_way"
+
+  describe ActiveRoad::OsmPbfImporter::EndpointToWayMap
+  
+  describe ActiveRoad::OsmPbfImporter::Way
+  
+  describe ActiveRoad::OsmPbfImporter::Node do
+    
+    let(:node) { ActiveRoad::OsmPbfImporter::Node.new("122323131", 34.2, 12.5) } 
+
+    it "should return a node object when unmarhalling a dump of node object" do
+      data = Marshal.dump(node)
+      object = Marshal.load(data)
+      expect(object).to be_an_instance_of(ActiveRoad::OsmPbfImporter::Node)
+      expect(object.id).to eq(node.id)
+      expect(object.lon).to eq(node.lon)
+      expect(object.lat).to eq(node.lat)
+      expect(object.ways).to eq(node.ways)
+    end
+
+    it "should return a node object with ways when we add a way" do
+      node.add_way("1223344")
+      data = Marshal.dump(node)
+      object = Marshal.load(data)
+      expect(object).to be_an_instance_of(ActiveRoad::OsmPbfImporter::Node)
+      expect(object.id).to eq(node.id)
+      expect(object.lon).to eq(node.lon)
+      expect(object.lat).to eq(node.lat)
+      expect(object.ways).to eq([ "1223344" ])
+    end
+
+  end
+  
+end

data/spec/models/active_road/street_number_spec.rb

@@ -1,78 +1,78 @@
-require 'spec_helper'
+# require 'spec_helper'
 
-describe ActiveRoad::StreetNumber do
+# describe ActiveRoad::StreetNumber do
 
-  subject { create :street_number }
+#   subject { create :street_number }
 
-  it "should have a number" do
-    subject.should respond_to(:number)
-  end
+#   it "should have a number" do
+#     subject.should respond_to(:number)
+#   end
 
-  describe "#previous" do
+#   describe "#previous" do
 
-    it "should find previous StreetNumber in the same road" do
-      other_number = create(:street_number, :physical_road => subject.road, :number => subject.number - 50)
-      subject.previous.should == other_number
-    end
+#     it "should find previous StreetNumber in the same road" do
+#       other_number = create(:street_number, :physical_road => subject.road, :number => subject.number - 50)
+#       subject.previous.should == other_number
+#     end
     
-  end
+#   end
 
-  describe "#next" do
+#   describe "#next" do
 
-    it "should find next StreetNumber in the same road" do
-      other_number = create(:street_number, :physical_road => subject.road, :number => subject.number + 50)
-      subject.next.should == other_number
-    end
+#     it "should find next StreetNumber in the same road" do
+#       other_number = create(:street_number, :physical_road => subject.road, :number => subject.number + 50)
+#       subject.next.should == other_number
+#     end
     
-  end
+#   end
 
-  describe "location_on_road" do
+#   describe "location_on_road" do
     
-    it "should return the stored location_on_road if exists" do
-      subject.location_on_road = 0.3
-      subject.location_on_road.should == 0.3
-    end
-
-    it "should be comptured when not specified at creation" do
-      create(:street_number, :location_on_road => nil).location_on_road.should_not be_nil
-    end
-
-    context "when no location is stored" do
-
-      before(:each) do
-        subject.location_on_road = nil
-      end
-
-      it "should return nil" do
-        subject.location_on_road.should be_nil
-      end
-
-      it "should use previous and next numbers to compute location" do
-        subject.stub :previous => mock(:number => 50, :location_on_road => 0.5)
-        subject.stub :next => mock(:number => 100, :location_on_road => 1)
-        subject.number = "75"
-        subject.location_on_road.should == 0.75
-      end
+#     it "should return the stored location_on_road if exists" do
+#       subject.location_on_road = 0.3
+#       subject.location_on_road.should == 0.3
+#     end
+
+#     it "should be comptured when not specified at creation" do
+#       create(:street_number, :location_on_road => nil).location_on_road.should_not be_nil
+#     end
+
+#     context "when no location is stored" do
+
+#       before(:each) do
+#         subject.location_on_road = nil
+#       end
+
+#       it "should return nil" do
+#         subject.location_on_road.should be_nil
+#       end
+
+#       it "should use previous and next numbers to compute location" do
+#         subject.stub :previous => mock(:number => 50, :location_on_road => 0.5)
+#         subject.stub :next => mock(:number => 100, :location_on_road => 1)
+#         subject.number = "75"
+#         subject.location_on_road.should == 0.75
+#       end
                                            
-    end
+#     end
 
 
-  end
+#   end
 
-end
+# end
 
-describe ActiveRoad::StreetNumber::Number do
+# describe ActiveRoad::StreetNumber::Number do
   
-  def number(value)
-    ActiveRoad::StreetNumber::Number.new value
-  end
+#   def number(value)
+#     ActiveRoad::StreetNumber::Number.new value
+#   end
 
-  it "should support addition" do
-    (number("50bis") + 50).should == number("100bis")
-  end
+#   it "should support addition" do
+#     (number("50bis") + 50).should == number("100bis")
+#   end
 
-  it "should support subtraction" do
-    (number("100bis") - 50).should == number("50bis")
-  end
+#   it "should support subtraction" do
+#     (number("100bis") - 50).should == number("50bis")
+#   end
 
-end
+# end

data/spec/models/active_road/terra_importer_spec.rb

@@ -0,0 +1,140 @@
+# require 'spec_helper'
+
+# describe ActiveRoad::TerraImporter do
+#   let(:xml_file) { File.expand_path("../../../fixtures/terra.xml", __FILE__) }
+  
+#   subject { ActiveRoad::TerraImporter.new( xml_file, "/tmp/terra_test.kch" ) } 
+
+#   describe "#physical_road_conditionnal_costs" do
+#     let(:physical_road) { create(:physical_road) }
+
+#     it "should returnconditionnal cost with pedestrian, bike and train to infinity when tag key is car" do 
+#       ActiveRoad::PhysicalRoadConditionnalCost.should_receive(:new).exactly(3).times 
+#       subject.physical_road_conditionnal_costs({"highway" => "primary"})
+#     end
+
+#     it "should return nothing if tag key is not in ['highway', 'railway']" do   
+#       ActiveRoad::PhysicalRoadConditionnalCost.should_receive(:new).exactly(0).times 
+#       subject.physical_road_conditionnal_costs({"test" => "test"})
+#     end
+#   end
+
+#   describe "#backup_nodes" do
+#     before :each do 
+#       subject.open_database(subject.database_path)
+#     end
+
+#     after :each  do
+#       subject.close_database
+#     end
+
+#     it "should have import all nodes in a temporary database" do         
+#       subject.backup_nodes(subject.database)
+#       object = Marshal.load(subject.database.get("ign-obj-100"))
+#       object.id.should ==  "ign-obj-100"
+#       object.geometry.should == "SRID=4326;POINT(2.331932632740265 48.85215698894743)"
+#       object.ways.should == ["ign-obj-184", "ign-obj-204"]
+#       object.end_of_way.should == false
+#     end
+#   end
+
+#   describe "#iterate_nodes" do
+#     let!(:point) { GeoRuby::SimpleFeatures::Point.from_x_y( 2.331932632740265, 48.85215698894743, 4326) }
+
+#     before :each do 
+#       subject.open_database(subject.database_path)
+#       subject.database.set("1", Marshal.dump(ActiveRoad::TerraImporter::Node.new("1", "SRID=4326;POINT(2.331932632740265 48.85215698894743)", ["1", "2"])) )
+#       subject.database.set("2", Marshal.dump(ActiveRoad::TerraImporter::Node.new("2", "SRID=4326;POINT(2.331932632740265 48.85215698894743)", ["1", "3"])) )
+#     end
+
+#     after :each  do
+#       subject.close_database
+#     end
+
+#     it "should iterate nodes to save it" do
+#       GeoRuby::SimpleFeatures::Point.stub :from_x_y => point
+#       subject.should_receive(:save_junctions).exactly(1).times.with([["1", point], ["2", point]], {"1" => ["1", "2"], "2" => ["1", "3"]})
+#       subject.iterate_nodes(subject.database)
+#     end
+#   end
+  
+#   describe "#save_junctions" do
+
+#     let!(:physical_road) { create(:physical_road, :objectid => "1") }
+#     let!(:point) { GeoRuby::SimpleFeatures::Point.from_x_y( 0, 0, 4326) }
+
+#     it "should save junctions in postgresql database" do         
+#       junctions_values = [["1", point], ["2", point]]
+#       junctions_ways = {"1" => ["1"], "2" => ["1"]}
+
+#       subject.save_junctions(junctions_values, junctions_ways)
+
+#       ActiveRoad::Junction.all.size.should == 2
+#       first_junction = ActiveRoad::Junction.first
+#       first_junction.objectid.should == "1"
+#       first_junction.physical_roads.should == [physical_road]
+
+#       last_junction = ActiveRoad::Junction.last
+#       last_junction.objectid.should == "2"
+#       last_junction.physical_roads.should == [physical_road]
+#     end
+#   end  
+
+#   describe "#import" do     
+    
+#     it "should have import all physical roads" do
+#       subject.import
+#       ActiveRoad::PhysicalRoad.all.size.should == 78
+#       ActiveRoad::Junction.all.size.should == 70
+#       #ActiveRoad::StreetNumber.all.size.should == 20
+#     end
+    
+#   end
+
+#   describe "#save_physical_roads_and_children" do
+#     let(:pr1) { ActiveRoad::PhysicalRoad.new :objectid => "physicalroad::1" }
+#     let(:pr2) { ActiveRoad::PhysicalRoad.new :objectid => "physicalroad::2" }
+#     let(:physical_roads) { [ pr1, pr2 ] }
+#     let(:prcc) { ActiveRoad::PhysicalRoadConditionnalCost.new :tags => "car", :cost => 0.3 }
+#     let(:physical_road_conditionnal_costs_by_objectid) { {pr1.objectid => [ [prcc] ]} }
+    
+#     it "should save physical roads in postgresql database" do  
+#       subject.save_physical_roads_and_children(physical_roads)
+#       ActiveRoad::PhysicalRoad.all.size.should == 2
+#       ActiveRoad::PhysicalRoad.first.objectid.should == "physicalroad::1"
+#       ActiveRoad::PhysicalRoad.last.objectid.should == "physicalroad::2"
+#     end
+
+#     it "should save physical road conditionnal costs in postgresql database" do   
+#       subject.save_physical_roads_and_children(physical_roads, physical_road_conditionnal_costs_by_objectid)
+#       ActiveRoad::PhysicalRoadConditionnalCost.all.size.should == 1
+#       ActiveRoad::PhysicalRoadConditionnalCost.first.physical_road_id.should == ActiveRoad::PhysicalRoad.first.id
+#     end
+#   end
+
+#   describe ActiveRoad::TerraImporter::Node do
+    
+#     let(:subject) { ActiveRoad::TerraImporter::Node.new("ign-obj-100", "SRID=4326;POINT(2.331932632740265 48.85215698894743") } 
+
+#     it "should return a node object when unmarhalling a dump of node object" do
+#       data = Marshal.dump(subject)
+#       object = Marshal.load(data)
+#       object.should be_an_instance_of(ActiveRoad::TerraImporter::Node)
+#       object.id.should == subject.id
+#       object.geometry.should == subject.geometry
+#       object.ways.should == subject.ways
+#     end
+
+#     it "should return a node object with ways when we add a way" do
+#       subject.add_way("1223344")
+#       data = Marshal.dump(subject)
+#       object = Marshal.load(data)
+#       object.should be_an_instance_of(ActiveRoad::TerraImporter::Node)
+#       object.id.should == subject.id
+#       object.geometry.should == subject.geometry
+#       object.ways.should == [ "1223344" ]
+#     end
+
+#   end
+  
+# end