botium-core 1.13.4 → 1.13.6

package/test/convo/fillAndApplyScriptingMemory.spec.js

@@ -1,4 +1,5 @@
 const path = require('path')
+const moment = require('moment')
 const assert = require('chai').assert
 const BotDriver = require('../../').BotDriver
 const Capabilities = require('../../').Capabilities
@@ -695,6 +696,39 @@ describe('convo.fillAndApplyScriptingMemory', function () {
         assert(result.length === 13, '$timestap is invalid')
       })
 
+      it('tomorrow without format', async function () {
+        const result = ScriptingMemory.apply(
+          { caps: CAPS_ENABLE_SCRIPTING_MEMORY },
+          {},
+          '$tomorrow'
+        )
+        assert.equal(result, moment().add(1, 'day').toDate().toLocaleDateString())
+      })
+      it('tomorrow with format', async function () {
+        const result = ScriptingMemory.apply(
+          { caps: CAPS_ENABLE_SCRIPTING_MEMORY },
+          {},
+          '$tomorrow(YYYY.MM.DD)'
+        )
+        assert.equal(result, moment().add(1, 'day').format('YYYY.MM.DD'))
+      })
+      it('yesterday without format', async function () {
+        const result = ScriptingMemory.apply(
+          { caps: CAPS_ENABLE_SCRIPTING_MEMORY },
+          {},
+          '$yesterday'
+        )
+        assert.equal(result, moment().subtract(1, 'day').toDate().toLocaleDateString())
+      })
+      it('yesterday with format', async function () {
+        const result = ScriptingMemory.apply(
+          { caps: CAPS_ENABLE_SCRIPTING_MEMORY },
+          {},
+          '$yesterday(YYYY.MM.DD)'
+        )
+        assert.equal(result, moment().subtract(1, 'day').format('YYYY.MM.DD'))
+      })
+
       it('year', async function () {
         const result = ScriptingMemory.apply(
           { caps: CAPS_ENABLE_SCRIPTING_MEMORY },
@@ -703,7 +737,7 @@ describe('convo.fillAndApplyScriptingMemory', function () {
         )
 
         const year = parseInt(result)
-        assert(year >= 2019 && year <= 2219, '$year invalid')
+        assert.equal(year, new Date().getFullYear(), '$year invalid')
       })
 
       it('month', async function () {
@@ -712,8 +746,7 @@ describe('convo.fillAndApplyScriptingMemory', function () {
           {},
           '$month'
         )
-
-        assert(result.length >= 2 && result.length <= 10, '$month invalid')
+        assert.equal(result, moment().format('MMMM'), '$month invalid')
       })
       it('month_MM', async function () {
         const result = ScriptingMemory.apply(
@@ -733,7 +766,7 @@ describe('convo.fillAndApplyScriptingMemory', function () {
         )
 
         const dayOfMonth = parseInt(result)
-        assert(dayOfMonth >= 1 && dayOfMonth <= 35, 'day_of_month invalid')
+        assert(dayOfMonth >= 1 && dayOfMonth <= 35, '$day_of_month invalid')
       })
 
       it('day_of_week', async function () {
@@ -746,6 +779,25 @@ describe('convo.fillAndApplyScriptingMemory', function () {
         assert(result.length >= 2 && result.length <= 20, '$day_of_week invalid')
       })
 
+      it('date_add', async function () {
+        const result = ScriptingMemory.apply(
+          { caps: CAPS_ENABLE_SCRIPTING_MEMORY },
+          {},
+          '$date_add(1, "day", YYYY.MM.DD)'
+        )
+
+        assert.equal(result, moment().add(1, 'day').format('YYYY.MM.DD'))
+      })
+      it('date_subtract', async function () {
+        const result = ScriptingMemory.apply(
+          { caps: CAPS_ENABLE_SCRIPTING_MEMORY },
+          {},
+          '$date_subtract(1, "month", YYYY.MM.DD)'
+        )
+
+        assert.equal(result, moment().subtract(1, 'month').format('YYYY.MM.DD'))
+      })
+
       it('random', async function () {
         const result = ScriptingMemory.apply(
           { caps: CAPS_ENABLE_SCRIPTING_MEMORY },
@@ -813,6 +865,14 @@ describe('convo.fillAndApplyScriptingMemory', function () {
         )
         assert.equal(result, 'botium')
       })
+      it('func with moment', async function () {
+        const result = ScriptingMemory.apply(
+          { caps: CAPS_ENABLE_SCRIPTING_MEMORY },
+          {},
+          '$func(moment(\\).subtract(1, "month"\\).startOf("month"\\).format("DD.MM.YYYY"\\))'
+        )
+        assert.equal(result, moment().subtract(1, 'month').startOf('month').format('DD.MM.YYYY'))
+      })
       it('environment variable', async function () {
         process.env.MY_VAR_VALUE = 'botium'
         const result = ScriptingMemory.apply(

package/test/convo/transcript.spec.js

@@ -287,11 +287,11 @@ describe('convo.transcript', function () {
 
       assert.equal(err.transcript.err.context.input.messageText, 'Hello')
       assert.equal(err.transcript.err.context.errors[0].type, 'asserter')
-      assert.equal(err.transcript.err.context.errors[0].source, 'TextMatchAsserter')
+      assert.equal(err.transcript.err.context.errors[0].source, 'Text Match Asserter')
       assert.equal(err.transcript.err.context.errors[1].type, 'asserter')
-      assert.equal(err.transcript.err.context.errors[1].source, 'ButtonsAsserter')
+      assert.equal(err.transcript.err.context.errors[1].source, 'Buttons Asserter')
       assert.equal(err.transcript.err.context.errors[2].type, 'asserter')
-      assert.equal(err.transcript.err.context.errors[2].source, 'ButtonsAsserter')
+      assert.equal(err.transcript.err.context.errors[2].source, 'Buttons Asserter')
     }
   })
   it('should throw simple error with multiple asserting errors if its enabled and assertConvoEnd fail', async function () {
@@ -317,11 +317,11 @@ describe('convo.transcript', function () {
 
       assert.equal(err.transcript.err.context.input.messageText, 'Hello')
       assert.equal(err.transcript.err.context.errors[0].type, 'asserter')
-      assert.equal(err.transcript.err.context.errors[0].source, 'TextMatchAsserter')
+      assert.equal(err.transcript.err.context.errors[0].source, 'Text Match Asserter')
       assert.equal(err.transcript.err.context.errors[1].type, 'asserter')
-      assert.equal(err.transcript.err.context.errors[1].source, 'ButtonsAsserter')
+      assert.equal(err.transcript.err.context.errors[1].source, 'Buttons Asserter')
       assert.equal(err.transcript.err.context.errors[2].type, 'asserter')
-      assert.equal(err.transcript.err.context.errors[2].source, 'ButtonsAsserter')
+      assert.equal(err.transcript.err.context.errors[2].source, 'Buttons Asserter')
       assert.equal(err.transcript.err.context.errors[3].type, 'asserter')
       assert.equal(err.transcript.err.context.errors[3].source, 'assertConvoEnd')
     }
@@ -398,4 +398,13 @@ describe('convo.transcript', function () {
       assert.equal(err.transcript.steps.length, 5)
     }
   })
+  it('should calculate assertion count', async function () {
+    this.compiler.ReadScript(path.resolve(__dirname, 'convos'), '2steps.convo.txt')
+    assert.equal(this.compiler.convos.length, 1)
+    assert.equal(this.compiler.GetAssertionCount(this.compiler.convos[0]), 2)
+
+    this.compiler.ReadScript(path.resolve(__dirname, 'convos'), 'asserters.convo.txt')
+    assert.equal(this.compiler.convos.length, 2)
+    assert.equal(this.compiler.GetAssertionCount(this.compiler.convos[1]), 1)
+  })
 })

package/test/scripting/asserters/convos/wer_threshold_nok_percentage.yml

@@ -0,0 +1,7 @@
+convos:
+  - name: wer_threshold_nok
+    steps:
+      - me:
+          - test 123
+      - bot:
+          - TEXT_WER tast 123|10

package/test/scripting/asserters/convos/wer_threshold_ok_percentage.yml

@@ -0,0 +1,7 @@
+convos:
+  - name: wer_threshold_ok
+    steps:
+      - me:
+          - test 123
+      - bot:
+          - TEXT_WER tast 123|60

package/test/scripting/asserters/entityContentAsserter.spec.js

@@ -20,10 +20,9 @@ describe('scripting.asserters.entityContentAsserter', function () {
       })
       assert.fail('should have failed')
     } catch (err) {
-      assert.isTrue(err.message.indexOf('EntityContentAsserter Missing argument') > 0)
+      assert.isTrue(err.message.indexOf('Missing argument') > 0)
       assert.isNotNull(err.context)
       assert.equal(err.context.type, 'asserter')
-      assert.equal(err.context.source, 'EntityContentAsserter')
     }
   })
 
@@ -36,10 +35,9 @@ describe('scripting.asserters.entityContentAsserter', function () {
       })
       assert.fail('should have failed')
     } catch (err) {
-      assert.isTrue(err.message.indexOf('EntityContentAsserter Missing argument') > 0)
+      assert.isTrue(err.message.indexOf('Missing argument') > 0)
       assert.isNotNull(err.context)
       assert.equal(err.context.type, 'asserter')
-      assert.equal(err.context.source, 'EntityContentAsserter')
     }
   })
 
@@ -55,7 +53,6 @@ describe('scripting.asserters.entityContentAsserter', function () {
       assert.isTrue(err.message.indexOf('Expected entity "something" but found nothing') > 0)
       assert.isNotNull(err.context)
       assert.equal(err.context.type, 'asserter')
-      assert.equal(err.context.source, 'EntityContentAsserter')
     }
   })
 
@@ -88,7 +85,6 @@ describe('scripting.asserters.entityContentAsserter', function () {
       assert.isTrue(err.message.indexOf('test: Missing entity content: [ \'something_value\' ] of entity "something"') >= 0)
       assert.isNotNull(err.context)
       assert.equal(err.context.type, 'asserter')
-      assert.equal(err.context.source, 'EntityContentAsserter')
       assert.isNotNull(err.context.cause)
       assert.equal(err.context.cause.entity, 'something')
       assert.deepEqual(err.context.cause.expected, ['something_value'])
@@ -126,7 +122,6 @@ describe('scripting.asserters.entityContentAsserter', function () {
       assert.isTrue(err.message.indexOf('test: Missing entity content: [ \'entity1_value1\', \'entity1_value3\' ] of entity "entity1"') >= 0)
       assert.isNotNull(err.context)
       assert.equal(err.context.type, 'asserter')
-      assert.equal(err.context.source, 'EntityContentAsserter')
       assert.isNotNull(err.context.cause)
       assert.equal(err.context.cause.entity, 'entity1')
       assert.deepEqual(err.context.cause.expected, ['entity1_value1', 'entity1_value1', 'entity1_value3'])

package/test/scripting/asserters/intentAsserter.spec.js

@@ -62,7 +62,7 @@ const _assert = (expected, found) => {
   ))
 
   if (!expected) {
-    return assert.isRejected(promise, `${steptag}: IntentAsserter Missing argument`)
+    return assert.isRejected(promise, `${steptag}: NLU Intent Asserter Missing argument`)
   } else if (!found) {
     return assert.isRejected(promise, `${steptag}: Expected intent "${expected}" but found nothing`)
   } else if (expected !== found) {

package/test/scripting/asserters/intentConfidenceAsserter.spec.js

@@ -61,16 +61,12 @@ describe('scripting.asserters.intentConfidenceAsserter', function () {
     [false, 80, 85, false]
   ]
 
-  cases.forEach((cse) => {
-    const useWithGlobal = cse[0]
-    const expected = cse[1]
-    const found = cse[2]
-    const negative = cse[3]
+  for (const [useWithGlobal, expected, found, negative] of cases) {
     const message = `${negative ? 'negative' : 'positive'} case for intent confidence asserter ${useWithGlobal ? 'with global args' : 'without global args'}, exp: ${expected}, found: ${found}`
     it(message,
       async function () {
-        return _assert(...cse)
+        return _assert(useWithGlobal, expected, found, negative)
       }
     )
-  })
+  }
 })

package/test/scripting/asserters/jsonpathAsserter.spec.js

@@ -278,7 +278,7 @@ describe('scripting.asserters.jsonPathAsserter', function () {
         })
         assert.fail('should have failed')
       } catch (err) {
-        assert.isTrue(err.message.indexOf('JsonPathAsserter 0 arguments expected') > 0)
+        assert.isTrue(err.message.indexOf('0 arguments expected') > 0)
       }
     })
     it('should succeed on existing jsonpath from pathPattern', async function () {

package/test/scripting/asserters/werAsserter.spec.js

@@ -27,16 +27,36 @@ describe('scripting.asserters.werAsserter', function () {
     this.container && await this.container.Clean()
   })
 
-  it('ok', async function () {
-    this.compiler.ReadScriptsFromDirectory(path.resolve(__dirname, 'convos', 'wer_threshold_ok.yml'))
+  it('ok (float)', async function () {
+    this.compiler.ReadScriptsFromDirectory(path.resolve(__dirname, 'convos', 'wer_threshold_ok_float.yml'))
 
     this.compiler.ExpandScriptingMemoryToConvos()
     assert.equal(this.compiler.convos.length, 1)
     await this.compiler.convos[0].Run(this.container)
   })
+  it('ok (percentage)', async function () {
+    this.compiler.ReadScriptsFromDirectory(path.resolve(__dirname, 'convos', 'wer_threshold_ok_percentage.yml'))
 
-  it('nok', async function () {
-    this.compiler.ReadScriptsFromDirectory(path.resolve(__dirname, 'convos', 'wer_threshold_nok.yml'))
+    this.compiler.ExpandScriptingMemoryToConvos()
+    assert.equal(this.compiler.convos.length, 1)
+    await this.compiler.convos[0].Run(this.container)
+  })
+
+  it('nok (float)', async function () {
+    this.compiler.ReadScriptsFromDirectory(path.resolve(__dirname, 'convos', 'wer_threshold_nok_float.yml'))
+
+    this.compiler.ExpandScriptingMemoryToConvos()
+    assert.equal(this.compiler.convos.length, 1)
+
+    try {
+      await this.compiler.convos[0].Run(this.container)
+      assert.fail('expected error')
+    } catch (err) {
+      assert.equal(err.message, 'wer_threshold_nok/Line 2: assertion error - Line 2: Word Error Rate (50%) higher than accepted (10%)')
+    }
+  })
+  it('nok (percentage)', async function () {
+    this.compiler.ReadScriptsFromDirectory(path.resolve(__dirname, 'convos', 'wer_threshold_nok_percentage.yml'))
 
     this.compiler.ExpandScriptingMemoryToConvos()
     assert.equal(this.compiler.convos.length, 1)
@@ -45,7 +65,7 @@ describe('scripting.asserters.werAsserter', function () {
       await this.compiler.convos[0].Run(this.container)
       assert.fail('expected error')
     } catch (err) {
-      assert.equal(err.message, 'wer_threshold_nok/Line 2: assertion error - Line 2: Word error rate 0.5 > 0.1 for tast 123')
+      assert.equal(err.message, 'wer_threshold_nok/Line 2: assertion error - Line 2: Word Error Rate (50%) higher than accepted (10%)')
     }
   })
 })

package/test/scripting/matching/matchingmode.spec.js

@@ -306,7 +306,7 @@ describe('scripting.matching.matchingmode', function () {
     })
   })
 
-  describe('wer.lowthreshold', function () {
+  describe('wer.lowthreshold (float)', function () {
     beforeEach(async function () {
       const myCaps = {
         [Capabilities.PROJECTNAME]: 'matching.matchingmode',
@@ -326,8 +326,28 @@ describe('scripting.matching.matchingmode', function () {
       assert.isFalse(this.compiler.Match('test 123', 'tast 123'))
     })
   })
+  describe('wer.lowthreshold (percentage)', function () {
+    beforeEach(async function () {
+      const myCaps = {
+        [Capabilities.PROJECTNAME]: 'matching.matchingmode',
+        [Capabilities.CONTAINERMODE]: echoConnector,
+        [Capabilities.SCRIPTING_MATCHING_MODE]: 'wer',
+        [Capabilities.SCRIPTING_MATCHING_MODE_ARGS]: [10]
+      }
+      const driver = new BotDriver(myCaps)
+      this.compiler = driver.BuildCompiler()
+      this.container = await driver.Build()
+    })
+    afterEach(async function () {
+      this.container && await this.container.Clean()
+    })
+
+    it('should not match because of low threshold', async function () {
+      assert.isFalse(this.compiler.Match('test 123', 'tast 123'))
+    })
+  })
 
-  describe('wer.highthreshold', function () {
+  describe('wer.highthreshold (float)', function () {
     beforeEach(async function () {
       const myCaps = {
         [Capabilities.PROJECTNAME]: 'matching.matchingmode',
@@ -343,6 +363,26 @@ describe('scripting.matching.matchingmode', function () {
       this.container && await this.container.Clean()
     })
 
+    it('should match because of high threshold', async function () {
+      assert.isTrue(this.compiler.Match('test 123', 'tast 123'))
+    })
+  })
+  describe('wer.highthreshold (percentage)', function () {
+    beforeEach(async function () {
+      const myCaps = {
+        [Capabilities.PROJECTNAME]: 'matching.matchingmode',
+        [Capabilities.CONTAINERMODE]: echoConnector,
+        [Capabilities.SCRIPTING_MATCHING_MODE]: 'wer',
+        [Capabilities.SCRIPTING_MATCHING_MODE_ARGS]: [60]
+      }
+      const driver = new BotDriver(myCaps)
+      this.compiler = driver.BuildCompiler()
+      this.container = await driver.Build()
+    })
+    afterEach(async function () {
+      this.container && await this.container.Clean()
+    })
+
     it('should match because of high threshold', async function () {
       assert.isTrue(this.compiler.Match('test 123', 'tast 123'))
     })

package/test/scripting/scriptingModificator.spec.js

@@ -55,9 +55,8 @@ describe('scriptingModificator.assertions', function () {
       })
       assert.fail('should have failed')
     } catch (err) {
-      assert.isTrue(err.message.indexOf('Expected asserter IntentAsserter with args "test1" to fail') > 0)
+      assert.isTrue(err.message.indexOf('Expected asserter NLU Intent Asserter with args "test1" to fail') > 0)
       assert.isNotNull(err.context)
-      assert.equal(err.context.source, 'IntentAsserter')
     }
   })
 })

package/test/scripting/scriptingProvider.spec.js

@@ -293,6 +293,48 @@ describe('scripting.scriptingProvider', function () {
       assert.equal(scriptingProvider.convos[1].header.name, 'test convo/utt1-L2')
       assert.equal(scriptingProvider.convos[1].conversation[0].messageText, 'TEXT2')
     })
+    it('should build convos for utterance using iterator', async function () {
+      const scriptingProvider = new ScriptingProvider(DefaultCapabilities)
+      await scriptingProvider.Build()
+      scriptingProvider.AddUtterances({
+        name: 'utt1',
+        utterances: ['TEXT1', 'TEXT2']
+      })
+      scriptingProvider.AddConvos(new Convo(scriptingProvider._buildScriptContext(), {
+        header: {
+          name: 'test convo'
+        },
+        conversation: [
+          {
+            sender: 'me',
+            messageText: 'utt1'
+          }
+        ]
+      }))
+
+      scriptingProvider.ExpandConvosIterable()
+      const expected = [
+        {
+          header: { name: 'test convo/utt1-L1' },
+          conversation: [{ messageText: 'TEXT1' }]
+        },
+        {
+          header: { name: 'test convo/utt1-L2' },
+          conversation: [{ messageText: 'TEXT2' }]
+        }
+      ]
+      let i = 0
+      for (const c of scriptingProvider.convosIterable) {
+        const exp = expected[i++]
+        assert.equal(c.header.name, exp.header.name)
+        assert.equal(c.conversation.length, exp.conversation.length)
+        assert.deepEqual(c.conversation.map(s => s.messageText), exp.conversation.map(s => s.messageText))
+      }
+      assert.equal(i, 2)
+      // scriptingProvider.convosIterable.forEach((iteratedConvo, index) => {
+      //   assert.deepEqual(iteratedConvo, expected[index])
+      // })
+    })
     it('should build convos for utterance with parameters', async function () {
       const scriptingProvider = new ScriptingProvider(DefaultCapabilities)
       await scriptingProvider.Build()
@@ -350,10 +392,12 @@ describe('scripting.scriptingProvider', function () {
       assert.equal(scriptingProvider.convos[1].conversation[0].messageText, 'TEXT2')
     })
     describe('should build convos for SCRIPTING_UTTEXPANSION_NAMING_MODE', function () {
-      const utterances = {
-        name: 'uttText',
-        utterances: ['TEXT1 01234567890123456789', 'TEXT2 01234567890123456789']
-      }
+      const utterances = [
+        {
+          name: 'uttText',
+          utterances: ['TEXT1 01234567890123456789', 'TEXT2 01234567890123456789']
+        }
+      ]
       const convoUtterances = {
         header: {
           name: 'test convo'
@@ -397,7 +441,38 @@ describe('scripting.scriptingProvider', function () {
         assert.equal(scriptingProvider.convos[0].header.name, 'test convo/uttText-L1-TEXT1 0123456...')
         assert.equal(scriptingProvider.convos[1].header.name, 'test convo/uttText-L2-TEXT2 0123456...')
       })
+      it('SCRIPTING_UTTEXPANSION_NAMING_MODE=utterance len=1', async function () {
+        const scriptingProvider = new ScriptingProvider(Object.assign(
+          {},
+          DefaultCapabilities,
+          {
+            [Capabilities.SCRIPTING_UTTEXPANSION_NAMING_MODE]: 'utterance'
+          }
+        ))
+        await scriptingProvider.Build()
+        scriptingProvider.AddUtterances([
+          {
+            name: 'uttText1',
+            utterances: ['TEXT1 01234567890123456789']
+          }
+        ])
+        scriptingProvider.AddConvos(new Convo(scriptingProvider._buildScriptContext(), {
+          header: {
+            name: 'test convo'
+          },
+          conversation: [
+            {
+              sender: 'me',
+              messageText: 'uttText1'
+            }
+          ]
+        }))
 
+        scriptingProvider.ExpandConvos()
+        assert.equal(scriptingProvider.convos.length, 1)
+        assert.equal(scriptingProvider.convos[0].conversation.length, 1)
+        assert.equal(scriptingProvider.convos[0].header.name, 'test convo')
+      })
       it('SCRIPTING_UTTEXPANSION_NAMING_MODE=utterance, turn length off', async function () {
         const scriptingProvider = new ScriptingProvider(Object.assign(
           {},
@@ -475,6 +550,42 @@ describe('scripting.scriptingProvider', function () {
         assert.equal(scriptingProvider.convos[1].header.name, 'test convo/MEDIA-L2-test2 0123456...')
         assert.equal(scriptingProvider.convos[2].header.name, 'test convo/MEDIA-L3-test3.jpg')
       })
+      it('SCRIPTING_UTTEXPANSION_NAMING_MODE=utterance userinputs len=1', async function () {
+        const scriptingProvider = new ScriptingProvider(Object.assign(
+          {},
+          DefaultCapabilities,
+          {
+            [Capabilities.SCRIPTING_UTTEXPANSION_NAMING_MODE]: 'utterance'
+          }
+        ))
+        await scriptingProvider.Build()
+        scriptingProvider.AddConvos(new Convo(scriptingProvider._buildScriptContext(), {
+          header: {
+            name: 'test convo'
+          },
+          sourceTag: {},
+          conversation: [
+            {
+              sender: 'me',
+              userInputs: [
+                {
+                  name: 'BUTTON',
+                  args: ['button1']
+                },
+                {
+                  name: 'MEDIA',
+                  args: ['test1.jpg']
+                }
+              ]
+            }
+          ]
+        }))
+
+        scriptingProvider.ExpandConvos()
+        assert.equal(scriptingProvider.convos.length, 1)
+        assert.equal(scriptingProvider.convos[0].conversation.length, 1)
+        assert.equal(scriptingProvider.convos[0].header.name, 'test convo')
+      })
       it('SCRIPTING_UTTEXPANSION_NAMING_MODE=utterance userinputs and utterances', async function () {
         const scriptingProvider = new ScriptingProvider(Object.assign(
           {},
@@ -518,6 +629,47 @@ describe('scripting.scriptingProvider', function () {
         assert.equal(scriptingProvider.convos[4].header.name, 'test convo/uttText-L2-TEXT2 0123456...')
       })
     })
+    describe('should have be possible to generate / store convos partially', function () {
+      const _createConvos = async () => {
+        const scriptingProvider = new ScriptingProvider(DefaultCapabilities)
+        await scriptingProvider.Build()
+        scriptingProvider.AddUtterances({
+          name: 'utt1',
+          utterances: ['TEXT1', 'TEXT2', 'TEXT3', 'TEXT4', 'TEXT5']
+        })
+        scriptingProvider.AddConvos(new Convo(scriptingProvider._buildScriptContext(), {
+          header: {
+            name: 'test convo'
+          },
+          conversation: [
+            {
+              sender: 'me',
+              messageText: 'utt1'
+            },
+            {
+              sender: 'bot',
+              messageText: 'some text'
+            },
+            {
+              sender: 'me',
+              messageText: 'utt1'
+            }
+          ]
+        }))
+        return scriptingProvider
+      }
+
+      it('should build convos with nulls (to detect convo count)', async function () {
+        const scriptingProvider = await _createConvos()
+        scriptingProvider.ExpandConvos({ justHeader: true })
+        assert.equal(scriptingProvider.convos.length, 25)
+        for (let i = 0; i < 25; i++) {
+          const keys = Object.keys(scriptingProvider.convos[i])
+          assert.equal(keys.length, 1)
+          assert.equal(keys[0], 'header')
+        }
+      })
+    })
   })
 
   describe('ExpandUtterancesToConvos', function () {

package/test/scripting/utteranceexpansion/associateByIndex.spec.js

@@ -70,15 +70,15 @@ describe('scripting.utteranceexpansion.associateByIndex', function () {
     scriptingProvider.ExpandConvos()
 
     assert.equal(scriptingProvider.convos.length, 5)
-    assert.equal(scriptingProvider.convos[0].header.name, 'test convo/UTT_HELLO-L1/UTT_BODY-L1/UTT_GOODBYE-L1')
+    assert.equal(scriptingProvider.convos[0].header.name, 'test convo/UTT_HELLO-L1/UTT_GOODBYE-L1')
     assert.deepEqual(scriptingProvider.convos[0].conversation.length, 6)
-    assert.equal(scriptingProvider.convos[1].header.name, 'test convo/UTT_HELLO-L2/UTT_BODY-L1/UTT_GOODBYE-L2')
+    assert.equal(scriptingProvider.convos[1].header.name, 'test convo/UTT_HELLO-L2/UTT_GOODBYE-L2')
     assert.deepEqual(scriptingProvider.convos[1].conversation.length, 6)
-    assert.equal(scriptingProvider.convos[2].header.name, 'test convo/UTT_HELLO-L3/UTT_BODY-L1/UTT_GOODBYE-L3')
+    assert.equal(scriptingProvider.convos[2].header.name, 'test convo/UTT_HELLO-L3/UTT_GOODBYE-L3')
     assert.deepEqual(scriptingProvider.convos[2].conversation.length, 6)
-    assert.equal(scriptingProvider.convos[3].header.name, 'test convo/UTT_HELLO-L3/UTT_BODY-L1/UTT_GOODBYE-L4')
+    assert.equal(scriptingProvider.convos[3].header.name, 'test convo/UTT_HELLO-L3/UTT_GOODBYE-L4')
     assert.deepEqual(scriptingProvider.convos[3].conversation.length, 6)
-    assert.equal(scriptingProvider.convos[4].header.name, 'test convo/UTT_HELLO-L3/UTT_BODY-L1/UTT_GOODBYE-L5')
+    assert.equal(scriptingProvider.convos[4].header.name, 'test convo/UTT_HELLO-L3/UTT_GOODBYE-L5')
     assert.deepEqual(scriptingProvider.convos[4].conversation.length, 6)
   })
   it('should associate media by index', async function () {
@@ -140,15 +140,15 @@ describe('scripting.utteranceexpansion.associateByIndex', function () {
     scriptingProvider.ExpandConvos()
 
     assert.equal(scriptingProvider.convos.length, 5)
-    assert.equal(scriptingProvider.convos[0].header.name, 'test convo/MEDIA-L1/MEDIA-L1/MEDIA-L1')
+    assert.equal(scriptingProvider.convos[0].header.name, 'test convo/MEDIA-step0voice0.wav/MEDIA-step2voice0.wav')
     assert.deepEqual(scriptingProvider.convos[0].conversation.length, 6)
-    assert.equal(scriptingProvider.convos[1].header.name, 'test convo/MEDIA-L2/MEDIA-L1/MEDIA-L2')
+    assert.equal(scriptingProvider.convos[1].header.name, 'test convo/MEDIA-step0voice1.wav/MEDIA-step2voice1.wav')
     assert.deepEqual(scriptingProvider.convos[1].conversation.length, 6)
-    assert.equal(scriptingProvider.convos[2].header.name, 'test convo/MEDIA-L3/MEDIA-L1/MEDIA-L3')
+    assert.equal(scriptingProvider.convos[2].header.name, 'test convo/MEDIA-step0voice2.wav/MEDIA-step2voice2.wav')
     assert.deepEqual(scriptingProvider.convos[2].conversation.length, 6)
-    assert.equal(scriptingProvider.convos[3].header.name, 'test convo/MEDIA-L3/MEDIA-L1/MEDIA-L4')
+    assert.equal(scriptingProvider.convos[3].header.name, 'test convo/MEDIA-step0voice2.wav/MEDIA-step2voice4.wav')
     assert.deepEqual(scriptingProvider.convos[3].conversation.length, 6)
-    assert.equal(scriptingProvider.convos[4].header.name, 'test convo/MEDIA-L3/MEDIA-L1/MEDIA-L5')
+    assert.equal(scriptingProvider.convos[4].header.name, 'test convo/MEDIA-step0voice2.wav/MEDIA-step2voice5.wav')
     assert.deepEqual(scriptingProvider.convos[4].conversation.length, 6)
   })
   it('should associate utterance and media by index', async function () {
@@ -245,15 +245,15 @@ describe('scripting.utteranceexpansion.associateByIndex', function () {
     scriptingProvider.ExpandConvos()
 
     assert.equal(scriptingProvider.convos.length, 5)
-    assert.equal(scriptingProvider.convos[0].header.name, 'test convo/UTT_HELLO-L1/UTT_BODY-L1/UTT_GOODBYE-L1/MEDIA-L1/MEDIA-L1/MEDIA-L1')
+    assert.equal(scriptingProvider.convos[0].header.name, 'test convo/UTT_HELLO-L1/UTT_GOODBYE-L1/MEDIA-step0voice0.wav/MEDIA-step2voice0.wav')
     assert.deepEqual(scriptingProvider.convos[0].conversation.length, 12)
-    assert.equal(scriptingProvider.convos[1].header.name, 'test convo/UTT_HELLO-L2/UTT_BODY-L1/UTT_GOODBYE-L2/MEDIA-L2/MEDIA-L1/MEDIA-L2')
+    assert.equal(scriptingProvider.convos[1].header.name, 'test convo/UTT_HELLO-L2/UTT_GOODBYE-L2/MEDIA-step0voice1.wav/MEDIA-step2voice1.wav')
     assert.deepEqual(scriptingProvider.convos[1].conversation.length, 12)
-    assert.equal(scriptingProvider.convos[2].header.name, 'test convo/UTT_HELLO-L3/UTT_BODY-L1/UTT_GOODBYE-L3/MEDIA-L3/MEDIA-L1/MEDIA-L3')
+    assert.equal(scriptingProvider.convos[2].header.name, 'test convo/UTT_HELLO-L3/UTT_GOODBYE-L3/MEDIA-step0voice2.wav/MEDIA-step2voice2.wav')
     assert.deepEqual(scriptingProvider.convos[2].conversation.length, 12)
-    assert.equal(scriptingProvider.convos[3].header.name, 'test convo/UTT_HELLO-L3/UTT_BODY-L1/UTT_GOODBYE-L4/MEDIA-L3/MEDIA-L1/MEDIA-L4')
+    assert.equal(scriptingProvider.convos[3].header.name, 'test convo/UTT_HELLO-L3/UTT_GOODBYE-L4/MEDIA-step0voice2.wav/MEDIA-step2voice4.wav')
     assert.deepEqual(scriptingProvider.convos[3].conversation.length, 12)
-    assert.equal(scriptingProvider.convos[4].header.name, 'test convo/UTT_HELLO-L3/UTT_BODY-L1/UTT_GOODBYE-L5/MEDIA-L3/MEDIA-L1/MEDIA-L5')
+    assert.equal(scriptingProvider.convos[4].header.name, 'test convo/UTT_HELLO-L3/UTT_GOODBYE-L5/MEDIA-step0voice2.wav/MEDIA-step2voice5.wav')
     assert.deepEqual(scriptingProvider.convos[4].conversation.length, 12)
   })
 })