@ds-sfdc/sfparty 1.2.6 → 1.3.1

package/test/lib/git/lastCommit.spec.js

@@ -0,0 +1,69 @@
+import path from 'path'
+import { execSync } from 'child_process'
+import * as fileUtils from '../../../src/lib/fileUtils.js'
+import { lastCommit } from '../../../src/lib/gitUtils.js'
+import { existsSync } from 'fs'
+
+const dir = '/test/sfparty'
+const fileName = 'index.yaml'
+const folder = path.resolve(dir, '.sfdx', 'sfparty')
+const filePath = path.resolve(folder, fileName)
+
+jest.mock('fs', () => ({
+    existsSync: jest.fn()
+}))
+
+jest.mock('../../../src/lib/fileUtils.js', () => {
+    return {
+        createDirectory: jest.fn(),
+        readFile: jest.fn()
+    }
+})
+
+jest.mock('child_process', () => {
+    return {
+        execSync: jest.fn()
+    }
+})
+
+beforeEach(() => {
+    jest.resetAllMocks()
+})
+
+it('should return the last commit and latest commit', () => {
+    const lastCommitHash = '16d69f0cf3d902a900a0609177fe5cf0fda9a961'
+    const latestCommitHash = '16d69f0cf3d902a900a0609177fe5cf0fda9a961'
+    fileUtils.createDirectory.mockReturnValue(undefined)
+    fileUtils.readFile.mockReturnValue({ git: { lastCommit: lastCommitHash } })
+    execSync.mockReturnValue(latestCommitHash)
+    existsSync.mockReturnValueOnce(true).mockReturnValueOnce(true)
+    const result = lastCommit(dir, fileName, existsSync, execSync, fileUtils)
+    expect(fileUtils.createDirectory).toHaveBeenCalledWith(folder)
+    expect(fileUtils.readFile).toHaveBeenCalledWith(filePath)
+    expect(execSync).toHaveBeenCalledWith(`git log --format=format:%H -1`, { cwd: dir, encoding: 'utf-8' })
+    expect(result).toEqual({lastCommit: lastCommitHash, latestCommit: latestCommitHash })
+})
+
+it('should return the latest commit if no lastCommit is found', () => {
+    const latestCommit = '16d69f0cf3d902a900a0609177fe5cf0fda9a961'
+    fileUtils.createDirectory.mockReturnValue(undefined)
+    fileUtils.readFile.mockReturnValue({ git: {} })
+    execSync.mockReturnValue(latestCommit)
+    existsSync.mockReturnValueOnce(true).mockReturnValueOnce(true)
+    const result = lastCommit(dir, fileName, existsSync, execSync, fileUtils)
+    expect(fileUtils.createDirectory).toHaveBeenCalledWith(folder)
+    expect(fileUtils.readFile).toHaveBeenCalledWith(filePath)
+    expect(execSync).toHaveBeenCalledWith(`git log --format=format:%H -1`, { cwd: dir, encoding: 'utf-8' })
+    expect(result).toEqual({ lastCommit: undefined, latestCommit })
+})
+
+it('should throw an error when fileUtils.readFile is called', () => {
+    const errorMessage = 'Unable to read file'
+    fileUtils.createDirectory.mockReturnValue(undefined)
+    fileUtils.readFile.mockImplementation(() => { throw new Error(errorMessage) })
+    execSync.mockReturnValue(undefined)
+    existsSync.mockReturnValueOnce(true).mockReturnValueOnce(true)
+    expect(() => lastCommit(dir, fileName, existsSync, execSync, fileUtils)).toThrowError(errorMessage)
+    expect(fileUtils.createDirectory).toHaveBeenCalledWith(folder)
+    expect(fileUtils.readFile).toHaveBeenCalledWith(filePath)
+})

package/test/lib/git/log.spec.js

