codify-plugin-lib 1.0.0

package/.eslintignore

@@ -0,0 +1 @@
+/dist

package/.eslintrc.json

@@ -0,0 +1,23 @@
+{
+  "extends": [
+    "oclif",
+    "oclif-typescript",
+    "prettier"
+  ],
+  "rules": {
+    "object-curly-spacing": [
+      "warn",
+      "always"
+    ],
+    "perfectionist/sort-classes": [
+      "off"
+    ],
+    "quotes": [
+      "error",
+      "single"
+    ]
+  },
+  "ignorePatterns": [
+    "*.test.ts"
+  ]
+}

package/.mocharc.json

@@ -0,0 +1,11 @@
+{
+  "require": [
+    "ts-node/register/transpile-only"
+  ],
+  "watch-extensions": [
+    "ts"
+  ],
+  "recursive": true,
+  "reporter": "spec",
+  "timeout": 60000
+}

package/.prettierrc.json

@@ -0,0 +1 @@
+"@oclif/prettier-config"

package/dist/entities/change-set.d.ts

@@ -0,0 +1,15 @@
+import { ParameterOperation, ResourceConfig, ResourceOperation } from 'codify-schemas';
+export interface ParameterChange {
+    name: string;
+    operation: ParameterOperation;
+    previousValue: string | null;
+    newValue: string | null;
+}
+export declare class ChangeSet {
+    operation: ResourceOperation;
+    parameterChanges: Array<ParameterChange>;
+    constructor(operation: ResourceOperation, parameterChanges: Array<ParameterChange>);
+    static createForNullCurrentConfig(desiredConfig: ResourceConfig): ChangeSet;
+    static calculateParameterChangeSet(prev: ResourceConfig, next: ResourceConfig): ParameterChange[];
+    static combineResourceOperations(prev: ResourceOperation, next: ResourceOperation): ResourceOperation;
+}

package/dist/entities/change-set.js

@@ -0,0 +1,88 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ChangeSet = void 0;
+const codify_schemas_1 = require("codify-schemas");
+class ChangeSet {
+    operation;
+    parameterChanges;
+    constructor(operation, parameterChanges) {
+        this.operation = operation;
+        this.parameterChanges = parameterChanges;
+    }
+    static createForNullCurrentConfig(desiredConfig) {
+        const parameterChangeSet = Object.entries(desiredConfig)
+            .filter(([k,]) => k !== 'type' && k !== 'name')
+            .map(([k, v]) => {
+            return {
+                name: k,
+                operation: codify_schemas_1.ParameterOperation.ADD,
+                previousValue: null,
+                newValue: v,
+            };
+        });
+        return new ChangeSet(codify_schemas_1.ResourceOperation.CREATE, parameterChangeSet);
+    }
+    static calculateParameterChangeSet(prev, next) {
+        const parameterChangeSet = new Array();
+        const filteredPrev = Object.fromEntries(Object.entries(prev)
+            .filter(([k,]) => k !== 'type' && k !== 'name'));
+        const filteredNext = Object.fromEntries(Object.entries(next)
+            .filter(([k,]) => k !== 'type' && k !== 'name'));
+        for (const [k, v] of Object.entries(filteredPrev)) {
+            if (!filteredNext[k]) {
+                parameterChangeSet.push({
+                    name: k,
+                    previousValue: v,
+                    newValue: null,
+                    operation: codify_schemas_1.ParameterOperation.REMOVE,
+                });
+                delete filteredPrev[k];
+                continue;
+            }
+            if (filteredPrev[k] !== filteredNext[k]) {
+                parameterChangeSet.push({
+                    name: k,
+                    previousValue: v,
+                    newValue: filteredNext[k],
+                    operation: codify_schemas_1.ParameterOperation.MODIFY,
+                });
+                delete filteredPrev[k];
+                delete filteredNext[k];
+                continue;
+            }
+            parameterChangeSet.push({
+                name: k,
+                previousValue: v,
+                newValue: filteredNext[k],
+                operation: codify_schemas_1.ParameterOperation.NOOP,
+            });
+            delete filteredPrev[k];
+            delete filteredNext[k];
+        }
+        if (Object.keys(filteredPrev).length !== 0) {
+            throw Error('Diff algorithm error');
+        }
+        for (const [k, v] of Object.entries(filteredNext)) {
+            parameterChangeSet.push({
+                name: k,
+                previousValue: null,
+                newValue: v,
+                operation: codify_schemas_1.ParameterOperation.ADD,
+            });
+        }
+        return parameterChangeSet;
+    }
+    static combineResourceOperations(prev, next) {
+        const orderOfOperations = [
+            codify_schemas_1.ResourceOperation.NOOP,
+            codify_schemas_1.ResourceOperation.MODIFY,
+            codify_schemas_1.ResourceOperation.RECREATE,
+            codify_schemas_1.ResourceOperation.CREATE,
+            codify_schemas_1.ResourceOperation.DESTROY,
+        ];
+        const indexPrev = orderOfOperations.indexOf(prev);
+        const indexNext = orderOfOperations.indexOf(next);
+        return orderOfOperations[Math.max(indexPrev, indexNext)];
+    }
+}
+exports.ChangeSet = ChangeSet;

