@kalisio/kdk 2.1.9 → 2.2.0

package/test/api/core/import-export.test.js

@@ -0,0 +1,86 @@
+import chai from 'chai'
+import chailint from 'chai-lint'
+import core, { kdk, hooks } from '../../../core/api/index.js'
+
+const { util, expect } = chai
+
+describe('core:import-export', () => {
+  let app, server, port, usersService, storageService, importExportService
+
+  before(async () => {
+    chailint(chai, util)
+    app = kdk()
+    // Register log hook
+    app.hooks({ error: { all: hooks.log } })
+    port = app.get('port')
+    await app.db.connect()
+    await app.db.instance.dropDatabase()
+  })
+
+  it('registers the services', async () => {
+    await app.configure(core)
+    // Ensure the users service exist
+    usersService = app.getService('users')
+    expect(usersService).toExist()
+    // Ensure the storage service exist
+    storageService = app.getService('storage')
+    expect(storageService).toExist()
+    // Ensure the expoter service exist
+    importExportService = app.getService('import-export')
+    expect(importExportService).toExist()
+    // Now app is configured launch the server
+    server = await app.listen(port)
+    await new Promise(resolve => server.once('listening', () => resolve()))
+  })
+  // Let enough time to process
+    .timeout(10000)
+
+  it('create a user collection', () => {
+    const users = []
+    for (let i = 0; i < 5000; i++) {
+      users.push({
+        email: `kalisio${i}@kalisio.xyz`,
+        password: 'Pass;word1',
+        description: 'Description for kalisio$[i}',
+        name: `user${i}`
+      })
+    }
+    return usersService._create(users, { noVerificationEmail: true })
+  })
+  // Let enough time to process
+    .timeout(50000)
+
+  it('export users collection in json', async () => {
+    const response = await importExportService.create({
+      method: 'export',
+      servicePath: 'api/users',
+      transform: {
+        omit: ['_id']
+      }
+    })
+    expect(response.SignedUrl).toExist()
+    await storageService.remove('import-export/' + response.id)
+  })
+    .timeout(30000)
+
+  it('export users collection in csv', async () => {
+    const response = await importExportService.create({
+      method: 'export',
+      servicePath: 'api/users',
+      transform: {
+        omit: ['_id']
+      },
+      format: 'csv'
+    })
+    expect(response.SignedUrl).toExist()
+    await storageService.remove('import-export/' + response.id)
+  })
+    .timeout(30000)
+
+  // Cleanup
+  after(async () => {
+    if (server) await server.close()
+    await app.db.instance.dropDatabase()
+    await app.db.disconnect()
+  })
+})

package/test/api/core/test-log-2024-01-04.log

@@ -0,0 +1,14 @@
+{"level":"error","message":"error: api/account - Method: create: The provided password does not comply to the password policy"}
+{"level":"error","message":"error: api/account - Method: create: The provided password does not comply to the password policy"}
+{"level":"error","message":"error: api/account - Method: create: The provided password does not comply to the password policy"}
+{"level":"error","message":"error: api/account - Method: create: The provided password does not comply to the password policy"}
+{"level":"error","message":"error: api/account - Method: create: The provided password does not comply to the password policy"}
+{"level":"error","message":"error: api/account - Method: create: The provided password does not comply to the password policy"}
+{"level":"error","message":"error: api/account - Method: create: The provided password does not comply to the password policy"}
+{"level":"error","message":"error: api/account - Method: create: The provided password does not comply to the password policy"}
+{"level":"error","message":"error: api/account - Method: create: The provided password does not comply to the password policy"}
+{"level":"error","message":"error: api/account - Method: create: The provided password does not comply to the password policy"}
+{"level":"error","message":"error: api/account - Method: create: The provided password does not comply to the password policy"}
+{"level":"error","message":"error: api/account - Method: create: The provided password does not comply to the password policy"}
+{"level":"error","message":"error: api/account - Method: create: The provided password does not comply to the password policy"}
+{"level":"error","message":"error: api/account - Method: create: The provided password does not comply to the password policy"}

package/test/api/map/catalog.test.js

