test: refactoring

Author: CountRedClaw

test/helpers/matchers.ts

@@ -15,10 +15,13 @@
  */
 
 import {
+  BuildResult,
   ChangeMessage,
   ChangeSummary,
   DeprecateItem,
   EMPTY_CHANGE_SUMMARY,
+  MESSAGE_SEVERITY,
+  NotificationMessage,
   OperationChanges,
   type OperationsApiType,
   OperationType,
@@ -32,6 +35,8 @@ import { ArrayContaining, ObjectContaining, RecursiveMatcher } from '../../.jest
 export type ApihubComparisonMatcher = ObjectContaining<VersionsComparison> & VersionsComparison
 export type ApihubOperationChangesMatcher = ObjectContaining<OperationChanges> & OperationChanges
 export type ApihubChangesSummaryMatcher = ObjectContaining<ChangeSummary> & ChangeSummary
+export type ApihubNotificationsMatcher = ObjectContaining<BuildResult> & BuildResult
+export type ApihubErrorNotificationMatcher = ObjectContaining<NotificationMessage> & NotificationMessage
 export type ApihubChangeMessagesMatcher = ArrayContaining<ChangeMessage> & ChangeMessage[]
 
 export function apihubComparisonMatcher(
@@ -130,3 +135,21 @@ export function deprecatedItemDescriptionMatcher(
 }
 
 type Matcher = ObjectContaining<DeprecateItem>
+
+export function notificationsMatcher(
+  expected: Array<RecursiveMatcher<NotificationMessage>>,
+): ApihubNotificationsMatcher {
+  return expect.objectContaining({
+      notifications: expect.toIncludeSameMembers(expected),
+    },
+  )
+}
+
+export function errorNotificationMatcher(
+  message: string | RegExp,
+): ApihubErrorNotificationMatcher {
+  return expect.objectContaining({
+    message: expect.stringMatching(message),
+    severity: MESSAGE_SEVERITY.Error,
+  })
+}

test/reference-bundling.test.ts

@@ -1,5 +1,5 @@
-import { LocalRegistry } from './helpers'
-import { MESSAGE_SEVERITY, VALIDATION_RULES_SEVERITY_LEVEL_ERROR } from '../src'
+import { errorNotificationMatcher, LocalRegistry, notificationsMatcher } from './helpers'
+import { VALIDATION_RULES_SEVERITY_LEVEL_ERROR } from '../src'
 
 describe('Reference bundling test', () => {
   test('external references should be bundled', async () => {
@@ -9,19 +9,22 @@ describe('Reference bundling test', () => {
     expect(result.documents.get('openapi.yaml')?.dependencies).toEqual(['reference.yaml'])
   })
 
-  test('should throw on missing external reference', async () => {
+  test('should throw on missing external reference if error severity level configured', async () => {
     const pkg = LocalRegistry.openPackage('reference-bundling/case2')
 
     await expect(
       pkg.publish(pkg.packageId, { validationRulesSeverity: { brokenRefs: VALIDATION_RULES_SEVERITY_LEVEL_ERROR } }),
     ).rejects.toThrow(/does not exist/)
   })
 
-  test('should not throw on missing external reference', async () => {
+  test('should collect missing external reference notifications if severity level is not configured', async () => {
     const pkg = LocalRegistry.openPackage('reference-bundling/case2')
     const result = await pkg.publish(pkg.packageId)
 
-    expect(result.notifications.filter(({ severity }) => severity === MESSAGE_SEVERITY.Error).length).toEqual(2)
+    expect(result).toEqual(notificationsMatcher([
+      errorNotificationMatcher('references an invalid location'),
+      errorNotificationMatcher('does not exist'),
+    ]))
     expect(result.operations.size).toBe(1)
     expect(result.documents.get('openapi.yaml')?.dependencies.length).toBe(0)
   })
@@ -36,40 +39,43 @@ describe('Reference bundling test', () => {
     ])
   })
 
-  test('should throw on missing transitive external reference', async () => {
+  test('should throw on missing transitive external reference if error severity level configured', async () => {
     const pkg = LocalRegistry.openPackage('reference-bundling/case4')
 
     await expect(
       pkg.publish(pkg.packageId, { validationRulesSeverity: { brokenRefs: VALIDATION_RULES_SEVERITY_LEVEL_ERROR } }),
     ).rejects.toThrow(/does not exist/)
   })
 
-  test('should not throw on missing transitive external reference', async () => {
+  test('should collect notifications when transitive external reference is missing if severity level is not configured', async () => {
     const pkg = LocalRegistry.openPackage('reference-bundling/case4')
     const result = await pkg.publish(pkg.packageId)
 
-    expect(result.notifications.filter(({ severity }) => severity === MESSAGE_SEVERITY.Error).length).toEqual(2)
+    expect(result).toEqual(notificationsMatcher([
+      errorNotificationMatcher('references an invalid location'),
+      errorNotificationMatcher('does not exist'),
+    ]))
     expect(result.operations.size).toBe(1)
     expect(result.documents.get('openapi.yaml')?.dependencies).toEqual(['reference.yaml'])
   })
 
-  test('should throw on missing internal reference', async () => {
+  test('should throw on missing internal reference if error severity level configured', async () => {
     const pkg = LocalRegistry.openPackage('reference-bundling/case5')
 
     await expect(
       pkg.publish(pkg.packageId, { validationRulesSeverity: { brokenRefs: VALIDATION_RULES_SEVERITY_LEVEL_ERROR } }),
     ).rejects.toThrow(/references an invalid location/)
   })
 
-  test('should not throw on missing internal reference', async () => {
+  test('should collect missing internal reference notification if severity level is not configured', async () => {
     const pkg = LocalRegistry.openPackage('reference-bundling/case5')
     const result = await pkg.publish(pkg.packageId)
 
-    expect(result.notifications.filter(({ severity }) => severity === MESSAGE_SEVERITY.Error).length).toEqual(1)
+    expect(result).toEqual(notificationsMatcher([errorNotificationMatcher('references an invalid location')]))
     expect(result.operations.size).toBe(1)
   })
 
-  test('should throw on non-textual external reference', async () => {
+  test('should throw on non-textual external reference if error severity level configured', async () => {
     const pkg = LocalRegistry.openPackage('reference-bundling/case6')
     await expect(
       pkg.publish(pkg.packageId, { validationRulesSeverity: { brokenRefs: VALIDATION_RULES_SEVERITY_LEVEL_ERROR } }),