@ds-sfdc/sfparty 1.3.9 → 1.3.11

package/src/party/split.js

@@ -1,7 +1,7 @@
 'use strict'
 
 import path from 'path'
-import { readFile } from 'fs'
+import fs from 'fs'
 import { Parser } from 'xml2js'
 import logUpdate from 'log-update'
 import clc from 'cli-color'
@@ -84,7 +84,9 @@ export class Split {
 			) {
 				global.logger.error('Invalid information passed to split')
 				resolve(false)
-			} else if (!fileUtils.fileExists(that.metaFilePath)) {
+			} else if (
+				!fileUtils.fileExists({ filePath: that.metaFilePath, fs })
+			) {
 				global.logger.error(`file not found: ${that.metaFilePath}`)
 				resolve(false)
 			} else {
@@ -94,7 +96,7 @@ export class Split {
 				)
 				let parser = new Parser()
 				const getJSON = new Promise((resolve, reject) => {
-					readFile(that.metaFilePath, function (err, data) {
+					fs.readFile(that.metaFilePath, function (err, data) {
 						parser.parseString(data, function (err, result) {
 							if (result) {
 								resolve({

package/test/lib/file/directoryExists.spec.js

@@ -0,0 +1,43 @@
+import { directoryExists } from '../../../src/lib/fileUtils'
+
+jest.mock('fs', () => {
+	return {
+		existsSync: jest.fn(),
+		statSync: jest.fn(),
+	}
+})
+
+it('should return true if the directory exists and is a directory', () => {
+	const fs = require('fs')
+	fs.existsSync.mockReturnValue(true)
+	fs.statSync.mockReturnValue({ isDirectory: () => true })
+
+	const dirPath = '/some/directory'
+	const result = directoryExists({ dirPath, fs })
+	expect(result).toBe(true)
+	expect(fs.existsSync).toHaveBeenCalledWith(dirPath)
+	expect(fs.statSync).toHaveBeenCalledWith(dirPath)
+})
+
+it('should return false if the directory exists but is not a directory', () => {
+	const fs = require('fs')
+	fs.existsSync.mockReturnValue(true)
+	fs.statSync.mockReturnValue({ isDirectory: () => false })
+
+	const dirPath = '/some/directory'
+	const result = directoryExists({ dirPath, fs })
+	expect(result).toBe(false)
+	expect(fs.existsSync).toHaveBeenCalledWith(dirPath)
+	expect(fs.statSync).toHaveBeenCalledWith(dirPath)
+})
+
+it('should return false if the directory does not exist', () => {
+	const fs = require('fs')
+	fs.existsSync.mockReturnValue(false)
+
+	const dirPath = '/some/directory'
+	const result = directoryExists({ dirPath, fs })
+	expect(result).toBe(false)
+	expect(fs.existsSync).toHaveBeenCalledWith(dirPath)
+	expect(fs.statSync).toHaveBeenCalled()
+})

package/test/lib/file/fileExists.spec.js

@@ -0,0 +1,36 @@
+import fs from 'fs'
+import { fileExists } from '../../../src/lib/fileUtils'
+
+beforeEach(() => {
+	fs.existsSync = jest.fn()
+	fs.statSync = jest.fn()
+})
+
+it('should return true if file exists', () => {
+	fs.existsSync.mockReturnValue(true)
+	fs.statSync.mockReturnValue({ isFile: () => true })
+
+	const filePath = '/path/to/file.txt'
+	const result = fileExists({ filePath, fs })
+
+	expect(result).toBe(true)
+})
+
+it('should return false if file does not exist', () => {
+	fs.existsSync.mockReturnValue(false)
+
+	const filePath = '/path/to/file.txt'
+	const result = fileExists({ filePath, fs })
+
+	expect(result).toBe(false)
+})
+
+it('should return false if file exists but is not a file', () => {
+	fs.existsSync.mockReturnValue(true)
+	fs.statSync.mockReturnValue({ isFile: () => false })
+
+	const filePath = '/path/to/file.txt'
+	const result = fileExists({ filePath, fs })
+
+	expect(result).toBe(false)
+})

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

@@ -1,52 +1,227 @@
-import { execSync } from 'child_process'
+import { execSync, spawn } from 'child_process'
 import { existsSync } from 'fs'
 import { diff } from '../../../src/lib/gitUtils'
 
 jest.mock('fs', () => ({
-    existsSync: jest.fn()
+	existsSync: jest.fn(),
 }))
 jest.mock('child_process', () => ({
-    execSync: jest.fn()
+	execSync: jest.fn(),
 }))
-const gitRef = "HEAD~1..HEAD"
+const mockStream = {
+	setEncoding: jest.fn(),
+	on: jest.fn(),
+}
+jest.mock('child_process', () => ({
+	spawn: jest.fn(() => ({
+		stdout: mockStream,
+		stderr: mockStream,
+	})),
+}))
+
+const gitRef = 'HEAD~1..HEAD'
 
 beforeEach(() => {
-    jest.clearAllMocks()
+	jest.clearAllMocks()
+})
+
+test('rejects if directory does not exist', async () => {
+	const existsSync = jest.fn().mockReturnValueOnce(false)
+	const spawn = jest.fn()
+	try {
+		await diff({ dir: '/path/to/dir', gitRef, existsSync, spawn })
+		fail('Expected function to throw an error')
+	} catch (error) {
+		expect(error.message).toEqual(
+			'The directory "/path/to/dir" does not exist',
+		)
+	}
 })
 
-test('rejects if directory is not a git repository', async () => {
-    existsSync.mockReturnValueOnce(false)
-    try {
-        await diff('/path/to/dir')
-        fail('Expected function to throw an error', gitRef, existsSync)
-    } catch (error) {
-        expect(error.message).toEqual('The directory "/path/to/dir" is not a git repository')
-    }
+test('rejects if .git directory does not exist', async () => {
+	existsSync.mockReturnValueOnce(true).mockReturnValueOnce(false)
+
+	try {
+		await diff({ dir: '/path/to/dir', gitRef, existsSync, spawn })
+		fail('Expected function to throw an error')
+	} catch (error) {
+		expect(error.message).toEqual(
+			`The directory "/path/to/dir" is not a git repository`,
+		)
+	}
+})
+
+test('rejects when git is not installed', async () => {
+	existsSync.mockReturnValueOnce(true).mockReturnValueOnce(true)
+	const git = {
+		on: jest.fn().mockImplementationOnce((event, callback) => {
+			if (event === 'error') {
+				callback(new Error('Command failed'))
+			}
+		}),
+	}
+	spawn.mockReturnValueOnce(git)
+
+	try {
+		await diff({ dir: '/path/to/dir', existsSync, spawn })
+		fail('Expected function to throw an error')
+	} catch (error) {
+		expect(error.message).toEqual('Git is not installed on this machine')
+	}
 })
 
 test('resolves with files when git diff command is successful', async () => {
-    existsSync.mockReturnValueOnce(true).mockReturnValueOnce(true)
-    execSync.mockReturnValueOnce(
-        `A\tfile1.txt
-M\tfile2.txt
-D\tfile3.txt`)
+	existsSync.mockReturnValueOnce(true).mockReturnValueOnce(true)
+	const git = {
+		on: jest.fn((event, callback) => {
+			if (event === 'close') {
+				callback(0)
+			}
+		}),
+	}
+	const gitDiff = {
+		stdout: {
+			setEncoding: jest.fn(),
+			on: jest.fn((event, callback) => {
+				if (event === 'data') {
+					callback('A\tfile1.txt\nM\tfile2.txt\nD\tfile3.txt')
+				} else if (event === 'close') {
+					callback(0)
+				}
+			}),
+		},
+		stderr: {
+			on: jest.fn((event, callback) => {
+				if (event === 'data') {
+					callback('')
+				}
+			}),
+		},
+	}
+	spawn.mockReturnValueOnce(git).mockReturnValueOnce(gitDiff)
+
+	const files = await diff({ dir: '/path/to/dir', gitRef, existsSync, spawn })
+	expect(files).toEqual([
+		{ type: 'add', path: 'file1.txt', action: 'add' },
+		{ type: 'modify', path: 'file2.txt', action: 'add' },
+		{ type: 'delete', path: 'file3.txt', action: 'delete' },
+	])
+})
+
+test('rejects when git diff command fails', async () => {
+	existsSync.mockReturnValueOnce(true).mockReturnValueOnce(true)
+	const git = {
+		on: jest.fn((event, callback) => {
+			if (event === 'close') {
+				callback(0)
+			}
+		}),
+	}
+	const gitDiff = {
+		stderr: {
+			on: jest.fn(),
+		},
+		stdout: {
+			setEncoding: jest.fn(),
+			on: jest.fn(),
+		},
+	}
+	gitDiff.stderr.on.mockImplementation((_, cb) => cb('Command failed'))
+	spawn.mockReturnValueOnce(git).mockReturnValueOnce(gitDiff)
+
+	try {
+		await diff({ dir: '/path/to/dir', gitRef, existsSync, spawn })
+		fail('Expected function to throw an error')
+	} catch (error) {
+		expect(error.message).toEqual(
+			'git diff command failed with error: Command failed',
+		)
+	}
+})
 
-    const files = await diff('/path/to/dir', gitRef, existsSync, execSync)
-    expect(files).toEqual([
-        { type: 'add', path: 'file1.txt', action: 'add' },
-        { type: 'modify', path: 'file2.txt', action: 'add' },
-        { type: 'delete', path: 'file3.txt', action: 'delete' }
-    ])
+test('ignores files when git diff output does not have a tab character', async () => {
+	existsSync.mockReturnValueOnce(true).mockReturnValueOnce(true)
+	const git = {
+		on: jest.fn((event, callback) => {
+			if (event === 'close') {
+				callback(0)
+			}
+		}),
+	}
+	const gitDiff = {
+		stderr: {
+			on: jest.fn(),
+		},
+		stdout: {
+			setEncoding: jest.fn(),
+			on: jest.fn((event, callback) => {
+				if (event === 'data') {
+					callback(`\t\t\nA\tfile1.txt\nM\tfile2.txt\nfile3.txt\n`)
+				}
+				if (event === 'close') {
+					callback(0)
+				}
+			}),
+		},
+	}
+	spawn.mockReturnValueOnce(git).mockReturnValueOnce(gitDiff)
+
+	const files = await diff({ dir: '/path/to/dir', gitRef, existsSync, spawn })
+	expect(files).toEqual([
+		{ type: 'add', path: 'file1.txt', action: 'add' },
+		{ type: 'modify', path: 'file2.txt', action: 'add' },
+	])
+})
+
+test('rejects when git --version command fails', async () => {
+	existsSync.mockReturnValueOnce(true).mockReturnValueOnce(true)
+	const git = {
+		on: jest.fn((event, callback) => {
+			if (event === 'close') {
+				callback(1)
+			}
+		}),
+	}
+	spawn.mockReturnValueOnce(git)
+
+	try {
+		await diff({ dir: '/path/to/dir', gitRef, existsSync, spawn })
+		fail('Expected function to throw an error')
+	} catch (error) {
+		expect(error.message).toEqual(
+			'git --version command failed with code 1',
+		)
+	}
 })
 
 test('rejects when git diff command fails', async () => {
-    existsSync.mockReturnValueOnce(true).mockReturnValueOnce(true)
-    execSync.mockImplementation(() => { throw new Error('Command failed') })
-
-    try {
-        await diff('/path/to/dir', gitRef, existsSync, execSync)
-        fail('Expected function to throw an error')
-    } catch (error) {
-        expect(error.message).toEqual('Command failed')
-    }
+	existsSync.mockReturnValueOnce(true).mockReturnValueOnce(true)
+	const git = {
+		on: jest.fn((event, callback) => {
+			if (event === 'close') {
+				callback(0)
+			}
+		}),
+	}
+	const gitDiff = {
+		stderr: {
+			on: jest.fn(),
+		},
+		stdout: {
+			setEncoding: jest.fn(),
+			on: jest.fn((event, callback) => {
+				if (event === 'close') {
+					callback(1)
+				}
+			}),
+		},
+	}
+	spawn.mockReturnValueOnce(git).mockReturnValueOnce(gitDiff)
+
+	try {
+		await diff({ dir: '/path/to/dir', gitRef, existsSync, spawn })
+		fail('Expected function to throw an error')
+	} catch (error) {
+		expect(error.message).toEqual('git diff command failed with code 1')
+	}
 })

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

@@ -1,69 +1,136 @@
 import path from 'path'
-import { execSync } from 'child_process'
-import * as fileUtils from '../../../src/lib/fileUtils.js'
+import fs from 'fs'
+import child_process, { execSync } from 'child_process'
 import { lastCommit } from '../../../src/lib/gitUtils.js'
-import { existsSync } from 'fs'
 
-const dir = '/test/sfparty'
+const dir = '/test'
 const fileName = 'index.yaml'
-const folder = path.resolve(dir, '.sfdx', 'sfparty')
-const filePath = path.resolve(folder, fileName)
 
-jest.mock('fs', () => ({
-    existsSync: jest.fn()
-}))
+const fileUtils = {
+	createDirectory: jest.fn(),
+	readFile: jest.fn((filePath) => {
+		if (filePath.indexOf('project') !== -1) {
+			return { git: { lastCommit: 'lastCommit' } }
+		}
+	}),
+	fileExists: jest.fn((filePath) => {
+		if (filePath.indexOf('project') !== -1) {
+			return true
+		}
+		return false
+	}),
+}
 
-jest.mock('../../../src/lib/fileUtils.js', () => {
-    return {
-        createDirectory: jest.fn(),
-        readFile: jest.fn()
-    }
+jest.mock('fs', () => {
+	return {
+		existsSync: jest.fn(),
+		statSync: jest.fn(),
+	}
 })
 
-jest.mock('child_process', () => {
-    return {
-        execSync: jest.fn()
-    }
+beforeEach(() => {
+	jest.clearAllMocks()
+	jest.mock('child_process', () => ({
+		execSync: jest.fn(() => {
+			return 'testCommit'
+		}),
+	}))
 })
 
-beforeEach(() => {
-    jest.resetAllMocks()
+test('should return lastCommit and latestCommit if file exists', async () => {
+	fs.existsSync.mockReturnValue(true)
+	const result = await lastCommit({
+		dir: 'project',
+		existsSync: fs.existsSync,
+		execSync: require('child_process').execSync,
+		fileUtils,
+	})
+	expect(result).toEqual({
+		lastCommit: 'lastCommit',
+		latestCommit: 'testCommit',
+	})
 })
 
-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 })
+test('should return only latestCommit if file does not exist', async () => {
+	fs.existsSync.mockReturnValue(false)
+	fileUtils.fileExists.mockReturnValue(false)
+	const result = await lastCommit({
+		dir: __dirname,
+		existsSync: fs.existsSync,
+		execSync: require('child_process').execSync,
+		fileUtils,
+	})
+	expect(result).toEqual({
+		lastCommit: undefined,
+		latestCommit: 'testCommit',
+	})
 })
 
-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', async () => {
+	jest.spyOn(fs, 'existsSync').mockImplementation(() => false)
+	try {
+		await lastCommit({
+			dir,
+			fileName,
+			existsSync: fs.existsSync,
+			execSync: require('child_process').execSync,
+			fileUtils,
+		})
+	} catch (e) {
+		expect(e.message).toBe(
+			`ENOENT: no such file or directory, access '${path.join(
+				dir,
+				'.sfdx',
+				'sfparty',
+				fileName,
+			)}'`,
+		)
+	}
 })
 
-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)
+it('should return only latest commit if lastCommit is undefined', async () => {
+	jest.spyOn(fs, 'existsSync').mockImplementation(() => true)
+	jest.spyOn(fileUtils, 'readFile').mockImplementation(() => ({ git: {} }))
+	jest.spyOn(child_process, 'execSync').mockImplementation(
+		() => 'latestCommit',
+	)
+
+	const result = await lastCommit({
+		dir: '/test',
+		fileUtils,
+		fs,
+		existsSync: fs.existsSync,
+		execSync: child_process.execSync,
+	})
+
+	expect(result).toEqual({
+		lastCommit: undefined,
+		latestCommit: 'latestCommit',
+	})
+	expect(fs.existsSync).toHaveBeenCalledWith('/test/.sfdx/sfparty/index.yaml')
+	expect(fileUtils.readFile).toHaveBeenCalledWith(
+		'/test/.sfdx/sfparty/index.yaml',
+	)
+	expect(child_process.execSync).toHaveBeenCalledWith(
+		'git log --format=format:%H -1',
+		{ cwd: '/test', encoding: 'utf-8' },
+	)
+})
+
+test('should throw an error when execSync returns an error', async () => {
+	jest.spyOn(child_process, 'execSync').mockImplementation(() => {
+		throw new Error('execSync error')
+	})
+
+	try {
+		await lastCommit({
+			dir: '/test',
+			fileUtils,
+			fs,
+			existsSync: fs.existsSync,
+			execSync: child_process.execSync,
+		})
+	} catch (e) {
+		expect(e.message).toBe('execSync error')
+	}
 })