seatsio 72.4.0 → 72.7.0

package/.github/workflows/release.yml

@@ -0,0 +1,42 @@
+# Very important!
+# Make sure that the github token has read AND WRITE access on github.
+#   1. hit https://github.com/seatsio/[REPO]/settings/actions
+#   2. under "Workflow permissions", make sure "Read and write permissions" is checked instead of the (default?) read only.
+#
+
+name: Release
+run-name: Release ${{ github.repository }}
+on:
+  workflow_dispatch:
+    inputs:
+      versionToBump:
+        description: 'The version to bump. Major for incompatible API changes, minor for adding BC features'
+        required: true
+        type: choice
+        options:
+          - minor
+          - major
+jobs:
+  release:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v3
+      - uses: fregante/setup-git-user@v2
+      - id: install-zx
+        run: npm i -g zx
+      - id: install-semver-tool
+        run: |
+          wget -O /usr/local/bin/semver https://raw.githubusercontent.com/fsaintjacques/semver-tool/master/src/semver
+          chmod +x /usr/local/bin/semver
+      - run: zx ./release.mjs -v $VERSION_TO_BUMP
+        env:
+          VERSION_TO_BUMP: ${{ inputs.versionToBump }}
+          GH_TOKEN: ${{ github.token }}
+      - uses: actions/setup-node@v1
+        with:
+          node-version: 18
+          registry-url: https://registry.npmjs.org/
+      - run: yarn install
+      - run: yarn publish
+        env:
+          NODE_AUTH_TOKEN: ${{secrets.NPM_TOKEN}}

package/README.md

