@ds-sfdc/sfparty 1.7.9 → 3.0.0

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

@@ -1,227 +0,0 @@
-import { execSync, spawn } from 'child_process'
-import { existsSync } from 'fs'
-import { diff } from '../../../src/lib/gitUtils'
-
-jest.mock('fs', () => ({
-	existsSync: jest.fn(),
-}))
-jest.mock('child_process', () => ({
-	execSync: jest.fn(),
-}))
-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()
-})
-
-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 .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)
-	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',
-		)
-	}
-})
-
-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)
-	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,163 +0,0 @@
-import path from 'path'
-import fs from 'fs'
-import child_process, { execSync } from 'child_process'
-import { lastCommit } from '../../../src/lib/gitUtils.js'
-
-const dir = '/test'
-const fileName = 'index.yaml'
-
-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('fs', () => {
-	return {
-		existsSync: jest.fn(),
-		statSync: jest.fn(),
-	}
-})
-
-beforeEach(() => {
-	jest.clearAllMocks()
-	jest.mock('child_process', () => ({
-		execSync: jest.fn(() => {
-			return 'testCommit'
-		}),
-	}))
-})
-
-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',
-	})
-})
-
-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 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 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')
-	}
-})
-
-// Mock execSync to simulate branch detection
-jest.mock('child_process', () => ({
-	...jest.requireActual('child_process'),
-	execSync: jest.fn((command) => {
-		if (command === 'git rev-parse --abbrev-ref HEAD') {
-			return 'currentBranch' // Simulate current branch name
-		}
-		return 'testCommit' // Simulate latest commit hash
-	}),
-}))
-
-test('should throw an error when execSync returns an error', async () => {
-	jest.spyOn(child_process, 'execSync').mockImplementationOnce(() => {
-		throw new Error('execSync error')
-	})
-
-	await expect(
-		lastCommit({
-			dir: '/test',
-			fileUtils,
-			fs,
-			existsSync: fs.existsSync,
-			execSync: child_process.execSync,
-		}),
-	).rejects.toThrow('execSync error')
-})

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

@@ -1,31 +0,0 @@
-import { execSync } from 'child_process'
-import * as os from 'os'
-import { log } from '../../../src/lib/gitUtils'
-
-jest.mock('child_process', () => {
-    return {
-        execSync: jest.fn()
-    }
-})
-
-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

@@ -1,79 +0,0 @@
-import * as fileUtils from '../../../src/lib/fileUtils.js'
-import { updateLastCommit } from '../../../src/lib/gitUtils.js'
-import { execSync } from 'child_process'
-
-let dir, latest
-
-beforeEach(() => {
-	dir = '/test/directory'
-	latest = '1234567890abcdef'
-})
-
-afterEach(() => {
-	jest.resetModules()
-})
-
-it('should throw an error if latest is not a string', () => {
-	latest = {}
-	expect(() => updateLastCommit({ dir, latest, fileUtils })).toThrowError(
-		'updateLastCommit received a object instead of string',
-	)
-})
-
-it('should not update lastCommit property if latest is undefined', () => {
-	latest = undefined
-	fileUtils.fileExists = jest.fn(() => true)
-	fileUtils.readFile = jest.fn(() => ({
-		git: { lastCommit: '1111111111abcdef' },
-	}))
-	fileUtils.saveFile = jest.fn()
-	updateLastCommit(dir, latest, fileUtils)
-	expect(fileUtils.fileExists).not.toHaveBeenCalled()
-	expect(fileUtils.readFile).not.toHaveBeenCalled()
-	expect(fileUtils.saveFile).not.toHaveBeenCalled()
-})
-
-jest.mock('child_process', () => ({
-	...jest.requireActual('child_process'), // This line ensures that other child_process methods are still available as normal
-	execSync: jest.fn().mockReturnValue('mock-branch'),
-}))
-
-// Then in your test:
-it('should update lastCommit property in index.yaml for the current branch', () => {
-	fileUtils.fileExists = jest.fn(() => true)
-	fileUtils.readFile = jest.fn(() => ({
-		git: { branches: { 'mock-branch': '1111111111abcdef' } },
-	}))
-	fileUtils.saveFile = jest.fn()
-
-	updateLastCommit({ dir, latest, fileUtils })
-
-	expect(fileUtils.saveFile).toHaveBeenCalledWith(
-		{ git: { branches: { 'mock-branch': latest } } },
-		'/test/directory/.sfdx/sfparty/index.yaml',
-	)
-})
-
-it('should save the default definition with branches object if file does not exist', () => {
-	jest.mock('child_process', () => ({
-		execSync: jest.fn().mockReturnValue('mock-branch'),
-	}))
-	fileUtils.fileExists = jest.fn(() => false)
-	fileUtils.saveFile = jest.fn()
-
-	const defaultDefinitionWithBranches = {
-		git: {
-			branches: { 'mock-branch': latest },
-		},
-		local: {
-			lastDate: undefined,
-		},
-	}
-
-	updateLastCommit({ dir, latest, fileUtils })
-
-	expect(fileUtils.saveFile).toHaveBeenCalledWith(
-		defaultDefinitionWithBranches,
-		'/test/directory/.sfdx/sfparty/index.yaml',
-	)
-})

package/test/lib/package/addMember.spec.js

@@ -1,49 +0,0 @@
-import * as packageDefinition from '../../../src/meta/Package.js'
-import { Package } from '../../../src/lib/packageUtil.js'
-
-let pkg;
-beforeEach(() => {
-    pkg = new Package('xmlPath');
-    pkg.packageJSON = JSON.parse(JSON.stringify(packageDefinition.metadataDefinition.emptyPackage));
-});
-
-afterEach(() => {
-    jest.clearAllMocks();
-});
-
-
-it('should add a member to the pkg JSON', () => {
-    pkg.addMember('type', 'member');
-    expect(pkg.packageJSON.Package.types[0].name).toBe('type');
-    expect(pkg.packageJSON.Package.types[0].members).toEqual(['member']);
-});
-
-it('should throw an error if packageJSON is undefined', () => {
-    pkg.packageJSON = undefined;
-    expect(() => pkg.addMember('type', 'member')).toThrowError('getPackageXML must be called before adding members');
-});
-
-it('should throw an error if type is undefined', () => {
-    expect(() => pkg.addMember(undefined, 'member')).toThrowError('An undefined type was received when attempting to add a member');
-});
-
-it('should throw an error if member is undefined', () => {
-    expect(() => pkg.addMember('type', undefined)).toThrowError('An undefined member was received when attempting to add a member');
-});
-
-it('should throw an error if member is a part file', () => {
-    global.format = "part"
-    expect(() => pkg.addMember('type', 'member.part')).toThrowError('Part file received as member is not allowed');
-});
-
-it('should not add the member if it already exists', () => {
-    pkg.packageJSON.Package.types = [{ name: "type", members: ["member"] }];
-    pkg.addMember('type', 'member');
-    expect(pkg.packageJSON.Package.types[0].members).toEqual(["member"]);
-});
-
-it('should not add the member if type already has an asterisk', () => {
-    pkg.packageJSON.Package.types = [{ name: "type", members: ["*"] }];
-    pkg.addMember('type', 'member');
-    expect(pkg.packageJSON.Package.types[0].members).toEqual(["*"]);
-});