package/dist/entities/plan.d.ts

@@ -0,0 +1,11 @@
+import { ChangeSet } from './change-set';
+import { PlanResponseData, ResourceConfig } from 'codify-schemas';
+export declare class Plan {
+    id: string;
+    changeSet: ChangeSet;
+    resourceConfig: ResourceConfig;
+    constructor(id: string, changeSet: ChangeSet, resourceConfig: ResourceConfig);
+    static create(changeSet: ChangeSet, resourceConfig: ResourceConfig): Plan;
+    getResourceType(): string;
+    toResponse(): PlanResponseData;
+}

package/dist/entities/plan.js

@@ -0,0 +1,30 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Plan = void 0;
+const crypto_1 = require("crypto");
+class Plan {
+    id;
+    changeSet;
+    resourceConfig;
+    constructor(id, changeSet, resourceConfig) {
+        this.id = id;
+        this.changeSet = changeSet;
+        this.resourceConfig = resourceConfig;
+    }
+    static create(changeSet, resourceConfig) {
+        return new Plan((0, crypto_1.randomUUID)(), changeSet, resourceConfig);
+    }
+    getResourceType() {
+        return this.resourceConfig.type;
+    }
+    toResponse() {
+        return {
+            planId: this.id,
+            operation: this.changeSet.operation,
+            resourceName: this.resourceConfig.name,
+            resourceType: this.resourceConfig.type,
+            parameters: this.changeSet.parameterChanges,
+        };
+    }
+}
+exports.Plan = Plan;

package/dist/entities/plugin.d.ts

@@ -0,0 +1,12 @@
+import { Resource } from './resource';
+import { ApplyRequestData, PlanRequestData, PlanResponseData, ResourceConfig, ValidateRequestData, ValidateResponseData } from 'codify-schemas';
+export declare class Plugin {
+    resources: Map<string, Resource<ResourceConfig>>;
+    planStorage: Map<string, any>;
+    constructor(resources: Map<string, Resource<ResourceConfig>>);
+    onInitialize(): Promise<void>;
+    validate(data: ValidateRequestData): Promise<ValidateResponseData>;
+    plan(data: PlanRequestData): Promise<PlanResponseData>;
+    apply(data: ApplyRequestData): Promise<void>;
+    protected crossValidateResources(configs: ResourceConfig[]): Promise<void>;
+}

package/dist/entities/plugin.js

