add integration tests

Author: ekraffmiller

test/integration/templates/TemplateRepository.test.ts

@@ -1,5 +1,11 @@
 import { ApiConfig, MetadataFieldTypeClass, WriteError } from '../../../src'
-import { createTemplate, getTemplatesByCollectionId } from '../../../src/templates'
+import {
+  createTemplate,
+  getTemplatesByCollectionId,
+  updateTemplateLicenseTerms,
+  updateTemplateMetadata,
+  updateTemplateTermsOfAccess
+} from '../../../src/templates'
 import { CreateTemplateDTO } from '../../../src/templates/domain/dtos/CreateTemplateDTO'
 import { TemplatesRepository } from '../../../src/templates/infra/repositories/TemplatesRepository'
 import { DataverseApiAuthMechanism } from '../../../src/core/infra/repositories/ApiConfig'
@@ -246,4 +252,116 @@ describe('TemplatesRepository', () => {
       await expect(sut.deleteTemplate(999999)).rejects.toThrow()
     })
   })
+
+  describe('updateTemplateMetadata', () => {
+    test('should update template metadata and instructions', async () => {
+      const templateName = `Template for UpdateTemplateMetadata ${Date.now()}`
+      await createTemplate.execute(
+        {
+          name: templateName,
+          isDefault: false,
+          fields: [
+            {
+              typeName: 'author',
+              typeClass: MetadataFieldTypeClass.Compound,
+              multiple: true,
+              value: [
+                {
+                  authorName: {
+                    typeName: 'authorName',
+                    typeClass: MetadataFieldTypeClass.Primitive,
+                    value: 'Belicheck, Bill'
+                  },
+                  authorAffiliation: {
+                    typeName: 'authorIdentifierScheme',
+                    typeClass: MetadataFieldTypeClass.Primitive,
+                    value: 'ORCID'
+                  }
+                }
+              ]
+            }
+          ],
+          instructions: [
+            {
+              instructionField: 'author',
+              instructionText: 'The author data'
+            }
+          ]
+        },
+        testCollectionAlias
+      )
+      const templates = await getTemplatesByCollectionId.execute(testCollectionAlias)
+      const templateId = templates[templates.length - 1].id
+
+      await updateTemplateMetadata.execute(
+        templateId,
+        {
+          name: `${templateName} updated`,
+          instructions: [
+            {
+              instructionField: 'author',
+              instructionText: 'Updated author instructions'
+            }
+          ]
+        },
+        true
+      )
+
+      const updatedTemplate = await sut.getTemplate(templateId)
+
+      expect(updatedTemplate.name).toBe(`${templateName} updated`)
+      expect(updatedTemplate.instructions).toContainEqual({
+        instructionField: 'author',
+        instructionText: 'Updated author instructions'
+      })
+
+      await deleteDatasetTemplateViaApi(templateId)
+    })
+  })
+
+  describe('updateTemplateLicenseTerms', () => {
+    test('should update template custom terms of use', async () => {
+      const templateName = `Template for UpdateTemplateLicenseTerms ${Date.now()}`
+      await createTemplate.execute({ name: templateName, isDefault: false }, testCollectionAlias)
+      const templates = await getTemplatesByCollectionId.execute(testCollectionAlias)
+      const templateId = templates[templates.length - 1].id
+
+      await updateTemplateLicenseTerms.execute(templateId, {
+        customTerms: {
+          termsOfUse: 'Updated template terms of use'
+        }
+      })
+
+      const updatedTemplate = await sut.getTemplate(templateId)
+
+      expect(updatedTemplate.termsOfUse.customTerms?.termsOfUse).toBe(
+        'Updated template terms of use'
+      )
+
+      await deleteDatasetTemplateViaApi(templateId)
+    })
+  })
+
+  describe('updateTemplateTermsOfAccess', () => {
+    test('should update template terms of access', async () => {
+      const templateName = `Template for UpdateTemplateTermsOfAccess ${Date.now()}`
+      await createTemplate.execute({ name: templateName, isDefault: false }, testCollectionAlias)
+      const templates = await getTemplatesByCollectionId.execute(testCollectionAlias)
+      const templateId = templates[templates.length - 1].id
+
+      await updateTemplateTermsOfAccess.execute(templateId, {
+        fileAccessRequest: true,
+        termsOfAccessForRestrictedFiles: 'Restricted access only'
+      })
+
+      const updatedTemplate = await sut.getTemplate(templateId)
+
+      expect(updatedTemplate.termsOfUse.termsOfAccess.fileAccessRequest).toBe(true)
+      expect(updatedTemplate.termsOfUse.termsOfAccess.termsOfAccessForRestrictedFiles).toBe(
+        'Restricted access only'
+      )
+
+      await deleteDatasetTemplateViaApi(templateId)
+    })
+  })
 })