test/lib/bounding_box_test.rb

   1 # frozen_string_literal: true
   2
   3 require "test_helper"
   4
   5 class BoundingBoxTest < ActiveSupport::TestCase
   6   def setup
   7     @size_error_message = "The maximum bbox size is 0.25, and your request was too large. Either request a smaller area, or use planet.osm"
   8     @malformed_error_message = "The parameter bbox must be of the form min_lon,min_lat,max_lon,max_lat"
   9     @lon_order_error_message = "The minimum longitude must be less than the maximum longitude, but it wasn't"
  10     @lat_order_error_message = "The minimum latitude must be less than the maximum latitude, but it wasn't"
  11     @bbox_out_of_limits_error_message = "The latitudes must be between -90.0 and 90.0, and longitudes between -180.0 and 180.0"
  12     @nil_error_message = "Should not contain nil"
  13
  14     @bbox_from_nils = BoundingBox.new(nil, nil, nil, nil)
  15     @bbox_expand = BoundingBox.new(0, 0, 0, 0)
  16     @bbox_expand_ten = BoundingBox.new(10, 10, 10, 10)
  17     @bbox_expand_minus_two = BoundingBox.new(-2, -2, -2, -2)
  18     @bbox_from_string = BoundingBox.from_s("1,2,3,4")
  19     @min_lon = 1.0
  20     @min_lat = 2.0
  21     @max_lon = 3.0
  22     @max_lat = 4.0
  23
  24     @bad_positive_boundary_bbox  = %w[181,91,0,0 0,0,181,91]
  25     @bad_negative_boundary_bbox  = %w[-181,-91,0,0 0,0,-181,-91]
  26     @bad_big_bbox = %w[-0.1,-0.1,1.1,1.1 10,10,11,11]
  27     @bad_malformed_bbox = %w[-0.1 hello 10N2W10.1N2.1W]
  28     @bad_lat_mixed_bbox = %w[0,0.1,0.1,0 -0.1,80,0.1,70 0.24,54.34,0.25,54.33]
  29     @bad_lon_mixed_bbox = %w[80,-0.1,70,0.1 54.34,0.24,54.33,0.25]
  30     @bad_limit_bbox = %w[-180.1,-90,180,90 -180,-90.1,180,90 -180,-90,180.1,90 -180,-90,180,90.1]
  31     @good_bbox = %w[-0.1,-0.1,0.1,0.1 51.1,-0.1,51.2,0 -0.1,%20-0.1,%200.1,%200.1
  32                     -0.1edcd,-0.1d,0.1,0.1 -0.1E,-0.1E,0.1S,0.1N S0.1,W0.1,N0.1,E0.1]
  33
  34     @expand_min_lon_array = %w[2,10,10,10 1,10,10,10 0,10,10,10 -1,10,10,10 -2,10,10,10 -8,10,10,10]
  35     @expand_min_lat_array = %w[10,2,10,10 10,1,10,10 10,0,10,10 10,-1,10,10 10,-2,10,10 10,-8,10,10]
  36     @expand_max_lon_array = %w[-2,-2,-1,-2 -2,-2,0,-2 -2,-2,1,-2 -2,-2,2,-2]
  37     @expand_max_lat_array = %w[-2,-2,-2,-1 -2,-2,-2,0 -2,-2,-2,1 -2,-2,-2,2]
  38     @expand_min_lon_margin_response = [[2, 10, 10, 10], [-7, 10, 10, 10], [-7, 10, 10, 10], [-7, 10, 10, 10], [-7, 10, 10, 10], [-25, 10, 10, 10]]
  39     @expand_min_lat_margin_response = [[10, 2, 10, 10], [10, -7, 10, 10], [10, -7, 10, 10], [10, -7, 10, 10], [10, -7, 10, 10], [10, -25, 10, 10]]
  40     @expand_max_lon_margin_response = [[-2, -2, -1, -2], [-2, -2, 1, -2], [-2, -2, 1, -2], [-2, -2, 5, -2]]
  41     @expand_max_lat_margin_response = [[-2, -2, -2, -1], [-2, -2, -2, 1], [-2, -2, -2, 1], [-2, -2, -2, 5]]
  42   end
  43
  44   def test_good_bbox_from_string
  45     @good_bbox.each do |string|
  46       bbox = BoundingBox.from_s(string)
  47       array = string.split(",").collect(&:to_f)
  48       check_bbox(bbox, array)
  49     end
  50   end
  51
  52   def test_bbox_from_s_malformed
  53     @bad_malformed_bbox.each do |bbox_string|
  54       bbox = BoundingBox.from_s(bbox_string)
  55       assert_nil bbox
  56     end
  57   end
  58
  59   def test_good_bbox_from_params
  60     @good_bbox.each do |string|
  61       bbox = BoundingBox.from_bbox_params(:bbox => string)
  62       array = string.split(",").collect(&:to_f)
  63       check_bbox(bbox, array)
  64     end
  65   end
  66
  67   def test_good_bbox_from_lon_lat_params
  68     @good_bbox.each do |string|
  69       array = string.split(",")
  70       bbox = BoundingBox.from_lon_lat_params(:minlon => array[0], :minlat => array[1], :maxlon => array[2], :maxlat => array[3])
  71       check_bbox(bbox, array.collect(&:to_f))
  72     end
  73   end
  74
  75   def test_bbox_from_params_malformed
  76     @bad_malformed_bbox.each do |bbox_string|
  77       exception = assert_raise(OSM::APIBadUserInput) { BoundingBox.from_bbox_params(:bbox => bbox_string) }
  78       assert_equal(@malformed_error_message, exception.message)
  79     end
  80   end
  81
  82   def test_good_bbox_from_new
  83     @good_bbox.each do |string|
  84       array = string.split(",")
  85       bbox = BoundingBox.new(array[0], array[1], array[2], array[3])
  86       check_bbox(bbox, array.collect(&:to_f))
  87     end
  88   end
  89
  90   def test_creation_from_new_with_nils
  91     check_bbox(@bbox_from_nils, [nil, nil, nil, nil])
  92   end
  93
  94   def test_expand_min_lon_boundary
  95     @bbox_expand.expand!(BoundingBox.new(-1810000000, 0, 0, 0))
  96     check_expand(@bbox_expand, "-1800000000,0,0,0")
  97   end
  98
  99   def test_expand_min_lat_boundary
 100     @bbox_expand.expand!(BoundingBox.new(0, -910000000, 0, 0))
 101     check_expand(@bbox_expand, "0,-900000000,0,0")
 102   end
 103
 104   def test_expand_max_lon_boundary
 105     @bbox_expand.expand!(BoundingBox.new(0, 0, 1810000000, 0))
 106     check_expand(@bbox_expand, "0,0,1800000000,0")
 107   end
 108
 109   def test_expand_max_lat_boundary
 110     @bbox_expand.expand!(BoundingBox.new(0, 0, 0, 910000000))
 111     check_expand(@bbox_expand, "0,0,0,900000000")
 112   end
 113
 114   def test_expand_min_lon_without_margin
 115     @expand_min_lon_array.each { |array_string| check_expand(@bbox_expand_ten, array_string) }
 116   end
 117
 118   def test_expand_min_lon_with_margin
 119     @expand_min_lon_array.each_with_index do |array_string, index|
 120       check_expand(@bbox_expand_ten, array_string, 1, @expand_min_lon_margin_response[index])
 121     end
 122   end
 123
 124   def test_expand_min_lat_without_margin
 125     @expand_min_lat_array.each { |array_string| check_expand(@bbox_expand_ten, array_string) }
 126   end
 127
 128   def test_expand_min_lat_with_margin
 129     @expand_min_lat_array.each_with_index do |array_string, index|
 130       check_expand(@bbox_expand_ten, array_string, 1, @expand_min_lat_margin_response[index])
 131     end
 132   end
 133
 134   def test_expand_max_lon_without_margin
 135     @expand_max_lon_array.each { |array_string| check_expand(@bbox_expand_minus_two, array_string) }
 136   end
 137
 138   def test_expand_max_lon_with_margin
 139     @expand_max_lon_array.each_with_index do |array_string, index|
 140       check_expand(@bbox_expand_minus_two, array_string, 1, @expand_max_lon_margin_response[index])
 141     end
 142   end
 143
 144   def test_expand_max_lat_without_margin
 145     @expand_max_lat_array.each { |array_string| check_expand(@bbox_expand_minus_two, array_string) }
 146   end
 147
 148   def test_expand_max_lat_with_margin
 149     @expand_max_lat_array.each_with_index do |array_string, index|
 150       check_expand(@bbox_expand_minus_two, array_string, 1, @expand_max_lat_margin_response[index])
 151     end
 152   end
 153
 154   def test_good_bbox_boundaries
 155     @good_bbox.each do |bbox_string|
 156       assert_nothing_raised { BoundingBox.from_s(bbox_string).check_boundaries }
 157     end
 158   end
 159
 160   def test_from_params_with_positive_out_of_boundary
 161     @bad_positive_boundary_bbox.each do |bbox_string|
 162       bbox = BoundingBox.from_bbox_params(:bbox => bbox_string)
 163       array = bbox.to_a
 164       assert_equal 180, [array[0], array[2]].max
 165       assert_equal 90, [array[1], array[3]].max
 166     end
 167   end
 168
 169   def test_from_params_with_negative_out_of_boundary
 170     @bad_negative_boundary_bbox.each do |bbox_string|
 171       bbox = BoundingBox.from_bbox_params(:bbox => bbox_string)
 172       array = bbox.to_a
 173       assert_equal(-180, [array[0], array[2]].min)
 174       assert_equal(-90, [array[1], array[3]].min)
 175     end
 176   end
 177
 178   def test_boundaries_mixed_lon
 179     @bad_lon_mixed_bbox.each do |bbox_string|
 180       exception = assert_raise(OSM::APIBadBoundingBox) { BoundingBox.from_s(bbox_string).check_boundaries }
 181       assert_equal(@lon_order_error_message, exception.message)
 182     end
 183   end
 184
 185   def test_boundaries_mixed_lat
 186     @bad_lat_mixed_bbox.each do |bbox_string|
 187       exception = assert_raise(OSM::APIBadBoundingBox) { BoundingBox.from_s(bbox_string).check_boundaries }
 188       assert_equal(@lat_order_error_message, exception.message)
 189     end
 190   end
 191
 192   def test_boundaries_out_of_limits
 193     @bad_limit_bbox.each do |bbox_string|
 194       exception = assert_raise(OSM::APIBadBoundingBox) { BoundingBox.from_s(bbox_string).check_boundaries }
 195       assert_equal(@bbox_out_of_limits_error_message, exception.message)
 196     end
 197   end
 198
 199   def test_good_bbox_size
 200     @good_bbox.each do |bbox_string|
 201       assert_nothing_raised { BoundingBox.from_s(bbox_string).check_size }
 202     end
 203   end
 204
 205   def test_size_to_big
 206     @bad_big_bbox.each do |bbox_string|
 207       bbox = nil
 208       assert_nothing_raised { bbox = BoundingBox.from_bbox_params(:bbox => bbox_string).check_boundaries }
 209       exception = assert_raise(OSM::APIBadBoundingBox) { bbox.check_size }
 210       assert_equal(@size_error_message, exception.message)
 211     end
 212   end
 213
 214   def test_good_bbox_area
 215     @good_bbox.each do |string|
 216       bbox = BoundingBox.from_s(string)
 217       array = string.split(",")
 218       assert_equal ((array[2].to_f - array[0].to_f) * (array[3].to_f - array[1].to_f)), bbox.area
 219     end
 220   end
 221
 222   def test_nil_bbox_area
 223     assert_equal 0, @bbox_from_nils.area
 224   end
 225
 226   def test_complete
 227     assert_not_predicate @bbox_from_nils, :complete?, "should contain a nil"
 228     assert_predicate @bbox_from_string, :complete?, "should not contain a nil"
 229   end
 230
 231   def test_centre_lon
 232     @good_bbox.each do |bbox_string|
 233       array = bbox_string.split(",")
 234       assert_equal ((array[0].to_f + array[2].to_f) / 2.0), BoundingBox.from_s(bbox_string).centre_lon
 235     end
 236   end
 237
 238   def test_centre_lat
 239     @good_bbox.each do |bbox_string|
 240       array = bbox_string.split(",")
 241       assert_equal ((array[1].to_f + array[3].to_f) / 2.0), BoundingBox.from_s(bbox_string).centre_lat
 242     end
 243   end
 244
 245   def test_width
 246     @good_bbox.each do |bbox_string|
 247       array = bbox_string.split(",")
 248       assert_equal (array[2].to_f - array[0].to_f), BoundingBox.from_s(bbox_string).width
 249     end
 250   end
 251
 252   def test_height
 253     @good_bbox.each do |bbox_string|
 254       array = bbox_string.split(",")
 255       assert_equal (array[3].to_f - array[1].to_f), BoundingBox.from_s(bbox_string).height
 256     end
 257   end
 258
 259   def test_slippy_width
 260     assert_in_delta 5.68888888888889, @bbox_from_string.slippy_width(2), 0.000000000000001
 261   end
 262
 263   def test_slippy_height
 264     assert_in_delta 5.69698684268433, @bbox_from_string.slippy_height(2), 0.000000000000001
 265   end
 266
 267   def test_add_bounds_to_no_underscore
 268     bounds = @bbox_from_string.add_bounds_to({})
 269     assert_equal 4, bounds.size
 270     assert_equal format("%<lon>.7f", :lon => @min_lon), bounds["minlon"]
 271     assert_equal format("%<lat>.7f", :lat => @min_lat), bounds["minlat"]
 272     assert_equal format("%<lon>.7f", :lon => @max_lon), bounds["maxlon"]
 273     assert_equal format("%<lat>.7f", :lat => @max_lat), bounds["maxlat"]
 274   end
 275
 276   def test_add_bounds_to_with_underscore
 277     bounds = @bbox_from_string.add_bounds_to({}, "_")
 278     assert_equal 4, bounds.size
 279     assert_equal format("%<lon>.7f", :lon => @min_lon), bounds["min_lon"]
 280     assert_equal format("%<lat>.7f", :lat => @min_lat), bounds["min_lat"]
 281     assert_equal format("%<lon>.7f", :lon => @max_lon), bounds["max_lon"]
 282     assert_equal format("%<lat>.7f", :lat => @max_lat), bounds["max_lat"]
 283   end
 284
 285   def test_to_scaled
 286     bbox = @bbox_from_string.to_scaled
 287     assert_equal @min_lon * GeoRecord::SCALE, bbox.min_lon
 288     assert_equal @min_lat * GeoRecord::SCALE, bbox.min_lat
 289     assert_equal @max_lon * GeoRecord::SCALE, bbox.max_lon
 290     assert_equal @max_lat * GeoRecord::SCALE, bbox.max_lat
 291   end
 292
 293   def test_to_unscaled
 294     scale = GeoRecord::SCALE
 295     bbox = BoundingBox.new(1.0 * scale, 2.0 * scale, 3.0 * scale, 4.0 * scale).to_unscaled
 296     check_bbox(bbox, [@min_lon, @min_lat, @max_lon, @max_lat])
 297   end
 298
 299   def test_to_a
 300     assert_equal [1.0, 2.0, 3.0, 4.0], @bbox_from_string.to_a
 301   end
 302
 303   def test_to_string
 304     assert_equal "#{@min_lon},#{@min_lat},#{@max_lon},#{@max_lat}", @bbox_from_string.to_s
 305   end
 306
 307   private
 308
 309   def check_expand(bbox, array_string, margin = 0, result = nil)
 310     array = array_string.split(",").collect(&:to_f)
 311     result ||= array
 312     bbox.expand!(BoundingBox.new(array[0], array[1], array[2], array[3]), margin)
 313     check_bbox(bbox, result)
 314   end
 315
 316   def check_bbox(bbox, result)
 317     assert_equal_allowing_nil result[0], bbox.min_lon, "min_lon"
 318     assert_equal_allowing_nil result[1], bbox.min_lat, "min_lat"
 319     assert_equal_allowing_nil result[2], bbox.max_lon, "max_lon"
 320     assert_equal_allowing_nil result[3], bbox.max_lat, "max_lat"
 321   end
 322 end