@codifycli/plugin-core 1.0.0-beta1

package/src/resource/resource-controller.test.ts

@@ -0,0 +1,1081 @@
+import { Resource } from './resource.js';
+import { OS, ResourceOperation } from 'codify-schemas';
+import { spy } from 'sinon';
+import { describe, expect, it } from 'vitest'
+import { ArrayParameterSetting, ParameterSetting, ResourceSettings } from './resource-settings.js';
+import { CreatePlan, DestroyPlan, ModifyPlan } from '../plan/plan-types.js';
+import { ParameterChange } from '../plan/change-set.js';
+import { ResourceController } from './resource-controller.js';
+import { TestConfig, testPlan, TestResource, TestStatefulParameter } from '../utils/test-utils.test.js';
+import { tildify, untildify } from '../utils/functions.js';
+import { ArrayStatefulParameter, StatefulParameter } from '../stateful-parameter/stateful-parameter.js';
+import { Plan } from '../plan/plan.js';
+import os from 'node:os';
+import { z } from 'zod';
+
+describe('Resource tests', () => {
+
+  it('Validate applies transformations before validating', async () => {
+    const resource = new class extends TestResource {
+      getSettings(): ResourceSettings<TestConfig> {
+        return {
+          id: 'type',
+          operatingSystems: [OS.Darwin],
+          dependencies: ['homebrew', 'python'],
+          parameterSettings: {
+            propA: {
+              canModify: true,
+              transformation: { to: (input) => untildify(input), from: (input) => tildify(input) }
+            },
+          },
+        }
+      }
+
+      async validate(parameters: Partial<TestConfig>): Promise<void> {
+        expect(parameters.propA).to.not.include('~');
+        expect(parameters.propB).to.not.exist;
+        expect(parameters.propC).to.equal(10);
+      }
+    }
+
+    const controller = new ResourceController(resource);
+    await controller.validate(
+      { type: 'type' },
+      {
+        type: 'type',
+        propA: '~/.tool_versions',
+        propB: 10,
+      }
+    )
+  })
+
+  it('Plans successfully', async () => {
+    const resource = new class extends TestResource {
+
+      async refresh(): Promise<TestConfig> {
+        return {
+          propA: 'propABefore',
+          propB: 10,
+        };
+      }
+    }
+
+    const controller = new ResourceController(resource)
+
+    const resourceSpy = spy(controller);
+    const result = await resourceSpy.plan(
+      { type: 'type', name: 'name' },
+      {
+        propA: 'propA',
+        propB: 10,
+      },
+      null,
+      false,
+    )
+
+    expect(result.desiredConfig).to.deep.eq({
+      propA: 'propA',
+      propB: 10,
+    });
+    expect(result.changeSet.operation).to.eq(ResourceOperation.RECREATE);
+    expect(result.changeSet.parameterChanges[0]).to.deep.eq({
+      name: 'propA',
+      previousValue: 'propABefore',
+      newValue: 'propA',
+      operation: 'modify',
+      isSensitive: false,
+    })
+    expect(result.changeSet.parameterChanges[1]).to.deep.eq({
+      name: 'propB',
+      previousValue: 10,
+      newValue: 10,
+      operation: 'noop',
+      isSensitive: false,
+    })
+  })
+
+  it('creates the resource if it doesnt exist', async () => {
+    const resource = new class extends TestResource {
+      async refresh(): Promise<TestConfig | null> {
+        return null;
+      }
+    }
+    const controller = new ResourceController(resource);
+
+    const resourceSpy = spy(controller);
+    const result = await resourceSpy.plan(
+      { type: 'type', name: 'name' },
+      {
+        propA: 'propA',
+        propB: 10,
+        propC: 'somethingAfter'
+      },
+      null,
+      false,
+    )
+
+    expect(result.changeSet.operation).to.eq(ResourceOperation.CREATE);
+    expect(result.changeSet.parameterChanges.length).to.eq(3);
+  })
+
+  it('handles empty parameters', async () => {
+    const resource = new class extends TestResource {
+      async refresh(): Promise<Partial<TestConfig> | null> {
+        return null;
+      }
+    }
+    const controller = new ResourceController(resource);
+
+    const resourceSpy = spy(controller);
+    const result = await resourceSpy.plan(
+      { type: 'type' },
+      {},
+      null,
+      false
+    )
+
+    expect(result.changeSet.operation).to.eq(ResourceOperation.CREATE);
+    expect(result.changeSet.parameterChanges.length).to.eq(0);
+  })
+
+  it('chooses the create apply properly', async () => {
+    const resource = new class extends TestResource {
+    }
+    const controller = new ResourceController(resource);
+
+    const controllerSpy = spy(controller);
+    const resourceSpy = spy(resource);
+
+    await controllerSpy.apply(
+      testPlan({
+        desired: { propA: 'a', propB: 0 },
+      })
+    )
+
+    expect(resourceSpy.create.calledOnce).to.be.true;
+  })
+
+  it('chooses the destroy apply properly', async () => {
+    const resource = new class extends TestResource {
+    }
+    const controller = new ResourceController(resource);
+
+    const controllerSpy = spy(controller);
+    const resourceSpy = spy(resource);
+
+    await controllerSpy.apply(
+      testPlan({
+        current: [{ propA: 'a', propB: 0 }],
+        state: { propA: 'a', propB: 0 },
+        isStateful: true,
+      })
+    )
+
+    expect(resourceSpy.destroy.calledOnce).to.be.true;
+  })
+
+  it('Defaults parameter changes to recreate', async () => {
+    const resource = new class extends TestResource {
+    }
+    const controller = new ResourceController(resource);
+
+    const controllerSpy = spy(controller);
+    const resourceSpy = spy(resource);
+
+    await controllerSpy.apply(
+      testPlan({
+        desired: { propA: 'a', propB: 0 },
+        current: [{ propA: 'b', propB: -1 }],
+        isStateful: true
+      })
+    );
+
+    expect(resourceSpy.destroy.calledOnce).to.be.true;
+    expect(resourceSpy.create.calledOnce).to.be.true;
+  })
+
+  it('Allows modification of parameter behavior to allow modify for parameters', async () => {
+    const resource = new class extends TestResource {
+      getSettings(): ResourceSettings<TestConfig> {
+        return {
+          id: 'resource',
+          operatingSystems: [OS.Darwin],
+          parameterSettings: {
+            propA: { canModify: true },
+            propB: { canModify: true },
+          }
+        }
+      }
+
+      async refresh(): Promise<TestConfig | null> {
+        return { propA: 'b', propB: -1 };
+      }
+    }
+    const controller = new ResourceController(resource);
+
+    const plan = await controller.plan(
+      { type: 'resource' },
+      { propA: 'a', propB: 0 },
+      null,
+      false,
+    )
+
+    const resourceSpy = spy(resource);
+    await controller.apply(
+      plan
+    );
+
+    expect(resourceSpy.modify.calledTwice).to.be.true;
+  })
+
+  it('Validates the resource options correct (pass)', () => {
+    const statefulParameter = new TestStatefulParameter();
+
+    expect(() => new ResourceController(new class extends TestResource {
+      getSettings(): ResourceSettings<TestConfig> {
+        return {
+          id: 'type',
+          operatingSystems: [OS.Darwin],
+          dependencies: ['homebrew', 'python'],
+          parameterSettings: {
+            propA: { canModify: true },
+            propB: { type: 'stateful', definition: statefulParameter },
+            propC: { isEqual: (a, b) => true },
+          }
+        }
+      }
+    })).to.not.throw;
+  })
+
+  it('Validates the resource options correct (fail)', () => {
+    const statefulParameter = new class extends TestStatefulParameter {
+      async refresh(desired: string | null): Promise<string | null> {
+        return null;
+      }
+    }
+
+    expect(() => new ResourceController(new class extends TestResource {
+      getSettings(): ResourceSettings<TestConfig> {
+        return {
+          id: 'type',
+          operatingSystems: [OS.Darwin],
+          dependencies: ['homebrew', 'python'],
+          parameterSettings: {
+            propA: { canModify: true },
+            propB: { type: 'stateful', definition: statefulParameter },
+            propC: { isEqual: (a, b) => true },
+          }
+        }
+      }
+    })).to.not.throw;
+  })
+
+  it('Allows default values to be added', async () => {
+    const resource = new class extends TestResource {
+      getSettings(): ResourceSettings<TestConfig> {
+        return {
+          id: 'type',
+          operatingSystems: [OS.Darwin],
+          parameterSettings: {
+            propA: { default: 'propADefault' }
+          }
+        }
+      }
+
+      // @ts-ignore
+      async refresh(desired: Partial<TestConfig>): Promise<Partial<TestConfig>> {
+        expect(desired['propA']).to.be.eq('propADefault');
+
+        return {
+          propA: 'propAAfter'
+        };
+      }
+    }
+    const controller = new ResourceController(resource);
+
+    const plan = await controller.plan({ type: 'resource' }, {}, null, false)
+    expect(plan.currentConfig?.propA).to.eq('propAAfter');
+    expect(plan.desiredConfig?.propA).to.eq('propADefault');
+    expect(plan.changeSet.operation).to.eq(ResourceOperation.RECREATE);
+  })
+
+  it('Allows default values to be added to both desired and current', async () => {
+    const resource = new class extends TestResource {
+      getSettings(): ResourceSettings<TestConfig> {
+        return {
+          id: 'type',
+          operatingSystems: [OS.Darwin],
+          parameterSettings: {
+            propE: { default: 'propEDefault' }
+          }
+        }
+      }
+
+      async refresh(parameters: Partial<TestConfig>): Promise<Partial<TestConfig> | null> {
+        expect(parameters['propE']).to.exist;
+
+        return {
+          propE: parameters['propE'],
+        };
+      }
+    }
+    const controller = new ResourceController(resource);
+
+    const plan = await controller.plan({ type: 'resource' }, {}, null, false)
+    expect(plan.currentConfig?.propE).to.eq('propEDefault');
+    expect(plan.desiredConfig?.propE).to.eq('propEDefault');
+    expect(plan.changeSet.operation).to.eq(ResourceOperation.NOOP);
+  })
+
+  it('Allows default values to be added even when refresh returns null', async () => {
+    const resource = new class extends TestResource {
+      getSettings(): ResourceSettings<TestConfig> {
+        return {
+          id: 'type',
+          operatingSystems: [OS.Darwin],
+          parameterSettings: {
+            propE: { default: 'propEDefault' }
+          }
+        }
+      }
+
+      async refresh(): Promise<Partial<TestConfig> | null> {
+        return null;
+      }
+    }
+    const controller = new ResourceController(resource);
+
+    const plan = await controller.plan({ type: 'resource' }, {}, null, false)
+    expect(plan.currentConfig).to.be.null
+    expect(plan.desiredConfig!.propE).to.eq('propEDefault');
+    expect(plan.changeSet.operation).to.eq(ResourceOperation.CREATE);
+  })
+
+  it('Allows default values to be added (ignore default value if already present)', async () => {
+    const resource = new class extends TestResource {
+      getSettings(): ResourceSettings<TestConfig> {
+        return {
+          id: 'type',
+          operatingSystems: [OS.Darwin],
+          parameterSettings: {
+            propA: { default: 'propADefault' }
+          }
+        }
+      }
+
+      // @ts-ignore
+      async refresh(parameters: Partial<TestConfig>): Promise<Partial<TestConfig>> {
+        expect(parameters['propA']).to.be.eq('propA');
+
+        return {
+          propA: 'propAAfter'
+        };
+      }
+    }
+    const controller = new ResourceController(resource);
+
+    const plan = await controller.plan({ type: 'resource' }, { propA: 'propA' }, null, false)
+    expect(plan.currentConfig?.propA).to.eq('propAAfter');
+    expect(plan.desiredConfig?.propA).to.eq('propA');
+    expect(plan.changeSet.operation).to.eq(ResourceOperation.RECREATE);
+  });
+
+  it('Sets the default value properly on the resource', () => {
+    const resource = new class extends TestResource {
+      getSettings(): ResourceSettings<TestConfig> {
+        return {
+          id: 'type',
+          operatingSystems: [OS.Darwin],
+          parameterSettings: {
+            propA: { default: 'propADefault' }
+          }
+        }
+      }
+    }
+    const controller = new ResourceController(resource);
+
+    expect(controller.parsedSettings.defaultValues).to.deep.eq({
+      propA: 'propADefault',
+    })
+  })
+
+  it('Has the correct typing for applys', () => {
+    const resource = new class extends Resource<TestConfig> {
+      getSettings(): ResourceSettings<TestConfig> {
+        return { id: 'type', operatingSystems: [OS.Darwin], }
+      }
+
+      async refresh(): Promise<Partial<TestConfig> | null> {
+        return null;
+      }
+
+      async create(plan: CreatePlan<TestConfig>): Promise<void> {
+        plan.desiredConfig.propA
+      }
+
+      async destroy(plan: DestroyPlan<TestConfig>): Promise<void> {
+        plan.currentConfig.propB
+      }
+
+      async modify(pc: ParameterChange<TestConfig>, plan: ModifyPlan<TestConfig>): Promise<void> {
+        plan.desiredConfig.propA
+        plan.currentConfig.propB
+      }
+    }
+  })
+
+  it('Can use multiple stateful parameters (create)', async () => {
+    const parameter1 = new class extends StatefulParameter<any, any> {
+      getSettings(): ParameterSetting {
+        return {
+          type: 'version',
+          operatingSystems: [OS.Darwin],
+        }
+      }
+
+      override async refresh(desired: any, config: Partial<any>): Promise<any> {
+        return null;
+      }
+
+      override async add(valueToAdd: any, plan: Plan<any>): Promise<void> {
+      }
+
+      override async modify(newValue: any, previousValue: any, plan: Plan<any>): Promise<void> {
+      }
+
+      override async remove(valueToRemove: any, plan: Plan<any>): Promise<void> {
+      }
+    }
+
+    const parameter2 = new class extends ArrayStatefulParameter<any, any> {
+      override getSettings(): ArrayParameterSetting {
+        return {
+          type: 'array',
+          isElementEqual: (desired, current) => current.includes(desired),
+        }
+      }
+
+      override async refresh(desired: any[] | null, config: Partial<any>): Promise<any[] | null> {
+        return null;
+      }
+
+      override async addItem(item: any, plan: Plan<any>): Promise<void> {
+      }
+
+      override async removeItem(item: any, plan: Plan<any>): Promise<void> {
+      }
+    }
+
+    const p1Spy = spy(parameter1);
+    const p2Spy = spy(parameter2);
+
+    const resource = new class extends TestResource {
+      getSettings(): ResourceSettings<TestConfig> {
+        return {
+          id: 'nvm',
+          operatingSystems: [OS.Darwin],
+          parameterSettings: {
+            global: { type: 'stateful', definition: parameter1, order: 2 },
+            nodeVersions: { type: 'stateful', definition: parameter2, order: 1 },
+          },
+        }
+      }
+
+      async refresh(parameters: Partial<TestConfig>): Promise<Partial<TestConfig> | null> {
+        return null;
+      }
+    }
+
+    const controller = new ResourceController(resource);
+    const plan = await controller.plan({ type: 'nvm' }, { global: '20.12', nodeVersions: ['18', '20'] }, null, false)
+
+    expect(plan).toMatchObject({
+      changeSet: {
+        operation: ResourceOperation.CREATE,
+      }
+    })
+
+    console.log(JSON.stringify(plan, null, 2))
+
+    await controller.apply(plan)
+
+    expect(p1Spy.add.calledOnce).to.be.true;
+    expect(p2Spy.addItem.calledTwice).to.be.true;
+  });
+
+  it('Can use multiple stateful parameters (modify)', async () => {
+    const parameter1 = spy(new class extends TestStatefulParameter {
+      async refresh(desired: string | null): Promise<string | null> {
+        return '16';
+      }
+    })
+
+    const parameter2 = spy(new class extends ArrayStatefulParameter<any, any> {
+      async refresh(desired: any[] | null, config: Partial<any>): Promise<any[] | null> {
+        return ['20']
+      }
+
+      async addItem(item: any, plan: Plan<any>): Promise<void> {
+      }
+
+      async removeItem(item: any, plan: Plan<any>): Promise<void> {
+      }
+    })
+
+    const resource = new class extends TestResource {
+      getSettings(): ResourceSettings<TestConfig> {
+        return {
+          id: 'nvm',
+          operatingSystems: [OS.Darwin],
+          parameterSettings: {
+            global: { type: 'stateful', definition: parameter1, order: 2 },
+            nodeVersions: { type: 'stateful', definition: parameter2, order: 1 },
+          },
+        }
+      }
+
+      async refresh(parameters: Partial<TestConfig>): Promise<Partial<TestConfig> | null> {
+        return {};
+      }
+    }
+
+    const controller = new ResourceController(resource);
+    const plan = await controller.plan({ type: 'nvm' }, { global: '20.12', nodeVersions: ['18', '20'] }, null, false)
+
+    expect(plan).toMatchObject({
+      changeSet: {
+        operation: ResourceOperation.MODIFY,
+      }
+    })
+
+    await controller.apply(plan)
+
+    expect(parameter1.modify.calledOnce).to.be.true;
+    expect(parameter2.addItem.calledOnce).to.be.true;
+  });
+
+  it('Applies reverse input transformations for imports', async () => {
+    const resource = new class extends TestResource {
+      getSettings(): ResourceSettings<TestConfig> {
+        return {
+          id: 'resourceType',
+          operatingSystems: [OS.Darwin],
+          parameterSettings: {
+            propD: {
+              type: 'array',
+              transformation: {
+                to: (hosts: Record<string, unknown>[]) => hosts.map((h) => Object.fromEntries(
+                    Object.entries(h)
+                      .map(([k, v]) => [
+                        k,
+                        typeof v === 'boolean'
+                          ? (v ? 'yes' : 'no') // The file takes 'yes' or 'no' instead of booleans
+                          : v,
+                      ])
+                  )
+                ),
+                from: (hosts: Record<string, unknown>[]) => hosts.map((h) => Object.fromEntries(
+                  Object.entries(h)
+                    .map(([k, v]) => [
+                      k,
+                      v === 'yes' || v === 'no'
+                        ? (v === 'yes')
+                        : v,
+                    ])
+                ))
+              }
+            }
+          }
+        }
+      }
+
+      async refresh(parameters: Partial<TestConfig>): Promise<Partial<TestConfig> | null> {
+        return {
+          propD: [
+            {
+              Host: 'new.com',
+              AddKeysToAgent: true,
+              IdentityFile: 'id_ed25519'
+            },
+            {
+              Host: 'github.com',
+              AddKeysToAgent: true,
+              UseKeychain: true,
+            },
+            {
+              Match: 'User bob,joe,phil',
+              PasswordAuthentication: true,
+            }
+          ],
+        }
+      }
+    }
+
+    const controller = new ResourceController(resource);
+    const plan = await controller.import({ type: 'resourceType' }, {});
+
+    expect(plan![0]).toMatchObject({
+      'core': {
+        'type': 'resourceType'
+      },
+      'parameters': {
+        'propD': [
+          {
+            'Host': 'new.com',
+            'AddKeysToAgent': true,
+            'IdentityFile': 'id_ed25519'
+          },
+          {
+            'Host': 'github.com',
+            'AddKeysToAgent': true,
+            'UseKeychain': true
+          },
+          {
+            'Match': 'User bob,joe,phil',
+            'PasswordAuthentication': true
+          }
+        ]
+      }
+    })
+  })
+
+  it('Applies reverse input transformations for imports (object level)', async () => {
+    const resource = new class extends TestResource {
+      getSettings(): ResourceSettings<TestConfig> {
+        return {
+          id: 'resourceType',
+          operatingSystems: [OS.Darwin],
+          parameterSettings: {
+            propD: {
+              type: 'array',
+            }
+          },
+          transformation: {
+            to: (input: any) => ({
+              ...input,
+              propD: input.propD?.map((h) => Object.fromEntries(
+                  Object.entries(h)
+                    .map(([k, v]) => [
+                      k,
+                      typeof v === 'boolean'
+                        ? (v ? 'yes' : 'no') // The file takes 'yes' or 'no' instead of booleans
+                        : v,
+                    ])
+                )
+              )
+            }),
+            from: (output: any) => ({
+              ...output,
+              propD: output.propD?.map((h) => Object.fromEntries(
+                Object.entries(h)
+                  .map(([k, v]) => [
+                    k,
+                    v === 'yes' || v === 'no'
+                      ? (v === 'yes')
+                      : v,
+                  ])
+              ))
+            })
+          }
+        }
+      }
+
+      async refresh(parameters: Partial<TestConfig>): Promise<Partial<TestConfig> | null> {
+        return {
+          propD: [
+            {
+              Host: 'new.com',
+              AddKeysToAgent: true,
+              IdentityFile: 'id_ed25519'
+            },
+            {
+              Host: 'github.com',
+              AddKeysToAgent: true,
+              UseKeychain: true,
+            },
+            {
+              Match: 'User bob,joe,phil',
+              PasswordAuthentication: true,
+            }
+          ],
+        }
+      }
+    }
+
+    const controller = new ResourceController(resource);
+    const plan = await controller.import({ type: 'resourceType' }, {});
+
+    expect(plan![0]).toMatchObject({
+      'core': {
+        'type': 'resourceType'
+      },
+      'parameters': {
+        'propD': [
+          {
+            'Host': 'new.com',
+            'AddKeysToAgent': true,
+            'IdentityFile': 'id_ed25519'
+          },
+          {
+            'Host': 'github.com',
+            'AddKeysToAgent': true,
+            'UseKeychain': true
+          },
+          {
+            'Match': 'User bob,joe,phil',
+            'PasswordAuthentication': true
+          }
+        ]
+      }
+    })
+  })
+
+  it('Applies removes default values if they remain default for imports', async () => {
+    const resource = new class extends TestResource {
+      getSettings(): ResourceSettings<TestConfig> {
+        return {
+          id: 'resourceType',
+          operatingSystems: [OS.Darwin],
+          parameterSettings: {
+            propA: { type: 'string', default: 'defaultValue' },
+            propB: { type: 'boolean', default: true }
+          },
+        }
+      }
+
+      async refresh(parameters: Partial<TestConfig>): Promise<Partial<TestConfig> | null> {
+        return {
+          propA: 'defaultValue',
+          propB: false,
+          propC: 'newPropC'
+        }
+      }
+    }
+
+    const controller = new ResourceController(resource);
+    const plan = await controller.import({ type: 'resourceType' }, {});
+
+    expect(plan![0]).toMatchObject({
+      'core': {
+        'type': 'resourceType'
+      },
+      'parameters': {
+        propB: false,
+        propC: 'newPropC'
+      }
+    })
+  })
+
+  it('Can plan with settings', async () => {
+    const resource = new class extends TestResource {
+      getSettings(): ResourceSettings<any> {
+        return {
+          id: 'path',
+          operatingSystems: [OS.Darwin],
+          parameterSettings: {
+            path: { type: 'string', isEqual: 'directory' },
+            paths: { canModify: true, type: 'array', isElementEqual: 'directory' },
+            prepend: { default: false, setting: true },
+            declarationsOnly: { default: false, setting: true },
+          },
+          importAndDestroy: {
+            refreshKeys: ['paths', 'declarationsOnly'],
+            defaultRefreshValues: {
+              paths: [],
+              declarationsOnly: true,
+            }
+          },
+          allowMultiple: {
+            matcher: (desired, current) => {
+              if (desired.path) {
+                return desired.path === current.path;
+              }
+
+              const currentPaths = new Set(current.paths)
+              return desired.paths?.some((p) => currentPaths.has(p));
+            }
+          }
+        }
+      }
+
+      async refresh(parameters: Partial<TestConfig>): Promise<Partial<TestConfig> | null> {
+        return { path: '$HOME/.bun/bin', prepend: false, declarationsOnly: false }
+      }
+    }
+
+    const controller = new ResourceController(resource);
+    const plan = await controller.plan({ type: 'path' }, { path: '$HOME/.bun/bin' }, null, false);
+
+    expect(plan.requiresChanges()).to.be.false;
+  })
+
+  it('Can import with the correct default parameters', async () => {
+    const resource = new class extends TestResource {
+      getSettings(): ResourceSettings<any> {
+        return {
+          id: 'path',
+          operatingSystems: [OS.Darwin],
+          parameterSettings: {
+            path: { type: 'string', isEqual: 'directory' },
+            paths: { canModify: true, type: 'array', isElementEqual: 'directory' },
+            prepend: { default: false, setting: true },
+            declarationsOnly: { default: false, setting: true },
+          },
+          importAndDestroy: {
+            refreshKeys: ['paths', 'declarationsOnly'],
+            defaultRefreshValues: {
+              paths: [],
+              declarationsOnly: true,
+            }
+          },
+          allowMultiple: {
+            matcher: (desired, current) => {
+              if (desired.path) {
+                return desired.path === current.path;
+              }
+
+              const currentPaths = new Set(current.paths)
+              return desired.paths?.some((p) => currentPaths.has(p));
+            }
+          }
+        }
+      }
+
+      async refresh(parameters: Partial<TestConfig>): Promise<Partial<TestConfig> | null> {
+        expect(parameters.declarationsOnly).to.be.true;
+
+        return null;
+      }
+    }
+
+    const controller = new ResourceController(resource);
+    await controller.import({ type: 'path' }, {});
+    ;
+  })
+
+  it('Can import and return all of the imported parameters', async () => {
+    const resource = new class extends TestResource {
+      getSettings(): ResourceSettings<any> {
+        return {
+          id: 'path',
+          operatingSystems: [OS.Darwin],
+          parameterSettings: {
+            path: { type: 'directory' },
+            paths: { canModify: true, type: 'array', itemType: 'directory' },
+            prepend: { default: false, setting: true },
+            declarationsOnly: { default: false, setting: true },
+          },
+          importAndDestroy: {
+            refreshMapper: (input, context) => {
+              if (Object.keys(input).length === 0) {
+                return { paths: [], declarationsOnly: true };
+              }
+
+              return input;
+            }
+          },
+          allowMultiple: {
+            matcher: (desired, current) => {
+              if (desired.path) {
+                return desired.path === current.path;
+              }
+
+              const currentPaths = new Set(current.paths)
+              return desired.paths?.some((p) => currentPaths.has(p));
+            }
+          }
+        }
+      }
+
+      async refresh(parameters: Partial<TestConfig>): Promise<Partial<TestConfig> | null> {
+        return {
+          paths: [
+            `${os.homedir()}/.pyenv/bin`,
+            `${os.homedir()}/.bun/bin`,
+            `${os.homedir()}/.deno/bin`,
+            `${os.homedir()}/.jenv/bin`,
+            `${os.homedir()}/a/random/path`,
+            `${os.homedir()}/.nvm/.bin/2`,
+            `${os.homedir()}/.nvm/.bin/3`
+          ]
+        }
+      }
+    }
+
+    const oldProcessEnv = structuredClone(process.env);
+
+    process.env['PYENV_ROOT'] = `${os.homedir()}/.pyenv`
+    process.env['BUN_INSTALL'] = `${os.homedir()}/.bun`
+    process.env['DENO_INSTALL'] = `${os.homedir()}/.deno`
+    process.env['JENV'] = `${os.homedir()}/.jenv`
+    process.env['NVM_DIR'] = `${os.homedir()}/.nvm`
+
+    const controller = new ResourceController(resource);
+    const importResult1 = await controller.import({ type: 'path' }, {});
+    expect(importResult1).toMatchObject([
+      {
+        'core': {
+          'type': 'path'
+        },
+        'parameters': {
+          'paths': [
+            '$PYENV_ROOT/bin',
+            '$BUN_INSTALL/bin',
+            '$DENO_INSTALL/bin',
+            '$JENV/bin',
+            '~/a/random/path',
+            '$NVM_DIR/.bin/2',
+            '$NVM_DIR/.bin/3'
+          ]
+        }
+      }
+    ])
+
+    const importResult2 = await controller.import({ type: 'path' }, { paths: ['$PYENV_ROOT/bin', '$BUN_INSTALL/bin'] });
+    expect(importResult2).toMatchObject([
+      {
+        'core': {
+          'type': 'path'
+        },
+        'parameters': {
+          'paths': [
+            '$PYENV_ROOT/bin',
+            '$BUN_INSTALL/bin',
+            '$DENO_INSTALL/bin',
+            '$JENV/bin',
+            '~/a/random/path',
+            '$NVM_DIR/.bin/2',
+            '$NVM_DIR/.bin/3'
+          ]
+        }
+      }
+    ])
+
+    process.env = oldProcessEnv;
+  })
+
+  it('Can import and return all of the imported parameters (zod schema)', async () => {
+    const schema = z.object({
+      path: z
+        .string()
+        .describe(
+          'A list of paths to add to the PATH environment variable'
+        ),
+      paths: z
+        .array(z.string())
+        .describe(
+          'A list of paths to add to the PATH environment variable'
+        ),
+      prepend: z
+        .boolean()
+        .describe(
+          'Whether to prepend the paths to the PATH environment variable'
+        ),
+      declarationsOnly: z
+        .boolean()
+        .describe(
+          'Whether to only declare the paths in the PATH environment variable'
+        ),
+    })
+
+    const resource = new class extends TestResource {
+      getSettings(): ResourceSettings<any> {
+        return {
+          id: 'path',
+          schema,
+          operatingSystems: [OS.Darwin],
+          parameterSettings: {
+            path: { type: 'directory' },
+            paths: { canModify: true, type: 'array', itemType: 'directory' },
+            prepend: { default: false, setting: true },
+            declarationsOnly: { default: false, setting: true },
+          },
+          importAndDestroy: {
+            refreshMapper: (input, context) => {
+              if (Object.keys(input).length === 0) {
+                return { paths: [], declarationsOnly: true };
+              }
+
+              return input;
+            }
+          },
+          allowMultiple: {
+            matcher: (desired, current) => {
+              if (desired.path) {
+                return desired.path === current.path;
+              }
+
+              const currentPaths = new Set(current.paths)
+              return desired.paths?.some((p) => currentPaths.has(p));
+            }
+          }
+        }
+      }
+
+      async refresh(parameters: Partial<TestConfig>): Promise<Partial<TestConfig> | null> {
+        return {
+          paths: [
+            `${os.homedir()}/.pyenv/bin`,
+            `${os.homedir()}/.bun/bin`,
+            `${os.homedir()}/.deno/bin`,
+            `${os.homedir()}/.jenv/bin`,
+            `${os.homedir()}/a/random/path`,
+            `${os.homedir()}/.nvm/.bin/2`,
+            `${os.homedir()}/.nvm/.bin/3`
+          ]
+        }
+      }
+    }
+
+    const oldProcessEnv = structuredClone(process.env);
+
+    process.env['PYENV_ROOT'] = `${os.homedir()}/.pyenv`
+    process.env['BUN_INSTALL'] = `${os.homedir()}/.bun`
+    process.env['DENO_INSTALL'] = `${os.homedir()}/.deno`
+    process.env['JENV'] = `${os.homedir()}/.jenv`
+    process.env['NVM_DIR'] = `${os.homedir()}/.nvm`
+
+    const controller = new ResourceController(resource);
+    const importResult1 = await controller.import({ type: 'path' }, {});
+    expect(importResult1).toMatchObject([
+      {
+        'core': {
+          'type': 'path'
+        },
+        'parameters': {
+          'paths': [
+            '$PYENV_ROOT/bin',
+            '$BUN_INSTALL/bin',
+            '$DENO_INSTALL/bin',
+            '$JENV/bin',
+            '~/a/random/path',
+            '$NVM_DIR/.bin/2',
+            '$NVM_DIR/.bin/3'
+          ]
+        }
+      }
+    ])
+
+    const importResult2 = await controller.import({ type: 'path' }, { paths: ['$PYENV_ROOT/bin', '$BUN_INSTALL/bin'] });
+    expect(importResult2).toMatchObject([
+      {
+        'core': {
+          'type': 'path'
+        },
+        'parameters': {
+          'paths': [
+            '$PYENV_ROOT/bin',
+            '$BUN_INSTALL/bin',
+            '$DENO_INSTALL/bin',
+            '$JENV/bin',
+            '~/a/random/path',
+            '$NVM_DIR/.bin/2',
+            '$NVM_DIR/.bin/3'
+          ]
+        }
+      }
+    ])
+
+    process.env = oldProcessEnv;
+  })
+});