@apexdevtools/git-ops 1.1.0 → 1.2.0

package/CHANGELOG.md

@@ -1,5 +1,16 @@
 # git-ops - Changelog
 
+## 1.2.0 - 2023-09-15
+
+- Add `OrgTracking` class
+  - adds the ability to get local status against the default org
+  - adds the ability to deploy and update source tracking given file paths
+- remove patch version checking in Git version
+
+## 1.1.1 - 2023-03-27
+
+- Update minimum version to 2.20.0
+
 ## 1.1.0 - 2023-03-21
 
 - add new method `getDiffRange`

package/README.md

@@ -4,7 +4,7 @@ Library to do git operations to find changed files in a given git repository.
 
 ## Prerequisite
 
-Minimum `git` version of `2.30.0` must already be installed on the host machine.
+Minimum `git` version of `2.20.0` must already be installed on the host machine.
 
 ## Getting Started
 

package/lib/src/Git/Git.d.ts

@@ -15,7 +15,6 @@ export declare enum FileStatus {
 export declare class Git implements IGit {
     private static MIN_GIT_VERSION_MAJOR;
     private static MIN_GIT_VERSION_MINOR;
-    private static MIN_GIT_VERSION_PATCH;
     private gitInstance;
     private dir;
     constructor(dir: string);

package/lib/src/Git/Git.js

@@ -36,10 +36,12 @@ class Git {
         return __awaiter(this, void 0, void 0, function* () {
             const version = yield git.version();
             const isSupported = version.major >= this.MIN_GIT_VERSION_MAJOR &&
-                version.minor >= this.MIN_GIT_VERSION_MINOR &&
-                version.patch >= this.MIN_GIT_VERSION_PATCH;
+                version.minor >= this.MIN_GIT_VERSION_MINOR;
+            if (!version.installed) {
+                throw new Error('"git" is not installed or available on the PATH');
+            }
             if (!isSupported)
-                throw new Error(`Unsupported version of git. Min version must be ${this.MIN_GIT_VERSION_MAJOR}.${this.MIN_GIT_VERSION_MINOR}.${this.MIN_GIT_VERSION_PATCH}`);
+                throw new Error(`Unsupported version of git. Min version must be ${this.MIN_GIT_VERSION_MAJOR}.${this.MIN_GIT_VERSION_MINOR}`);
         });
     }
     get git() {
@@ -105,5 +107,4 @@ class Git {
 }
 exports.Git = Git;
 Git.MIN_GIT_VERSION_MAJOR = 2;
-Git.MIN_GIT_VERSION_MINOR = 30;
-Git.MIN_GIT_VERSION_PATCH = 0;
+Git.MIN_GIT_VERSION_MINOR = 20;

package/lib/src/OrgTracking/Tracking.d.ts

@@ -0,0 +1,37 @@
+import { Connection } from '@salesforce/core';
+import { Logger } from '../logger/Logger';
+export declare enum FileState {
+    Added = "add",
+    Modified = "modify",
+    Deleted = "delete",
+    NonDelete = "nondelete",
+    Ignored = "ignore",
+    Conflicted = "conflict"
+}
+export interface SyncStatusRow {
+    fullName: string;
+    path?: string;
+    state: FileState[];
+    type: string;
+    origin: string;
+}
+export interface SyncStatus {
+    local: SyncStatusRow[];
+    remote: SyncStatusRow[];
+}
+export interface OrgTrackingOptions {
+    connection: Connection;
+    projectDir: string;
+    logger: Logger;
+}
+export declare class OrgTracking {
+    private options;
+    private logger;
+    constructor(options: OrgTrackingOptions);
+    getLocalStatus(withConflicts?: boolean): Promise<SyncStatus>;
+    deployAndUpdateSourceTracking(paths: Array<string>): Promise<void>;
+    private deploy;
+    private updateSourceTracking;
+    private toSyncStatusRow;
+    private withWorkingDir;
+}

package/lib/src/OrgTracking/Tracking.js

@@ -0,0 +1,139 @@
+"use strict";
+/*
+ * Copyright (c) 2023 Certinia Inc. All rights reserved.
+ */
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.OrgTracking = exports.FileState = void 0;
+const core_1 = require("@salesforce/core");
+const process_1 = require("process");
+const source_tracking_1 = require("@salesforce/source-tracking");
+const source_deploy_retrieve_1 = require("@salesforce/source-deploy-retrieve");
+var FileState;
+(function (FileState) {
+    FileState["Added"] = "add";
+    FileState["Modified"] = "modify";
+    FileState["Deleted"] = "delete";
+    FileState["NonDelete"] = "nondelete";
+    FileState["Ignored"] = "ignore";
+    FileState["Conflicted"] = "conflict";
+})(FileState = exports.FileState || (exports.FileState = {}));
+class OrgTracking {
+    constructor(options) {
+        this.options = options;
+        this.logger = options.logger;
+    }
+    getLocalStatus(withConflicts = false) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const project = core_1.SfProject.getInstance(this.options.projectDir);
+            const org = yield core_1.Org.create({ connection: this.options.connection });
+            return yield this.withWorkingDir(this.options.projectDir, () => __awaiter(this, void 0, void 0, function* () {
+                const tracking = yield source_tracking_1.SourceTracking.create({
+                    org,
+                    project,
+                    ignoreLocalCache: true,
+                });
+                yield tracking.ensureRemoteTracking(true);
+                const initValue = { local: [], remote: [] };
+                const status = yield tracking
+                    .getStatus({ local: true, remote: false })
+                    .then((res) => __awaiter(this, void 0, void 0, function* () {
+                    if (withConflicts) {
+                        //Taken from sourceTracking.ts from the @salesforce/source-tracking lib
+                        const conflictFiles = (yield tracking.getConflicts())
+                            .flatMap(conflict => conflict.filenames)
+                            .filter((value) => typeof value === 'string');
+                        res = res.map(row => (Object.assign(Object.assign({}, row), { conflict: !!row.filePath && conflictFiles.includes(row.filePath) })));
+                    }
+                    return res;
+                }))
+                    .catch(e => {
+                    this.logger.logError(e);
+                    return [];
+                });
+                return status.reduce((acc, row) => {
+                    acc[row.origin].push(this.toSyncStatusRow(row));
+                    return acc;
+                }, initValue);
+            }));
+        });
+    }
+    deployAndUpdateSourceTracking(paths) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return yield this.withWorkingDir(this.options.projectDir, () => __awaiter(this, void 0, void 0, function* () {
+                return this.deploy(paths)
+                    .then(res => this.updateSourceTracking(res))
+                    .catch(e => this.logger.logError(e));
+            }));
+        });
+    }
+    deploy(paths) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const set = source_deploy_retrieve_1.ComponentSet.fromSource(paths);
+            const deploy = yield set.deploy({
+                usernameOrConnection: this.options.connection,
+            });
+            this.logger.logDeployProgress('Starting deploy');
+            deploy.onUpdate(response => {
+                const { status, numberComponentsDeployed, numberComponentsTotal, } = response;
+                const progress = `${numberComponentsDeployed}/${numberComponentsTotal}`;
+                const message = `Status: ${status} Progress: ${progress}`;
+                this.logger.logDeployProgress(message);
+            });
+            return yield deploy.pollStatus().then(res => {
+                this.logger.logMessage('Finished deploy');
+                return res;
+            });
+        });
+    }
+    updateSourceTracking(result) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const project = core_1.SfProject.getInstance(this.options.projectDir);
+            const org = yield core_1.Org.create({ connection: this.options.connection });
+            const tracking = yield source_tracking_1.SourceTracking.create({
+                org,
+                project,
+                ignoreLocalCache: true,
+            });
+            yield tracking.updateTrackingFromDeploy(result);
+        });
+    }
+    toSyncStatusRow(from) {
+        const state = [];
+        if (from.ignored) {
+            state.push(FileState.Ignored);
+        }
+        if (from.conflict) {
+            state.push(FileState.Conflicted);
+        }
+        state.push(from.state);
+        return {
+            fullName: from.fullName,
+            path: from.filePath,
+            state: state,
+            type: from.type,
+            origin: from.origin,
+        };
+    }
+    withWorkingDir(path, op) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const startDir = (0, process_1.cwd)();
+            (0, process_1.chdir)(path);
+            try {
+                return yield op();
+            }
+            finally {
+                (0, process_1.chdir)(startDir);
+            }
+        });
+    }
+}
+exports.OrgTracking = OrgTracking;

