@ds-sfdc/sfparty 1.3.9 → 1.3.11

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

@@ -2,64 +2,83 @@ 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()
-    }
-})
+let dir, latest
 
 beforeEach(() => {
-    jest.resetModules()
+	dir = '/test/directory'
+	latest = '1234567890abcdef'
 })
 
 afterEach(() => {
-    jest.clearAllMocks()
+	jest.resetModules()
 })
 
-it('throws error when latest is not a string or undefined', () => {
-    expect(() => updateLastCommit('dir', {})).toThrowError(/string/)
+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('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)
+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()
+})
 
-    expect(fileUtils.fileExists).toHaveBeenCalledWith(fileName)
-    expect(fileUtils.readFile).toHaveBeenCalledWith(fileName)
-    expect(fileUtils.saveFile).toHaveBeenCalledWith({ git: { lastCommit: latest } }, fileName)
+it('should update lastCommit property in index.yaml file', () => {
+	// mock the fileExists method of fileUtils
+	fileUtils.fileExists = jest.fn(() => true)
+	// mock the readFile method of fileUtils
+	fileUtils.readFile = jest.fn(() => ({
+		git: { lastCommit: '1111111111abcdef' },
+	}))
+	// mock the saveFile method of fileUtils
+	fileUtils.saveFile = jest.fn()
+	updateLastCommit({ dir, latest, fileUtils })
+	expect(fileUtils.readFile).toHaveBeenCalled()
+	expect(fileUtils.saveFile).toHaveBeenCalledWith(
+		{ git: { lastCommit: latest } },
+		'/test/directory/.sfdx/sfparty/index.yaml',
+	)
 })
 
-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,
-        }
-    }
+it('should use existing index.yaml if it exists', () => {
+	fileUtils.fileExists = jest.fn(() => false)
+	fileUtils.readFile = jest.fn()
+	fileUtils.saveFile = jest.fn()
+	updateLastCommit({ dir, latest, fileUtils })
+	expect(fileUtils.fileExists).toHaveBeenCalled()
+	expect(fileUtils.readFile).not.toHaveBeenCalled()
+	expect(fileUtils.saveFile).toHaveBeenCalled()
+})
 
-    fileUtils.fileExists.mockReturnValue(false)
-    expect(fileUtils.readFile).not.toHaveBeenCalled()
+it('should save the default definition if file does not exist', () => {
+	fileUtils.fileExists = jest.fn(() => false)
+	fileUtils.readFile = jest.fn()
+	fileUtils.saveFile = jest.fn()
 
-    updateLastCommit(dir, latest, fileUtils)
+	const defaultDefinition = {
+		git: {
+			lastCommit: latest,
+		},
+		local: {
+			lastDate: undefined,
+		},
+	}
 
-    expect(fileUtils.fileExists).toHaveBeenCalledWith(fileName)
-    expect(fileUtils.readFile).not.toHaveBeenCalled()
-    expect(fileUtils.saveFile).toHaveBeenCalledWith(defaultDefinition, fileName)
+	updateLastCommit({ dir, latest, fileUtils })
+	expect(fileUtils.fileExists).toHaveBeenCalled()
+	expect(fileUtils.readFile).not.toHaveBeenCalled()
+	expect(fileUtils.saveFile).toHaveBeenCalledWith(
+		defaultDefinition,
+		'/test/directory/.sfdx/sfparty/index.yaml',
+	)
 })

package/test/lib/package/getPackageXML.spec.js

@@ -1,4 +1,4 @@
-
+import fs from 'fs'
 import * as packageDefinition from '../../../src/meta/Package.js'
 import { Package } from '../../../src/lib/packageUtil.js'
 import * as labelDefinition from '../../../src/meta/CustomLabels.js'
