manual merge

Author: madkoo

helm/safe-settings/README.md

@@ -37,6 +37,7 @@ A Helm chart for Kubernetes
 | nodeSelector | object | `{}` |  |
 | podAnnotations | object | `{}` |  |
 | podSecurityContext | object | `{}` |  |
+| priorityClassName | string | `""` | Priority class name for the pod. |
 | replicaCount | int | `1` |  |
 | resources | object | `{}` |  |
 | securityContext.allowPrivilegeEscalation | bool | `false` |  |

helm/safe-settings/templates/deployment.yaml

@@ -77,3 +77,6 @@ spec:
       tolerations:
         {{- toYaml . | nindent 8 }}
       {{- end }}
+      {{- if .Values.priorityClassName }}
+      priorityClassName: {{ .Values.priorityClassName }}
+      {{- end }}

helm/safe-settings/values.yaml

@@ -118,6 +118,8 @@ tolerations: []
 
 affinity: {}
 
+priorityClassName: ""
+
 deploymentConfig:
   restrictedRepos:
     # You can exclude certain repos from safe-settings processing

lib/settings.js

@@ -949,14 +949,19 @@ class Settings {
         const RepoPlugin = Settings.PLUGINS.repository
 
         const archivePlugin = new Archive(this.nop, this.github, repo, repoConfig, this.log)
-        const { shouldArchive, shouldUnarchive } = await archivePlugin.getState()
+        const { isArchived, shouldArchive, shouldUnarchive } = await archivePlugin.getState()
 
         if (shouldUnarchive) {
           this.log.debug(`Unarchiving repo ${repo.repo}`)
           const unArchiveResults = await archivePlugin.sync()
           this.appendToResults(unArchiveResults)
         }
 
+        if (isArchived && !shouldUnarchive) {
+          this.log.debug(`Skipping repo/child plugin updates for archived repo ${repo.repo}`)
+          return
+        }
+
         const repoResults = await new RepoPlugin(this.nop, this.github, repo, repoConfig, this.installation_id, this.log, this.errors).sync()
         this.appendToResults(repoResults)
 

package-lock.json

@@ -49,7 +49,7 @@
     "eslint-plugin-promise": "^6.6.0",
     "http-status-codes": "^2.2.0",
     "jest": "^29.5.0",
-    "jest-junit": "^16.0.0",
+    "jest-junit": "^17.0.0",
     "jest-when": "^3.5.2",
     "lockfile-lint": "^4.14.0",
     "nock": "^14.0.1",

package.json

@@ -93,6 +93,56 @@ describe('Archive Plugin', () => {
     })
   })
 
+  describe('getState', () => {
+    it('getState when repo is already archived and desired state is not set returns isArchived true shouldArchive false shouldUnarchive false', async () => {
+      // Arrange
+      github.rest.repos.get.mockResolvedValue({ data: { archived: true } })
+      archive = new Archive(false, github, repo, {}, log)
+
+      // Act
+      const result = await archive.getState()
+
+      // Assert
+      expect(result).toEqual({
+        isArchived: true,
+        shouldArchive: false,
+        shouldUnarchive: false
+      })
+    })
+
+    it('getState when repo is not archived and desired state is not set returns isArchived false shouldArchive false shouldUnarchive false', async () => {
+      // Arrange
+      github.rest.repos.get.mockResolvedValue({ data: { archived: false } })
+      archive = new Archive(false, github, repo, {}, log)
+
+      // Act
+      const result = await archive.getState()
+
+      // Assert
+      expect(result).toEqual({
+        isArchived: false,
+        shouldArchive: false,
+        shouldUnarchive: false
+      })
+    })
+
+    it('getState when repo is archived and desired state is false returns isArchived true shouldArchive false shouldUnarchive true', async () => {
+      // Arrange
+      github.rest.repos.get.mockResolvedValue({ data: { archived: true } })
+      archive = new Archive(false, github, repo, { archived: false }, log)
+
+      // Act
+      const result = await archive.getState()
+
+      // Assert
+      expect(result).toEqual({
+        isArchived: true,
+        shouldArchive: false,
+        shouldUnarchive: true
+      })
+    })
+  })
+
   describe('sync', () => {
     beforeEach(() => {
       archive = new Archive(false, github, repo, settings, log)

test/unit/lib/plugins/archive.test.js

@@ -498,4 +498,91 @@ repository:
       handleResultsSpy.mockRestore()
     })
   })
+
+  describe('updateRepos - archived repo skipping', () => {
+    const Archive = require('../../../lib/plugins/archive')
+
+    let settings
+    let mockRepoSync
+    let originalRepoPlugin
+
+    beforeEach(() => {
+      // Preserve the original RepoPlugin so it can be restored after each test
+      originalRepoPlugin = Settings.PLUGINS.repository
+
+      // Replace RepoPlugin with a mock constructor whose sync() we can assert on
+      mockRepoSync = jest.fn().mockResolvedValue([])
+      Settings.PLUGINS.repository = jest.fn().mockImplementation(() => ({
+        sync: mockRepoSync
+      }))
+
+      // Build a Settings instance that will enter the `if (repoConfig)` branch:
+      //   config.repository must be defined so repoConfig is truthy
+      settings = new Settings(
+        false,
+        stubContext,
+        { owner: 'test-org', repo: 'test-repo' },
+        { repository: { name: 'test-repo' } },
+        'main'
+      )
+
+      // Pre-set subOrgConfigs so updateRepos() does not call the async getSubOrgConfigs()
+      settings.subOrgConfigs = {}
+
+      // Pre-set repoConfigs so getRepoOverrideConfig() does not throw on undefined
+      settings.repoConfigs = {}
+    })
+
+    afterEach(() => {
+      // Restore the real RepoPlugin and all prototype spies
+      Settings.PLUGINS.repository = originalRepoPlugin
+      jest.restoreAllMocks()
+    })
+
+    it('updateRepos when repo is already archived and not being unarchived does not call RepoPlugin sync', async () => {
+      // Arrange
+      jest.spyOn(Archive.prototype, 'getState').mockResolvedValue({
+        isArchived: true,
+        shouldArchive: false,
+        shouldUnarchive: false
+      })
+
+      // Act
+      await settings.updateRepos({ owner: 'test-org', repo: 'test-repo' })
+
+      // Assert
+      expect(mockRepoSync).not.toHaveBeenCalled()
+    })
+
+    it('updateRepos when repo is archived but is being unarchived calls RepoPlugin sync', async () => {
+      // Arrange
+      jest.spyOn(Archive.prototype, 'getState').mockResolvedValue({
+        isArchived: true,
+        shouldArchive: false,
+        shouldUnarchive: true
+      })
+      jest.spyOn(Archive.prototype, 'sync').mockResolvedValue([])
+
+      // Act
+      await settings.updateRepos({ owner: 'test-org', repo: 'test-repo' })
+
+      // Assert
+      expect(mockRepoSync).toHaveBeenCalledTimes(1)
+    })
+
+    it('updateRepos when repo is not archived calls RepoPlugin sync', async () => {
+      // Arrange
+      jest.spyOn(Archive.prototype, 'getState').mockResolvedValue({
+        isArchived: false,
+        shouldArchive: false,
+        shouldUnarchive: false
+      })
+
+      // Act
+      await settings.updateRepos({ owner: 'test-org', repo: 'test-repo' })
+
+      // Assert
+      expect(mockRepoSync).toHaveBeenCalledTimes(1)
+    })
+  }) // updateRepos - archived repo skipping
 }) // Settings Tests