@@ -0,0 +1,33 @@
+import { execSync } from 'child_process'
+import * as os from 'os'
+import { log } from '../../../src/lib/gitUtils'
+
+jest.mock('child_process', () => {
+    return {
+        execSync: jest.fn()
+    }
+})
+
+describe('log', () => {
+    beforeEach(() => {
+        jest.resetAllMocks()
+    })
+
+    it('should return an array of git commit hashes', () => {
+        const commits = ['1234567890abcdef', '234567890abcdef1', '34567890abcdef12']
+        execSync.mockReturnValue(commits.join(os.EOL))
+        const dir = process.cwd()
+        const gitRef = 'HEAD~1..HEAD'
+        const result = log(dir, gitRef, execSync)
+        expect(execSync).toHaveBeenCalledWith(`git log --format=format:%H ${gitRef}`, { cwd: dir, encoding: 'utf-8' })
+        expect(result).toEqual(commits)
+    })
+
+    it('should throw an error if git is not installed or no entry found in path', () => {
+        const error = { message: 'ENOENT' }
+        execSync.mockImplementation(() => { throw error })
+        const dir = process.cwd()
+        const gitRef = 'HEAD~1..HEAD'
+        expect(() => log(dir, gitRef, execSync)).toThrowError('git not installed or no entry found in path')
+    })
+})

package/test/lib/git/updateLastCommit.spec.js

@@ -0,0 +1,65 @@
+import path from 'path'
+import * as fileUtils from '../../../src/lib/fileUtils.js'
+import { updateLastCommit } from '../../../src/lib/gitUtils.js'
+
+jest.mock('../../../src/lib/fileUtils.js', () => {
+    return {
+        fileExists: jest.fn(),
+        readFile: jest.fn(),
+        saveFile: jest.fn()
+    }
+})
+
+beforeEach(() => {
+    jest.resetModules()
+})
+
+afterEach(() => {
+    jest.clearAllMocks()
+})
+
+it('throws error when latest is not a string or undefined', () => {
+    expect(() => updateLastCommit('dir', {})).toThrowError(/string/)
+})
+
+it('saves file with updated last commit', () => {
+    const dir = 'dir'
+    const latest = 'latest'
+    const folder = path.join(dir, '.sfdx', 'sfparty')
+    const fileName = path.join(folder, 'index.yaml')
+    const data = { git: { lastCommit: 'old' } }
+
+    fileUtils.fileExists.mockReturnValue(true)
+    fileUtils.readFile.mockReturnValue(data)
+
+    updateLastCommit(dir, latest, fileUtils)
+
+    expect(fileUtils.fileExists).toHaveBeenCalledWith(fileName)
+    expect(fileUtils.readFile).toHaveBeenCalledWith(fileName)
+    expect(fileUtils.saveFile).toHaveBeenCalledWith({ git: { lastCommit: latest } }, fileName)
+})
+
+it('creates file with default definition if it does not exist', () => {
+    const dir = 'dir'
+    const latest = 'latest'
+    const folder = path.join(dir, '.sfdx', 'sfparty')
+    const fileName = path.join(folder, 'index.yaml')
+    const defaultDefinition = {
+        git: {
+            lastCommit: latest,
+            latestCommit: undefined,
+        },
+        local: {
+            lastDate: undefined,
+        }
+    }
+
+    fileUtils.fileExists.mockReturnValue(false)
+    expect(fileUtils.readFile).not.toHaveBeenCalled()
+
+    updateLastCommit(dir, latest, fileUtils)
+
+    expect(fileUtils.fileExists).toHaveBeenCalledWith(fileName)
+    expect(fileUtils.readFile).not.toHaveBeenCalled()
+    expect(fileUtils.saveFile).toHaveBeenCalledWith(defaultDefinition, fileName)
+})

package/test/root.spec.js

@@ -0,0 +1,7 @@
+const sum = (a, b) => {
+    return a + b
+}
+
+test('adds 1 + 2 to equal 3', () => {
+    expect(sum(1, 2)).toBe(3)
+})

package/test_mocha/lib/fileUtils.js