@@ -0,0 +1,35 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Plugin = void 0;
+class Plugin {
+    resources;
+    planStorage;
+    constructor(resources) {
+        this.resources = resources;
+        this.planStorage = new Map();
+    }
+    async onInitialize() {
+    }
+    async validate(data) {
+        for (const config of data.configs) {
+            if (!this.resources.has(config.type)) {
+                throw new Error(`Resource type not found: ${config.type}`);
+            }
+            await this.resources.get(config.type).validate(config);
+        }
+        await this.crossValidateResources(data.configs);
+        return null;
+    }
+    async plan(data) {
+        if (!this.resources.has(data.type)) {
+            throw new Error(`Resource type not found: ${data.type}`);
+        }
+        const plan = await this.resources.get(data.type).plan(data);
+        this.planStorage.set(plan.id, plan);
+        return plan.toResponse();
+    }
+    async apply(data) {
+    }
+    async crossValidateResources(configs) { }
+}
+exports.Plugin = Plugin;

package/dist/entities/resource.d.ts

@@ -0,0 +1,18 @@
+import { ResourceConfig, ResourceOperation } from 'codify-schemas';
+import { ChangeSet, ParameterChange } from './change-set';
+import { Plan } from './plan';
+export declare abstract class Resource<T extends ResourceConfig> {
+    private dependencies;
+    constructor(dependencies?: Resource<any>[]);
+    abstract getTypeId(): string;
+    onInitialize(): Promise<void>;
+    plan(desiredConfig: T): Promise<Plan>;
+    apply(plan: Plan): Promise<any>;
+    abstract validate(config: ResourceConfig): Promise<boolean>;
+    abstract getCurrentConfig(): Promise<T | null>;
+    abstract calculateOperation(change: ParameterChange): ResourceOperation.MODIFY | ResourceOperation.RECREATE;
+    abstract applyCreate(changeSet: ChangeSet): Promise<void>;
+    abstract applyModify(changeSet: ChangeSet): Promise<void>;
+    abstract applyRecreate(changeSet: ChangeSet): Promise<void>;
+    abstract applyDestroy(changeSet: ChangeSet): Promise<void>;
+}

package/dist/entities/resource.js

@@ -0,0 +1,41 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Resource = void 0;
+const codify_schemas_1 = require("codify-schemas");
+const change_set_1 = require("./change-set");
+const plan_1 = require("./plan");
+class Resource {
+    dependencies;
+    constructor(dependencies = []) {
+        this.dependencies = dependencies;
+    }
+    async onInitialize() { }
+    async plan(desiredConfig) {
+        await this.validate(desiredConfig);
+        const currentConfig = await this.getCurrentConfig();
+        if (!currentConfig) {
+            return plan_1.Plan.create(change_set_1.ChangeSet.createForNullCurrentConfig(desiredConfig), desiredConfig);
+        }
+        const parameterChangeSet = change_set_1.ChangeSet.calculateParameterChangeSet(currentConfig, desiredConfig);
+        const resourceOperation = parameterChangeSet
+            .filter((change) => change.operation !== codify_schemas_1.ParameterOperation.NOOP)
+            .reduce((operation, curr) => {
+            const newOperation = this.calculateOperation(curr);
+            return change_set_1.ChangeSet.combineResourceOperations(operation, newOperation);
+        }, codify_schemas_1.ResourceOperation.NOOP);
+        return plan_1.Plan.create(new change_set_1.ChangeSet(resourceOperation, parameterChangeSet), desiredConfig);
+    }
+    async apply(plan) {
+        if (plan.getResourceType()) {
+            throw new Error('Internal error: Plan set to wrong resource during apply');
+        }
+        const changeSet = plan.changeSet;
+        switch (plan.changeSet.operation) {
+            case codify_schemas_1.ResourceOperation.CREATE: return this.applyCreate(changeSet);
+            case codify_schemas_1.ResourceOperation.MODIFY: return this.applyModify(changeSet);
+            case codify_schemas_1.ResourceOperation.RECREATE: return this.applyRecreate(changeSet);
+            case codify_schemas_1.ResourceOperation.DESTROY: return this.applyDestroy(changeSet);
+        }
+    }
+}
+exports.Resource = Resource;

package/dist/index.d.ts

@@ -0,0 +1,8 @@
+import { Plugin } from './entities/plugin';
+export * from './entities/resource';
+export * from './entities/plugin';
+export * from './entities/change-set';
+export * from './entities/plan';
+export * from './utils/test-utils';
+export * from './utils/utils';
+export declare function runPlugin(plugin: Plugin): Promise<void>;