@@ -56,6 +56,19 @@ let event = await client.events.create(chart.key)
 console.log(`Created a chart with key ${chart.key} and an event with key: ${event.key}`)
 ```
 
+### Creating multiple events
+
+```js
+import { SeatsioClient, Region, Events } from 'seatsio'
+
+let client = new SeatsioClient(Region.EU(), <WORKSPACE SECRET KEY>)
+let chart = await client.charts.create()
+let events = await client.events.createMultiple(chart.key, [ Events.eventCreationParams(), Events.eventCreationParams('aSpecificEventKey') ])
+for (const event of events) {
+    console.log(`Created an event with key: ${event.key}`)
+}
+```
+
 ### Booking objects
 
 Booking an object changes its status to `booked`. Booked seats are not selectable on a rendered chart.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "seatsio",
-  "version": "72.4.0",
+  "version": "72.7.0",
   "main": "index.js",
   "description": "Official JavaScript and Node.JS client library for the Seats.io REST API",
   "license": "MIT",
@@ -13,16 +13,16 @@
     "url": "https://github.com/seatsio/seatsio-js"
   },
   "dependencies": {
-    "axios": "1.3.4"
+    "axios": "1.4.0"
   },
   "devDependencies": {
-    "eslint": "8.35.0",
+    "eslint": "8.39.0",
     "eslint-config-standard": "17.0.0",
     "eslint-plugin-import": "2.27.5",
-    "eslint-plugin-n": "15.6.1",
+    "eslint-plugin-n": "15.7.0",
     "eslint-plugin-promise": "6.1.1",
-    "jest": "29.4.3",
-    "jest-cli": "29.4.3",
+    "jest": "29.5.0",
+    "jest-cli": "29.5.0",
     "uuid": "9.0.0"
   }
 }

package/release.mjs

@@ -0,0 +1,92 @@
+#!/usr/bin/env zx
+
+/*
+* Script to release the seats.io java lib.
+*   - changes the version number in README.md
+*   - changes the version number in build.gradle
+*   - creates the release in Gihub (using gh cli)
+*
+*
+* Prerequisites:
+*   - zx installed (https://github.com/google/zx)
+*   - gh cli installed (https://cli.github.com/)
+*   - semver cli installed (https://github.com/fsaintjacques/semver-tool)
+*
+* Usage:
+*   zx ./release.mjs -v major/minor -n "release notes"
+* */
+
+// don't output the commands themselves
+$.verbose = false
+
+const versionToBump = getVersionToBump()
+const latestVersion = await fetchLatestReleasedVersionNumber()
+const nextVersion = await determineNextVersionNumber(latestVersion)
+
+await pullLastVersion()
+    .then(bumpVersionInFiles)
+    .then(commitAndPush)
+    .then(release)
+
+function getVersionToBump() {
+    if (!argv.v || !(argv.v === 'minor' || argv.v === 'major')) {
+        throw new Error ("Please specify -v major/minor")
+    }
+    return argv.v
+}
+
+function removeLeadingV(tagName) {
+    if (tagName.startsWith('v')) {
+        return tagName.substring(1)
+    }
+    return tagName
+}
+
+async function fetchLatestReleasedVersionNumber() {
+    let result = await $`gh release view --json tagName`
+    let tagName = JSON.parse(result).tagName
+    return removeLeadingV(tagName)
+}
+
+async function determineNextVersionNumber(previous) {
+    return (await $`semver bump ${versionToBump} ${previous}`).stdout.trim()
+}
+
+async function bumpVersionInFiles() {
+    await replaceInFile("package.json", `"version": "${latestVersion}",`, `"version": "${nextVersion}",`)
+}
+
+async function replaceInFile(filename, latestVersion, nextVersion) {
+    return await fs.readFile(filename, 'utf8')
+        .then(text => {
+            if (text.indexOf(latestVersion) < 0) {
+                throw new Error('Not the correct version. Could not find ' + latestVersion + ' in ' + filename)
+            }
+            return text
+        })
+        .then(text => text.replace(latestVersion, nextVersion))
+        .then(text => fs.writeFileSync(filename, text))
+        .then(() => gitAdd(filename))
+}
+
+async function pullLastVersion() {
+    await $`git checkout master`
+    await $`git pull origin master`
+}
+
+async function gitAdd(filename) {
+    return await $`git add ${filename}`
+}
+
+async function commitAndPush() {
+    await $`git commit -m "version bump"`
+    await $`git push origin master`
+}
+
+async function release() {
+    const newTag = 'v' + nextVersion
+    return await $`gh release create ${newTag} --generate-notes`.catch(error => {
+        console.error('something went wrong while creating the release. Please revert the version change!')
+        throw error
+    })
+}

package/src/Events/Events.js

@@ -16,7 +16,6 @@ class Events {
         this.channels = new Channels(this.client)
     }
 
-    /* @return Event */
     /**
      * @param {string} chartKey
      * @param {?string} eventKey
@@ -55,6 +54,73 @@ class Events {
             .then((res) => new EventDeserializer().fromJson(res.data))
     }
 
+    /**
+     * @param {?string} eventKey
+     * @param {?TableBookingConfig} tableBookingConfig
+     * @param {?string} socialDistancingRulesetKey
+     * @param {?object} objectCategories
+     * @param {?array} categories
+     * @returns an object containing the necessary data for event creation
+     * @static
+     */
+    static eventCreationParams (eventKey = null, tableBookingConfig = null, socialDistancingRulesetKey = null, objectCategories = null, categories = null) {
+        const eventDefinition = {}
+        eventDefinition.eventKey = eventKey
+        eventDefinition.tableBookingConfig = tableBookingConfig
+        eventDefinition.socialDistancingRulesetKey = socialDistancingRulesetKey
+        eventDefinition.objectCategories = objectCategories
+        eventDefinition.categories = categories
+        return eventDefinition
+    }
+
+    /**
+     * @param {string} chartKey
+     * @param {object[]} events use {@link Events.eventCreationParams()} as a convenience function to create these objects
+     * @returns {Promise<Event[]>}
+     */
+    createMultiple (chartKey, events) {
+        const requestParameters = {}
+
+        requestParameters.chartKey = chartKey
+        requestParameters.events = []
+
+        if (events) {
+            for (let i = 0; i < events.length; i++) {
+                const event = {}
+                if (events[i].eventKey !== null) {
+                    event.eventKey = events[i].eventKey
+                }
+
+                if (events[i].tableBookingConfig !== null) {
+                    event.tableBookingConfig = events[i].tableBookingConfig
+                }
+
+                if (events[i].socialDistancingRulesetKey !== null) {
+                    event.socialDistancingRulesetKey = events[i].socialDistancingRulesetKey
+                }
+
+                if (events[i].objectCategories !== null) {
+                    event.objectCategories = events[i].objectCategories
+                }
+
+                if (events[i].categories != null) {
+                    event.categories = events[i].categories
+                }
+                requestParameters.events.push(event)
+            }
+        }
+
+        return this.client.post('/events/actions/create-multiple', requestParameters)
+            .then((res) => {
+                const result = []
+                const deserializer = new EventDeserializer()
+                for (const event of res.data.events) {
+                    result.push(deserializer.fromJson(event))
+                }
+                return result
+            })
+    }
+
     /**
      * @param {string} eventKey
      * @returns {Promise<Event>}
@@ -389,8 +455,8 @@ class Events {
      * @param {?string[]} channelKeys
      * @returns {Promise<BestAvailableObjects>}
      */
-    bookBestAvailable (eventKey, number, categories = null, holdToken = null, extraData = null, ticketTypes = null, orderId = null, keepExtraData = null, ignoreChannels = null, channelKeys = null) {
-        return this.changeBestAvailableObjectStatus(encodeURIComponent(eventKey), number, EventObjectInfo.BOOKED, categories, holdToken, extraData, ticketTypes, orderId, keepExtraData, ignoreChannels, channelKeys)
+    bookBestAvailable (eventKey, number, categories = null, holdToken = null, extraData = null, ticketTypes = null, orderId = null, keepExtraData = null, ignoreChannels = null, channelKeys = null, tryToPreventOrphanSeats = null) {
+        return this.changeBestAvailableObjectStatus(encodeURIComponent(eventKey), number, EventObjectInfo.BOOKED, categories, holdToken, extraData, ticketTypes, orderId, keepExtraData, ignoreChannels, channelKeys, tryToPreventOrphanSeats)
     }
 
     /**
@@ -436,8 +502,8 @@ class Events {
      * @param {?string[]} ticketTypes
      * @returns {Promise<BestAvailableObjects>}
      */
-    holdBestAvailable (eventKey, number, holdToken, categories = null, extraData = null, ticketTypes = null, orderId = null, keepExtraData = null, ignoreChannels = null, channelKeys = null) {
-        return this.changeBestAvailableObjectStatus(encodeURIComponent(eventKey), number, EventObjectInfo.HELD, categories, holdToken, extraData, ticketTypes, orderId, keepExtraData, ignoreChannels, channelKeys)
+    holdBestAvailable (eventKey, number, holdToken, categories = null, extraData = null, ticketTypes = null, orderId = null, keepExtraData = null, ignoreChannels = null, channelKeys = null, tryToPreventOrphanSeats = null) {
+        return this.changeBestAvailableObjectStatus(encodeURIComponent(eventKey), number, EventObjectInfo.HELD, categories, holdToken, extraData, ticketTypes, orderId, keepExtraData, ignoreChannels, channelKeys, tryToPreventOrphanSeats)
     }
 
     /**
@@ -454,7 +520,7 @@ class Events {
      * @param {?string[]} channelKeys
      * @returns {Promise<BestAvailableObjects>}
      */
-    changeBestAvailableObjectStatus (eventKey, number, status, categories = null, holdToken = null, extraData = null, ticketTypes = null, orderId = null, keepExtraData = null, ignoreChannels = null, channelKeys = null) {
+    changeBestAvailableObjectStatus (eventKey, number, status, categories = null, holdToken = null, extraData = null, ticketTypes = null, orderId = null, keepExtraData = null, ignoreChannels = null, channelKeys = null, tryToPreventOrphanSeats = null) {
         const requestParameters = {}
         const bestAvailable = {}
         requestParameters.status = status
@@ -474,6 +540,9 @@ class Events {
         if (ticketTypes !== null) {
             bestAvailable.ticketTypes = ticketTypes
         }
+        if (tryToPreventOrphanSeats !== null) {
+            bestAvailable.tryToPreventOrphanSeats = tryToPreventOrphanSeats
+        }
         if (keepExtraData !== null) {
             requestParameters.keepExtraData = keepExtraData
         }

package/tests/events/changeBestAvailableObjectStatus.test.js

@@ -10,7 +10,7 @@ test('should change best available object status', async () => {
     const bestAvailableObjs = await client.events.changeBestAvailableObjectStatus(event.key, 2, 'lolzor')
 
     expect(bestAvailableObjs.nextToEachOther).toBe(true)
-    expect(bestAvailableObjs.objects.sort()).toEqual(['B-4', 'B-5'])
+    expect(bestAvailableObjs.objects.sort()).toEqual(['A-4', 'A-5'])
 })
 
 test('should change best available object status with categories', async () => {
@@ -32,9 +32,9 @@ test('should change best available object status with extra data', async () => {
 
     const bestAvailableObjs = await client.events.changeBestAvailableObjectStatus(event.key, 2, 'lolzor', null, null, extraData)
 
-    const objectInfo4 = await client.events.retrieveObjectInfo(event.key, 'B-4')
-    const objectInfo5 = await client.events.retrieveObjectInfo(event.key, 'B-5')
-    expect(bestAvailableObjs.objects.sort()).toEqual(['B-4', 'B-5'])
+    const objectInfo4 = await client.events.retrieveObjectInfo(event.key, 'A-4')
+    const objectInfo5 = await client.events.retrieveObjectInfo(event.key, 'A-5')
+    expect(bestAvailableObjs.objects.sort()).toEqual(['A-4', 'A-5'])
     expect(objectInfo4.extraData).toEqual(extraData[0])
     expect(objectInfo5.extraData).toEqual(extraData[1])
 })
@@ -75,7 +75,19 @@ test('should book best available object with extra data', async () => {
     const bestAvailableObjs = await client.events.bookBestAvailable(event.key, 3, null, null, extraData)
 
     expect(bestAvailableObjs.nextToEachOther).toBe(true)
-    expect(bestAvailableObjs.objects).toEqual(['B-4', 'B-5', 'B-6'])
+    expect(bestAvailableObjs.objects).toEqual(['A-4', 'A-5', 'A-6'])
+})
+
+test('should book best available while leaving orphan seats', async () => {
+    const { client, user } = await testUtils.createTestUserAndClient()
+    const chartKey = testUtils.getChartKey()
+    await testUtils.createTestChart(chartKey, user.secretKey)
+    const event = await client.events.create(chartKey)
+    await client.events.book(event.key, ['A-4', 'A-5'])
+
+    const bestAvailableObjs = await client.events.bookBestAvailable(event.key, 2, null, null, null, null, null, null, null, null, false)
+
+    expect(bestAvailableObjs.objects).toEqual(['A-2', 'A-3'])
 })
 
 test('should book best available object', async () => {
@@ -87,7 +99,7 @@ test('should book best available object', async () => {
     const bestAvailableObjs = await client.events.bookBestAvailable(event.key, 3)
 
     expect(bestAvailableObjs.nextToEachOther).toBe(true)
-    expect(bestAvailableObjs.objects).toEqual(['B-4', 'B-5', 'B-6'])
+    expect(bestAvailableObjs.objects).toEqual(['A-4', 'A-5', 'A-6'])
 })
 
 test('should hold best available object ', async () => {
@@ -139,11 +151,11 @@ test('should respect keepExtraData=true', async () => {
     const chartKey = testUtils.getChartKey()
     await testUtils.createTestChart(chartKey, user.secretKey)
     const event = await client.events.create(chartKey)
-    await client.events.updateExtraData(event.key, 'B-5', { foo: 'bar' })
+    await client.events.updateExtraData(event.key, 'A-5', { foo: 'bar' })
 
     await client.events.changeBestAvailableObjectStatus(event.key, 1, 'someStatus', null, null, null, null, null, true)
 
-    const status = await client.events.retrieveObjectInfo(event.key, 'B-5')
+    const status = await client.events.retrieveObjectInfo(event.key, 'A-5')
     expect(status.extraData).toEqual({ foo: 'bar' })
 })
 
@@ -152,11 +164,11 @@ test('should respect keepExtraData=false', async () => {
     const chartKey = testUtils.getChartKey()
     await testUtils.createTestChart(chartKey, user.secretKey)
     const event = await client.events.create(chartKey)
-    await client.events.updateExtraData(event.key, 'B-5', { foo: 'bar' })
+    await client.events.updateExtraData(event.key, 'A-5', { foo: 'bar' })
 
     await client.events.changeBestAvailableObjectStatus(event.key, 1, 'someStatus', null, null, null, null, null, false)
 
-    const status = await client.events.retrieveObjectInfo(event.key, 'B-5')
+    const status = await client.events.retrieveObjectInfo(event.key, 'A-5')
     expect(status.extraData).toBeFalsy()
 })
 
@@ -165,11 +177,11 @@ test('should respect no keepExtraData', async () => {
     const chartKey = testUtils.getChartKey()
     await testUtils.createTestChart(chartKey, user.secretKey)
     const event = await client.events.create(chartKey)
-    await client.events.updateExtraData(event.key, 'B-5', { foo: 'bar' })
+    await client.events.updateExtraData(event.key, 'A-5', { foo: 'bar' })
 
     await client.events.changeBestAvailableObjectStatus(event.key, 1, 'someStatus')
 
-    const status = await client.events.retrieveObjectInfo(event.key, 'B-5')
+    const status = await client.events.retrieveObjectInfo(event.key, 'A-5')
     expect(status.extraData).toBeFalsy()
 })
 
@@ -181,11 +193,11 @@ test('should accept channel keys', async () => {
     await client.events.channels.replace(event.key, {
         channelKey1: { name: 'channel 1', color: '#FFAABB', index: 1 }
     })
-    await client.events.channels.setObjects(event.key, { channelKey1: ['B-6'] })
+    await client.events.channels.setObjects(event.key, { channelKey1: ['A-6'] })
 
     const bestAvailableObjs = await client.events.changeBestAvailableObjectStatus(event.key, 1, 'lolzor', null, null, null, null, null, null, null, ['channelKey1'])
 
-    expect(bestAvailableObjs.objects).toEqual(['B-6'])
+    expect(bestAvailableObjs.objects).toEqual(['A-6'])
 })
 
 test('should accept ignoreChannels', async () => {
@@ -200,5 +212,5 @@ test('should accept ignoreChannels', async () => {
 
     const bestAvailableObjs = await client.events.changeBestAvailableObjectStatus(event.key, 1, 'lolzor', null, null, null, null, null, null, true)
 
-    expect(bestAvailableObjs.objects).toEqual(['B-5'])
+    expect(bestAvailableObjs.objects).toEqual(['A-5'])
 })

package/tests/events/changeObjectStatus.test.js

@@ -29,7 +29,7 @@ test('should change object status', async () => {
             isAvailable: false,
             availabilityReason: 'lolzor',
             isDisabledBySocialDistancing: false,
-            distanceToFocalPoint: 79.43847425150014
+            distanceToFocalPoint: 98.67842540608864
         }
     })
 })
@@ -62,9 +62,9 @@ test('should change object status with GA', async () => {
     await testUtils.createTestChart(chartKey, user.secretKey)
     const event = await client.events.create(chartKey)
 
-    const result = await client.events.changeObjectStatus(event.key, '34', 'lolzor')
+    const result = await client.events.changeObjectStatus(event.key, 'GA2', 'lolzor')
 
-    expect(Object.keys(result.objects)).toEqual(['34'])
+    expect(Object.keys(result.objects)).toEqual(['GA2'])
 })
 
 test('should change object status with GA and quantity', async () => {

package/tests/events/changeObjectStatusForMultipleObjects.test.js

@@ -101,13 +101,13 @@ test('should change object status for multiple objects with quantity', async ()
     const event = await client.events.create(chartKey)
     const objects = [
         (new ObjectProperties('GA1')).setQuantity(5),
-        (new ObjectProperties('34')).setQuantity(10)
+        (new ObjectProperties('GA2')).setQuantity(10)
     ]
 
     await client.events.changeObjectStatus(event.key, objects, 'lolzor')
 
     const status1 = await client.events.retrieveObjectInfo(event.key, 'GA1')
-    const status2 = await client.events.retrieveObjectInfo(event.key, '34')
+    const status2 = await client.events.retrieveObjectInfo(event.key, 'GA2')
     expect(status1.numBooked).toBe(5)
     expect(status2.numBooked).toBe(10)
 })

package/tests/events/createEvents.test.js

@@ -0,0 +1,134 @@
+const testUtils = require('../testUtils.js')
+const SocialDistancingRuleset = require('../../src/Charts/SocialDistancingRuleset.js')
+const TableBookingConfig = require('../../src/Events/TableBookingConfig')
+const Category = require('../../src/Charts/Category')
+const Events = require('../../src/Events/Events')
+
+test('should check that a minimum of one event is required', async () => {
+    const { client, user } = await testUtils.createTestUserAndClient()
+    const chartKey = testUtils.getChartKey()
+    await testUtils.createTestChart(chartKey, user.secretKey)
+
+    try {
+        await client.events.createMultiple(chartKey)
+    } catch (e) {
+        expect(e.errors.length).toEqual(1)
+        expect(e.errors[0].code).toBe('GENERAL_ERROR')
+        expect(e.errors[0].message).toBe('#/events: expected minimum item count: 1, found: 0')
+    }
+})
+
+test('should check that an empty object is a valid event definition', async () => {
+    const { client, user } = await testUtils.createTestUserAndClient()
+    const chartKey = testUtils.getChartKey()
+    await testUtils.createTestChart(chartKey, user.secretKey)
+
+    const events = await client.events.createMultiple(chartKey, [{}])
+
+    expect(events).toHaveLength(1)
+    expect(events[0].key).toBeTruthy()
+})
+
+test('should create a single event', async () => {
+    const { client } = await testUtils.createTestUserAndClient()
+    const chart = await client.charts.create()
+
+    const events = await client.events.createMultiple(chart.key, [
+        Events.eventCreationParams('eventKey')
+    ])
+
+    expect(events).toHaveLength(1)
+    expect(events[0].key).toEqual('eventKey')
+
+    const retrievedEvent = await client.events.retrieve('eventKey')
+    expect(retrievedEvent.key).toEqual('eventKey')
+})
+
+test('should create multiple events', async () => {
+    const { client } = await testUtils.createTestUserAndClient()
+    const chart = await client.charts.create()
+
+    const events = [
+        Events.eventCreationParams('eventKey1'),
+        Events.eventCreationParams('eventKey2')
+    ]
+    const createdEvents = await client.events.createMultiple(chart.key, events)
+
+    expect(createdEvents).toHaveLength(2)
+    expect(createdEvents[0].key).toEqual('eventKey1')
+    expect(createdEvents[1].key).toEqual('eventKey2')
+
+    for (const event of events) {
+        const retrievedEvent = await client.events.retrieve(event.eventKey)
+        expect(retrievedEvent.key).toEqual(event.eventKey)
+    }
+})
+
+test('supports tableBookingConfig custom', async () => {
+    const { client, user } = await testUtils.createTestUserAndClient()
+    const chartKey = testUtils.getChartKey()
+    await testUtils.createTestChartWithTables(chartKey, user.secretKey)
+    const tableBookingConfig = TableBookingConfig.custom({ T1: 'BY_TABLE', T2: 'BY_SEAT' })
+
+    const events = await client.events.createMultiple(chartKey, [
+        Events.eventCreationParams(null, tableBookingConfig)
+    ])
+
+    expect(events[0].key).toBeTruthy()
+    expect(events[0].tableBookingConfig).toEqual(tableBookingConfig)
+})
+
+test('supports tableBookingConfig inherit', async () => {
+    const { client, user } = await testUtils.createTestUserAndClient()
+    const chartKey = testUtils.getChartKey()
+    await testUtils.createTestChartWithTables(chartKey, user.secretKey)
+
+    const events = await client.events.createMultiple(chartKey, [
+        Events.eventCreationParams(null, TableBookingConfig.inherit())
+    ])
+
+    expect(events[0].key).toBeTruthy()
+    expect(events[0].tableBookingConfig).toEqual(TableBookingConfig.inherit())
+})
+
+test('it supports a social distancing ruleset key', async () => {
+    const { client } = await testUtils.createTestUserAndClient()
+    const chart = await client.charts.create()
+    const rulesets = { ruleset1: SocialDistancingRuleset.ruleBased('My ruleset').build() }
+    await client.charts.saveSocialDistancingRulesets(chart.key, rulesets)
+
+    const events = await client.events.createMultiple(chart.key, [
+        Events.eventCreationParams(null, null, 'ruleset1')
+    ])
+
+    expect(events[0].socialDistancingRulesetKey).toBe('ruleset1')
+})
+
+test('it supports object categories', async () => {
+    const { client, user } = await testUtils.createTestUserAndClient()
+    const chartKey = testUtils.getChartKey()
+    await testUtils.createTestChart(chartKey, user.secretKey)
+
+    const events = await client.events.createMultiple(chartKey, [
+        Events.eventCreationParams(null, null, null, { 'A-1': 10 })
+    ])
+
+    expect(events[0].objectCategories).toEqual({ 'A-1': 10 })
+})
+
+test('it supports categories', async () => {
+    const { client, user } = await testUtils.createTestUserAndClient()
+    const chartKey = testUtils.getChartKey()
+    await testUtils.createTestChart(chartKey, user.secretKey)
+
+    const eventCategory = new Category('eventCat1', 'Event Level Category', '#AAABBB')
+
+    const events = await client.events.createMultiple(chartKey, [
+        Events.eventCreationParams(null, null, null, null, [eventCategory])
+    ])
+
+    expect(events[0].categories.length).toEqual(4) // 3 from sampleChart.json, 1 event level category
+    expect(events[0].categories.filter(cat => cat.key === 'eventCat1').length).toEqual(1)
+    expect(events[0].categories.filter(cat => cat.key === 'eventCat1')[0].label).toEqual('Event Level Category')
+    expect(events[0].categories.filter(cat => cat.key === 'eventCat1')[0].color).toEqual('#AAABBB')
+})