@@ -9,163 +9,185 @@ import * as workflowDefinition from '../../../src/meta/Workflows.js'
 global.__basedir = '.'
 global.format = 'yaml'
 global.metaTypes = {
-    label: {
-        type: labelDefinition.metadataDefinition.filetype,
-        definition: labelDefinition.metadataDefinition,
-        add: { files: [], directories: [] },
-        remove: { files: [], directories: [] },
-    },
-    profile: {
-        type: profileDefinition.metadataDefinition.filetype,
-        definition: profileDefinition.metadataDefinition,
-        add: { files: [], directories: [] },
-        remove: { files: [], directories: [] },
-    },
-    permset: {
-        type: permsetDefinition.metadataDefinition.filetype,
-        definition: permsetDefinition.metadataDefinition,
-        add: { files: [], directories: [] },
-        remove: { files: [], directories: [] },
-    },
-    workflow: {
-        type: workflowDefinition.metadataDefinition.filetype,
-        definition: workflowDefinition.metadataDefinition,
-        add: { files: [], directories: [] },
-        remove: { files: [], directories: [] },
-    },
+	label: {
+		type: labelDefinition.metadataDefinition.filetype,
+		definition: labelDefinition.metadataDefinition,
+		add: { files: [], directories: [] },
+		remove: { files: [], directories: [] },
+	},
+	profile: {
+		type: profileDefinition.metadataDefinition.filetype,
+		definition: profileDefinition.metadataDefinition,
+		add: { files: [], directories: [] },
+		remove: { files: [], directories: [] },
+	},
+	permset: {
+		type: permsetDefinition.metadataDefinition.filetype,
+		definition: permsetDefinition.metadataDefinition,
+		add: { files: [], directories: [] },
+		remove: { files: [], directories: [] },
+	},
+	workflow: {
+		type: workflowDefinition.metadataDefinition.filetype,
+		definition: workflowDefinition.metadataDefinition,
+		add: { files: [], directories: [] },
+		remove: { files: [], directories: [] },
+	},
 }
 
 let pkg
 const fileUtils = {
-    fileExists: jest.fn(),
-    readFile: jest.fn(),
+	fileExists: jest.fn(),
+	readFile: jest.fn(),
 }
 beforeEach(() => {
-    pkg = new Package('xmlPath')
+	pkg = new Package('xmlPath')
 })
 