package/dist/index.js

@@ -0,0 +1,30 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.runPlugin = void 0;
+const handlers_1 = require("./messages/handlers");
+__exportStar(require("./entities/resource"), exports);
+__exportStar(require("./entities/plugin"), exports);
+__exportStar(require("./entities/change-set"), exports);
+__exportStar(require("./entities/plan"), exports);
+__exportStar(require("./utils/test-utils"), exports);
+__exportStar(require("./utils/utils"), exports);
+async function runPlugin(plugin) {
+    await plugin.onInitialize();
+    const messageHandler = new handlers_1.MessageHandler(plugin);
+    process.on('message', (message) => messageHandler.onMessage(message));
+}
+exports.runPlugin = runPlugin;

package/dist/messages/handlers.d.ts

@@ -0,0 +1,11 @@
+import { Plugin } from '../entities/plugin';
+export declare class MessageHandler {
+    private ajv;
+    private readonly plugin;
+    private messageSchemaValidator;
+    private requestValidators;
+    private responseValidators;
+    constructor(plugin: Plugin);
+    onMessage(message: unknown): Promise<void>;
+    private validateMessage;
+}

package/dist/messages/handlers.js

@@ -0,0 +1,81 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MessageHandler = void 0;
+const _2020_1 = __importDefault(require("ajv/dist/2020"));
+const ajv_formats_1 = __importDefault(require("ajv-formats"));
+const codify_schemas_1 = require("codify-schemas");
+const SupportedRequests = {
+    'validate': {
+        requestValidator: codify_schemas_1.ValidateRequestDataSchema,
+        responseValidator: codify_schemas_1.ValidateResponseDataSchema,
+        handler: async (plugin, data) => plugin.validate(data)
+    },
+    'plan': {
+        requestValidator: codify_schemas_1.PlanRequestDataSchema,
+        responseValidator: codify_schemas_1.PlanResponseDataSchema,
+        handler: async (plugin, data) => plugin.plan(data)
+    },
+    'apply': {
+        requestValidator: codify_schemas_1.ApplyRequestDataSchema,
+        responseValidator: codify_schemas_1.ApplyRequestDataSchema,
+        handler: async (plugin, data) => plugin.apply(data)
+    }
+};
+class MessageHandler {
+    ajv;
+    plugin;
+    messageSchemaValidator;
+    requestValidators;
+    responseValidators;
+    constructor(plugin) {
+        this.ajv = new _2020_1.default({ strict: true });
+        (0, ajv_formats_1.default)(this.ajv);
+        this.ajv.addSchema(codify_schemas_1.ResourceSchema);
+        this.plugin = plugin;
+        this.messageSchemaValidator = this.ajv.compile(codify_schemas_1.IpcMessageSchema);
+        this.requestValidators = new Map(Object.entries(SupportedRequests)
+            .map(([k, v]) => [k, this.ajv.compile(v.requestValidator)]));
+        this.responseValidators = new Map(Object.entries(SupportedRequests)
+            .map(([k, v]) => [k, this.ajv.compile(v.responseValidator)]));
+    }
+    async onMessage(message) {
+        if (!this.validateMessage(message)) {
+            throw new Error(`Message is malformed: ${JSON.stringify(this.messageSchemaValidator.errors, null, 2)}`);
+        }
+        if (!this.requestValidators.has(message.cmd)) {
+            throw new Error(`Unsupported message: ${message.cmd}`);
+        }
+        const requestValidator = this.requestValidators.get(message.cmd);
+        if (!requestValidator(message.data)) {
+            throw new Error(`Malformed message data: ${JSON.stringify(requestValidator.errors, null, 2)}`);
+        }
+        let result;
+        try {
+            result = await SupportedRequests[message.cmd].handler(this.plugin, message.data);
+        }
+        catch (e) {
+            process.send({
+                cmd: message.cmd + '_Response',
+                status: codify_schemas_1.MessageStatus.ERROR,
+                data: e.message,
+            });
+            return;
+        }
+        const responseValidator = this.responseValidators.get(message.cmd);
+        if (responseValidator && !responseValidator(result)) {
+            throw new Error(`Malformed response data: ${JSON.stringify(responseValidator.errors, null, 2)}`);
+        }
+        process.send({
+            cmd: message.cmd + '_Response',
+            status: codify_schemas_1.MessageStatus.SUCCESS,
+            data: result,
+        });
+    }
+    validateMessage(message) {
+        return this.messageSchemaValidator(message);
+    }
+}
+exports.MessageHandler = MessageHandler;