@@ -0,0 +1,164 @@
+import chai from 'chai'
+import chailint from 'chai-lint'
+import _ from 'lodash'
+import path from 'path'
+import fs from 'fs-extra'
+import { fileURLToPath } from 'url'
+import core, { kdk, hooks, permissions } from '../../../core/api/index.js'
+import map, {
+  permissions as mapPermissions, createCatalogService, createProjectsService
+} from '../../../map/api/index.js'
+
+const __dirname = path.dirname(fileURLToPath(import.meta.url))
+const { util, expect } = chai
+
+describe('map:catalog', () => {
+  let app, server, port, // baseUrl,
+    userService, userObject, catalogService, defaultLayers,
+    zonesLayer, vigicruesLayer, contextObject, projectService, projectObject
+
+  before(() => {
+    chailint(chai, util)
+
+    // Register all default hooks for authorisation
+    // Default rules for all users
+    permissions.defineAbilities.registerHook(permissions.defineUserAbilities)
+    // Then rules for maps
+    permissions.defineAbilities.registerHook(mapPermissions.defineUserAbilities)
+
+    app = kdk()
+    // Register authorisation/log hook
+    app.hooks({
+      before: { all: [hooks.authorise] },
+      error: { all: hooks.log }
+    })
+    port = app.get('port')
+    // baseUrl = `http://localhost:${port}${app.get('apiPath')}`
+    return app.db.connect()
+  })
+
+  it('registers the services', async () => {
+    await app.configure(core)
+    userService = app.getService('users')
+    expect(userService).toExist()
+    await app.configure(map)
+    // Create a global catalog/project service
+    await createCatalogService.call(app)
+    catalogService = app.getService('catalog')
+    expect(catalogService).toExist()
+    await createProjectsService.call(app)
+    projectService = app.getService('projects')
+    expect(projectService).toExist()
+    // Now app is configured launch the server
+    server = await app.listen(port)
+    await new Promise(resolve => server.once('listening', () => resolve()))
+  })
+  // Let enough time to process
+    .timeout(5000)
+
+  it('creates a test user', async () => {
+    userObject = await userService.create({ email: 'test-user@test.org', name: 'test-user' }, { checkAuthorisation: true })
+    const users = await userService.find({ query: { 'profile.name': 'test-user' }, user: userObject, checkAuthorisation: true })
+    expect(users.data.length > 0).beTrue()
+  })
+  // Let enough time to process
+    .timeout(5000)
+
+  it('registers the default layer catalog', async () => {
+    const layers = await fs.readJson(path.join(__dirname, 'config/layers.json'))
+    expect(layers.length > 0)
+    // Create a global catalog service
+    defaultLayers = await catalogService.create(layers)
+    expect(defaultLayers.length > 0)
+    zonesLayer = _.find(defaultLayers, { name: 'zones' })
+    vigicruesLayer = _.find(defaultLayers, { name: 'vigicrues-stations' })
+  })
+
+  it('manages layers, contexts and categories', async () => {
+    const layer = await catalogService.create({ name: 'dummy', type: 'OverlayLayer' })
+    // Can't duplicate name
+    let doublonLayer
+    try {
+      doublonLayer = await catalogService.create({ name: 'dummy', type: 'OverlayLayer' })
+    } catch (error) {
+      expect(error).toExist()
+      expect(error.name).to.equal('Conflict')
+      expect(error.data.translation.key).to.equal('OBJECT_ID_ALREADY_TAKEN')
+    }
+    expect(doublonLayer).beUndefined()
+    // Can duplicate if we target different types
+    let context = await catalogService.create({ name: 'dummy', type: 'Context', layers: ['dummy'] })
+    let category = await catalogService.create({ name: 'dummy', type: 'Category', layers: ['dummy'] })
+    // Check for context/category filtering by default
+    const response = await catalogService.find({ query: {}, paginate: false })
+    expect(response.length === defaultLayers.length + 1)
+    // Check for automated context/category update whn layer is renamed/removed
+    await catalogService.patch(layer._id.toString(), { name: 'oldDummy' })
+    context = await catalogService.get(context._id.toString())
+    expect(context.layers).to.deep.equal(['oldDummy'])
+    category = await catalogService.get(category._id.toString())
+    expect(category.layers).to.deep.equal(['oldDummy'])
+    await catalogService.remove(layer._id.toString())
+    context = await catalogService.get(context._id.toString())
+    expect(context.layers).to.deep.equal([])
+    await catalogService.remove(context._id.toString())
+    category = await catalogService.get(category._id.toString())
+    expect(category.layers).to.deep.equal([])
+    await catalogService.remove(category._id.toString())
+  })
+  // Let enough time to process
+    .timeout(5000)
+
+  it('creates a context', async () => {
+    contextObject = await catalogService.create({ name: 'context', type: 'Context', layers: ['vigicrues-stations', 'zones'] })
+    // Rename layer and check it has been updated in context
+    zonesLayer = await catalogService.patch(zonesLayer._id, { name: 'new-zones' })
+    contextObject = await catalogService.get(contextObject._id)
+    expect(contextObject.layers).to.deep.equal(['vigicrues-stations', 'new-zones'])
+  })
+
+  it('creates a project', async () => {
+    projectObject = await projectService.create({
+      name: 'project', views: [{ _id: contextObject._id }], layers: [{ _id: zonesLayer._id }, { name: vigicruesLayer.name }]
+    })
+    // Remove context and check it has been updated in project
+    await catalogService.remove(contextObject._id)
+    projectObject = await projectService.get(projectObject._id)
+    expect(projectObject.views).to.deep.equal([])
+    // Remove layer and check it has been updated in project
+    await catalogService.remove(zonesLayer._id)
+    projectObject = await projectService.get(projectObject._id, { query: { populate: true } })
+    expect(projectObject.layers).to.deep.equal([{
+      _id: vigicruesLayer._id,
+      name: vigicruesLayer.name,
+      service: vigicruesLayer.name
+    }])
+  })
+
+  it('clears the catalog and projects', async () => {
+    await catalogService.remove(null, { query: { } })
+    const layers = await catalogService.find({ query: {}, paginate: false })
+    expect(layers.length === 0)
+    await projectService.remove(projectObject._id)
+    const projects = await projectService.find({ query: {}, paginate: false })
+    expect(projects.length === 0)
+  })
+
+  it('removes the test user', async () => {
+    await userService.remove(userObject._id, {
+      user: userObject,
+      checkAuthorisation: true
+    })
+    const users = await userService.find({ query: { name: 'test-user' } })
+    expect(users.data.length === 0).beTrue()
+  })
+
+  // Cleanup
+  after(async () => {
+    if (server) await server.close()
+    await catalogService.Model.drop()
+    await projectService.Model.drop()
+    await userService.Model.drop()
+    await app.db.disconnect()
+  })
+})