@@ -0,0 +1,374 @@
+import fs from 'fs'
+import path from 'path'
+import * as yaml from 'js-yaml'
+import { Parser } from 'xml2js'
+import { expect } from 'chai'
+import sinon from 'sinon'
+import {
+    directoryExists,
+    fileExists,
+    createDirectory,
+    deleteDirectory,
+    getFiles,
+    getDirectories,
+    deleteFile,
+    fileInfo,
+    saveFile,
+    readFile,
+    writeFile
+} from '../../src/lib/fileUtils.js'
+
+describe('fileUtils', () => {
+    describe('directoryExists', () => {
+        let sandbox
+        beforeEach(() => {
+            sandbox = sinon.createSandbox()
+        })
+        afterEach(() => {
+            sandbox.restore()
+        })
+
+        it('should return true if directory exists', () => {
+            sandbox.stub(fs, 'existsSync').returns(true)
+            sandbox.stub(fs, 'statSync').returns({ isDirectory: () => true })
+            expect(directoryExists('/path/to/directory', fs)).to.be.true
+        })
+        it('should return false if directory does not exist', () => {
+            sandbox.stub(fs, 'existsSync').returns(false)
+            expect(directoryExists('/path/to/directory', fs)).to.be.false
+        })
+        it('should return false if directory exists but is not a directory', () => {
+            sandbox.stub(fs, 'existsSync').returns(true)
+            sandbox.stub(fs, 'statSync').returns({ isDirectory: () => false })
+            expect(directoryExists('/path/to/directory', fs)).to.be.false
+        })
+    })
+
+    describe('fileExists', () => {
+        let sandbox
+        beforeEach(() => {
+            sandbox = sinon.createSandbox()
+        })
+        afterEach(() => {
+            sandbox.restore()
+        })
+
+        it('should return true if file exists', () => {
+            sandbox.stub(fs, 'existsSync').returns(true)
+            sandbox.stub(fs, 'statSync').returns({ isFile: () => true })
+            expect(fileExists('/path/to/file', fs)).to.be.true
+        })
+        it('should return false if file does not exist', () => {
+            sandbox.stub(fs, 'existsSync').returns(false)
+            expect(fileExists('/path/to/file', fs)).to.be.false
+        })
+        it('should return false if file exists but is not a file', () => {
+            sandbox.stub(fs, 'existsSync').returns(true)
+            sandbox.stub(fs, 'statSync').returns({ isFile: () => false })
+            expect(fileExists('/path/to/file', fs)).to.be.false
+        })
+    })
+
+    describe('createDirectory', () => {
+        let sandbox
+        beforeEach(() => {
+            sandbox = sinon.createSandbox()
+        })
+        afterEach(() => {
+            sandbox.restore()
+        })
+        it('should create directory if it does not exist', () => {
+            sandbox.stub(fs, 'existsSync').returns(false)
+            sandbox.stub(fs, 'mkdirSync')
+            createDirectory('/path/to/directory', fs)
+            sinon.assert.calledOnce(fs.mkdirSync)
+        })
+        it('should not create directory if it already exists', () => {
+            sandbox.stub(fs, 'existsSync').returns(true)
+            sandbox.stub(fs, 'mkdirSync')
+            createDirectory('/path/to/directory', fs)
+            sinon.assert.notCalled(fs.mkdirSync)
+        })
+    })
+
+    describe('deleteDirectory', () => {
+        let sandbox
+        beforeEach(() => {
+            sandbox = sinon.createSandbox()
+        })
+        afterEach(() => {
+            sandbox.restore()
+        })
+
+        it('should delete directory if it exists', () => {
+            sandbox.stub(fs, 'existsSync').returns(true)
+            sandbox.stub(fs, 'readdirSync').returns([])
+            sandbox.stub(fs, 'statSync').returns({ isDirectory: () => true })
+            sandbox.stub(fs, 'rmdirSync')
+            deleteDirectory('/path/to/directory', false, fs)
+            sinon.assert.calledOnce(fs.rmdirSync)
+        })
+        it('should not delete directory if it does not exist', () => {
+            sandbox.stub(fs, 'existsSync').returns(false)
+            sandbox.stub(fs, 'statSync').returns({ isDirectory: () => false })
+            sandbox.stub(fs, 'rmdirSync')
+            deleteDirectory('/path/to/directory', false, fs)
+            sinon.assert.notCalled(fs.rmdirSync)
+        })
+        it('should delete directory and files', () => {
+            sandbox.stub(fs, 'existsSync').returns(true)
+            sandbox.stub(fs, 'readdirSync').returns(['file1.txt', 'file2.txt'])
+            sandbox.stub(fs, 'statSync').returns({ isDirectory: () => true })
+            sandbox.stub(fs, 'lstatSync').returns({ isDirectory: () => false })
+            sandbox.stub(fs, 'unlinkSync')
+            sandbox.stub(fs, 'rmdirSync')
+            deleteDirectory('/path/to/directory', false, fs)
+            sinon.assert.calledTwice(fs.unlinkSync)
+            sinon.assert.calledOnce(fs.rmdirSync)
+        })
+    })
+
+    describe('getFiles', () => {
+        let sandbox
+        beforeEach(() => {
+            sandbox = sinon.createSandbox()
+        })
+        afterEach(() => {
+            sandbox.restore()
+        })
+
+        it('should return all files in the directory if filter is undefined', () => {
+            sandbox.stub(fs, 'existsSync').returns(true)
+            sandbox.stub(fs, 'statSync').returns({ isDirectory: () => true })
+            sandbox.stub(fs, 'readdirSync').returns(['file1.txt', 'file2.txt', 'file3.jpg'])
+            let files = getFiles('/path/to/directory', undefined, fs)
+            expect(files).to.deep.equal(['file1.txt', 'file2.txt', 'file3.jpg'])
+        })
+
+        it('should return filtered files in the directory if filter is provided', () => {
+            sandbox.stub(fs, 'existsSync').returns(true)
+            sandbox.stub(fs, 'statSync').returns({ isDirectory: () => true })
+            sandbox.stub(fs, 'readdirSync').returns(['file1.txt', 'file2.txt', 'file3.jpg', 'file4.yaml'])
+            let files = getFiles('/path/to/directory', '.yaml', fs)
+            expect(files).to.deep.equal(['file4.yaml'])
+        })
+
+        it('should return empty array if directory does not exist', () => {
+            sandbox.stub(fs, 'existsSync').returns(false)
+            sandbox.stub(fs, 'statSync').returns({ isDirectory: () => true })
+            sandbox.stub(fs, 'readdirSync').returns(['file1.txt', 'file2.txt'])
+            let files = getFiles('/path/to/directory', '.yaml', fs)
+            expect(files).to.deep.equal([])
+        })
+    })
+
+    describe('getDirectories', () => {
+        let sandbox
+        beforeEach(() => {
+            sandbox = sinon.createSandbox()
+        })
+        afterEach(() => {
+            sandbox.restore()
+        })
+
+        it('should return all directories in the directory', () => {
+            sandbox.stub(fs, 'existsSync').returns(true)
+            sandbox.stub(fs, 'statSync').returns({ isDirectory: () => true })
+            sandbox.stub(fs, 'readdirSync').returns([
+                { name: 'dir1', isDirectory: () => true },
+                { name: 'file1.txt', isDirectory: () => false },
+                { name: 'dir2', isDirectory: () => true },
+                { name: 'file2.txt', isDirectory: () => false }
+            ])
+            let dirs = getDirectories('/path/to/directory', fs)
+            expect(dirs).to.deep.equal(['dir1', 'dir2'])
+        })
+
+        it('should return empty array if directory does not exist', () => {
+            sandbox.stub(fs, 'existsSync').returns(false)
+            let dirs = getDirectories('/path/to/directory', fs)
+            expect(dirs).to.deep.equal([])
+        })
+    })
+
+    describe('deleteFile', () => {
+        let sandbox
+        beforeEach(() => {
+            sandbox = sinon.createSandbox()
+        })
+        afterEach(() => {
+            sandbox.restore()
+        })
+
+        it('should delete the file if it exists', () => {
+            sandbox.stub(fs, 'existsSync').returns(true)
+            sandbox.stub(fs, 'statSync').returns({ isFile: () => true })
+            sandbox.stub(fs, 'unlinkSync')
+            deleteFile('path/to/file.txt', fs)
+            sinon.assert.calledOnce(fs.unlinkSync)
+        })
+
+
+        it('should not delete the file if it does not exist', () => {
+            sandbox.stub(fs, 'existsSync').returns(false)
+            sandbox.stub(fs, 'unlinkSync')
+            deleteFile('/path/to/file.txt', fs)
+            sinon.assert.notCalled(fs.unlinkSync)
+        })
+    })
+
+    describe('fileInfo', () => {
+        let sandbox
+        beforeEach(() => {
+            sandbox = sinon.createSandbox()
+        })
+        afterEach(() => {
+            sandbox.restore()
+        })
+
+        it('should return file information if file exists', () => {
+            sandbox.stub(path, 'parse').returns({
+                dir: 'path/to',
+                base: 'existingfile.txt',
+                ext: '.txt',
+                name: 'existingfile'
+            })
+            sandbox.stub(fs, 'existsSync').returns(true)
+            sandbox.stub(fs, 'statSync').returns({
+                size: 12345,
+                birthtime: new Date()
+            })
+            let fileResult = fileInfo('path/to/existingfile.txt', fs)
+            expect(fileResult).to.have.property('dirname', 'path/to')
+            expect(fileResult).to.have.property('basename', 'existingfile')
+            expect(fileResult).to.have.property('filename', 'existingfile.txt')
+            expect(fileResult).to.have.property('extname', '.txt')
+            expect(fileResult).to.have.property('exists', true)
+            expect(fileResult).to.have.property('stats')
+            expect(fileResult.stats).to.have.property('size', 12345)
+            expect(fileResult.stats.birthtime).to.be.a('date')
+        })
+    })
+
+    describe('saveFile', () => {
+        let sandbox
+        beforeEach(() => {
+            sandbox = sinon.createSandbox()
+        })
+
+        afterEach(() => {
+            sandbox.restore()
+        })
+
+        it('should write json file correctly', () => {
+            const json = { key: 'value' }
+            const fileName = 'test.json'
+            const format = 'json'
+            const fs = { writeFileSync: sandbox.stub() }
+
+            expect(saveFile(json, fileName, format, fs)).to.be.true
+            sinon.assert.calledWith(fs.writeFileSync, fileName, JSON.stringify(json, null, '\t'))
+        })
+
+        it('should write yaml file correctly', () => {
+            const json = { key: 'value' }
+            const fileName = 'test.yaml'
+            const format = 'yaml'
+            const fs = { writeFileSync: sandbox.stub() }
+
+            expect(saveFile(json, fileName, format, fs)).to.be.true
+            sinon.assert.calledWith(fs.writeFileSync, fileName, yaml.dump(json))
+        })
+
+        it('should return true if format is not json or yaml', () => {
+            const json = { key: 'value' }
+            const fileName = 'test.yaml'
+            const format = 'txt'
+            const fs = { writeFileSync: sandbox.stub() }
+
+            expect(saveFile(json, fileName, format, fs)).to.be.true
+            sinon.assert.notCalled(fs.writeFileSync)
+        })
+    })
+
+    describe('readFile', () => {
+        let sandbox
+        beforeEach(() => {
+            sandbox = sinon.createSandbox()
+            sandbox.stub(fs, 'existsSync').returns(true)
+            sandbox.stub(fs, 'statSync').returns({ isFile: () => true })
+        })
+
+        afterEach(() => {
+            sandbox.restore()
+        })
+
+        it('should read json file correctly with convert as true', () => {
+            const fileName = 'test.json'
+            const json = { key: 'value' }
+            sandbox.stub(fs, 'readFileSync').returns(JSON.stringify(json))
+
+            expect(readFile(fileName, true, fs)).to.deep.equal(json)
+            sinon.assert.calledWith(fs.readFileSync, fileName)
+        })
+
+        it('should read yaml file correctly with convert as true', () => {
+            const fileName = 'test.yaml'
+            const json = { key: 'value' }
+            sandbox.stub(fs, 'readFileSync').returns(yaml.dump(json))
+
+            expect(readFile(fileName, true, fs)).to.deep.equal(json)
+            sinon.assert.calledWith(fs.readFileSync, fileName)
+        })
+
+        it('should return string content of file with convert as false', () => {
+            const fileName = 'test.txt'
+            const content = 'test content'
+            sandbox.stub(fs, 'readFileSync').returns(content)
+
+            expect(readFile(fileName, false, fs)).to.equal(content)
+            sinon.assert.calledWith(fs.readFileSync, fileName)
+        })
+
+        it('should return string content of file if file extension is not json, yaml, or xml', () => {
+            const fileName = 'test.txt'
+            const json = { key: 'value' }
+            sandbox.stub(fs, 'readFileSync').returns(JSON.stringify(json))
+
+            expect(readFile(fileName, true, fs)).to.equal(JSON.stringify(json))
+            sinon.assert.calledWith(fs.readFileSync, fileName)
+        })
+    })
+    
+    describe('writeFile', () => {
+        let sandbox;
+        beforeEach(() => {
+            sandbox = sinon.createSandbox();
+            sandbox.stub(fs, 'writeFileSync');
+            sandbox.stub(fs, 'utimesSync');
+        });
+    
+        afterEach(() => {
+            sandbox.restore();
+        });
+    
+        it('should write json file correctly', async () => {
+            const fileName = 'test.json';
+            const json = { key: 'value' };
+    
+            writeFile(fileName, JSON.stringify(json, null, '\t'), null, null, fs);
+            sinon.assert.calledWith(fs.writeFileSync, fileName, JSON.stringify(json, null, '\t'));
+            sinon.assert.calledOnce(fs.utimesSync);
+        });
+    
+        it('should write yaml file correctly', async () => {
+            const fileName = 'test.yaml';
+            const json = { key: 'value' };
+    
+            writeFile(fileName, yaml.dump(json), null, null, fs);
+            sinon.assert.calledWith(fs.writeFileSync, fileName, yaml.dump(json));
+            sinon.assert.calledOnce(fs.utimesSync);
+        });
+    });
+        
+})