package/dist/utils/test-utils.d.ts

@@ -0,0 +1,5 @@
+/// <reference types="node" />
+import { ChildProcess } from 'child_process';
+export declare class CodifyTestUtils {
+    static sendMessageToProcessAwaitResponse(process: ChildProcess, message: any): Promise<any>;
+}

package/dist/utils/test-utils.js

@@ -0,0 +1,21 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CodifyTestUtils = void 0;
+class CodifyTestUtils {
+    static sendMessageToProcessAwaitResponse(process, message) {
+        return new Promise((resolve, reject) => {
+            process.on('message', (response) => {
+                resolve(response);
+            });
+            process.on('error', (err) => reject(err));
+            process.on('exit', (code) => {
+                if (code != 0) {
+                    reject('Exit code is not 0');
+                }
+                resolve(code);
+            });
+            process.send(message);
+        });
+    }
+}
+exports.CodifyTestUtils = CodifyTestUtils;

package/dist/utils/utils.d.ts

@@ -0,0 +1,16 @@
+/// <reference types="node" />
+/// <reference types="node" />
+import { SpawnOptions } from 'child_process';
+export interface SpawnResult {
+    code: number;
+    signal: NodeJS.Signals | null;
+    stdout: string;
+    stderr: string;
+}
+type CodifySpawnOptions = {
+    cwd?: string;
+    stdioString?: boolean;
+} & SpawnOptions;
+export declare function codifySpawn(cmd: string, args: string[], opts?: CodifySpawnOptions, extras?: Record<any, any>): Promise<SpawnResult>;
+export declare function isDebug(): boolean;
+export {};

package/dist/utils/utils.js

@@ -0,0 +1,16 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isDebug = exports.codifySpawn = void 0;
+const promise_spawn_1 = __importDefault(require("@npmcli/promise-spawn"));
+async function codifySpawn(cmd, args, opts, extras) {
+    const stdio = isDebug() ? 'inherit' : 'pipe';
+    return (0, promise_spawn_1.default)(cmd, args, { ...opts, stdio, stdioString: true }, extras);
+}
+exports.codifySpawn = codifySpawn;
+function isDebug() {
+    return process.env.DEBUG != null && process.env.DEBUG.includes('codify');
+}
+exports.isDebug = isDebug;

package/package.json

@@ -0,0 +1,49 @@
+{
+  "name": "codify-plugin-lib",
+  "version": "1.0.0",
+  "description": "",
+  "main": "dist/index.js",
+  "typings": "dist/index.d.ts",
+  "scripts": {
+    "test": "echo \"Error: no test specified\" && exit 1"
+  },
+  "keywords": [],
+  "author": "",
+  "license": "ISC",
+  "dependencies": {
+    "ajv": "^8.12.0",
+    "ajv-formats": "^2.1.1",
+    "codify-schemas": "../codify-schemas",
+    "@npmcli/promise-spawn": "^7.0.1"
+  },
+  "devDependencies": {
+    "@oclif/prettier-config": "^0.2.1",
+    "@oclif/test": "^3",
+    "@types/npmcli__promise-spawn": "^6.0.3",
+    "@types/chai": "^4",
+    "@types/chai-as-promised": "^7.1.7",
+    "@types/mocha": "^9.0.0",
+    "@types/node": "^18",
+    "@types/semver": "^7.5.4",
+    "@types/sinon": "^17.0.3",
+    "@types/sinon-chai": "^3.2.12",
+    "chai": "^4",
+    "chai-as-promised": "^7.1.1",
+    "eslint": "^8.51.0",
+    "eslint-config-oclif": "^5",
+    "eslint-config-oclif-typescript": "^3",
+    "mocha": "^10",
+    "mock-fs": "^5.2.0",
+    "sinon": "^17.0.1",
+    "sinon-chai": "^3.7.0",
+    "oclif": "^4.0.0",
+    "shx": "^0.3.3",
+    "ts-node": "^10.9.1",
+    "tsc-watch": "^6.0.4",
+    "typescript": "^5",
+    "eslint-config-prettier": "^9.0.0"
+  },
+  "engines": {
+    "node": ">=18.0.0"
+  }
+}

