openlayers/tests/Strategy/BBOX.html

   1 <html>
   2 <head>
   3   <script src="../../lib/OpenLayers.js"></script>
   4   <script type="text/javascript">
   5
   6     function test_initialize(t) {
   7         t.plan(1);
   8
   9         var ratio = 4;
  10
  11         var s = new OpenLayers.Strategy.BBOX({ratio: ratio});
  12         t.eq(s.ratio, ratio, "ctor sets ratio");
  13     }
  14
  15     function test_activate(t) {
  16         t.plan(5);
  17
  18         var l = new OpenLayers.Layer.Vector();
  19         var s = new OpenLayers.Strategy.BBOX();
  20         s.setLayer(l);
  21
  22         t.eq(s.active, false, "not active after construction");
  23
  24         var activated = s.activate();
  25         t.eq(activated, true, "activate returns true");
  26         t.eq(s.active, true, "activated after activate");
  27         t.ok(l.events.listeners["moveend"][0].obj == s &&
  28              l.events.listeners["moveend"][0].func == s.update,
  29              "activates registers moveend listener");
  30         t.ok(l.events.listeners["refresh"][0].obj == s &&
  31              l.events.listeners["refresh"][0].func == s.update,
  32              "activates registers refresh listener");
  33     }
  34
  35     function test_update(t) {
  36         t.plan(5);
  37
  38         // Create a dummy layer that can act as the map base layer.
  39         // This will be unnecessary if #1921 is addressed (allowing
  40         // map to have different projection than base layer).
  41         var dummy = new OpenLayers.Layer(null, {isBaseLayer: true});
  42
  43         var strategy = new OpenLayers.Strategy.BBOX({
  44             ratio: 1 // makes for easier comparison to map bounds
  45         });
  46         var layer = new OpenLayers.Layer.Vector(null, {
  47             isBaseLayer: true,
  48             protocol: new OpenLayers.Protocol(),
  49             strategies: [strategy]
  50         });
  51
  52         // create a map with the layers and a center
  53         var map = new OpenLayers.Map("map");
  54         map.addLayers([dummy, layer]);
  55         map.zoomToMaxExtent();
  56
  57         /**
  58          * The setCenter call above should set strategy bounds.  I *think* this
  59          * issue is captured in http://trac.openlayers.org/ticket/1835.
  60          * For now, I'm going to force an update on the strategy.  This line
  61          * should be removed when the issue(s) described in #1835 are addressed.
  62          */
  63         strategy.update({force: true});
  64
  65         // test that the strategy bounds were set
  66         t.ok(map.getExtent().equals(strategy.bounds), "[set center] bounds set to map extent");
  67
  68         // zoom and test that bounds are not reset
  69         var old = strategy.bounds.clone();
  70         map.zoomIn();
  71         t.ok(strategy.bounds.equals(old), "[zoom in] bounds not reset");
  72
  73         // force update and check that bounds change
  74         strategy.update({force: true});
  75         t.ok(!strategy.bounds.equals(old), "[force update] bounds changed");
  76         t.ok(strategy.bounds.equals(map.getExtent()), "[force update] bounds set to map extent");
  77
  78         // change the layer projection to confirm strategy uses same
  79         layer.projection = new OpenLayers.Projection("EPSG:900913");
  80         strategy.update({force: true});
  81         var from = map.getProjectionObject();
  82         var to = layer.projection;
  83         t.ok(strategy.bounds.equals(map.getExtent().transform(from, to)), "[force update different proj] bounds transformed");
  84
  85
  86     }
  87
  88     function test_events(t) {
  89
  90         t.plan(2);
  91         var log = {
  92             loadstart: 0,
  93             loadend: 0
  94         };
  95
  96         var map = new OpenLayers.Map("map");
  97         var layer = new OpenLayers.Layer.Vector(null, {
  98             strategies: [new OpenLayers.Strategy.BBOX()],
  99             protocol: new OpenLayers.Protocol({
 100                 read: function(config) {
 101                     config.callback.call(config.scope, {});
 102                 }
 103             }),
 104             isBaseLayer: true,
 105             eventListeners: {
 106                 loadstart: function() {
 107                     ++log.loadstart;
 108                 },
 109                 loadend: function() {
 110                     ++log.loadend;
 111                 }
 112             }
 113         });
 114         map.addLayer(layer);
 115         map.zoomToMaxExtent();
 116
 117         t.eq(log.loadstart, 1, "loadstart triggered");
 118         t.eq(log.loadend, 1, "loadend triggered");
 119
 120         map.destroy();
 121
 122     }
 123
 124     function test_triggerRead(t) {
 125         t.plan(4);
 126
 127         var s = new OpenLayers.Strategy.BBOX();
 128
 129         var filter = {"fake": "filter"};
 130
 131         s.createFilter = function() {
 132             return filter;
 133         };
 134         s.response = {"fake": "response"};
 135
 136         var log = {};
 137
 138         var protocol = new OpenLayers.Protocol({
 139             read: function(options) {
 140                 log.options = options;
 141             },
 142             abort: function(response) {
 143                 log.abort = response.fake;
 144             }
 145         });
 146
 147         var layer = new OpenLayers.Layer.Vector(null, {
 148             strategies: [s],
 149             protocol: protocol,
 150             isBaseLayer: true
 151         });
 152         var map = new OpenLayers.Map("map");
 153         map.addLayer(layer);
 154         map.zoomToMaxExtent();
 155
 156         t.ok(log.options.filter == filter,
 157                 "protocol read called with correct filter");
 158         t.ok(log.options.callback == s.merge,
 159                 "protocol read called with correct callback");
 160         t.ok(log.options.scope == s,
 161                 "protocol read called with correct scope");
 162         t.eq(log.abort, "response",
 163                 "protocol abort called with correct response");
 164
 165         map.destroy();
 166
 167     }
 168
 169     function test_resFactor(t) {
 170         t.plan(2);
 171
 172         var map = new OpenLayers.Map("map");
 173         var bbox = new OpenLayers.Strategy.BBOX();
 174         var fakeProtocol = new OpenLayers.Protocol({
 175             'read': function() {
 176                 t.ok(true, "read called once without resfactor");
 177             }
 178         });
 179         var layer = new OpenLayers.Layer.Vector("test", {
 180             strategies: [bbox],
 181             protocol: fakeProtocol,
 182             isBaseLayer: true
 183         });
 184         map.addLayer(layer);
 185         map.setCenter(new OpenLayers.LonLat(0, 0), 0);
 186         map.zoomIn();
 187
 188         fakeProtocol.read = function() {
 189             t.ok("read called again on zooming with resFactor: 1");
 190         }
 191         bbox.resFactor = 1;
 192         map.zoomIn();
 193
 194     }
 195
 196     function test_createFilter(t) {
 197         t.plan(3);
 198
 199         var s = new OpenLayers.Strategy.BBOX();
 200
 201         var f;
 202
 203         // 2 test
 204         s.setLayer({});
 205         f = s.createFilter();
 206         t.ok(f.CLASS_NAME.search(/^OpenLayers.Filter.Spatial/) != -1,
 207              "createFilter returns a spatial filter object");
 208         t.eq(f.type, OpenLayers.Filter.Spatial.BBOX,
 209              "createFilter returns a BBOX-typed filter");
 210
 211         // 1 test
 212         s.setLayer({filter: {fake: "filter"}});
 213         f = s.createFilter();
 214         t.ok(f.CLASS_NAME.search(/^OpenLayers.Filter.Logical/) != -1,
 215              "createFilter returns a logical filter object");
 216     }
 217
 218     function test_merge(t) {
 219         t.plan(4);
 220
 221         var strategy = new OpenLayers.Strategy.BBOX();
 222
 223         // create map with default projection
 224         var map = new OpenLayers.Map("map");
 225
 226         // create layer with custom projection
 227         var layer = new OpenLayers.Layer.Vector(null, {
 228             isBaseLayer: true,
 229             strategies: [strategy],
 230             protocol: new OpenLayers.Protocol(),
 231             projection: new OpenLayers.Projection("EPSG:900913")
 232         });
 233         map.addLayer(layer);
 234         map.zoomToMaxExtent();
 235
 236         // create some features
 237         var geometries = [
 238             new OpenLayers.Geometry.Point(100, 200),
 239             new OpenLayers.Geometry.Point(1000, 2000)
 240         ];
 241         var features = [
 242             new OpenLayers.Feature.Vector(geometries[0].clone()),
 243             new OpenLayers.Feature.Vector(geometries[1].clone())
 244         ];
 245
 246         // call merge with a mocked up response
 247         strategy.merge({features: features});
 248
 249         // test that feature geometries have been transformed to map projection
 250         var from = layer.projection;
 251         var to = map.getProjectionObject();
 252         t.geom_eq(layer.features[0].geometry, features[0].geometry.transform(from, to), "[different proj] feature 0 geometry transformed");
 253         t.geom_eq(layer.features[1].geometry, features[1].geometry.transform(from, to), "[different proj] feature 1 geometry transformed");
 254
 255         // same as above but with same map/layer projection
 256         layer.destroyFeatures();
 257         layer.projection = map.getProjectionObject();
 258
 259         features = [
 260             new OpenLayers.Feature.Vector(geometries[0].clone()),
 261             new OpenLayers.Feature.Vector(geometries[1].clone())
 262         ];
 263
 264         // call merge again with mocked up response
 265         strategy.merge({features: features});
 266
 267         // test that feature geometries have not been transformed
 268         t.geom_eq(layer.features[0].geometry, features[0].geometry, "[same proj] feature 0 geometry not transformed");
 269         t.geom_eq(layer.features[1].geometry, features[1].geometry, "[same proj] feature 1 geometry not transformed");
 270
 271     }
 272
 273   </script>
 274 </head>
 275 <body>
 276     <div id="map" style="width: 400px; height: 200px" />
 277 </body>
 278 </html>