OpenLayers OpenLayers

Ticket #1649: patch-1649-r7658-C0.diff

File patch-1649-r7658-C0.diff, 10.9 kB (added by fredj, 5 months ago)

Same patch but add unit tests in Vector.html to test the autoDestroy. Also fix the typo spotted in #1659

  • tests/Protocol.html

    old new  
    44  <script type="text/javascript"> 
    55 
    66    function test_initialize(t) { 
    7         t.plan(2); 
     7        t.plan(3); 
    88        var options = {}; 
    99        var protocol = new OpenLayers.Protocol(options); 
    1010 
    1111        t.ok(protocol instanceof OpenLayers.Protocol, 
    1212             "new OpenLayers.Protocol returns object" ); 
    1313        t.eq(protocol.options, options, "constructor sets this.options"); 
     14        t.eq(protocol.autoDestroy, true, "constructor does not modify this.autoDestroy"); 
    1415    } 
    1516     
    1617    function test_destroy(t) { 

  • tests/Strategy.html

    old new  
    44  <script type="text/javascript"> 
    55 
    66    function test_initialize(t) { 
    7         t.plan(2); 
     7        t.plan(5); 
    88        var options = {}; 
    99        var strategy = new OpenLayers.Strategy(options); 
    1010 
    1111        t.ok(strategy instanceof OpenLayers.Strategy, 
    1212             "new OpenLayers.Strategy returns object" ); 
    1313        t.eq(strategy.options, options, "constructor sets this.options"); 
     14        t.eq(strategy.active, false, "constructor sets this.active to false"); 
     15        t.eq(strategy.autoActivate, true, "constructor does not modify this.autoActivate"); 
     16        t.eq(strategy.autoDestroy, true, "constructor does not modify this.autoDestroy"); 
    1417    } 
    1518     
    1619    function test_destroy(t) { 
    …… 
    2528        t.eq(strategy.options, null, "destroy nullify protocol.options"); 
    2629    } 
    2730 
     31    function test_activate(t) { 
     32        t.plan(4); 
     33        var strategy = new OpenLayers.Strategy({ 
     34            layer: 'foo' 
     35        }); 
     36 
     37        var ret = strategy.activate(); 
     38 
     39        t.eq(strategy.active, true, "activate sets this.active to true on first call"); 
     40        t.eq(ret, true, "activate returns true on first call"); 
     41 
     42        ret = strategy.activate(); 
     43 
     44        t.eq(strategy.active, true, "activate does not modify this.active on second call"); 
     45        t.eq(ret, false, "activate returns false on second call"); 
     46    } 
     47 
     48    function test_deactivate(t) { 
     49        t.plan(4); 
     50        var strategy = new OpenLayers.Strategy({ 
     51            layer: 'foo' 
     52        }); 
     53        strategy.activate(); 
     54 
     55        var ret = strategy.deactivate(); 
     56 
     57        t.eq(strategy.active, false, "deactivate sets this.active to false on first call"); 
     58        t.eq(ret, true, "deactivate returns true on first call"); 
     59 
     60        ret = strategy.deactivate(); 
     61 
     62        t.eq(strategy.active, false, "deactivate does not modify this.active on second call"); 
     63        t.eq(ret, false, "deactivate returns false on second call"); 
     64    } 
     65 
    2866  </script> 
    2967</head> 
    3068<body> 

  • tests/Layer/Vector.html

    old new  
    66    var name = "Vector Layer"; 
    77     
    88    function test_Layer_Vector_constructor(t) { 
    9         t.plan(3); 
     9        t.plan(4); 
    1010 
    11         var layer = new OpenLayers.Layer.Vector(name); 
     11        var options = {protocol: new OpenLayers.Protocol(),  
     12                       strategies: [new OpenLayers.Strategy(), new OpenLayers.Strategy()]} 
     13        var layer = new OpenLayers.Layer.Vector(name, options); 
     14 
    1215        t.ok(layer instanceof OpenLayers.Layer.Vector, "new OpenLayers.Layer.Vector returns correct object" ); 
    1316        t.eq(layer.name, name, "layer name is correctly set"); 
    1417        t.ok(layer.renderer.CLASS_NAME, "layer has a renderer"); 
    15  
     18         
     19        t.ok((layer.name == layer.strategies[0].layer.name) && 
     20             (layer.strategies[0].layer.name == layer.strategies[1].layer.name),  
     21             "setLayer was called on strategies"); 
    1622    } 
    1723     
    1824    function test_Layer_Vector_addFeatures(t) { 
    …… 
    216222    } 
    217223 
    218224    function test_Layer_Vector_destroy (t) { 
    219         t.plan(2);     
    220         layer = new OpenLayers.Layer.Vector(name); 
     225        t.plan(4);     
     226 
     227        var options = {protocol: new OpenLayers.Protocol(),  
     228                       strategies: [new OpenLayers.Strategy(), new OpenLayers.Strategy()]} 
     229        var layer = new OpenLayers.Layer.Vector(name, options); 
    221230        var map = new OpenLayers.Map('map'); 
    222231        map.addLayer(layer); 
    223232        layer.destroy(); 
    224233        t.eq(layer.map, null, "layer.map is null after destroy"); 
    225         t.eq(layer.getFeatureFromEvent({'target':'map'}), null, "getFeatureIdFromEvent doesn't cause an error when called on layer which has been destroyed."); 
     234        t.eq(layer.getFeatureFromEvent({'target':'map'}), null,  
     235            "getFeatureIdFromEvent doesn't cause an error when called on layer which has been destroyed."); 
     236 
     237        t.eq(layer.protocol, null, "layer.protocol is null after destroy"); 
     238        t.eq(layer.strategies, null, "layer.strategies is null after destroy"); 
    226239    } 
    227240 
     241    function test_Layer_Vector_destroy_no_autoDestroy (t) { 
     242        t.plan(4);     
     243 
     244        var options = {protocol: new OpenLayers.Protocol({autoDestroy: false}),  
     245                       strategies: [new OpenLayers.Strategy({autoDestroy: false}),  
     246                                    new OpenLayers.Strategy({autoDestroy: false})]} 
     247        var layer = new OpenLayers.Layer.Vector(name, options); 
     248        var map = new OpenLayers.Map('map'); 
     249        map.addLayer(layer); 
     250        layer.destroy(); 
     251         
     252        t.ok(options.protocol.options != null, "options.protocol.destroy was not called") 
     253        t.ok(options.strategies[0].layer != null &&  
     254             options.strategies[1].layer != null, "options.strategies.destroy was not called") 
     255        t.eq(layer.protocol, null, "layer.protocol is null after destroy"); 
     256        t.eq(layer.strategies, null, "layer.strategies is null after destroy");                             
     257    } 
     258 
    228259    function test_Layer_Vector_externalGraphic(t) { 
    229260        t.plan(11); 
    230261        var layer = new OpenLayers.Layer.Vector("Test Layer", {isBaseLayer: true}); 

  • lib/OpenLayers/Layer/Vector.js

    old new  
    228228     * Destroy this layer 
    229229     */ 
    230230    destroy: function() { 
    231         if (this.stategies) { 
    232             for(var i=0, len=this.strategies.length; i<len; i++) { 
    233                 this.strategies[i].destroy(); 
     231        if (this.strategies) { 
     232            var strategy; 
     233            for (var i = 0, len = this.strategies.length; i < len; i++) { 
     234                strategy = this.strategies[i]; 
     235                if (strategy.autoDestroy) { 
     236                    strategy.destroy(); 
     237                } 
    234238            } 
    235239            this.strategies = null; 
    236240        } 
    237241        if (this.protocol) { 
    238             this.protocol.destroy(); 
     242            if (this.protocol.autoDestroy) { 
     243                this.protocol.destroy(); 
     244            } 
    239245            this.protocol = null; 
    240246        } 
    241247        this.destroyFeatures(); 
    …… 
    295301            this.renderer.map = this.map; 
    296302            this.renderer.setSize(this.map.getSize()); 
    297303        } 
    298         if(this.strategies) { 
    299             for(var i=0, len=this.strategies.length; i<len; i++) { 
    300                 this.strategies[i].activate(); 
     304        if (this.strategies) { 
     305            var strategy; 
     306            for(var i = 0, len = this.strategies.length; i < len; i++) { 
     307                strategy = this.strategies[i]; 
     308                if (strategy.autoActivate) { 
     309                    strategy.activate(); 
     310                } 
    301311            } 
    302312        } 
    303313    }, 
     314 
     315    /** 
     316     * Method: removeMap 
     317     * The layer has been removed from the map. 
     318     * 
     319     * Parameters: 
     320     * map - {<OpenLayers.Map>} 
     321     */ 
     322    removeMap: function(map) { 
     323        if (this.strategies) { 
     324            var strategy; 
     325            for(var i = 0, len = this.strategies.length; i < len; i++) { 
     326                strategy = this.strategies[i]; 
     327                if (strategy.autoActivate) { 
     328                    strategy.deactivate(); 
     329                } 
     330            } 
     331        } 
     332    }, 
    304333     
    305334    /** 
    306335     * Method: onMapResize 

  • lib/OpenLayers/Protocol.js

    old new  
    2020     * Any options sent to the constructor. 
    2121     */ 
    2222    options: null, 
    23      
     23 
    2424    /** 
     25     * Property: autoDestroy 
     26     * {Boolean} The creator of the protocol can set autoDestroy to false 
     27     *      to fully control when the protocol is destroyed. Defaults to 
     28     *      true. 
     29     */ 
     30    autoDestroy: true, 
     31    
     32    /** 
    2533     * Constructor: OpenLayers.Protocol 
    2634     * Abstract class for vector protocols.  Create instances of a subclass. 
    2735     * 

  • lib/OpenLayers/Strategy.js

    old new  
    2121     */ 
    2222    options: null, 
    2323 
     24    /**  
     25     * Property: active  
     26     * {Boolean} The control is active. 
     27     */ 
     28    active: null, 
     29 
    2430    /** 
     31     * Property: autoActivate 
     32     * {Boolean} The creator of the strategy can set autoActivate to false 
     33     *      to fully control when the protocol is activated and deactivated. 
     34     *      Defaults to true. 
     35     */ 
     36    autoActivate: true, 
     37 
     38    /** 
     39     * Property: autoDestroy 
     40     * {Boolean} The creator of the strategy can set autoDestroy to false 
     41     *      to fully control when the strategy is destroyed. Defaults to 
     42     *      true. 
     43     */ 
     44    autoDestroy: true, 
     45 
     46    /** 
    2547     * Constructor: OpenLayers.Strategy 
    2648     * Abstract class for vector strategies.  Create instances of a subclass. 
    2749     * 
    …… 
    3254    initialize: function(options) { 
    3355        OpenLayers.Util.extend(this, options); 
    3456        this.options = options; 
     57        this.active = false; 
    3558    }, 
    3659     
    3760    /** 
    …… 
    5780    /** 
    5881     * Method: activate 
    5982     * Activate the strategy.  Register any listeners, do appropriate setup. 
     83     * 
     84     * Returns: 
     85     * {Boolean} True if the strategy was effectively deactivated and false 
     86     *     if it was already activated. 
    6087     */ 
    6188    activate: function() { 
     89        if (!this.active) { 
     90            this.active = true; 
     91            return true; 
     92        } 
     93        return false; 
    6294    }, 
    6395     
    6496    /** 
    6597     * Method: deactivate 
    6698     * Deactivate the strategy.  Unregister any listeners, do appropriate 
    6799     *     tear-down. 
     100     * 
     101     * Returns: 
     102     * {Boolean} True if the strategy was effectively activated and false 
     103     *     if it was already deactivated. 
    68104     */ 
    69105    deactivate: function() { 
     106        if (this.active) { 
     107            this.active = false; 
     108            return true; 
     109        } 
     110        return false; 
    70111    }, 
    71112    
    72113    CLASS_NAME: "OpenLayers.Strategy"