package/src/entities/change-set.test.ts

@@ -0,0 +1,100 @@
+import { ChangeSet } from './change-set';
+import { expect } from 'chai';
+import { ParameterOperation, ResourceOperation } from 'codify-schemas';
+
+describe('Change set tests', () => {
+  it ('Correctly diffs two resource configs (modify)', () => {
+    const before = {
+      type: 'config',
+      propA: 'before',
+      propB: 'before'
+    }
+
+    const after = {
+      type: 'config',
+      propA: 'after',
+      propB: 'after'
+    }
+
+    const cs = ChangeSet.calculateParameterChangeSet(before, after);
+    expect(cs.length).to.eq(2);
+    expect(cs[0].operation).to.eq(ParameterOperation.MODIFY);
+    expect(cs[1].operation).to.eq(ParameterOperation.MODIFY);
+  })
+
+  it ('Correctly diffs two resource configs (add)', () => {
+    const before = {
+      type: 'config',
+      propA: 'before',
+    }
+
+    const after = {
+      type: 'config',
+      propA: 'after',
+      propB: 'after'
+    }
+
+    const cs = ChangeSet.calculateParameterChangeSet(before, after);
+    expect(cs.length).to.eq(2);
+    expect(cs[0].operation).to.eq(ParameterOperation.MODIFY);
+    expect(cs[1].operation).to.eq(ParameterOperation.ADD);
+  })
+
+  it ('Correctly diffs two resource configs (remove)', () => {
+    const before = {
+      type: 'config',
+      propA: 'before',
+      propB: 'before'
+    }
+
+    const after = {
+      type: 'config',
+      propA: 'after',
+    }
+
+    const cs = ChangeSet.calculateParameterChangeSet(before, after);
+    expect(cs.length).to.eq(2);
+    expect(cs[0].operation).to.eq(ParameterOperation.MODIFY);
+    expect(cs[1].operation).to.eq(ParameterOperation.REMOVE);
+  })
+
+  it ('Correctly diffs two resource configs (no-op)', () => {
+    const before = {
+      type: 'config',
+      propA: 'prop',
+    }
+
+    const after = {
+      type: 'config',
+      propA: 'prop',
+    }
+
+    const cs = ChangeSet.calculateParameterChangeSet(before, after);
+    expect(cs.length).to.eq(1);
+    expect(cs[0].operation).to.eq(ParameterOperation.NOOP);
+  })
+
+  it ('determines the order of operations 1', () => {
+    const op1 = ResourceOperation.MODIFY;
+    const op2 = ResourceOperation.CREATE
+
+    const opResult = ChangeSet.combineResourceOperations(op1, op2);
+    expect(opResult).to.eq(ResourceOperation.CREATE);
+  })
+
+  it ('determines the order of operations 2', () => {
+    const op1 = ResourceOperation.NOOP;
+    const op2 = ResourceOperation.MODIFY
+
+    const opResult = ChangeSet.combineResourceOperations(op1, op2);
+    expect(opResult).to.eq(ResourceOperation.MODIFY);
+  })
+
+  it ('determines the order of operations 3', () => {
+    const op1 = ResourceOperation.MODIFY;
+    const op2 = ResourceOperation.MODIFY
+
+    const opResult = ChangeSet.combineResourceOperations(op1, op2);
+    expect(opResult).to.eq(ResourceOperation.MODIFY);
+  })
+})