package/test_mocha/lib/git.js

@@ -0,0 +1,82 @@
+import { expect } from 'chai'
+import sinon from 'sinon'
+import fs from 'fs'
+import child_process from 'child_process'
+import { diff, log } from '../../src/lib/gitUtils.js'
+
+describe('git', () => {
+
+    describe('diff function', () => {
+        let sandbox
+        beforeEach(() => {
+            sandbox = sinon.createSandbox()
+        })
+
+        afterEach(() => {
+            sandbox.restore()
+        })
+
+        it('should return files array if dir and gitRef are provided', async () => {
+            sandbox.stub(fs, 'existsSync').returns(true)
+            sandbox.stub(child_process, 'execSync').returns('A\tfile1\nM\tfile2\nD\tfile3')
+    
+            const result = await diff('/path/to/dir', 'HEAD', fs.existsSync, child_process.execSync)
+            expect(result).to.deep.equal([
+                { type: 'add', path: 'file1', action: 'add' },
+                { type: 'modify', path: 'file2', action: 'add' },
+                { type: 'delete', path: 'file3', action: 'delete' }
+            ])
+        })
+
+        it('should throw an error if dir is not a git repository', async () => {
+            sandbox.stub(fs, 'existsSync').returns(false)
+    
+            try {
+                await diff('/path/to/dir', 'HEAD', fs.existsSync, child_process.execSync)
+                throw new Error('Unexpected behavior')
+            } catch (error) {
+                expect(error.message).to.equal(`The directory "/path/to/dir" is not a git repository`)
+            }
+        })
+
+        it('should throw an error if gitRef not exist', async () => {
+            sandbox.stub(fs, 'existsSync').returns(true)
+            sandbox.stub(child_process, 'execSync').throws(new Error('gitRef not exist'))
+            try {
+                await diff('/path/to/dir', 'HEAD', fs.existsSync, child_process.execSync)
+                throw new Error('Unexpected behavior')
+            } catch (error) {
+                expect(error.message).to.equal(`gitRef not exist`)
+            }
+        })
+    })
+
+    describe('log', () => {
+        let sandbox
+        beforeEach(() => {
+            sandbox = sinon.createSandbox()
+        })
+    
+        afterEach(() => {
+            sandbox.restore()
+        })
+    
+        it('should return an array of commits', () => {
+            // Stub execSync to return a string of commits
+            sandbox.stub(child_process, 'execSync').returns('abc123\ndef456\nghi789')
+    
+            const commits = log('/path/to/repo', 'master', child_process.execSync)
+    
+            expect(commits).to.deep.equal(['abc123', 'def456', 'ghi789'])
+        })
+    
+        it('should throw an error if git is not installed', () => {
+            // Stub execSync to throw an ENOENT error
+            sandbox.stub(child_process, 'execSync').throws(new Error('ENOENT'))
+    
+            expect(() => log('/path/to/repo', 'master', child_process.execSync)).to.throw('git not installed or no entry found in path')
+        })
+    })        
+})
+
+