package/lib/src/index.d.ts

@@ -1,3 +1,5 @@
 export { getDefaultBranchDiff, getDefaultBranchDiffByRef, getDiffRange, getLocalChanges, } from './FilesChanged/BranchChanges';
+export { OrgTracking, OrgTrackingOptions, FileState, SyncStatusRow, SyncStatus, } from './OrgTracking/Tracking';
+export { Logger } from './logger/Logger';
 export { IGit } from './api/IGit';
 export { Git } from './Git/Git';

package/lib/src/index.js

@@ -3,11 +3,14 @@
  * Copyright (c) 2023, FinancialForce.com, inc. All rights reserved.
  */
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.Git = exports.getLocalChanges = exports.getDiffRange = exports.getDefaultBranchDiffByRef = exports.getDefaultBranchDiff = void 0;
+exports.Git = exports.FileState = exports.OrgTracking = exports.getLocalChanges = exports.getDiffRange = exports.getDefaultBranchDiffByRef = exports.getDefaultBranchDiff = void 0;
 var BranchChanges_1 = require("./FilesChanged/BranchChanges");
 Object.defineProperty(exports, "getDefaultBranchDiff", { enumerable: true, get: function () { return BranchChanges_1.getDefaultBranchDiff; } });
 Object.defineProperty(exports, "getDefaultBranchDiffByRef", { enumerable: true, get: function () { return BranchChanges_1.getDefaultBranchDiffByRef; } });
 Object.defineProperty(exports, "getDiffRange", { enumerable: true, get: function () { return BranchChanges_1.getDiffRange; } });
 Object.defineProperty(exports, "getLocalChanges", { enumerable: true, get: function () { return BranchChanges_1.getLocalChanges; } });
