umap-project 1.14.0a4__py3-none-any.whl → 2.0.0a0__py3-none-any.whl

umap/static/umap/test/DataLayer.js

@@ -1,55 +1,54 @@
-describe('L.U.DataLayer', function () {
-  var path = '/map/99/datalayer/edit/62/'
-
-  before(function () {
-    this.server = sinon.fakeServer.create()
-    this.server.respondWith(
-      /\/datalayer\/62\/\?.*/,
-      JSON.stringify(RESPONSES.datalayer62_GET)
-    )
-    this.map = initMap({ umap_id: 99 })
-    this.datalayer = this.map.getDataLayerByUmapId(62)
-    this.server.respond()
+describe('U.DataLayer', () => {
+  let path = '/map/99/datalayer/update/62/',
+    map,
+    datalayer
+
+  before(async () => {
+    fetchMock.mock(/\/datalayer\/62\/\?.*/, JSON.stringify(RESPONSES.datalayer62_GET))
+    fetchMock.sticky('/map/99/update/settings/', { id: 99 })
+    this.options = {
+      umap_id: 99,
+    }
+    MAP = map = initMap({ umap_id: 99 })
+    const datalayer_options = defaultDatalayerData()
+    await map.initDataLayers([datalayer_options])
+    datalayer = map.getDataLayerByUmapId(62)
     enableEdit()
   })
-  after(function () {
-    this.server.restore()
+  after(() => {
+    fetchMock.restore()
     resetMap()
   })
 
-  describe('#init()', function () {
-    it('should be added in datalayers index', function () {
-      assert.notEqual(this.map.datalayers_index.indexOf(this.datalayer), -1)
+  describe('#init()', () => {
+    it('should be added in datalayers index', () => {
+      assert.notEqual(map.datalayers_index.indexOf(datalayer), -1)
     })
   })
 
-  describe('#edit()', function () {
+  describe('#edit()', () => {
     var editButton, form, input, forceButton
 
-    it('row in control should be active', function () {
+    it('row in control should be active', () => {
       assert.notOk(
-        qs(
-          '.leaflet-control-browse #browse_data_toggle_' +
-            L.stamp(this.datalayer) +
-            '.off'
-        )
+        qs('.leaflet-control-browse #browse_data_toggle_' + L.stamp(datalayer) + '.off')
       )
     })
 
-    it('should have edit button', function () {
-      editButton = qs('#browse_data_toggle_' + L.stamp(this.datalayer) + ' .layer-edit')
+    it('should have edit button', () => {
+      editButton = qs('#browse_data_toggle_' + L.stamp(datalayer) + ' .layer-edit')
       assert.ok(editButton)
     })
 
-    it('should have toggle visibility element', function () {
+    it('should have toggle visibility element', () => {
       assert.ok(qs('.leaflet-control-browse i.layer-toggle'))
     })
 
-    it('should exist only one datalayer', function () {
+    it('should exist only one datalayer', () => {
       assert.equal(qsa('.leaflet-control-browse i.layer-toggle').length, 1)
     })
 
-    it('should build a form on edit button click', function () {
+    it('should build a form on edit button click', () => {
       happen.click(editButton)
       form = qs('form.umap-form')
       input = qs('form.umap-form input[name="name"]')
@@ -57,97 +56,81 @@ describe('L.U.DataLayer', function () {
       assert.ok(input)
     })
 
-    it('should update name on input change', function () {
+    it('should update name on input change', () => {
       var new_name = 'This is a new name'
       input.value = new_name
       happen.once(input, { type: 'input' })
-      assert.equal(this.datalayer.options.name, new_name)
+      assert.equal(datalayer.options.name, new_name)
     })
 
-    it('should have made datalayer dirty', function () {
-      assert.ok(this.datalayer.isDirty)
-      assert.notEqual(this.map.dirty_datalayers.indexOf(this.datalayer), -1)
+    it('should have made datalayer dirty', () => {
+      assert.ok(datalayer.isDirty)
+      assert.notEqual(map.dirty_datalayers.indexOf(datalayer), -1)
     })
 
-    it('should have made Map dirty', function () {
-      assert.ok(this.map.isDirty)
+    it('should have made Map dirty', () => {
+      assert.ok(map.isDirty)
     })
 
-    it('should call datalayer.save on save button click', function (done) {
-      sinon.spy(this.datalayer, 'save')
-      this.server.flush()
-      this.server.respondWith(
-        'POST',
-        '/map/99/update/settings/',
-        JSON.stringify({ id: 99 })
-      )
-      this.server.respondWith(
-        'POST',
-        '/map/99/datalayer/update/62/',
-        JSON.stringify(defaultDatalayerData())
-      )
+    it('should call datalayer.save on save button click', (done) => {
+      const postDatalayer = fetchMock.post(path, () => {
+        return defaultDatalayerData()
+      })
       clickSave()
-      this.server.respond()
-      this.server.respond()
-      assert(this.datalayer.save.calledOnce)
-      this.datalayer.save.restore()
-      done()
+      window.setTimeout(() => {
+        assert(fetchMock.called(path))
+        done()
+      }, 500)
     })
 
-    it('should show alert if server respond 412', function () {
+    it('should show alert if server respond 412', (done) => {
       cleanAlert()
-      this.server.flush()
-      this.server.respondWith(
-        'POST',
-        '/map/99/update/settings/',
-        JSON.stringify({ id: 99 })
-      )
-      this.server.respondWith('POST', '/map/99/datalayer/update/62/', [412, {}, ''])
+      fetchMock.restore()
+      fetchMock.post(path, 412)
       happen.click(editButton)
       input = qs('form.umap-form input[name="name"]')
       input.value = 'a new name'
       happen.once(input, { type: 'input' })
       clickSave()
-      this.server.respond()
-      this.server.respond()
-      assert(L.DomUtil.hasClass(this.map._container, 'umap-alert'))
-      assert.notEqual(this.map.dirty_datalayers.indexOf(this.datalayer), -1)
-      forceButton = qs('#umap-alert-container .umap-action')
-      assert.ok(forceButton)
-    })
-
-    it('should save anyway on force save button click', function () {
-      sinon.spy(this.map, 'continueSaving')
+      window.setTimeout(() => {
+        assert(L.DomUtil.hasClass(map._container, 'umap-alert'))
+        assert.notEqual(map.dirty_datalayers.indexOf(datalayer), -1)
+        const forceButton = qs('#umap-alert-container .umap-action')
+        assert.ok(forceButton)
+        done()
+      }, 500)
+    })
+
+    it('should save anyway on force save button click', (done) => {
+      const forceButton = qs('#umap-alert-container .umap-action')
+      fetchMock.restore()
+      fetchMock.post(path, defaultDatalayerData)
       happen.click(forceButton)
-      this.server.flush()
-      this.server.respond(
-        'POST',
-        '/map/99/datalayer/update/62/',
-        JSON.stringify(defaultDatalayerData())
-      )
-      assert.notOk(qs('#umap-alert-container .umap-action'))
-      assert(this.map.continueSaving.calledOnce)
-      this.map.continueSaving.restore()
-      assert.equal(this.map.dirty_datalayers.indexOf(this.datalayer), -1)
+      window.setTimeout(() => {
+        assert.notOk(qs('#umap-alert-container .umap-action'))
+        assert(fetchMock.called(path))
+        assert.equal(map.dirty_datalayers.indexOf(datalayer), -1)
+        done()
+      }, 500)
     })
   })
 
-  describe('#save() new', function () {
-    var newLayerButton, form, input, newDatalayer, editButton, manageButton
+  describe('#save() new', () => {
+    let newLayerButton, form, input, newDatalayer, editButton, manageButton
 
-    it('should have a manage datalayers action', function () {
+    it('should have a manage datalayers action', () => {
       enableEdit()
       manageButton = qs('.manage-datalayers')
       assert.ok(manageButton)
       happen.click(manageButton)
     })
 
-    it('should have a new layer button', function () {
+    it('should have a new layer button', () => {
       newLayerButton = qs('#umap-ui-container .add-datalayer')
       assert.ok(newLayerButton)
     })
 
-    it('should build a form on new layer button click', function () {
+    it('should build a form on new layer button click', () => {
       happen.click(newLayerButton)
       form = qs('form.umap-form')
       input = qs('form.umap-form input[name="name"]')
@@ -155,86 +138,72 @@ describe('L.U.DataLayer', function () {
       assert.ok(input)
     })
 
-    it('should have an empty name', function () {
+    it('should have an empty name', () => {
       assert.notOk(input.value)
     })
 
-    it('should have created a new datalayer', function () {
-      assert.equal(this.map.datalayers_index.length, 2)
-      newDatalayer = this.map.datalayers_index[1]
+    it('should have created a new datalayer', () => {
+      assert.equal(map.datalayers_index.length, 2)
+      newDatalayer = map.datalayers_index[1]
     })
 
-    it('should have made Map dirty', function () {
-      assert.ok(this.map.isDirty)
+    it('should have made Map dirty', () => {
+      assert.ok(map.isDirty)
     })
 
-    it('should update name on input change', function () {
+    it('should update name on input change', () => {
       var new_name = 'This is a new name'
       input.value = new_name
       happen.once(input, { type: 'input' })
       assert.equal(newDatalayer.options.name, new_name)
     })
 
-    it('should set umap_id on save callback', function () {
+    it('should set umap_id on save callback', async () => {
       assert.notOk(newDatalayer.umap_id)
-      this.server.flush()
-      this.server.respondWith(
-        'POST',
-        '/map/99/update/settings/',
-        JSON.stringify({ id: 99 })
-      )
-      this.server.respondWith(
-        'POST',
-        '/map/99/datalayer/create/',
-        JSON.stringify(defaultDatalayerData({ id: 63 }))
-      )
+      fetchMock.post('/map/99/datalayer/create/', defaultDatalayerData({ id: 63 }))
       clickSave()
-      this.server.respond()
-      this.server.respond() // First respond will then trigger another Xhr request (continueSaving)
-      assert.equal(newDatalayer.umap_id, 63)
+      return new Promise((resolve) => {
+        window.setTimeout(() => {
+          assert.equal(newDatalayer.umap_id, 63)
+          resolve()
+        }, 1000)
+      })
     })
 
-    it('should have unset map dirty', function () {
-      assert.notOk(this.map.isDirty)
+    it('should have unset map dirty', () => {
+      assert.notOk(map.isDirty)
     })
 
-    it('should have edit button', function () {
+    it('should have edit button', () => {
       editButton = qs('#browse_data_toggle_' + L.stamp(newDatalayer) + ' .layer-edit')
       assert.ok(editButton)
     })
 
-    it('should call update if we edit again', function () {
+    it('should call update if we edit again', async () => {
       happen.click(editButton)
-      assert.notOk(this.map.isDirty)
+      assert.notOk(map.isDirty)
       input = qs('form.umap-form input[name="name"]')
       input.value = "a new name again but we don't care which"
       happen.once(input, { type: 'input' })
-      assert.ok(this.map.isDirty)
-      var response = function (request) {
-        return request.respond(
-          200,
-          {},
-          JSON.stringify(defaultDatalayerData({ pk: 63 }))
-        )
+      assert.ok(map.isDirty)
+      var response = () => {
+        return defaultDatalayerData({ pk: 63 })
       }
       var spy = sinon.spy(response)
-      this.server.flush()
-      this.server.respondWith(
-        'POST',
-        '/map/99/update/settings/',
-        JSON.stringify({ id: 99 })
-      )
-      this.server.respondWith('POST', '/map/99/datalayer/update/63/', spy)
-      clickSave()
-      this.server.respond()
-      this.server.respond()
-      assert.ok(spy.calledOnce)
+      fetchMock.post('/map/99/datalayer/update/63/', spy)
+      return new Promise((resolve) => {
+        clickSave()
+        window.setTimeout(() => {
+          assert.ok(spy.calledOnce)
+          resolve()
+        }, 1000)
+      })
     })
   })
 
-  describe('#iconClassChange()', function () {
-    it('should change icon class', function () {
-      happen.click(qs('[data-id="' + this.datalayer._leaflet_id + '"] .layer-edit'))
+  describe('#iconClassChange()', () => {
+    it('should change icon class', () => {
+      happen.click(qs('[data-id="' + datalayer._leaflet_id + '"] .layer-edit'))
       changeSelectValue(
         qs('form#datalayer-advanced-properties select[name=iconClass]'),
         'Circle'
@@ -250,53 +219,53 @@ describe('L.U.DataLayer', function () {
     })
   })
 
-  describe('#show/hide', function () {
-    it('should hide features on hide', function () {
+  describe('#show/hide', () => {
+    it('should hide features on hide', () => {
       assert.ok(qs('div.umap-div-icon'))
       assert.ok(qs('path[fill="none"]'))
-      this.datalayer.hide()
+      datalayer.hide()
       assert.notOk(qs('div.umap-div-icon'))
       assert.notOk(qs('path[fill="none"]'))
     })
 
-    it('should show features on show', function () {
+    it('should show features on show', () => {
       assert.notOk(qs('div.umap-div-icon'))
       assert.notOk(qs('path[fill="none"]'))
-      this.datalayer.show()
+      datalayer.show()
       assert.ok(qs('div.umap-div-icon'))
       assert.ok(qs('path[fill="none"]'))
     })
   })
 
-  describe('#clone()', function () {
-    it('should clone everything but the id and the name', function () {
+  describe('#clone()', () => {
+    it('should clone everything but the id and the name', () => {
       enableEdit()
-      var clone = this.datalayer.clone()
+      var clone = datalayer.clone()
       assert.notOk(clone.umap_id)
-      assert.notEqual(clone.options.name, this.datalayer.name)
+      assert.notEqual(clone.options.name, datalayer.name)
       assert.ok(clone.options.name)
-      assert.equal(clone.options.color, this.datalayer.options.color)
-      assert.equal(clone.options.stroke, this.datalayer.options.stroke)
+      assert.equal(clone.options.color, datalayer.options.color)
+      assert.equal(clone.options.stroke, datalayer.options.stroke)
       clone._delete()
       clickSave()
     })
   })
 
-  describe('#restore()', function () {
+  describe('#restore()', () => {
     var oldConfirm,
-      newConfirm = function () {
+      newConfirm = () => {
         return true
       }
 
-    before(function () {
+    before(() => {
       oldConfirm = window.confirm
       window.confirm = newConfirm
     })
-    after(function () {
+    after(() => {
       window.confirm = oldConfirm
     })
 
-    it('should restore everything', function () {
+    it('should restore everything', (done) => {
       enableEdit()
       var geojson = L.Util.CopyJSON(RESPONSES.datalayer62_GET)
       geojson.features.push({
@@ -309,33 +278,31 @@ describe('L.U.DataLayer', function () {
         properties: { _umap_options: {}, name: 'new point from restore' },
       })
       geojson._umap_options.color = 'Chocolate'
-      this.server.respondWith(
-        'GET',
-        '/datalayer/62/olderversion.geojson',
-        JSON.stringify(geojson)
-      )
+      fetchMock.get('/datalayer/62/olderversion.geojson', geojson)
       sinon.spy(window, 'confirm')
-      this.datalayer.restore('olderversion.geojson')
-      this.server.respond()
-      assert(window.confirm.calledOnce)
-      window.confirm.restore()
-      assert.equal(this.datalayer.umap_id, 62)
-      assert.ok(this.datalayer.isDirty)
-      assert.equal(this.datalayer._index.length, 4)
-      assert.ok(qs('path[fill="Chocolate"]'))
-    })
-
-    it('should revert anything on cancel click', function () {
+      datalayer.restore('olderversion.geojson')
+      window.setTimeout(() => {
+        assert(window.confirm.calledOnce)
+        window.confirm.restore()
+        assert.equal(datalayer.umap_id, 62)
+        assert.ok(datalayer.isDirty)
+        assert.equal(datalayer._index.length, 4)
+        assert.ok(qs('path[fill="Chocolate"]'))
+        done()
+      }, 1000)
+    })
+
+    it('should revert anything on cancel click', () => {
       clickCancel()
-      assert.equal(this.datalayer._index.length, 3)
+      assert.equal(datalayer._index.length, 3)
       assert.notOk(qs('path[fill="Chocolate"]'))
     })
   })
 
-  describe('#smart-options()', function () {
+  describe('#smart-options()', () => {
     let poly, marker
-    before(function () {
-      this.datalayer.eachLayer(function (layer) {
+    before(() => {
+      datalayer.eachLayer(function (layer) {
         if (!poly && layer instanceof L.Polygon) {
           poly = layer
         }
@@ -345,39 +312,35 @@ describe('L.U.DataLayer', function () {
       })
     })
 
-    it('should parse color variable', function () {
+    it('should parse color variable', () => {
       let icon = qs('div.umap-div-icon .icon_container')
       poly.properties.mycolor = 'DarkGoldenRod'
       marker.properties.mycolor = 'DarkRed'
       marker.properties._umap_options.color = undefined
       assert.notOk(qs('path[fill="DarkGoldenRod"]'))
       assert.equal(icon.style.backgroundColor, 'olivedrab')
-      this.datalayer.options.color = '{mycolor}'
-      this.datalayer.options.fillColor = '{mycolor}'
-      this.datalayer.indexProperties(poly)
-      this.datalayer.indexProperties(marker)
-      this.datalayer.redraw()
+      datalayer.options.color = '{mycolor}'
+      datalayer.options.fillColor = '{mycolor}'
+      datalayer.indexProperties(poly)
+      datalayer.indexProperties(marker)
+      datalayer.redraw()
       icon = qs('div.umap-div-icon .icon_container')
       assert.equal(icon.style.backgroundColor, 'darkred')
       assert.ok(qs('path[fill="DarkGoldenRod"]'))
     })
   })
 
-  describe('#facet-search()', function () {
-    before(function () {
-      this.server.respondWith(
-        /\/datalayer\/63\/\?.*/,
-        JSON.stringify(RESPONSES.datalayer63_GET)
-      )
-      this.map.options.facetKey = 'name'
-      this.map.createDataLayer(RESPONSES.datalayer63_GET._umap_options)
-      this.server.respond()
+  describe('#facet-search()', () => {
+    before(async () => {
+      fetchMock.get(/\/datalayer\/63\/\?.*/, RESPONSES.datalayer63_GET)
+      map.options.facetKey = 'name'
+      await map.initDataLayers([RESPONSES.datalayer63_GET._umap_options])
     })
-    it('should not impact non browsable layer', function () {
+    it('should not impact non browsable layer', () => {
       assert.ok(qs('path[fill="SteelBlue"]'))
     })
-    it('should allow advanced filter', function () {
-      this.map.openFacet()
+    it('should allow advanced filter', () => {
+      map.openFacet()
       assert.ok(qs('div.umap-facet-search'))
       // This one if from the normal datalayer
       // it's name is "test", so it should be hidden
@@ -390,104 +353,109 @@ describe('L.U.DataLayer', function () {
       assert.ok(qs('path[fill="SteelBlue"]'))
       happen.click(qs('input[data-value="name poly"]')) // Undo
     })
-    it('should allow to control facet label', function () {
-      this.map.options.facetKey = 'name|Nom'
-      this.map.openFacet()
+    it('should allow to control facet label', () => {
+      map.options.facetKey = 'name|Nom'
+      map.openFacet()
       assert.ok(qs('div.umap-facet-search h5'))
       assert.equal(qs('div.umap-facet-search h5').textContent, 'Nom')
     })
   })
-  describe('#zoomEnd', function () {
-    it('should honour the fromZoom option', function () {
-      this.map.setZoom(6, { animate: false })
+  describe('#zoomEnd', () => {
+    it('should honour the fromZoom option', () => {
+      map.setZoom(6, { animate: false })
       assert.ok(qs('path[fill="none"]'))
-      this.datalayer.options.fromZoom = 6
-      this.map.setZoom(5, { animate: false })
+      datalayer.options.fromZoom = 6
+      map.setZoom(5, { animate: false })
       assert.notOk(qs('path[fill="none"]'))
-      this.map.setZoom(6, { animate: false })
+      map.setZoom(6, { animate: false })
       assert.ok(qs('path[fill="none"]'))
     })
 
-    it('should honour the toZoom option', function () {
-      this.map.setZoom(6, { animate: false })
+    it('should honour the toZoom option', () => {
+      map.setZoom(6, { animate: false })
       assert.ok(qs('path[fill="none"]'))
-      this.datalayer.options.toZoom = 6
-      this.map.setZoom(7, { animate: false })
+      datalayer.options.toZoom = 6
+      map.setZoom(7, { animate: false })
       assert.notOk(qs('path[fill="none"]'))
-      this.map.setZoom(6, { animate: false })
+      map.setZoom(6, { animate: false })
       assert.ok(qs('path[fill="none"]'))
     })
   })
 
-  describe('#displayOnLoad', function () {
-    beforeEach(function () {
-      this.server.respondWith(
-        /\/datalayer\/64\/\?.*/,
-        JSON.stringify(RESPONSES.datalayer64_GET)
-      )
-      this.datalayer = this.map.createDataLayer(RESPONSES.datalayer64_GET._umap_options)
-      // Force fetching the data, so to deal here with fake server
-      this.datalayer.fetchData()
-      this.server.respond()
-      this.map.setZoom(10, { animate: false })
+  describe('#displayOnLoad', () => {
+    before(() => {
+      fetchMock.get(/\/datalayer\/64\/\?.*/, RESPONSES.datalayer64_GET)
     })
 
-    afterEach(function () {
-      this.datalayer._delete()
+    beforeEach(async () => {
+      await map.initDataLayers([RESPONSES.datalayer64_GET._umap_options])
+      datalayer = map.getDataLayerByUmapId(64)
+      map.setZoom(10, { animate: false })
     })
 
-    it('should not display layer at load', function () {
+    afterEach(() => {
+      datalayer._delete()
+    })
+
+    it('should not display layer at load', () => {
       assert.notOk(qs('path[fill="AliceBlue"]'))
     })
 
-    it('should display on click', function () {
-      happen.click(qs(`[data-id='${L.stamp(this.datalayer)}'] .layer-toggle`))
-      assert.ok(qs('path[fill="AliceBlue"]'))
+    it('should display on click', (done) => {
+      happen.click(qs(`[data-id='${L.stamp(datalayer)}'] .layer-toggle`))
+      window.setTimeout(() => {
+        assert.ok(qs('path[fill="AliceBlue"]'))
+        done()
+      }, 500)
     })
 
-    it('should not display on zoom', function () {
-      this.map.setZoom(9, { animate: false })
-      assert.notOk(qs('path[fill="AliceBlue"]'))
+    it('should not display on zoom', (done) => {
+      map.setZoom(9, { animate: false })
+      window.setTimeout(() => {
+        assert.notOk(qs('path[fill="AliceBlue"]'))
+        done()
+      }, 500)
     })
   })
 
-  describe('#delete()', function () {
-    var deleteLink,
+  describe('#delete()', () => {
+    let deleteLink,
       deletePath = '/map/99/datalayer/delete/62/'
+    before(() => {
+      datalayer = map.getDataLayerByUmapId(62)
+    })
 
-    it('should have a delete link in update form', function () {
+    it('should have a delete link in update form', () => {
       enableEdit()
-      happen.click(
-        qs('#browse_data_toggle_' + L.stamp(this.datalayer) + ' .layer-edit')
-      )
+      happen.click(qs('#browse_data_toggle_' + L.stamp(datalayer) + ' .layer-edit'))
       deleteLink = qs('button.delete_datalayer_button')
       assert.ok(deleteLink)
     })
 
-    it('should delete features on datalayer delete', function () {
+    it('should delete features on datalayer delete', () => {
       happen.click(deleteLink)
       assert.notOk(qs('div.icon_container'))
     })
 
-    it('should have set map dirty', function () {
-      assert.ok(this.map.isDirty)
+    it('should have set map dirty', () => {
+      assert.ok(map.isDirty)
     })
 
-    it('should delete layer control row on delete', function () {
+    it('should delete layer control row on delete', () => {
       assert.notOk(
-        qs('.leaflet-control-browse #browse_data_toggle_' + L.stamp(this.datalayer))
+        qs('.leaflet-control-browse #browse_data_toggle_' + L.stamp(datalayer))
       )
     })
 
-    it('should be removed from map.datalayers_index', function () {
-      assert.equal(this.map.datalayers_index.indexOf(this.datalayer), -1)
+    it('should be removed from map.datalayers_index', () => {
+      assert.equal(map.datalayers_index.indexOf(datalayer), -1)
     })
 
-    it('should be removed from map.datalayers', function () {
-      assert.notOk(this.map.datalayers[L.stamp(this.datalayer)])
+    it('should be removed from map.datalayers', () => {
+      assert.notOk(map.datalayers[L.stamp(datalayer)])
     })
 
-    it('should be visible again on edit cancel', function () {
+    it('should be visible again on edit cancel', () => {
       clickCancel()
       assert.ok(qs('div.icon_container'))
     })