package/test/api/map/index.test.js

@@ -16,9 +16,9 @@ const { util, expect } = chai
 
 describe('map:services', () => {
   let app, server, port, // baseUrl,
-    userService, userObject, geocoderService, catalogService, defaultLayers,
-    zonesService, vigicruesStationsService, vigicruesObsService, adsbObsService,
-    position, items, eventListeners, eventCount, eventData
+    userService, userObject, catalogService, defaultLayers,
+    zonesService, vigicruesStationsService, nbStations, vigicruesObsService,
+    adsbObsService, items, eventListeners, eventCount, eventData
 
   function eventsOn (service) {
     eventListeners = {}
@@ -81,8 +81,6 @@ describe('map:services', () => {
     userService = app.getService('users')
     expect(userService).toExist()
     await app.configure(map)
-    geocoderService = app.getService('geocoder')
-    expect(geocoderService).toExist()
     // Create a global catalog service
     await createCatalogService.call(app)
     catalogService = app.getService('catalog')
@@ -110,41 +108,6 @@ describe('map:services', () => {
     expect(defaultLayers.length > 0)
   })
 
-  it('manages layers, contexts and categories', async () => {
-    const layer = await catalogService.create({ name: 'dummy', type: 'OverlayLayer' })
-    // Can't duplicate name
-    let doublonLayer
-    try {
-      doublonLayer = await catalogService.create({ name: 'dummy', type: 'OverlayLayer' })
-    } catch (error) {
-      expect(error).toExist()
-      expect(error.name).to.equal('Conflict')
-      expect(error.data.translation.key).to.equal('OBJECT_ID_ALREADY_TAKEN')
-    }
-    expect(doublonLayer).beUndefined()
-    // Can duplicate if we target different types
-    let context = await catalogService.create({ name: 'dummy', type: 'Context', layers: ['dummy'] })
-    let category = await catalogService.create({ name: 'dummy', type: 'Category', layers: ['dummy'] })
-    // Check for context/category filtering by default
-    const response = await catalogService.find({ query: {}, paginate: false })
-    expect(response.length === defaultLayers.length + 1)
-    // Check for automated context/category update whn layer is renamed/removed
-    await catalogService.patch(layer._id.toString(), { name: 'oldDummy' })
-    context = await catalogService.get(context._id.toString())
-    expect(context.layers).to.deep.equal(['oldDummy'])
-    category = await catalogService.get(category._id.toString())
-    expect(category.layers).to.deep.equal(['oldDummy'])
-    await catalogService.remove(layer._id.toString())
-    context = await catalogService.get(context._id.toString())
-    expect(context.layers).to.deep.equal([])
-    await catalogService.remove(context._id.toString())
-    category = await catalogService.get(category._id.toString())
-    expect(category.layers).to.deep.equal([])
-    await catalogService.remove(category._id.toString())
-  })
-  // Let enough time to process
-    .timeout(5000)
-
   it('create and feed the zones service', async () => {
     // Create the service
     const zonesLayer = _.find(defaultLayers, { name: 'zones' })
@@ -217,6 +180,7 @@ describe('map:services', () => {
     expect(vigicruesStationsService).toExist()
     // Feed the collection
     const stations = fs.readJsonSync(path.join(__dirname, 'data/vigicrues.stations.json')).features
+    nbStations = stations.length
     await vigicruesStationsService.create(stations)
   })
   // Let enough time to process
@@ -315,7 +279,27 @@ describe('map:services', () => {
     .timeout(5000)
 
   it('performs spatial filtering on vigicrues stations service', async () => {
-    const result = await vigicruesStationsService.find({
+    let result = await vigicruesStationsService.find({
+      query: { south: -90, north: 90, east: 180, west: -180 },
+      paginate: false
+    })
+    expect(result.features.length).to.equal(nbStations)
+    result = await vigicruesStationsService.find({
+      query: { south: 80, north: 85, east: 180, west: -180 },
+      paginate: false
+    })
+    expect(result.features.length).to.equal(0)
+    result = await vigicruesStationsService.find({
+      query: { south: -85, north: -80, east: 180, west: -180 },
+      paginate: false
+    })
+    expect(result.features.length).to.equal(0)
+    result = await vigicruesStationsService.find({
+      query: { south: -20, north: 20, east: 100, west: -100 },
+      paginate: false
+    })
+    expect(result.features.length).to.equal(0)
+    result = await vigicruesStationsService.find({
       query: {
         geometry: {
           $near: {
@@ -512,26 +496,6 @@ describe('map:services', () => {
   // Let enough time to process
     .timeout(10000)
 
-  it('geocode an address', async () => {
-    const address = '80 chemin des tournesols, 11400 Castelnaudary'
-    const response = await geocoderService.create({ address: address }, { user: userObject, checkAuthorisation: true })
-    expect(response.length === 1).beTrue()
-    position = response[0]
-    expect(position.latitude).toExist()
-    expect(position.longitude).toExist()
-  })
-  // Let enough time to process
-    .timeout(10000)
-
-  it('reverse geocode a position', async () => {
-    const response = await geocoderService.create(position, { user: userObject, checkAuthorisation: true })
-    expect(response.length > 0).beTrue()
-    expect(response[0].country).toExist()
-    expect(response[0].streetName).toExist()
-  })
-  // Let enough time to process
-    .timeout(10000)
-
   it('clears the layers', async () => {
     for (let i = 0; i < defaultLayers.length; ++i) {
       await catalogService.remove(defaultLayers[i]._id)

package/test/api/map/test-log-2024-01-04.log

@@ -0,0 +1,2 @@
+{"level":"error","message":"error: api/catalog - Method: create: Object with name equals to dummy already exist for service catalog"}
+{"level":"error","message":"error: api/catalog - Method: create: Object with name equals to dummy already exist for service catalog"}

package/test/api/map/test-log-2024-01-11.log

@@ -0,0 +1 @@
+{"level":"error","message":"error: api/catalog - Method: create: Object with name equals to dummy already exist for service catalog"}

package/test/api/map/test-log-2024-01-25.log

@@ -0,0 +1,19 @@
+{"level":"info","message":"Logger configured"}
+{"level":"info","message":"Initializing weacast-gfs plugin"}
+{"level":"info","message":"Initializing gfs-world forecast"}
+{"level":"info","message":"Checking for up-to-date forecast data on gfs-world/u-wind"}
+{"level":"info","message":"Checking for up-to-date forecast data on gfs-world/v-wind"}
+{"level":"info","message":"Completed forecast data update on gfs-world/u-wind"}
+{"level":"info","message":"Completed forecast data update on gfs-world/v-wind"}
+{"level":"error","message":"Cannot check alert 65b23e9b0c441d5b46ac6f77 as target probes service is not available"}
+{"level":"error","message":"error: api/alerts - Method: create: Not Found"}
+{"level":"error","message":"Cannot check alert 65b23e9b0c441d5b46ac6f78 as target probes service is not available"}
+{"level":"error","message":"error: api/alerts - Method: create: Not Found"}
+{"level":"error","message":"Cannot check alert 65b23e9b0c441d5b46ac6f79 as target probes service is not available"}
+{"level":"error","message":"error: api/alerts - Method: create: Not Found"}
+{"level":"error","message":"error: api/alerts - Method: create: Not Found"}
+{"level":"error","message":"error: api/alerts - Method: create: Not Found"}
+{"level":"error","message":"Cannot check alert 65b23e9b0c441d5b46ac74bc as no data is available for features service vigicrues-observations"}
+{"level":"error","message":"error: api/alerts - Method: create: Not Found"}
+{"level":"error","message":"error: api/catalog - Method: create: Object with name equals to dummy already exist for service catalog"}
+{"level":"info","message":"Logger configured"}

package/test/client/core/layout.js

@@ -1,5 +1,5 @@
 import makeDebug from 'debug'
-import { click, clickAction, isElementVisible } from './utils.js'
+import { countElements, click, clickAction, isElementVisible, isActionVisible } from './utils.js'
 
 const debug = makeDebug('kdk:core:test:layout')
 
@@ -79,26 +79,46 @@ export async function isWindowMaximized (page, placement) {
   return isElementVisible(page, `#restore-${placement}-window`)
 }
 
+async function clickWindowControl (page, placement, control) {
+  const action = `${control}-${placement}-window`
+  if (!await isActionVisible(page, action)) await clickAction(page, 'window-controls')
+  await clickAction(page, action)
+}
+
 export async function closeWindow (page, placement) {
-  await clickAction(page, `close-${placement}-window`)
+  await clickWindowControl(page, placement, 'close')
 }
 
 export async function maximizeWindow (page, placement) {
-  await clickAction(page, `maximize-${placement}-window`)
+  await clickWindowControl(page, placement, 'maximize')
 }
 
 export async function restoreWindow (page, placement) {
-  await clickAction(page, `restore-${placement}-window`)
+  await clickWindowControl(page, placement, 'restore')
 }
 
 export async function pinWindow (page, placement) {
-  await clickAction(page, `pin-${placement}-window`)
+  await clickWindowControl(page, placement, 'pin')
+}
+
+export async function unpinWindow (page, placement) {
+  await clickWindowControl(page, placement, 'unpin')
 }
 
 export async function clickFab (page) {
   return clickAction(page, 'fab')
 }
 
+export async function clickFabAction (page, action) {
+  await clickAction(page, 'fab')
+  return clickAction(page, action)
+}
+
+export async function countFabActions (page) {
+  return countElements(page, '//a[contains(@class, "k-action-fab-action")]')
+}
+
+
 export async function closeWelcomeDialog (page) {
   await click(page, '.q-dialog #close-button')
 }

package/test/client/core/utils.js

@@ -52,6 +52,13 @@ export async function click (page, selector, wait = 500) {
   }
 }
 
+/* Helper function to check whether an action is visible
+ */
+export async function isActionVisible (page, action) {
+  const selector = `#${action}`
+  return isElementVisible(page, selector)
+}
+
 /* Helper function to click on an action selector
  */
 export async function clickAction (page, action, wait = 500) {

package/test/client/map/catalog.js

@@ -29,6 +29,14 @@ export async function clickLayerCategory (page, tabId, categoryId, wait = 500) {
   await core.clickPaneAction(page, 'right', categoryId, wait)
 }
 
+export async function layerExists (page, tabId, layer) {
+  const isCatalogOpened = await clickCatalogTab(page, tabId)
+  const layerId = getLayerId(layer)
+  const exists = await core.elementExists(page, `#${layerId}`)
+  if (!isCatalogOpened) await core.clickOpener(page, 'right')
+  return exists
+}
+
 export async function clickLayer (page, tabId, layer, wait = 1000) {
   const isCatalogOpened = await clickCatalogTab(page, tabId)
   const layerId = getLayerId(layer)
@@ -39,7 +47,7 @@ export async function clickLayer (page, tabId, layer, wait = 1000) {
     if (!isCategoryOpened) await core.clickPaneAction(page, 'right', categoryId, 1000)
   }
   let selector = `#${layerId} .q-toggle`
-  // some layers have a toggle (regulaer layers), some don't (base layers)
+  // some layers have a toggle (regular layers), some don't (base layers)
   if (!await core.elementExists(page, selector)) {
     selector = `#${layerId}`
   }
@@ -111,6 +119,7 @@ export async function dropFile (page, filePath, wait = 2000) {
   const loaderSelector = '#dropFileInput'
   const loader = await page.$(loaderSelector)
   await loader.uploadFile(filePath)
+  await page.waitForNetworkIdle()  
   await page.waitForTimeout(wait)
 }
 
@@ -126,6 +135,12 @@ export async function addView (page) {
   await page.waitForTimeout(1000)
 }
 
+export async function addProject (page) {
+  await core.clickFab(page)
+  await core.clickAction(page, 'create-project')
+  await page.waitForTimeout(1000)
+}
+
 export async function importLayer (page, filePath, featureId = undefined, wait = 2000) {
   await addLayer(page)
   await core.uploadFile(page, '#file-field', filePath)
@@ -189,5 +204,67 @@ export async function removeView (page, tabId, name) {
   const isCatalogOpened = await clickCatalogTab(page, tabId, 2000)
   await core.clickItemAction(page, 'catalog/KViewSelector', name, 'view-overflowmenu', 1000)
   await core.clickAction(page, 'remove-view', 1000)
+  await core.click(page, '.q-dialog button:nth-child(2)', 1000)
+  if (!isCatalogOpened) await core.clickOpener(page, 'right')
+}
+
+export async function createProject (page, name, options, wait = 2000) {
+  const { categories, layers, views } = options
+  await addProject(page)
+  await core.type(page, '#name-field', name)
+  await core.type(page, '#description-field', `${name} description`)
+  // Open categories first
+  for (let i = 0; i < categories.length; i++) {
+    const category = categories[i]
+    await core.clickXPath(page, `//div[contains(text(), "${category}")]`)
+  }
+  // Then select layers
+  for (let i = 0; i < layers.length; i++) {
+    const layer = layers[i]
+    await core.clickXPath(page, `//div[contains(text(), "${layer}")]/../../preceding-sibling::div[contains(@class, "q-checkbox")]`)
+  }
+  if (views) {
+    for (let i = 0; i < views.length; i++) {
+      const view = views[i]
+      await core.clickXPath(page, `//div[contains(text(), "${view}")]/../../preceding-sibling::div[contains(@class, "q-checkbox")]`)
+    }
+  }
+  await core.clickAction(page, 'apply-button', 1000)
+  await page.waitForTimeout(wait)
+}
+
+export async function projectExists (page, tabId, name) {
+  const isCatalogOpened = await clickCatalogTab(page, tabId, 2000)
+  const exists = await core.itemExists(page, 'catalog/KProjectSelector', name)
+  if (!isCatalogOpened) await core.clickOpener(page, 'right')
+  return exists
+}
+
+export async function clickProject (page, tabId, name) {
+  const isCatalogOpened = await clickCatalogTab(page, tabId, 2000)
+  await core.clickItem(page, 'catalog/KProjectSelector', name)
+  // Switching to project automatically closes the catalog tab
+  if (isCatalogOpened) await core.clickOpener(page, 'right')
+  await page.waitForNetworkIdle()
+}
+
+export async function switchProject (page, name, wait = 2000) {
+  await core.click(page, '#project-menu', 2000)
+  await core.clickXPath(page, `//div[contains(@component, "collection/KItem") and contains(., "${name}")]`, 1000)
+  await page.waitForNetworkIdle()
+  await page.waitForTimeout(wait)
+}
+
+export async function closeProject (page, wait = 2000) {
+  await core.click(page, '#close-project')
+  await page.waitForNetworkIdle()
+  await page.waitForTimeout(wait)
+}
+
+export async function removeProject (page, tabId, name) {
+  const isCatalogOpened = await clickCatalogTab(page, tabId, 2000)
+  await core.clickItemAction(page, 'catalog/KProjectSelector', name, 'project-overflowmenu', 1000)
+  await core.clickAction(page, 'remove-project', 1000)
+  await core.click(page, '.q-dialog button:nth-child(2)', 1000)
   if (!isCatalogOpened) await core.clickOpener(page, 'right')
 }

package/test/client/map/time.js

@@ -11,7 +11,8 @@ export async function openTimeline (page) {
 
 export async function clickTimelineHour (page, hour, wait = 1000) {
   const isTimelineOpened = await openTimeline(page)
-  const xpath = `//div[contains(., "${hour}h") and contains(@class, "k-timeline-hour-frame")]`
+  await core.click(page, '#time-button', wait)
+  const xpath = `//div[contains(@class, "q-time__clock-pos-${hour}")]`
   const elements = await page.$x(xpath)
   if (elements.length > 0) {
     elements[0].click()