+var Tracking_1 = require("./OrgTracking/Tracking");
+Object.defineProperty(exports, "OrgTracking", { enumerable: true, get: function () { return Tracking_1.OrgTracking; } });
+Object.defineProperty(exports, "FileState", { enumerable: true, get: function () { return Tracking_1.FileState; } });
 var Git_1 = require("./Git/Git");
 Object.defineProperty(exports, "Git", { enumerable: true, get: function () { return Git_1.Git; } });

package/lib/src/logger/Logger.d.ts

@@ -0,0 +1,5 @@
+export interface Logger {
+    logError(error: any): void;
+    logMessage(message: any): void;
+    logDeployProgress(status: string): void;
+}

package/lib/src/logger/Logger.js

@@ -0,0 +1,5 @@
+"use strict";
+/*
+ * Copyright (c) 2023 Certinia Inc. All rights reserved.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });

package/lib/test/Git/Git.spec.js

@@ -28,37 +28,62 @@ describe('Git', () => {
         yield repoManager.tearDown();
     }));
     describe('version check', () => {
-        it('does not fail when Git version is equal to 2.30.0', () => {
+        it('does not fail when Git version is equal to 2.20.0', () => {
             //Given/When
             const mock = {
-                version: jest.fn().mockReturnValue({ major: 2, minor: 30, patch: 0 }),
+                version: jest.fn().mockReturnValue({
+                    installed: true,
+                    major: 2,
+                    minor: 20,
+                    patch: 0,
+                }),
             };
             expect(Git_1.Git.versionCheck(mock)).resolves;
         });
-        it('fails when Git major version is lower', () => __awaiter(void 0, void 0, void 0, function* () {
+        it('does not fail when Git version is higher', () => {
+            //Given/When
+            const mock = {
+                version: jest.fn().mockReturnValue({
+                    installed: true,
+                    major: 2,
+                    minor: 30,
+                    patch: 2,
+                }),
+            };
+            //Then
+            expect(Git_1.Git.versionCheck(mock)).resolves;
+        });
+        it('fails when Git is not installed', () => __awaiter(void 0, void 0, void 0, function* () {
             //Given/When
             const mock = {
-                version: jest.fn().mockReturnValue({ major: 1 }),
+                version: jest.fn().mockReturnValue({ installed: false }),
             };
             //Then
-            yield expect(Git_1.Git.versionCheck(mock)).rejects.toThrow(Error('Unsupported version of git. Min version must be 2.30.0'));
+            yield expect(Git_1.Git.versionCheck(mock)).rejects.toThrow(Error('"git" is not installed or available on the PATH'));
         }));
-        it('fails when Git minor version is lower', () => __awaiter(void 0, void 0, void 0, function* () {
+        it('fails when Git major version is lower', () => __awaiter(void 0, void 0, void 0, function* () {
             //Given/When
             const mock = {
-                version: jest.fn().mockReturnValue({ major: 3, minor: 36 }),
+                version: jest.fn().mockReturnValue({
+                    installed: true,
+                    major: 1,
+                }),
             };
             //Then
-            yield expect(Git_1.Git.versionCheck(mock)).rejects.toThrow(Error('Unsupported version of git. Min version must be 2.30.0'));
+            yield expect(Git_1.Git.versionCheck(mock)).rejects.toThrow(Error('Unsupported version of git. Min version must be 2.20'));
         }));
-        it('fails when Git patch version is more than 0', () => {
+        it('fails when Git minor version is lower', () => __awaiter(void 0, void 0, void 0, function* () {
             //Given/When
             const mock = {
-                version: jest.fn().mockReturnValue({ major: 3, minor: 38, patch: 1 }),
+                version: jest.fn().mockReturnValue({
+                    installed: true,
+                    major: 2,
+                    minor: 19,
+                }),
             };
             //Then
-            expect(Git_1.Git.versionCheck(mock)).resolves;
-        });
+            yield expect(Git_1.Git.versionCheck(mock)).rejects.toThrow(Error('Unsupported version of git. Min version must be 2.20'));
+        }));
     });
     describe('rev parse', () => {
         it('get git root', () => __awaiter(void 0, void 0, void 0, function* () {

package/lib/test/OrgTracking/Tracking.spec.d.ts

@@ -0,0 +1 @@
+export {};

package/lib/test/OrgTracking/Tracking.spec.js

@@ -0,0 +1,312 @@
+"use strict";
+/*
+ * Copyright (c) 2023 Certinia Inc. All rights reserved.
+ */
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const src_1 = require("../../src");
+const core_1 = require("@salesforce/core");
+const mockGetStatusData = [
+    {
+        fullName: 'SomeComponent',
+        filePath: 'path/to/file',
+        type: 'class',
+        origin: 'local',
+        ignored: false,
+        conflict: false,
+        state: 'add',
+    },
+    {
+        fullName: 'SomeComponent1',
+        filePath: 'path/to/file/1',
+        type: 'class',
+        origin: 'local',
+        ignored: false,
+        conflict: true,
+        state: 'delete',
+    },
+    {
+        fullName: 'SomeComponent2',
+        filePath: 'path/to/file/2',
+        type: 'class',
+        origin: 'local',
+        ignored: true,
+        conflict: false,
+        state: 'modify',
+    },
+    {
+        fullName: 'SomeComponent3',
+        filePath: 'path/to/file/3',
+        type: 'class',
+        origin: 'local',
+        ignored: true,
+        conflict: true,
+        state: 'nondelete',
+    },
+    {
+        fullName: 'NoPathComponent',
+        filePath: undefined,
+        type: 'metadata',
+        origin: 'local',
+        ignored: false,
+        conflict: false,
+        state: 'add',
+    },
+];
+const mockConflictsData = [
+    {
+        filenames: [
+            'path/to/file',
+            'path/to/file/3',
+            { nonString: 'object' },
+            'path/to/file/non/existent',
+        ],
+    },
+];
+jest.mock('@salesforce/core', () => {
+    return {
+        SfProject: { getInstance: jest.fn() },
+        Org: { create: jest.fn() },
+    };
+});
+const mockConnection = jest.fn();
+const mockSourceTracking = {
+    ensureRemoteTracking: jest.fn(),
+    getStatus: jest
+        .fn()
+        .mockImplementation(() => Promise.resolve(mockGetStatusData)),
+    getConflicts: jest
+        .fn()
+        .mockImplementation(() => Promise.resolve(mockConflictsData)),
+    updateTrackingFromDeploy: jest
+        .fn()
+        .mockImplementation(() => Promise.resolve()),
+};
+jest.mock('@salesforce/source-tracking', () => {
+    return {
+        SourceTracking: {
+            create: jest
+                .fn()
+                .mockImplementation(() => Promise.resolve(Object.assign({}, mockSourceTracking))),
+        },
+    };
+});
+const mockDeploy = {
+    onUpdate: jest.fn(),
+    pollStatus: jest
+        .fn()
+        .mockImplementation(() => Promise.resolve(mockDeployResult)),
+};
+const mockDeployResult = { done: true };
+const mockComponentSet = {
+    deploy: jest
+        .fn()
+        .mockImplementation(() => Promise.resolve(Object.assign({}, mockDeploy))),
+};
+jest.mock('@salesforce/source-deploy-retrieve', () => {
+    return {
+        ComponentSet: {
+            fromSource: jest.fn().mockImplementation(() => {
+                return Object.assign({}, mockComponentSet);
+            }),
+        },
+    };
+});
+describe('OrgTracking', () => {
+    const PROJECT_DIR = 'path/to/dir';
+    let cwdSpy, chdirSpy;
+    const sfCoreSpy = {
+        SfProject: { getInstance: jest.spyOn(core_1.SfProject, 'getInstance') },
+        Org: { create: jest.spyOn(core_1.Org, 'create') },
+    };
+    beforeEach(() => {
+        jest.mock('process');
+        cwdSpy = jest
+            .spyOn(process, 'cwd')
+            .mockImplementation(() => 'mocked/current/working/dir');
+        chdirSpy = jest.spyOn(process, 'chdir').mockImplementation(() => {
+            return;
+        });
+    });
+    afterEach(() => {
+        jest.clearAllMocks();
+    });
+    const mockLogger = {
+        logDeployProgress: jest.fn(),
+        logError: jest.fn(),
+        logMessage: jest.fn(),
+    };
+    describe('getLocalStatus', () => {
+        it('returns the correct status', () => __awaiter(void 0, void 0, void 0, function* () {
+            const tracking = new src_1.OrgTracking({
+                connection: mockConnection,
+                projectDir: PROJECT_DIR,
+                logger: mockLogger,
+            });
+            const res = yield tracking.getLocalStatus();
+            expect(cwdSpy).toHaveBeenCalled();
+            // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access
+            expect(chdirSpy.mock.calls).toEqual([
+                [PROJECT_DIR],
+                ['mocked/current/working/dir'],
+            ]);
+            expect(sfCoreSpy.Org.create).toHaveBeenCalledWith({
+                connection: mockConnection,
+            });
+            expect(sfCoreSpy.SfProject.getInstance).toHaveBeenCalledWith(PROJECT_DIR);
+            expect(mockSourceTracking.ensureRemoteTracking).toHaveBeenCalledWith(true);
+            expect(mockSourceTracking.getStatus).toHaveBeenCalledWith({
+                local: true,
+                remote: false,
+            });
+            expect(mockSourceTracking.getConflicts).not.toBeCalled();
+            expect(res).toEqual({
+                local: [
+                    {
+                        fullName: 'SomeComponent',
+                        origin: 'local',
+                        path: 'path/to/file',
+                        state: ['add'],
+                        type: 'class',
+                    },
+                    {
+                        fullName: 'SomeComponent1',
+                        origin: 'local',
+                        path: 'path/to/file/1',
+                        state: ['conflict', 'delete'],
+                        type: 'class',
+                    },
+                    {
+                        fullName: 'SomeComponent2',
+                        origin: 'local',
+                        path: 'path/to/file/2',
+                        state: ['ignore', 'modify'],
+                        type: 'class',
+                    },
+                    {
+                        fullName: 'SomeComponent3',
+                        origin: 'local',
+                        path: 'path/to/file/3',
+                        state: ['ignore', 'conflict', 'nondelete'],
+                        type: 'class',
+                    },
+                    {
+                        fullName: 'NoPathComponent',
+                        path: undefined,
+                        type: 'metadata',
+                        origin: 'local',
+                        state: ['add'],
+                    },
+                ],
+                remote: [],
+            });
+        }));
+        it('returns the correct status with conflicts', () => __awaiter(void 0, void 0, void 0, function* () {
+            //Given
+            const tracking = new src_1.OrgTracking({
+                connection: mockConnection,
+                projectDir: PROJECT_DIR,
+                logger: mockLogger,
+            });
+            //When
+            const res = yield tracking.getLocalStatus(true);
+            //Then
+            expect(cwdSpy).toHaveBeenCalled();
+            // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access
+            expect(chdirSpy.mock.calls).toEqual([
+                [PROJECT_DIR],
+                ['mocked/current/working/dir'],
+            ]);
+            expect(sfCoreSpy.Org.create).toHaveBeenCalledWith({
+                connection: mockConnection,
+            });
+            expect(sfCoreSpy.SfProject.getInstance).toHaveBeenCalledWith(PROJECT_DIR);
+            expect(mockSourceTracking.ensureRemoteTracking).toHaveBeenCalledWith(true);
+            expect(mockSourceTracking.getStatus).toHaveBeenCalledWith({
+                local: true,
+                remote: false,
+            });
+            expect(mockSourceTracking.getConflicts).toBeCalled();
+            expect(res).toEqual({
+                local: [
+                    {
+                        fullName: 'SomeComponent',
+                        origin: 'local',
+                        path: 'path/to/file',
+                        state: ['conflict', 'add'],
+                        type: 'class',
+                    },
+                    {
+                        fullName: 'SomeComponent1',
+                        origin: 'local',
+                        path: 'path/to/file/1',
+                        state: ['delete'],
+                        type: 'class',
+                    },
+                    {
+                        fullName: 'SomeComponent2',
+                        origin: 'local',
+                        path: 'path/to/file/2',
+                        state: ['ignore', 'modify'],
+                        type: 'class',
+                    },
+                    {
+                        fullName: 'SomeComponent3',
+                        origin: 'local',
+                        path: 'path/to/file/3',
+                        state: ['ignore', 'conflict', 'nondelete'],
+                        type: 'class',
+                    },
+                    {
+                        fullName: 'NoPathComponent',
+                        origin: 'local',
+                        path: undefined,
+                        state: ['add'],
+                        type: 'metadata',
+                    },
+                ],
+                remote: [],
+            });
+        }));
+    });
+    describe('deployAndUpdateSourceTracking', () => {
+        it('deploys and update tracking given paths', () => __awaiter(void 0, void 0, void 0, function* () {
+            //Given
+            const paths = ['/path/to/component', '/path/to/component/1'];
+            const tracking = new src_1.OrgTracking({
+                connection: mockConnection,
+                projectDir: PROJECT_DIR,
+                logger: mockLogger,
+            });
+            //When
+            yield tracking.deployAndUpdateSourceTracking(paths);
+            //Then
+            expect(cwdSpy).toHaveBeenCalled();
+            // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access
+            expect(chdirSpy.mock.calls).toEqual([
+                [PROJECT_DIR],
+                ['mocked/current/working/dir'],
+            ]);
+            expect(mockComponentSet.deploy).toHaveBeenCalledWith({
+                usernameOrConnection: mockConnection,
+            });
+            expect(mockDeploy.onUpdate).toHaveBeenCalled();
+            expect(mockDeploy.pollStatus).toHaveBeenCalled();
+            expect(sfCoreSpy.Org.create).toHaveBeenCalledWith({
+                connection: mockConnection,
+            });
+            expect(sfCoreSpy.SfProject.getInstance).toHaveBeenCalledWith(PROJECT_DIR);
+            expect(mockSourceTracking.updateTrackingFromDeploy).toHaveBeenCalledWith(mockDeployResult);
+            // eslint-disable-next-line @typescript-eslint/unbound-method
+            expect(mockLogger.logDeployProgress).toBeCalledWith('Starting deploy');
+        }));
+    });
+});

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@apexdevtools/git-ops",
-  "version": "1.1.0",
+  "version": "1.2.0",
   "description": "Library to do git operations to find changed files in a given git repository",
   "author": {
     "name": "Apex Dev Tools Team",
@@ -50,7 +50,9 @@
     "typescript": "^4.9.5"
   },
   "dependencies": {
-    "install": "^0.13.0",
+    "@salesforce/core": "^3.36.1",
+    "@salesforce/source-deploy-retrieve": "8.6.0",
+    "@salesforce/source-tracking": "3.1.2",
     "simple-git": "^3.16.0"
   },
   "config": {