@actions/artifact package

packages/artifact/__tests__/upload-specification.test.ts

@@ -0,0 +1,349 @@
+import * as io from '../../io/src/io'
+import * as path from 'path'
+import {promises as fs} from 'fs'
+import {getUploadSpecification} from '../src/upload-specification'
+
+const artifactName = 'my-artifact'
+const root = path.join(__dirname, '_temp', 'upload-specification')
+const goodItem1Path = path.join(
+  root,
+  'folder-a',
+  'folder-b',
+  'folder-c',
+  'good-item1.txt'
+)
+const goodItem2Path = path.join(root, 'folder-d', 'good-item2.txt')
+const goodItem3Path = path.join(root, 'folder-d', 'good-item3.txt')
+const goodItem4Path = path.join(root, 'folder-d', 'good-item4.txt')
+const goodItem5Path = path.join(root, 'good-item5.txt')
+const badItem1Path = path.join(
+  root,
+  'folder-a',
+  'folder-b',
+  'folder-c',
+  'bad-item1.txt'
+)
+const badItem2Path = path.join(root, 'folder-d', 'bad-item2.txt')
+const badItem3Path = path.join(root, 'folder-f', 'bad-item3.txt')
+const badItem4Path = path.join(root, 'folder-h', 'folder-i', 'bad-item4.txt')
+const badItem5Path = path.join(root, 'folder-h', 'folder-i', 'bad-item5.txt')
+const extraFileInFolderCPath = path.join(
+  root,
+  'folder-a',
+  'folder-b',
+  'folder-c',
+  'extra-file-in-folder-c.txt'
+)
+const amazingFileInFolderHPath = path.join(root, 'folder-h', 'amazing-item.txt')
+
+const artifactFilesToUpload = [
+  goodItem1Path,
+  goodItem2Path,
+  goodItem3Path,
+  goodItem4Path,
+  goodItem5Path,
+  extraFileInFolderCPath,
+  amazingFileInFolderHPath
+]
+
+describe('Search', () => {
+  beforeAll(async () => {
+    // clear temp directory
+    await io.rmRF(root)
+    await fs.mkdir(path.join(root, 'folder-a', 'folder-b', 'folder-c'), {
+      recursive: true
+    })
+    await fs.mkdir(path.join(root, 'folder-a', 'folder-b', 'folder-e'), {
+      recursive: true
+    })
+    await fs.mkdir(path.join(root, 'folder-d'), {
+      recursive: true
+    })
+    await fs.mkdir(path.join(root, 'folder-f'), {
+      recursive: true
+    })
+    await fs.mkdir(path.join(root, 'folder-g'), {
+      recursive: true
+    })
+    await fs.mkdir(path.join(root, 'folder-h', 'folder-i'), {
+      recursive: true
+    })
+
+    await fs.writeFile(goodItem1Path, 'good item1 file')
+    await fs.writeFile(goodItem2Path, 'good item2 file')
+    await fs.writeFile(goodItem3Path, 'good item3 file')
+    await fs.writeFile(goodItem4Path, 'good item4 file')
+    await fs.writeFile(goodItem5Path, 'good item5 file')
+
+    await fs.writeFile(badItem1Path, 'bad item1 file')
+    await fs.writeFile(badItem2Path, 'bad item2 file')
+    await fs.writeFile(badItem3Path, 'bad item3 file')
+    await fs.writeFile(badItem4Path, 'bad item4 file')
+    await fs.writeFile(badItem5Path, 'bad item5 file')
+
+    await fs.writeFile(extraFileInFolderCPath, 'extra file')
+
+    await fs.writeFile(amazingFileInFolderHPath, 'amazing file')
+    /*
+      Directory structure of files that get created:
+      root/
+          folder-a/
+              folder-b/
+                  folder-c/
+                      good-item1.txt
+                      bad-item1.txt
+                      extra-file-in-folder-c.txt
+                  folder-e/
+          folder-d/
+              good-item2.txt
+              good-item3.txt
+              good-item4.txt
+              bad-item2.txt
+          folder-f/
+              bad-item3.txt
+          folder-g/
+          folder-h/
+              amazing-item.txt
+              folder-i/
+                  bad-item4.txt
+                  bad-item5.txt
+          good-item5.txt
+    */
+  })
+
+  it('Upload Specification - Fail non-existent rootDirectory', async () => {
+    const invalidRootDirectory = path.join(
+      __dirname,
+      '_temp',
+      'upload-specification-invalid'
+    )
+    expect(() => {
+      getUploadSpecification(
+        artifactName,
+        invalidRootDirectory,
+        artifactFilesToUpload
+      )
+    }).toThrow(`Provided rootDirectory ${invalidRootDirectory} does not exist`)
+  })
+
+  it('Upload Specification - Fail invalid rootDirectory', async () => {
+    expect(() => {
+      getUploadSpecification(artifactName, goodItem1Path, artifactFilesToUpload)
+    }).toThrow(
+      `Provided rootDirectory ${goodItem1Path} is not a valid directory`
+    )
+  })
+
+  it('Upload Specification - File does not exist', async () => {
+    const fakeFilePath = path.join(
+      artifactName,
+      'folder-a',
+      'folder-b',
+      'non-existent-file.txt'
+    )
+    expect(() => {
+      getUploadSpecification(artifactName, root, [fakeFilePath])
+    }).toThrow(`File ${fakeFilePath} does not exist`)
+  })
+
+  it('Upload Specification - Non parent directory', async () => {
+    const folderADirectory = path.join(root, 'folder-a')
+    const artifactFiles = [
+      goodItem1Path,
+      badItem1Path,
+      extraFileInFolderCPath,
+      goodItem5Path
+    ]
+    expect(() => {
+      getUploadSpecification(artifactName, folderADirectory, artifactFiles)
+    }).toThrow(
+      `The rootDirectory: ${folderADirectory} is not a parent directory of the file: ${goodItem5Path}`
+    )
+  })
+
+  it('Upload Specification - Success', async () => {
+    const specifications = getUploadSpecification(
+      artifactName,
+      root,
+      artifactFilesToUpload
+    )
+    expect(specifications.length).toEqual(7)
+
+    const absolutePaths = specifications.map(item => item.absoluteFilePath)
+    expect(absolutePaths.includes(goodItem1Path)).toEqual(true)
+    expect(absolutePaths.includes(goodItem2Path)).toEqual(true)
+    expect(absolutePaths.includes(goodItem3Path)).toEqual(true)
+    expect(absolutePaths.includes(goodItem4Path)).toEqual(true)
+    expect(absolutePaths.includes(goodItem5Path)).toEqual(true)
+    expect(absolutePaths.includes(extraFileInFolderCPath)).toEqual(true)
+    expect(absolutePaths.includes(amazingFileInFolderHPath)).toEqual(true)
+
+    for (const specification of specifications) {
+      if (specification.absoluteFilePath === goodItem1Path) {
+        expect(specification.uploadFilePath).toEqual(
+          path.join(
+            artifactName,
+            'folder-a',
+            'folder-b',
+            'folder-c',
+            'good-item1.txt'
+          )
+        )
+      }
+      if (specification.absoluteFilePath === goodItem2Path) {
+        expect(specification.uploadFilePath).toEqual(
+          path.join(artifactName, 'folder-d', 'good-item2.txt')
+        )
+      }
+      if (specification.absoluteFilePath === goodItem3Path) {
+        expect(specification.uploadFilePath).toEqual(
+          path.join(artifactName, 'folder-d', 'good-item3.txt')
+        )
+      }
+      if (specification.absoluteFilePath === goodItem4Path) {
+        expect(specification.uploadFilePath).toEqual(
+          path.join(artifactName, 'folder-d', 'good-item4.txt')
+        )
+      }
+      if (specification.absoluteFilePath === goodItem5Path) {
+        expect(specification.uploadFilePath).toEqual(
+          path.join(artifactName, 'good-item5.txt')
+        )
+      }
+      if (specification.absoluteFilePath === extraFileInFolderCPath) {
+        expect(specification.uploadFilePath).toEqual(
+          path.join(
+            artifactName,
+            'folder-a',
+            'folder-b',
+            'folder-c',
+            'extra-file-in-folder-c.txt'
+          )
+        )
+      }
+      if (specification.absoluteFilePath === amazingFileInFolderHPath) {
+        expect(specification.uploadFilePath).toEqual(
+          path.join(artifactName, 'folder-h', 'amazing-item.txt')
+        )
+      }
+    }
+  })
+
+  it('Upload Specification - Success with extra slash', async () => {
+    const rootWithSlash = `${root}/`
+    const specifications = getUploadSpecification(
+      artifactName,
+      rootWithSlash,
+      artifactFilesToUpload
+    )
+    expect(specifications.length).toEqual(7)
+
+    const absolutePaths = specifications.map(item => item.absoluteFilePath)
+    expect(absolutePaths.includes(goodItem1Path)).toEqual(true)
+    expect(absolutePaths.includes(goodItem2Path)).toEqual(true)
+    expect(absolutePaths.includes(goodItem3Path)).toEqual(true)
+    expect(absolutePaths.includes(goodItem4Path)).toEqual(true)
+    expect(absolutePaths.includes(goodItem5Path)).toEqual(true)
+    expect(absolutePaths.includes(extraFileInFolderCPath)).toEqual(true)
+    expect(absolutePaths.includes(amazingFileInFolderHPath)).toEqual(true)
+
+    for (const specification of specifications) {
+      if (specification.absoluteFilePath === goodItem1Path) {
+        expect(specification.uploadFilePath).toEqual(
+          path.join(
+            artifactName,
+            'folder-a',
+            'folder-b',
+            'folder-c',
+            'good-item1.txt'
+          )
+        )
+      }
+      if (specification.absoluteFilePath === goodItem2Path) {
+        expect(specification.uploadFilePath).toEqual(
+          path.join(artifactName, 'folder-d', 'good-item2.txt')
+        )
+      }
+      if (specification.absoluteFilePath === goodItem3Path) {
+        expect(specification.uploadFilePath).toEqual(
+          path.join(artifactName, 'folder-d', 'good-item3.txt')
+        )
+      }
+      if (specification.absoluteFilePath === goodItem4Path) {
+        expect(specification.uploadFilePath).toEqual(
+          path.join(artifactName, 'folder-d', 'good-item4.txt')
+        )
+      }
+      if (specification.absoluteFilePath === goodItem5Path) {
+        expect(specification.uploadFilePath).toEqual(
+          path.join(artifactName, 'good-item5.txt')
+        )
+      }
+      if (specification.absoluteFilePath === extraFileInFolderCPath) {
+        expect(specification.uploadFilePath).toEqual(
+          path.join(
+            artifactName,
+            'folder-a',
+            'folder-b',
+            'folder-c',
+            'extra-file-in-folder-c.txt'
+          )
+        )
+      }
+      if (specification.absoluteFilePath === amazingFileInFolderHPath) {
+        expect(specification.uploadFilePath).toEqual(
+          path.join(artifactName, 'folder-h', 'amazing-item.txt')
+        )
+      }
+    }
+  })
+
+  it('Upload Specification - Directories should not be included', async () => {
+    const folderEPath = path.join(root, 'folder-a', 'folder-b', 'folder-e')
+    const filesWithDirectory = [
+      goodItem1Path,
+      goodItem4Path,
+      folderEPath,
+      badItem3Path
+    ]
+    const specifications = getUploadSpecification(
+      artifactName,
+      root,
+      filesWithDirectory
+    )
+    expect(specifications.length).toEqual(3)
+    const absolutePaths = specifications.map(item => item.absoluteFilePath)
+    expect(absolutePaths.includes(goodItem1Path)).toEqual(true)
+    expect(absolutePaths.includes(goodItem4Path)).toEqual(true)
+    expect(absolutePaths.includes(badItem3Path)).toEqual(true)
+
+    for (const specification of specifications) {
+      if (specification.absoluteFilePath === goodItem1Path) {
+        expect(specification.uploadFilePath).toEqual(
+          path.join(
+            artifactName,
+            'folder-a',
+            'folder-b',
+            'folder-c',
+            'good-item1.txt'
+          )
+        )
+      }
+      if (specification.absoluteFilePath === goodItem2Path) {
+        expect(specification.uploadFilePath).toEqual(
+          path.join(artifactName, 'folder-d', 'good-item2.txt')
+        )
+      }
+      if (specification.absoluteFilePath === goodItem4Path) {
+        expect(specification.uploadFilePath).toEqual(
+          path.join(artifactName, 'folder-d', 'good-item4.txt')
+        )
+      }
+      if (specification.absoluteFilePath === badItem3Path) {
+        expect(specification.uploadFilePath).toEqual(
+          path.join(artifactName, 'folder-f', 'bad-item3.txt')
+        )
+      }
+    }
+  })
+})