-
 afterEach(() => {
-    jest.clearAllMocks()
+	jest.clearAllMocks()
 })
 
 it('should default the package if the json is empty', async () => {
-    fileUtils.fileExists.mockReturnValue(true)
-    fileUtils.readFile.mockResolvedValue({})
-    global.git = { append: true }
-    const result = await pkg.getPackageXML(fileUtils)
-    expect(result).toBe('existing')
-    expect(fileUtils.fileExists).toHaveBeenCalled()
-    expect(fileUtils.readFile).toHaveBeenCalled()
-    expect(pkg.packageJSON).toEqual(packageDefinition.metadataDefinition.emptyPackage)
+	fileUtils.fileExists.mockReturnValue(true)
+	fileUtils.readFile.mockResolvedValue({})
+	global.git = { append: true }
+	const result = await pkg.getPackageXML(fileUtils)
+	expect(result).toBe('existing')
+	expect(fileUtils.fileExists).toHaveBeenCalled()
+	expect(fileUtils.readFile).toHaveBeenCalled()
+	expect(pkg.packageJSON).toEqual(
+		packageDefinition.metadataDefinition.emptyPackage,
+	)
 })
 
 it('should read an existing file and call processJSON', async () => {
-    fileUtils.fileExists.mockReturnValue(true)
-    fileUtils.readFile.mockResolvedValue(packageDefinition.metadataDefinition.emptyPackage)
-    global.git = { append: true }
-    const result = await pkg.getPackageXML(fileUtils)
-    expect(result).toBe('existing')
-    expect(fileUtils.fileExists).toHaveBeenCalled()
-    expect(fileUtils.readFile).toHaveBeenCalled()
+	fileUtils.fileExists.mockReturnValue(true)
+	fileUtils.readFile.mockResolvedValue(
+		packageDefinition.metadataDefinition.emptyPackage,
+	)
+	global.git = { append: true }
+	const result = await pkg.getPackageXML(fileUtils)
+	expect(result).toBe('existing')
+	expect(fileUtils.fileExists).toHaveBeenCalled()
+	expect(fileUtils.readFile).toHaveBeenCalled()
 })
 
 it('should create an empty pkg JSON and call processJSON', async () => {
-    fileUtils.fileExists.mockReturnValue(false)
-    const finalJSON = JSON.parse(JSON.stringify(packageDefinition.metadataDefinition.emptyPackage))
-    finalJSON.Package.version = packageDefinition.metadataDefinition.fallbackVersion
-    const result = await pkg.getPackageXML(fileUtils)
-    expect(result).toBe('not found')
-    expect(fileUtils.fileExists).toHaveBeenCalled()
-    expect(pkg.packageJSON).toEqual(finalJSON)
+	fileUtils.fileExists.mockReturnValue(false)
+	const finalJSON = JSON.parse(
+		JSON.stringify(packageDefinition.metadataDefinition.emptyPackage),
+	)
+	finalJSON.Package.version =
+		packageDefinition.metadataDefinition.fallbackVersion
+	const result = await pkg.getPackageXML(fileUtils)
+	expect(result).toBe('not found')
+	expect(fileUtils.fileExists).toHaveBeenCalled()
+	expect(pkg.packageJSON).toEqual(finalJSON)
 })
 
 it('should throw an error if xmlPath is undefined', async () => {
-    pkg.xmlPath = undefined
-    await expect(pkg.getPackageXML(fileUtils)).rejects.toThrowError('Package not initialized')
+	pkg.xmlPath = undefined
+	await expect(pkg.getPackageXML(fileUtils)).rejects.toThrowError(
+		'Package not initialized',
+	)
 })
 
 it('should throw an error if error occurs during processing', async () => {
-    fileUtils.fileExists.mockReturnValue(true)
-    fileUtils.readFile.mockRejectedValue(new Error('Error'))
-    await expect(pkg.getPackageXML(fileUtils)).rejects.toThrowError('Error')
+	fileUtils.fileExists.mockReturnValue(true)
+	fileUtils.readFile.mockRejectedValue(new Error('Error'))
+	await expect(pkg.getPackageXML(fileUtils)).rejects.toThrowError('Error')
 })
 
 it('should catch errors and reject the promise', async () => {
-    fileUtils.fileExists.mockReturnValue(true)
-    fileUtils.readFile.mockRejectedValue(new Error('Test Error'))
-    global.git = { append: true }
-    try {
-        await pkg.getPackageXML(fileUtils)
-    } catch (error) {
-        expect(error.message).toEqual('Test Error')
-    }
+	fileUtils.fileExists.mockReturnValue(true)
+	fileUtils.readFile.mockRejectedValue(new Error('Test Error'))
+	global.git = { append: true }
+	try {
+		await pkg.getPackageXML(fileUtils)
+	} catch (error) {
+		expect(error.message).toEqual('Test Error')
+	}
 })
 
 it('should default to an empty package if the read file is empty', async () => {
-    fileUtils.fileExists.mockReturnValue(true)
-    fileUtils.readFile.mockResolvedValue('')
-    global.git = { append: true }
-    const result = await pkg.getPackageXML(fileUtils)
-    expect(result).toBe('existing')
-    expect(pkg.packageJSON).toEqual(packageDefinition.metadataDefinition.emptyPackage)
-    expect(fileUtils.fileExists).toHaveBeenCalled()
-    expect(fileUtils.readFile).toHaveBeenCalled()
+	fileUtils.fileExists.mockReturnValue(true)
+	fileUtils.readFile.mockResolvedValue('')
+	global.git = { append: true }
+	const result = await pkg.getPackageXML(fileUtils)
+	expect(result).toBe('existing')
+	expect(pkg.packageJSON).toEqual(
+		packageDefinition.metadataDefinition.emptyPackage,
+	)
+	expect(fileUtils.fileExists).toHaveBeenCalled()
+	expect(fileUtils.readFile).toHaveBeenCalled()
 })
 
 it('should throw an error if fileUtils.readFile() returns a rejected promise', async () => {
-    fileUtils.fileExists.mockReturnValue(true)
-    fileUtils.readFile.mockRejectedValue(new Error('Test Error'))
-    global.git = { append: true }
-    await expect(pkg.getPackageXML(fileUtils)).rejects.toThrowError('Test Error')
-    expect(fileUtils.fileExists).toHaveBeenCalled()
-    expect(fileUtils.readFile).toHaveBeenCalled()
+	fileUtils.fileExists.mockReturnValue(true)
+	fileUtils.readFile.mockRejectedValue(new Error('Test Error'))
+	global.git = { append: true }
+	await expect(pkg.getPackageXML(fileUtils)).rejects.toThrowError(
+		'Test Error',
+	)
+	expect(fileUtils.fileExists).toHaveBeenCalled()
+	expect(fileUtils.readFile).toHaveBeenCalled()
 })
 
 it('should correctly process the json object returned from the XML file', async () => {
-    fileUtils.fileExists.mockReturnValue(true)
-    fileUtils.readFile.mockResolvedValueOnce({
-        "Package": {
-            "types": [{
-                "members": ["Test", "Test.yaml"],
-                "name": "CustomLabels"
-            }, {
-                "members": ["Test", "Test.yaml"],
-                "name": "Profile"
-            }, {
-                "members": ["Test", "Test.yaml"],
-                "name": "PermissionSet"
-            }, {
-                "members": ["Test", "Test.yaml"],
-                "name": "Workflow"
-            }],
-            "version": "56.0"
-        }
-    })
-    fileUtils.readFile.mockImplementationOnce(() => {
-        return { sourceApiVersion: '56.0' }
-    })
-    global.git = { append: true }
-    const result = await pkg.getPackageXML(fileUtils)
-    expect(result).toBe('existing')
-    expect(fileUtils.fileExists).toHaveBeenCalled()
-    expect(fileUtils.readFile).toHaveBeenCalled()
-    expect(pkg.packageJSON).toEqual({
-        "Package": {
-            "types": [{
-                "members": ["Test"],
-                "name": "CustomLabels"
-            }, {
-                "members": ["Test"],
-                "name": "Profile"
-            }, {
-                "members": ["Test"],
-                "name": "PermissionSet"
-            }, {
-                "members": ["Test"],
-                "name": "Workflow"
-            }],
-            "version": "56.0"
-        }
-    })
+	fileUtils.fileExists.mockReturnValue(true)
+	fileUtils.readFile.mockResolvedValueOnce({
+		Package: {
+			types: [
+				{
+					members: ['Test', 'Test.yaml'],
+					name: 'CustomLabels',
+				},
+				{
+					members: ['Test', 'Test.yaml'],
+					name: 'Profile',
+				},
+				{
+					members: ['Test', 'Test.yaml'],
+					name: 'PermissionSet',
+				},
+				{
+					members: ['Test', 'Test.yaml'],
+					name: 'Workflow',
+				},
+			],
+			version: '56.0',
+		},
+	})
+	fileUtils.readFile.mockImplementationOnce(() => {
+		return { sourceApiVersion: '56.0' }
+	})
+	global.git = { append: true }
+	const result = await pkg.getPackageXML(fileUtils)
+	expect(result).toBe('existing')
+	expect(fileUtils.fileExists).toHaveBeenCalled()
+	expect(fileUtils.readFile).toHaveBeenCalled()
+	expect(pkg.packageJSON).toEqual({
+		Package: {
+			types: [
+				{
+					members: ['Test'],
+					name: 'CustomLabels',
+				},
+				{
+					members: ['Test'],
+					name: 'Profile',
+				},
+				{
+					members: ['Test'],
+					name: 'PermissionSet',
+				},
+				{
+					members: ['Test'],
+					name: 'Workflow',
+				},
+			],
+			version: '56.0',
+		},
+	})
 })