package/test_mocha/lib/gitUtils.js

@@ -0,0 +1,54 @@
+import * as git from '../../src/lib/gitUtils.js'
+import chai from 'chai'
+import chaiAsPromised from 'chai-as-promised'
+import fs from 'fs'
+import path from 'path'
+import * as yaml from 'js-yaml'
+
+
+chai.use(chaiAsPromised)
+const expect = chai.expect
+
+describe('git Util', () => {
+    describe('lastCommit function', () => {
+        it('should return an error if the file is not in the repository', async () => {
+            try {
+                await git.lastCommit(process.cwd(), 'invalid-index.yaml')
+            } catch (err) {
+                expect(err.message).to.equal('file not found in repository')
+            }
+        })
+    
+        it('should return an error if git is not installed or not in PATH', async () => {
+            try {
+                await git.lastCommit(process.cwd())
+            } catch (err) {
+                expect(err.message).to.equal('git not installed or no entry found in path')
+            }
+        })
+        
+        it('should return the last commit hash for a given file', async () => {
+            const commitHash = await git.lastCommit(process.cwd())
+            expect(commitHash).to.be.an('object')
+            expect(commitHash).to.have.all.keys('lastCommit', 'latestCommit')
+            expect(commitHash.lastCommit).to.satisfy(val => val === undefined || (val.length === 40 && /^[a-f0-9]+$/.test(val)))
+            expect(commitHash.latestCommit).to.satisfy(val =>val === undefined || (val.length === 40 && /^[a-f0-9]+$/.test(val)))
+        })
+    })
+
+    describe('updateLastCommit function', () => {
+        it('should update the last commit hash for a file', async () => {
+            const dir = process.cwd()
+            const commitHash = await git.lastCommit(dir)
+            const lastCommitHash = '16d69f0cf3d902a900a0609177fe5cf0fda9a965'
+            git.updateLastCommit(dir, lastCommitHash)
+            const folder = path.join(dir, '.sfdx', 'sfparty')
+            const fileName = path.join(folder, 'index.yaml')
+            const fileData1 = yaml.load(fs.readFileSync(fileName))
+            expect(fileData1.git.lastCommit).to.equal(lastCommitHash)
+            git.updateLastCommit(dir, commitHash.lastCommit)
+            const fileData2 = yaml.load(fs.readFileSync(fileName))
+            expect(fileData2.git.lastCommit).to.satisfy((val) => val === commitHash.lastCommit)
+        })
+    })
+})