@api-client/core 0.20.10 → 0.21.1

package/tests/unit/models/project_folder.spec.ts

@@ -1,926 +0,0 @@
-import { test } from '@japa/runner'
-import sinon from 'sinon'
-import { HttpProject } from '../../../src/models/HttpProject.js'
-import { ProjectFolder, DefaultFolderName, IProjectFolder } from '../../../src/models/ProjectFolder.js'
-import { ProjectItem } from '../../../src/models/ProjectItem.js'
-import { Environment, Kind as EnvironmentKind } from '../../../src/models/Environment.js'
-import { ProjectRequest } from '../../../src/models/ProjectRequest.js'
-import { ProjectFolderKind, ThingKind } from '../../../src/models/kinds.js'
-
-test.group('Models > ProjectFolder > Initialization', (group) => {
-  let project: HttpProject
-  group.each.setup(() => {
-    project = new HttpProject()
-  })
-
-  test('initializes a default folder', ({ assert }) => {
-    const result = new ProjectFolder(project)
-    assert.equal(result.kind, ProjectFolderKind, 'sets the kind property')
-    assert.deepEqual(result.items, [], 'sets the items property')
-    assert.typeOf(result.updated, 'number', 'sets the updated property')
-    assert.typeOf(result.created, 'number', 'sets the created property')
-
-    const { info } = result
-    assert.typeOf(info, 'EventTarget', 'sets the default info property')
-    assert.equal(info.kind, ThingKind, 'sets the info.kind property')
-    assert.equal(info.name, DefaultFolderName, 'sets the info.name property')
-  })
-})
-
-test.group('Models > ProjectFolder > From schema initialization', (group) => {
-  let project: HttpProject
-  let base: IProjectFolder
-  group.each.setup(() => {
-    project = new HttpProject()
-    base = {
-      kind: ProjectFolderKind,
-      items: [],
-      updated: 123,
-      created: 456,
-      key: 'test1234',
-      info: {
-        kind: ThingKind,
-        name: '',
-      },
-    }
-  })
-
-  test('sets the info', ({ assert }) => {
-    const init: IProjectFolder = {
-      ...base,
-      ...{
-        info: {
-          kind: ThingKind,
-          name: 'Test project',
-          description: 'Project description',
-          version: '1.2.3',
-        },
-      },
-    }
-    const result = new ProjectFolder(project, init)
-    const { info } = result
-    assert.equal(info.kind, ThingKind, 'sets the info.kind property')
-    assert.equal(info.name, 'Test project', 'sets the info.name property')
-    assert.equal(info.description, 'Project description', 'sets the info.description property')
-    assert.equal(info.version, '1.2.3', 'sets the info.version property')
-  })
-
-  test('sets the created/updated', ({ assert }) => {
-    const result = new ProjectFolder(project, base)
-    assert.equal(result.created, 456)
-    assert.equal(result.updated, 123)
-  })
-
-  test('sets the passed key', ({ assert }) => {
-    const result = new ProjectFolder(project, base)
-    assert.equal(result.key, 'test1234')
-  })
-
-  test('sets a new key when the passed key is missing', ({ assert }) => {
-    // @ts-expect-error Used in testing
-    delete base.key
-    const result = new ProjectFolder(project, base)
-    assert.typeOf(result.key, 'string')
-  })
-
-  test('creates the default items', ({ assert }) => {
-    // @ts-expect-error Used in testing
-    delete base.items
-    const result = new ProjectFolder(project, base)
-    assert.deepEqual(result.items, [])
-  })
-
-  test('sets the stored items', ({ assert }) => {
-    base.items = [ProjectItem.projectFolder(project, 'a-key')]
-    const serialized = JSON.stringify(base)
-    const result = new ProjectFolder(project, serialized)
-    assert.lengthOf(result.items, 1, 'has a single item')
-    assert.equal(result.items[0].key, 'a-key', 'has the serialized item')
-  })
-})
-
-test.group('Models > ProjectFolder > From JSON string initialization', () => {
-  test('restores project data from JSON string', ({ assert }) => {
-    const project = new HttpProject()
-    const folder = project.addFolder('a folder')
-    const str = JSON.stringify(folder)
-
-    const result = new ProjectFolder(project, str)
-
-    assert.equal(result.key, folder.key, 'restores the key')
-    assert.equal(result.info.name, 'a folder', 'restores the info object')
-  })
-
-  test('throws when invalid folder object', ({ assert }) => {
-    const project = new HttpProject()
-    const folder = project.addFolder('a folder')
-    const schema = folder.toJSON()
-    // @ts-expect-error Used in testing
-    delete schema.kind
-    const str = JSON.stringify(schema)
-
-    assert.throws(() => {
-      new ProjectFolder(project, str)
-    })
-  })
-})
-
-test.group('Models > ProjectFolder > toJSON()', (group) => {
-  let project: HttpProject
-  let base: IProjectFolder
-  group.each.setup(() => {
-    project = new HttpProject()
-    base = {
-      kind: ProjectFolderKind,
-      items: [],
-      updated: 123,
-      created: 456,
-      key: 'test1234',
-      info: {
-        kind: ThingKind,
-        name: '',
-      },
-    }
-  })
-
-  test('serializes the info object', ({ assert }) => {
-    const init: IProjectFolder = {
-      ...base,
-      ...{
-        info: {
-          kind: ThingKind,
-          name: 'Test project',
-          description: 'Project description',
-          version: '1.2.3',
-        },
-      },
-    }
-    const folder = new ProjectFolder(project, init)
-    const result = folder.toJSON()
-    assert.equal(result.info.kind, ThingKind, 'has the kind')
-    assert.equal(result.info.name, 'Test project', 'has the name')
-    assert.equal(result.info.description, 'Project description', 'has the description')
-    assert.equal(result.info.version, '1.2.3', 'has the version')
-  })
-
-  test('serializes the key', ({ assert }) => {
-    const init: IProjectFolder = { ...base }
-    const folder = new ProjectFolder(project, init)
-    const result = folder.toJSON()
-    assert.equal(result.key, init.key)
-  })
-
-  test('serializes the created/updated', ({ assert }) => {
-    const init: IProjectFolder = { ...base }
-    const folder = new ProjectFolder(project, init)
-    const result = folder.toJSON()
-    assert.equal(result.created, init.created)
-    assert.equal(result.updated, init.updated)
-  })
-
-  test('serializes the items', ({ assert }) => {
-    const init: IProjectFolder = { ...base, ...{ items: [ProjectItem.projectFolder(project, 'a-key')] } }
-    const folder = new ProjectFolder(project, init)
-    const result = folder.toJSON()
-    assert.lengthOf(result.items, 1)
-  })
-})
-
-test.group('Models > ProjectFolder > ProjectFolder.fromName()', (group) => {
-  let project: HttpProject
-  group.each.setup(() => {
-    project = new HttpProject()
-  })
-
-  test('sets the name', ({ assert }) => {
-    const result = ProjectFolder.fromName(project, 'a name')
-    assert.equal(result.info.name, 'a name')
-  })
-
-  test('uses the default name', ({ assert }) => {
-    const result = ProjectFolder.fromName(project)
-    assert.equal(result.info.name, DefaultFolderName)
-  })
-
-  test('generates the key', ({ assert }) => {
-    const result = ProjectFolder.fromName(project, 'a name')
-    assert.typeOf(result.key, 'string')
-  })
-
-  test('generates the created/updated', ({ assert }) => {
-    const result = ProjectFolder.fromName(project, 'a name')
-    assert.closeTo(result.updated, Date.now(), 100)
-    assert.closeTo(result.created, Date.now(), 100)
-  })
-
-  test('adds empty items', ({ assert }) => {
-    const result = ProjectFolder.fromName(project, 'a name')
-    assert.deepEqual(result.items, [])
-  })
-
-  test('sets the kind', ({ assert }) => {
-    const result = ProjectFolder.fromName(project, 'a name')
-    assert.equal(result.kind, ProjectFolderKind)
-  })
-})
-
-test.group('Models > ProjectFolder > new()', () => {
-  test('restores a folder definition', ({ assert }) => {
-    const project = new HttpProject()
-    const folder = project.addFolder('a folder')
-    const time = 12345
-    folder.new({
-      created: time,
-      updated: time,
-      info: {
-        kind: ThingKind,
-        name: 'test',
-      },
-      items: [],
-      key: 'abc',
-      kind: ProjectFolderKind,
-    })
-    assert.equal(folder.created, time, 'updates the created')
-    assert.equal(folder.updated, time, 'updates the updated') // Corrected from 'updates the created'
-    assert.equal(folder.key, 'abc', 'updates the key')
-    assert.equal(folder.info.name, 'test', 'updates the info')
-  })
-
-  test('restores items', ({ assert }) => {
-    const project = new HttpProject()
-    const folder = project.addFolder('a folder')
-    const time = 12345
-    const def: IProjectFolder = {
-      created: time,
-      updated: time,
-      info: {
-        kind: ThingKind,
-        name: 'test',
-      },
-      items: [], // Assuming items should be processed by .new() if present in schema
-      key: 'abc',
-      kind: ProjectFolderKind,
-    }
-    folder.new(def)
-    assert.equal(folder.created, time, 'updates the created')
-    assert.equal(folder.updated, time, 'updates the updated') // Corrected
-    assert.equal(folder.key, 'abc', 'updates the key')
-    assert.equal(folder.info.name, 'test', 'updates the info')
-    // Add assertion for items if .new() is expected to process them
-    assert.deepEqual(folder.items, [], 'updates the items')
-  })
-
-  test('adds the default info object', ({ assert }) => {
-    const project = new HttpProject()
-    const folder = project.addFolder('a folder')
-    const time = 12345
-    const def: IProjectFolder = {
-      created: time,
-      updated: time,
-      info: {
-        // This info will be deleted before calling new()
-        kind: ThingKind,
-        name: 'test',
-      },
-      items: [],
-      key: 'abc',
-      kind: ProjectFolderKind,
-    }
-    // @ts-expect-error Used in testing
-    delete def.info
-    folder.new(def)
-    assert.equal(folder.info.name, DefaultFolderName)
-  })
-})
-
-test.group('Models > ProjectFolder > addFolder()', (group) => {
-  let project: HttpProject
-  group.each.setup(() => {
-    project = new HttpProject()
-  })
-
-  test("calls the project's add folder function", ({ assert }) => {
-    const parent = project.addFolder('parent')
-    const spy = sinon.spy(project, 'addFolder')
-    parent.addFolder('a folder')
-    assert.isTrue(spy.calledOnce)
-    assert.equal(spy.args[0][0], 'a folder', 'has the name')
-    assert.deepEqual(spy.args[0][1], { parent: parent.key }, 'has the options')
-    spy.restore()
-  })
-
-  test('adds the folder to the items', ({ assert }) => {
-    const parent = project.addFolder('parent')
-    parent.addFolder('sub')
-    assert.lengthOf(parent.items, 1)
-  })
-
-  test('adds a folder by name', ({ assert }) => {
-    const parent = project.addFolder('parent')
-    parent.addFolder('sub')
-    const def = project.findFolder('sub')!
-    assert.equal(def.info.name, 'sub')
-  })
-
-  test('adds a folder by schema', ({ assert }) => {
-    const parent = project.addFolder('parent')
-    const f = new ProjectFolder(project)
-    f.info.name = 'sub'
-    parent.addFolder(f.toJSON())
-    const def = project.findFolder('sub')!
-    assert.equal(def.info.name, 'sub')
-  })
-
-  test('adds a folder by an instance', ({ assert }) => {
-    const parent = project.addFolder('parent')
-    const f = new ProjectFolder(project)
-    f.info.name = 'sub'
-    parent.addFolder(f)
-    const def = project.findFolder('sub')!
-    assert.equal(def.info.name, 'sub')
-  })
-})
-
-test.group('Models > ProjectFolder > addRequest()', (group) => {
-  let project: HttpProject
-  group.each.setup(() => {
-    project = new HttpProject()
-  })
-
-  test("calls the project's add request function", ({ assert }) => {
-    const parent = project.addFolder('parent')
-    const spy = sinon.spy(project, 'addRequest')
-    const request = ProjectRequest.fromName('test', project)
-    parent.addRequest(request)
-    assert.isTrue(spy.calledOnce)
-    assert.deepEqual(spy.args[0][0], request, 'has the request')
-    assert.deepEqual(spy.args[0][1], { parent: parent.key }, 'has the options')
-    spy.restore()
-  })
-
-  test('adds the request to the items', ({ assert }) => {
-    const parent = project.addFolder('parent')
-    const request = ProjectRequest.fromName('test', project)
-    parent.addRequest(request)
-    assert.lengthOf(parent.items, 1)
-  })
-
-  test('adds a request from the url', ({ assert }) => {
-    const parent = project.addFolder('parent')
-    const request = parent.addRequest('https://api.com')
-    assert.equal(request.info.name, 'https://api.com')
-    assert.equal(request.expects.url, 'https://api.com')
-  })
-})
-
-test.group('Models > ProjectFolder > listFolderItems()', (group) => {
-  let project: HttpProject
-  group.each.setup(() => {
-    project = new HttpProject()
-  })
-
-  test('returns empty array when no folders', ({ assert }) => {
-    const folder = project.addFolder('parent')
-
-    const request = ProjectRequest.fromName('test', project)
-    folder.addRequest(request)
-
-    const result = folder.listFolderItems()
-    assert.deepEqual(result, [])
-  })
-
-  test('returns folder folders', ({ assert }) => {
-    const folder = project.addFolder('parent')
-    const f1 = folder.addFolder('f1')
-    const f2 = folder.addFolder('f2')
-
-    const request = ProjectRequest.fromName('test', project)
-    folder.addRequest(request)
-
-    const result = folder.listFolderItems()
-    assert.lengthOf(result, 2, 'has 2 items')
-    assert.equal(result[0].key, f1.key, 'has the first folder')
-    assert.equal(result[1].key, f2.key, 'has the second folder')
-  })
-})
-
-test.group('Models > ProjectFolder > listRequestItems()', (group) => {
-  let project: HttpProject
-  group.each.setup(() => {
-    project = new HttpProject()
-  })
-
-  test('returns empty array when no requests', ({ assert }) => {
-    const folder = project.addFolder('parent')
-    folder.addFolder('f1')
-
-    const result = folder.listRequestItems()
-    assert.deepEqual(result, [])
-  })
-
-  test('returns folder requests', ({ assert }) => {
-    const folder = project.addFolder('parent')
-    const request = ProjectRequest.fromName('test', project)
-    folder.addRequest(request)
-
-    const result = folder.listRequestItems()
-    assert.lengthOf(result, 1, 'has the request')
-    assert.equal(result[0].key, request.key, 'has the key')
-  })
-})
-
-test.group('Models > ProjectFolder > listFolders()', (group) => {
-  let project: HttpProject
-  group.each.setup(() => {
-    project = new HttpProject()
-  })
-
-  test("calls the project's listFolders function", ({ assert }) => {
-    const folder = project.addFolder('parent')
-    const spy = sinon.spy(project, 'listFolders')
-    folder.listFolders()
-    assert.isTrue(spy.calledOnce)
-    assert.deepEqual(spy.args[0][0], { folder: folder.key }, 'has the only argument')
-    // Original was spy.args[0][0]!.folder
-    spy.restore()
-  })
-
-  test('returns the list', ({ assert }) => {
-    const folder = project.addFolder('parent')
-    const child = folder.addFolder('child')
-    const result = folder.listFolders()
-    assert.deepEqual(result, [child])
-  })
-})
-
-test.group('Models > ProjectFolder > listRequests()', (group) => {
-  let project: HttpProject
-  group.each.setup(() => {
-    project = new HttpProject()
-  })
-
-  test("calls the project's listRequests function", ({ assert }) => {
-    const folder = project.addFolder('parent')
-    const spy = sinon.spy(project, 'listRequests')
-    folder.listRequests()
-    assert.isTrue(spy.calledOnce)
-    assert.equal(spy.args[0][0], folder.key, 'has the only argument')
-    spy.restore()
-  })
-
-  test('returns the list', ({ assert }) => {
-    const folder = project.addFolder('parent')
-
-    const request = ProjectRequest.fromName('test', project)
-    folder.addRequest(request)
-
-    const result = folder.listRequests()
-    assert.deepEqual(result, [request])
-  })
-})
-
-test.group('Models > ProjectFolder > remove()', (group) => {
-  let project: HttpProject
-  let folder: ProjectFolder
-
-  group.each.setup(() => {
-    project = new HttpProject()
-    folder = project.addFolder('test')
-  })
-
-  test('removes the folder from the project definitions', ({ assert }) => {
-    folder.remove()
-    assert.deepEqual(project.definitions.folders, [])
-  })
-
-  test('removes the folder from the project items', ({ assert }) => {
-    folder.remove()
-    assert.deepEqual(project.items, [])
-  })
-
-  test('removes the folder from the parent folder items', ({ assert }) => {
-    const sub = folder.addFolder('sub')
-    sub.remove()
-    assert.deepEqual(folder.items, [])
-  })
-
-  test('removes the sub-folder from the project definitions', ({ assert }) => {
-    const sub = folder.addFolder('sub')
-    assert.lengthOf(project.definitions.folders, 2, 'has 2 definitions')
-    sub.remove()
-    assert.lengthOf(project.definitions.folders, 1, 'has 1 definition')
-  })
-})
-
-test.group('Models > ProjectFolder > getParent()', (group) => {
-  let project: HttpProject
-  group.each.setup(() => {
-    project = new HttpProject()
-  })
-
-  test('returns the project object', ({ assert }) => {
-    const folder = project.addFolder('test')
-    const result = folder.getParent()
-    assert.isTrue(result === project)
-  })
-
-  test('returns the folder object', ({ assert }) => {
-    const parent = project.addFolder('test')
-    const folder = parent.addFolder('test 2')
-    const result = folder.getParent()
-    assert.isTrue(result === parent)
-  })
-})
-
-test.group('Models > ProjectFolder > getProject()', (group) => {
-  let project: HttpProject
-  group.each.setup(() => {
-    project = new HttpProject()
-  })
-
-  test('returns the project when added to the project', ({ assert }) => {
-    const folder = project.addFolder('test')
-    const result = folder.getProject()
-    assert.isTrue(result === project)
-  })
-
-  test('returns the project when added to a folder', ({ assert }) => {
-    const parent = project.addFolder('test')
-    const folder = parent.addFolder('test 2')
-    const result = folder.getProject()
-    assert.isTrue(result === project)
-  })
-})
-
-test.group('Models > ProjectFolder > clone()', (group) => {
-  let project: HttpProject
-  let folder: ProjectFolder
-
-  group.each.setup(() => {
-    project = new HttpProject()
-    folder = project.addFolder('test')
-  })
-
-  test('updates the key by default', ({ assert }) => {
-    const { key: oldKey } = folder
-    const copy = folder.clone()
-    assert.typeOf(copy.key, 'string', 'has the key')
-    assert.notEqual(copy.key, oldKey, 'has a new key')
-  })
-
-  test('adds the copy to the project definitions (project root)', ({ assert }) => {
-    const copy = folder.clone()
-    assert.lengthOf(project.definitions.folders, 2, 'has 2 definitions')
-    assert.isTrue(
-      project.definitions.folders.some((i) => i.key === copy.key),
-      'has the folder definition'
-    )
-  })
-
-  test('adds the copy to the project definitions (folder root)', ({ assert }) => {
-    const sub = folder.addFolder('sub')
-    const copy = sub.clone()
-    assert.lengthOf(project.definitions.folders, 3, 'has 3 definitions')
-    assert.isTrue(
-      project.definitions.folders.some((i) => i.key === copy.key),
-      'has the folder definition'
-    )
-  })
-
-  test('adds the copy to the project items (project root)', ({ assert }) => {
-    const copy = folder.clone()
-    assert.lengthOf(project.items, 2, 'has 2 items')
-    assert.isTrue(
-      project.items.some((i) => i.key === copy.key),
-      'has the folder item'
-    )
-  })
-
-  test('adds the copy to the sub-folder items', ({ assert }) => {
-    const sub = folder.addFolder('sub')
-    const copy = sub.clone()
-    assert.lengthOf(project.items, 1, 'project has 1 item')
-    assert.lengthOf(folder.items, 2, 'parent has 2 items')
-    assert.isTrue(
-      folder.items.some((i) => i.key === copy.key),
-      'the folder is added to the parent'
-    )
-  })
-
-  test('copies requests with the folder by default', ({ assert }) => {
-    const r = folder.addRequest('https://copy.com')
-    const copy = folder.clone()
-
-    assert.lengthOf(copy.items, 1, 'the copy has one request')
-    assert.typeOf(copy.items[0].key, 'string', 'the request has the key')
-    assert.notEqual(copy.items[0].key, r.key, 'the copied request has a different key')
-  })
-
-  test('adds the copied folder and request to the project definitions', ({ assert }) => {
-    folder.addRequest('https://copy.com')
-    folder.clone()
-
-    assert.lengthOf(project.definitions.requests, 2, 'the project has 2 request definitions')
-    assert.lengthOf(project.definitions.folders, 2, 'the project has 2 folder definitions')
-    // Corrected from project.definitions.requests
-
-    const [f1, f2] = project.definitions.folders
-    const [r1, r2] = project.definitions.requests
-
-    assert.notEqual(f1.key, f2.key, 'folder keys are different')
-    assert.notEqual(r1.key, r2.key, 'request keys are different')
-  })
-
-  test('quietly ignores missing requests', ({ assert }) => {
-    const r = folder.addRequest('https://copy.com')
-    const i = project.definitions.requests.findIndex((item) => item.key === r.key)
-    project.definitions.requests.splice(i, 1)
-    folder.clone()
-    assert.lengthOf(project.definitions.folders, 2, 'the project has 2 definitions')
-    const [f1, f2] = project.definitions.folders
-    assert.notEqual(f1.key, f2.key, 'folder keys are different')
-  })
-
-  test('copies sub-folders with the folder by default', ({ assert }) => {
-    const sub = folder.addFolder('sub')
-    const copy = folder.clone()
-
-    assert.lengthOf(copy.items, 1, 'the copy has one item') // Corrected from 'one request'
-    assert.typeOf(copy.items[0].key, 'string', 'the folder has the key')
-    assert.notEqual(copy.items[0].key, sub.key, 'the copied folder has a different key')
-  })
-
-  test('adds a sub-folder of the copied folder to the project definitions', ({ assert }) => {
-    folder.addFolder('sub orig')
-    folder.clone()
-
-    assert.lengthOf(project.definitions.folders, 4, 'the project has 4 folder definitions')
-
-    // It's better to find them by known properties if order is not guaranteed
-    const originalMainFolder = project.definitions.folders.find((f) => f.info.name === 'test' && f.key === folder.key)
-    const originalSubFolder = project.definitions.folders.find((f) => f.info.name === 'sub orig')
-    const clonedMainFolder = project.definitions.folders.find((f) => f.info.name === 'test' && f.key !== folder.key)
-    const clonedSubFolder = project.definitions.folders.find(
-      (f) => f.info.name === 'sub orig' && f.key !== originalSubFolder!.key
-    )
-
-    assert.ok(originalMainFolder, 'Original main folder found')
-    assert.ok(originalSubFolder, 'Original sub folder found')
-    assert.ok(clonedMainFolder, 'Cloned main folder found')
-    assert.ok(clonedSubFolder, 'Cloned sub folder found')
-
-    assert.notEqual(originalMainFolder!.key, clonedMainFolder!.key, 'folder keys are different')
-    assert.equal(originalMainFolder!.info.name, clonedMainFolder!.info.name, 'folder 1 names match')
-    // Corrected from 'request keys'
-    assert.notEqual(originalSubFolder!.key, clonedSubFolder!.key, 'sub-folder keys are different')
-    assert.equal(originalSubFolder!.info.name, clonedSubFolder!.info.name, 'folder 2 names match')
-  })
-
-  test('quietly ignores missing folders', ({ assert }) => {
-    const sub = folder.addFolder('sub')
-    const i = project.definitions.folders.findIndex((item) => item.key === sub.key)
-    project.definitions.folders.splice(i, 1)
-    folder.clone()
-    assert.lengthOf(project.definitions.folders, 2, 'the project has 2 definitions')
-    const [f1, f2] = project.definitions.folders
-    assert.notEqual(f1.key, f2.key, 'folder keys are different')
-  })
-
-  test('copies a folder with a sub-folder with requests', ({ assert }) => {
-    const sub = folder.addFolder('sub')
-    const origRequest = sub.addRequest('http://api.com')
-
-    const result = folder.clone()
-
-    const projectFolders = project.listFolders() // This lists all folders in the project
-    // After clone, project should have original 'test' folder and its clone.
-    // 'sub' is inside 'test', and its clone is inside the clone of 'test'.
-    // So, project.listFolders() without arguments should list 'test' and its clone.
-    assert.lengthOf(
-      projectFolders.filter((pf) => pf.getParent() === project),
-      2,
-      'the project has 2 top-level folders'
-    )
-
-    const originalTestFolder = projectFolders.find((pf) => pf.key === folder.key)
-    const clonedTestFolder = projectFolders.find((pf) => pf.key === result.key)
-
-    assert.deepEqual(originalTestFolder, folder, 'folder #1 is set')
-    assert.deepEqual(clonedTestFolder, result, 'folder #2 is set')
-
-    const originalSubFolder = originalTestFolder!.listFolders()[0]
-    assert.lengthOf(originalSubFolder.listRequests(), 1, 'original sub-folder has a single request')
-    assert.deepEqual(originalSubFolder.listRequests()[0], origRequest, 'original sub-folder has the original request')
-
-    const topRequests = result.listRequests()
-    assert.lengthOf(topRequests, 0, 'root copy folder has no requests')
-
-    const foldersInCloned = result.listFolders()
-    assert.lengthOf(foldersInCloned, 1, 'root copy folder has a folder')
-
-    const [subCopy] = foldersInCloned
-    const subRequests = subCopy.listRequests()
-    assert.lengthOf(subRequests, 1, 'sub folder has a request')
-  })
-
-  test('copies a folder to a specific folder inside the same project', ({ assert }) => {
-    const sub = folder.addFolder('sub1')
-    sub.addRequest('http://api.com')
-    const targetFolder = project.addFolder('sub2') // This is a top-level folder
-    const clonedFolderInTarget = folder.clone({ targetFolder: targetFolder.key })
-
-    const subFoldersInTarget = targetFolder.listFolders()
-    assert.lengthOf(subFoldersInTarget, 1, 'has the copied folder')
-    const [copyTopLevelFolder] = subFoldersInTarget
-    assert.equal(copyTopLevelFolder.key, clonedFolderInTarget.key)
-    assert.equal(copyTopLevelFolder.info.name, folder.info.name)
-
-    const [subLevelCopy] = copyTopLevelFolder.listFolders()
-    assert.ok(subLevelCopy, 'has the copied sub-folder')
-    assert.equal(subLevelCopy.info.name, sub.info.name)
-
-    const subRequests = subLevelCopy.listRequests()
-    assert.lengthOf(subRequests, 1, 'has the copied request')
-  })
-
-  test('copies a folder to another project to the root level', ({ assert }) => {
-    const sub = folder.addFolder('sub')
-    const origRequest = sub.addRequest('http://api.com')
-
-    const origSnapshot = project.toJSON()
-
-    const targetProject = new HttpProject()
-    const clonedInTargetProject = folder.clone({ targetProject })
-
-    assert.deepEqual(project.toJSON(), origSnapshot, 'the original project is not changed')
-
-    const copiedTopFolder = targetProject.findFolder(folder.info.name!)!
-    assert.ok(copiedTopFolder, 'target project has the top-level folder')
-    assert.equal(copiedTopFolder.key, clonedInTargetProject.key)
-    assert.notEqual(copiedTopFolder.key, folder.key, 'target folder has a new key')
-
-    const subFolderInTarget = copiedTopFolder.listFolders()[0]
-    assert.ok(subFolderInTarget, 'target project has the sub-folder')
-    assert.notEqual(subFolderInTarget.key, sub.key, 'the sub-folder has a new key')
-
-    const copiedRequest = subFolderInTarget.listRequests()[0]
-    assert.ok(copiedRequest, 'target project has the request')
-    assert.notEqual(copiedRequest.key, origRequest.key, 'the request has a new key')
-  })
-
-  test('copies a folder to another project under a folder', ({ assert }) => {
-    const sub = folder.addFolder('sub')
-    sub.addRequest('http://api.com')
-
-    const origSnapshot = project.toJSON()
-
-    const targetProject = new HttpProject()
-    const targetFolderInTargetProject = targetProject.addFolder('parent')
-    folder.clone({ targetProject, targetFolder: targetFolderInTargetProject.key })
-
-    assert.deepEqual(project.toJSON(), origSnapshot, 'the original project is not changed')
-
-    // the target project has 'parent' folder, then 'test' (cloned) inside 'parent', then 'sub' (cloned) inside 'test'.
-    // So 3 folder definitions. And 1 request definition.
-    assert.lengthOf(targetProject.definitions.folders, 3, 'has the copied folder definitions')
-    assert.lengthOf(targetProject.definitions.requests, 1, 'has the copied requests definitions')
-
-    const rootFoldersInTarget = targetFolderInTargetProject.listFolders()
-    assert.lengthOf(rootFoldersInTarget, 1, 'the target folder has a root folder from the originating project')
-
-    const [rootFolderCopy] = rootFoldersInTarget
-    const subFoldersInCopy = rootFolderCopy.listFolders()
-    assert.lengthOf(subFoldersInCopy, 1, 'the copied folder has a sub-folder')
-
-    const [subFolderCopy] = subFoldersInCopy
-
-    const requestsInSubCopy = subFolderCopy.listRequests()
-    assert.lengthOf(requestsInSubCopy, 1, 'the sub-folder has a request')
-  })
-
-  test('throws when unable to find a parent in the same project', ({ assert }) => {
-    const sub = folder.addFolder('sub')
-    sub.addRequest('http://api.com')
-    assert.throws(() => {
-      folder.clone({ targetFolder: 'test-non-existent' })
-    })
-  })
-
-  test('throws when unable to find a parent in the foreign project', ({ assert }) => {
-    const sub = folder.addFolder('sub')
-    sub.addRequest('http://api.com')
-
-    const targetProject = new HttpProject()
-    assert.throws(() => {
-      folder.clone({ targetProject, targetFolder: 'test-non-existent' })
-    })
-  })
-})
-
-test.group('Models > ProjectFolder > addEnvironment()', (group) => {
-  let project: HttpProject
-  let f1: ProjectFolder
-  group.each.setup(() => {
-    project = HttpProject.fromName('test')
-    f1 = project.addFolder('f1')
-  })
-
-  test('adds environment by name', ({ assert }) => {
-    const created = f1.addEnvironment('test')
-    assert.lengthOf(f1.items, 1, 'has an item')
-    assert.equal(f1.items[0].key, created.key, 'has the item key')
-    assert.equal(f1.items[0].kind, EnvironmentKind, 'has the item kind')
-  })
-
-  test('adds environment from an instance', ({ assert }) => {
-    const created = Environment.fromName('test')
-    f1.addEnvironment(created)
-    assert.lengthOf(f1.items, 1, 'has an item')
-    assert.equal(f1.items[0].key, created.key, 'has the item key')
-  })
-
-  test('adds environment from a schema', ({ assert }) => {
-    const created = Environment.fromName('test')
-    f1.addEnvironment(created.toJSON())
-    assert.lengthOf(f1.items, 1, 'has an item')
-    assert.equal(f1.items[0].key, created.key, 'has the item key')
-  })
-})
-
-test.group('Models > ProjectFolder > getEnvironments()', () => {
-  test('returns project class initialization environments', ({ assert }) => {
-    const project = new HttpProject(undefined, [Environment.fromName('test').toJSON()])
-    const f1 = project.addFolder('f1') // Corrected: addFolder needs project instance
-    f1.addEnvironment(Environment.fromName('other'))
-    const envs = f1.getEnvironments()
-    assert.typeOf(envs, 'array')
-    assert.lengthOf(envs, 1)
-    assert.equal(envs[0].info.name, 'test')
-  })
-
-  test('returns environments when no initialization environments', ({ assert }) => {
-    const project = new HttpProject()
-    const f1 = project.addFolder('f1')
-    const e1 = f1.addEnvironment(Environment.fromName('other'))
-    project.addEnvironment('e2') // This is a root environment, getEnvironments on folder should not see it.
-
-    const result = f1.getEnvironments()
-    assert.deepEqual(result, [e1])
-  })
-})
-
-test.group('Models > ProjectFolder > listEnvironments()', (group) => {
-  let project: HttpProject
-  let f1: ProjectFolder
-  let e2: Environment
-  group.each.setup(() => {
-    project = new HttpProject()
-    project.addEnvironment('e1') // Root environment
-    f1 = project.addFolder('f1')
-    e2 = f1.addEnvironment('e2') // Environment in folder f1
-  })
-
-  test('returns environments defined in the folder', ({ assert }) => {
-    // This method is on HttpProject, not ProjectFolder.
-    // It lists environments associated with a specific parent (folder key or project).
-    const result = project.listEnvironments({ parent: f1.key })
-    assert.deepEqual(result, [e2])
-  })
-
-  test('ignores sub-folders', ({ assert }) => {
-    const f2 = f1.addFolder('f2')
-    f2.addEnvironment('e3')
-    const result = project.listEnvironments({ parent: f1.key })
-    assert.deepEqual(result, [e2]) // Should only list e2, as e3 is in f2, not directly in f1.
-  })
-})
-
-test.group('Models > ProjectFolder > removeEnvironment()', (group) => {
-  let project: HttpProject
-  let f1: ProjectFolder
-  let e2: Environment
-  group.each.setup(() => {
-    project = new HttpProject()
-    project.addEnvironment('e1')
-    f1 = project.addFolder('f1')
-    e2 = f1.addEnvironment('e2')
-  })
-
-  test('removes the environment from folder items', ({ assert }) => {
-    f1.removeEnvironment(e2.key)
-    assert.deepEqual(f1.items, [])
-  })
-
-  test('does nothing when the environment is not in the folder', ({ assert }) => {
-    const f2 = f1.addFolder('f2') // e2 is in f1, f2 is a child of f1
-    const e3 = f2.addEnvironment('e3') // e3 is in f2
-    const result = f1.removeEnvironment(e3.key) // Trying to remove e3 from f1
-    assert.isUndefined(result)
-    assert.lengthOf(f1.items, 2) // f1 should still have e2 and f2
-  })
-
-  test('returns the removed environment', ({ assert }) => {
-    const result = f1.removeEnvironment(e2.key)
-    assert.deepEqual(result, e2)
-  })
-})