export async function generateTest()

in experimental/generation/generator/packages/library/src/testGenerator.ts [18:100]
81 lines of code
17 McCabe index (conditional complexity)

export async function generateTest(path: string, dialog: string, output: string, mock: boolean, schema?: string): Promise<string> {
    let transcript = JSON.parse(await fs.readFile(path, 'utf8'))
    await fs.ensureDir(output)
    let outputPath = ppath.resolve(ppath.join(output, ppath.basename(path, ppath.extname(path)) + '.test.dialog'))
    let test: any = {}
    if (schema) {
        test.$schema = ppath.relative(ppath.resolve(schema), ppath.resolve(outputPath))
    } else {
        test.$schema = 'https://raw.githubusercontent.com/microsoft/botbuilder-samples/main/experimental/generation/TestBot/TestBot/TestBot.schema'
    }
    test.$kind = 'Microsoft.Test.Script'
    test.dialog = dialog
    let script: object[] = []
    test.script = script
    let mocks: any[] = []
    test.httpRequestMocks = mocks

    let userCount = 0
    let responses = 0
    let description = 'BeginDialog'
    for (let record of transcript) {
        if (isBot(record)) {
            if (record.text) {
                ++responses
                script.push({
                    $kind: 'Microsoft.Test.AssertReply',
                    text: record.text,
                    description: `${responses}: ${description}`
                })
            } else if (record.attachments) {
                let assertions: any[] = []
                ++responses
                script.push({
                    $kind: 'Microsoft.Test.AssertReplyActivity',
                    assertions,
                    description: `${responses}: ${description}`
                })
                assertions.push(`type == 'message'`)
                objectAssertions(record.attachments, assertions, 'attachments')
            }
        } else if (isUser(record)) {
            if (record.text) {
                script.push({$kind: 'Microsoft.Test.UserSays', 'text': record.text})
            } else if (record.value) {
                script.push({$kind: 'Microsoft.Test.UserActivity', 'activity': {'type': record.type, 'value': record.value}})
            }
            ++userCount
            responses = 0
            description = `Response to input ${userCount}`
        } else if (isSetTestOptions(record)) {
            script.push({
                $kind: 'Microsoft.Test.CustomEvent',
                name: 'SetTestOptions',
                value: record.value
            })
        } else if (isConversationUpdate(record)) {
            let membersAdded: string[] = []
            let membersRemoved: string[] = []
            for (let member of record.membersAdded) {
                membersAdded.push(member.name)
            }
            for (let member of record.membersRemoved) {
                membersRemoved.push(member.name)
            }
            script.push({$kind: 'Microsoft.Test.UserConversationUpdate', membersAdded, membersRemoved})
        } else if (mock && isHttpRequest(record)) {
            let request = record.value.request
            let mock = mocks.find(m => m.url === request.url && m.method === request.method)
            if (!mock) {
                mock = {url: request.url, method: request.method}
                mocks.push(mock)
            }
            mock.responses.push({
                // TODO: Responses really should include a status code as well to model errors.
                contentType: 'String',
                content: record.value.response
            })
        }
    }

    await fs.writeFile(outputPath, normalizeEOL(JSON.stringify(test, undefined, 2)))
    return outputPath
}