Address PR review comments: add Object.values assertions and endpoint-event test

smoghe-bw · claude · smoghe-bw · commit 9435add602b9 · 2026-04-02T15:24:13.000-04:00
- Add Object.values() assertions to all 37 enum tests to catch future changes
- Add missing endpoint-event.test.ts with proper date assertions

Generated from Claude9 with Claude Code

Co-Authored-By: Claude Sonnet 4.6 &lt;noreply@anthropic.com&gt;
diff --git a/tests/unit/models/business-entity-type-enum.test.ts b/tests/unit/models/business-entity-type-enum.test.ts
@@ -7,5 +7,6 @@ describe('BusinessEntityTypeEnum', () => {
         expect(BusinessEntityTypeEnum.PublicProfit).toBe('PUBLIC_PROFIT');
         expect(BusinessEntityTypeEnum.NonProfit).toBe('NON_PROFIT');
         expect(BusinessEntityTypeEnum.Government).toBe('GOVERNMENT');
+        expect(Object.values(BusinessEntityTypeEnum)).toEqual(['SOLE_PROPRIETOR', 'PRIVATE_PROFIT', 'PUBLIC_PROFIT', 'NON_PROFIT', 'GOVERNMENT']);
     });
 });
diff --git a/tests/unit/models/business-registration-issuing-country-enum.test.ts b/tests/unit/models/business-registration-issuing-country-enum.test.ts
@@ -19,5 +19,6 @@ describe('BusinessRegistrationIssuingCountryEnum', () => {
         expect(BusinessRegistrationIssuingCountryEnum.Ind).toBe('IND');
         expect(BusinessRegistrationIssuingCountryEnum.Chn).toBe('CHN');
         expect(BusinessRegistrationIssuingCountryEnum.Bgr).toBe('BGR');
+        expect(Object.values(BusinessRegistrationIssuingCountryEnum)).toEqual(['USA', 'CAN', 'HKG', 'GBR', 'IRL', 'BRA', 'NLD', 'AUS', 'FRA', 'NZL', 'DEU', 'ESP', 'CHE', 'CYP', 'IND', 'CHN', 'BGR']);
     });
 });
diff --git a/tests/unit/models/business-registration-type-enum.test.ts b/tests/unit/models/business-registration-type-enum.test.ts
@@ -20,5 +20,6 @@ describe('BusinessRegistrationTypeEnum', () => {
         expect(BusinessRegistrationTypeEnum.Cnpj).toBe('CNPJ');
         expect(BusinessRegistrationTypeEnum.Uid).toBe('UID');
         expect(BusinessRegistrationTypeEnum.Other).toBe('OTHER');
+        expect(Object.values(BusinessRegistrationTypeEnum)).toEqual(['EIN', 'CBN', 'NEQ', 'PROVINCIAL_NUMBER', 'CRN', 'VAT', 'ACN', 'ABN', 'BRN', 'SIREN', 'SIRET', 'NZBN', 'UST_IDNR', 'CIF', 'NIF', 'CNPJ', 'UID', 'OTHER']);
     });
 });
diff --git a/tests/unit/models/call-direction-enum.test.ts b/tests/unit/models/call-direction-enum.test.ts
@@ -4,5 +4,6 @@ describe('CallDirectionEnum', () => {
     test('should define the expected values', () => {
         expect(CallDirectionEnum.Inbound).toBe('inbound');
         expect(CallDirectionEnum.Outbound).toBe('outbound');
+        expect(Object.values(CallDirectionEnum)).toEqual(['inbound', 'outbound']);
     });
 });
diff --git a/tests/unit/models/call-state-enum.test.ts b/tests/unit/models/call-state-enum.test.ts
@@ -4,5 +4,6 @@ describe('CallStateEnum', () => {
     test('should define the expected values', () => {
         expect(CallStateEnum.Active).toBe('active');
         expect(CallStateEnum.Completed).toBe('completed');
+        expect(Object.values(CallStateEnum)).toEqual(['active', 'completed']);
     });
 });
diff --git a/tests/unit/models/call-transcription-detected-language-enum.test.ts b/tests/unit/models/call-transcription-detected-language-enum.test.ts
@@ -5,5 +5,6 @@ describe('CallTranscriptionTrackEnum', () => {
         expect(CallTranscriptionDetectedLanguageEnum.EnUs).toBe('en-US');
         expect(CallTranscriptionDetectedLanguageEnum.EsUs).toBe('es-US');
         expect(CallTranscriptionDetectedLanguageEnum.FrFr).toBe('fr-FR');
+        expect(Object.values(CallTranscriptionDetectedLanguageEnum)).toEqual(['en-US', 'es-US', 'fr-FR']);
     });
 });
diff --git a/tests/unit/models/call-transcription-track-enum.test.ts b/tests/unit/models/call-transcription-track-enum.test.ts
@@ -4,5 +4,6 @@ describe('CallTranscriptionTrackEnum', () => {
     test('should define the expected values', () => {
         expect(CallTranscriptionTrackEnum.Inbound).toBe('inbound');
         expect(CallTranscriptionTrackEnum.Outbound).toBe('outbound');
+        expect(Object.values(CallTranscriptionTrackEnum)).toEqual(['inbound', 'outbound']);
     });
 });
diff --git a/tests/unit/models/callback-method-enum.test.ts b/tests/unit/models/callback-method-enum.test.ts
@@ -4,5 +4,6 @@ describe('CallbackMethodEnum', () => {
     test('should define the expected values', () => {
         expect(CallbackMethodEnum.Get).toBe('GET');
         expect(CallbackMethodEnum.Post).toBe('POST');
+        expect(Object.values(CallbackMethodEnum)).toEqual(['GET', 'POST']);
     });
 });
diff --git a/tests/unit/models/card-width-enum.test.ts b/tests/unit/models/card-width-enum.test.ts
@@ -4,5 +4,6 @@ describe('CardWidthEnum', () => {
     test('should define the expected values', () => {
         expect(CardWidthEnum.Small).toBe('SMALL');
         expect(CardWidthEnum.Medium).toBe('MEDIUM');
+        expect(Object.values(CardWidthEnum)).toEqual(['SMALL', 'MEDIUM']);
     });
 });
diff --git a/tests/unit/models/completed-lookup-status-enum.test.ts b/tests/unit/models/completed-lookup-status-enum.test.ts
@@ -5,5 +5,6 @@ describe('CompletedLookupStatusEnum', () => {
         expect(CompletedLookupStatusEnum.Complete).toBe('COMPLETE');
         expect(CompletedLookupStatusEnum.PartialComplete).toBe('PARTIAL_COMPLETE');
         expect(CompletedLookupStatusEnum.Failed).toBe('FAILED');
+        expect(Object.values(CompletedLookupStatusEnum)).toEqual(['COMPLETE', 'PARTIAL_COMPLETE', 'FAILED']);
     });
 });
diff --git a/tests/unit/models/conference-state-enum.test.ts b/tests/unit/models/conference-state-enum.test.ts
@@ -4,5 +4,6 @@ describe('ConferenceStateEnum', () => {
     test('should define the expected values', () => {
         expect(ConferenceStateEnum.Active).toBe('active');
         expect(ConferenceStateEnum.Completed).toBe('completed');
+        expect(Object.values(ConferenceStateEnum)).toEqual(['active', 'completed']);
     });
 });
diff --git a/tests/unit/models/deactivation-event-enum.test.ts b/tests/unit/models/deactivation-event-enum.test.ts
@@ -3,5 +3,6 @@ import { DeactivationEventEnum } from '../../../models/deactivation-event-enum';
 describe('DeactivationEventEnum', () => {
     test('should define the expected values', () => {
         expect(DeactivationEventEnum.Deactivated).toBe('DEACTIVATED');
+        expect(Object.values(DeactivationEventEnum)).toEqual(['DEACTIVATED']);
     });
 });
diff --git a/tests/unit/models/endpoint-event.test.ts b/tests/unit/models/endpoint-event.test.ts
@@ -0,0 +1,25 @@
+import { EndpointEvent } from '../../../models/endpoint-event';
+import { EndpointStatusEnum } from '../../../models/endpoint-status-enum';
+import { EndpointTypeEnum } from '../../../models/endpoint-type-enum';
+
+describe('EndpointEvent', () => {
+    test('should create an endpoint event with all fields', () => {
+        const event: EndpointEvent = {
+            endpointId: 'ep-123456',
+            type: EndpointTypeEnum.Webrtc,
+            status: EndpointStatusEnum.Connected,
+            creationTimestamp: '2024-02-18T10:30:00Z',
+            expirationTimestamp: '2024-02-19T10:30:00Z',
+            tag: 'test-event'
+        };
+
+        expect(event.endpointId).toBe('ep-123456');
+        expect(event.type).toBe('WEBRTC');
+        expect(event.status).toBe('CONNECTED');
+        expect(new Date(event.creationTimestamp).getFullYear()).toBe(2024);
+        expect(new Date(event.creationTimestamp).toISOString()).toBe('2024-02-18T10:30:00.000Z');
+        expect(new Date(event.expirationTimestamp).getFullYear()).toBe(2024);
+        expect(new Date(event.expirationTimestamp).toISOString()).toBe('2024-02-19T10:30:00.000Z');
+        expect(event.tag).toBe('test-event');
+    });
+});
diff --git a/tests/unit/models/file-format-enum.test.ts b/tests/unit/models/file-format-enum.test.ts
@@ -4,5 +4,6 @@ describe('FileFormatEnum', () => {
     test('should define the expected values', () => {
         expect(FileFormatEnum.Mp3).toBe('mp3');
         expect(FileFormatEnum.Wav).toBe('wav');
+        expect(Object.values(FileFormatEnum)).toEqual(['mp3', 'wav']);
     });
 });
diff --git a/tests/unit/models/in-progress-lookup-status-enum.test.ts b/tests/unit/models/in-progress-lookup-status-enum.test.ts
@@ -6,6 +6,7 @@ describe('InProgressLookupStatusEnum', () => {
         expect(InProgressLookupStatusEnum.Complete).toBe('COMPLETE');
         expect(InProgressLookupStatusEnum.PartialComplete).toBe('PARTIAL_COMPLETE');
         expect(InProgressLookupStatusEnum.Failed).toBe('FAILED');
+        expect(Object.values(InProgressLookupStatusEnum)).toEqual(['IN_PROGRESS', 'COMPLETE', 'PARTIAL_COMPLETE', 'FAILED']);
     });
 });
 
diff --git a/tests/unit/models/inbound-callback-type-enum.test.ts b/tests/unit/models/inbound-callback-type-enum.test.ts
@@ -5,5 +5,6 @@ describe('InboundCallbackTypeEnum', () => {
         expect(InboundCallbackTypeEnum.MessageReceived).toBe('message-received');
         expect(InboundCallbackTypeEnum.RequestLocationResponse).toBe('request-location-response');
         expect(InboundCallbackTypeEnum.SuggestionResponse).toBe('suggestion-response');
+        expect(Object.values(InboundCallbackTypeEnum)).toEqual(['message-received', 'request-location-response', 'suggestion-response']);
     });
 });
diff --git a/tests/unit/models/latest-message-delivery-status-enum.test.ts b/tests/unit/models/latest-message-delivery-status-enum.test.ts
@@ -6,6 +6,7 @@ describe('LatestMessageDeliveryStatusEnum', () => {
         expect(LatestMessageDeliveryStatusEnum.Deactivated).toBe('DEACTIVATED');
         expect(LatestMessageDeliveryStatusEnum.Unknown).toBe('UNKNOWN');
         expect(LatestMessageDeliveryStatusEnum.NotEnabled).toBe('NOT_ENABLED');
+        expect(Object.values(LatestMessageDeliveryStatusEnum)).toEqual(['ACTIVE', 'DEACTIVATED', 'UNKNOWN', 'NOT_ENABLED']);
     });
 });
 
diff --git a/tests/unit/models/line-type-enum.test.ts b/tests/unit/models/line-type-enum.test.ts
@@ -6,6 +6,7 @@ describe('LineTypeEnum', () => {
         expect(LineTypeEnum.VoipFixed).toBe('VOIP-FIXED');
         expect(LineTypeEnum.Mobile).toBe('MOBILE');
         expect(LineTypeEnum.Voip).toBe('VOIP');
+        expect(Object.values(LineTypeEnum)).toEqual(['FIXED', 'VOIP-FIXED', 'MOBILE', 'VOIP']);
     });
 });
 
diff --git a/tests/unit/models/list-message-direction-enum.test.ts b/tests/unit/models/list-message-direction-enum.test.ts
@@ -4,5 +4,6 @@ describe('ListMessageDirectionEnum', () => {
     test('should define the expected values', () => {
         expect(ListMessageDirectionEnum.Inbound).toBe('INBOUND');
         expect(ListMessageDirectionEnum.Outbound).toBe('OUTBOUND');
+        expect(Object.values(ListMessageDirectionEnum)).toEqual(['INBOUND', 'OUTBOUND']);
     });
 });
diff --git a/tests/unit/models/machine-detection-mode-enum.test.ts b/tests/unit/models/machine-detection-mode-enum.test.ts
@@ -4,5 +4,6 @@ describe('MachineDetectionModeEnum', () => {
     test('should define the expected values', () => {
         expect(MachineDetectionModeEnum.Sync).toBe('sync');
         expect(MachineDetectionModeEnum.Async).toBe('async');
+        expect(Object.values(MachineDetectionModeEnum)).toEqual(['sync', 'async']);
     });
 });
diff --git a/tests/unit/models/message-direction-enum.test.ts b/tests/unit/models/message-direction-enum.test.ts
@@ -4,5 +4,6 @@ describe('MessageDirectionEnum', () => {
     test('should define the expected values', () => {
         expect(MessageDirectionEnum.In).toBe('in');
         expect(MessageDirectionEnum.Out).toBe('out');
+        expect(Object.values(MessageDirectionEnum)).toEqual(['in', 'out']);
     });
 });
diff --git a/tests/unit/models/message-status-enum.test.ts b/tests/unit/models/message-status-enum.test.ts
@@ -10,5 +10,6 @@ describe('MessageStatusEnum', () => {
         expect(MessageStatusEnum.Delivered).toBe('DELIVERED');
         expect(MessageStatusEnum.Accepted).toBe('ACCEPTED');
         expect(MessageStatusEnum.Undelivered).toBe('UNDELIVERED');
+        expect(Object.values(MessageStatusEnum)).toEqual(['RECEIVED', 'QUEUED', 'SENDING', 'SENT', 'FAILED', 'DELIVERED', 'ACCEPTED', 'UNDELIVERED']);
     });
 });
diff --git a/tests/unit/models/message-type-enum.test.ts b/tests/unit/models/message-type-enum.test.ts
@@ -5,5 +5,6 @@ describe('MessageTypeEnum', () => {
         expect(MessageTypeEnum.Sms).toBe('sms');
         expect(MessageTypeEnum.Mms).toBe('mms');
         expect(MessageTypeEnum.Rcs).toBe('rcs');
+        expect(Object.values(MessageTypeEnum)).toEqual(['sms', 'mms', 'rcs']);
     });
 });
diff --git a/tests/unit/models/multi-channel-message-channel-enum.test.ts b/tests/unit/models/multi-channel-message-channel-enum.test.ts
@@ -5,5 +5,6 @@ describe('MultiChannelMessageChannelEnum', () => {
         expect(MultiChannelMessageChannelEnum.Rbm).toBe('RBM');
         expect(MultiChannelMessageChannelEnum.Sms).toBe('SMS');
         expect(MultiChannelMessageChannelEnum.Mms).toBe('MMS');
+        expect(Object.values(MultiChannelMessageChannelEnum)).toEqual(['RBM', 'SMS', 'MMS']);
     });
 });
diff --git a/tests/unit/models/priority-enum.test.ts b/tests/unit/models/priority-enum.test.ts
@@ -4,5 +4,6 @@ describe('PriorityEnum', () => {
     test('should define the expected values', () => {
         expect(PriorityEnum.Default).toBe('default');
         expect(PriorityEnum.High).toBe('high');
+        expect(Object.values(PriorityEnum)).toEqual(['default', 'high']);
     });
 });
diff --git a/tests/unit/models/product-type-enum.test.ts b/tests/unit/models/product-type-enum.test.ts
@@ -11,5 +11,6 @@ describe('ProductTypeEnum', () => {
         expect(ProductTypeEnum.RbmMedia).toBe('RBM_MEDIA');
         expect(ProductTypeEnum.RbmRich).toBe('RBM_RICH');
         expect(ProductTypeEnum.RbmConversational).toBe('RBM_CONVERSATIONAL');
+        expect(Object.values(ProductTypeEnum)).toEqual(['LOCAL_A2P', 'P2P', 'SHORT_CODE_REACH', 'TOLL_FREE', 'HOSTED_SHORT_CODE', 'ALPHA_NUMERIC', 'RBM_MEDIA', 'RBM_RICH', 'RBM_CONVERSATIONAL']);
     });
 });
diff --git a/tests/unit/models/rbm-action-type-enum.test.ts b/tests/unit/models/rbm-action-type-enum.test.ts
@@ -8,5 +8,6 @@ describe('RbmActionTypeEnum', () => {
         expect(RbmActionTypeEnum.CreateCalendarEvent).toBe('CREATE_CALENDAR_EVENT');
         expect(RbmActionTypeEnum.OpenUrl).toBe('OPEN_URL');
         expect(RbmActionTypeEnum.RequestLocation).toBe('REQUEST_LOCATION');
+        expect(Object.values(RbmActionTypeEnum)).toEqual(['REPLY', 'DIAL_PHONE', 'SHOW_LOCATION', 'CREATE_CALENDAR_EVENT', 'OPEN_URL', 'REQUEST_LOCATION']);
     });
 });
diff --git a/tests/unit/models/rbm-media-height-enum.test.ts b/tests/unit/models/rbm-media-height-enum.test.ts
@@ -5,5 +5,6 @@ describe('RbmMediaHeightEnum', () => {
         expect(RbmMediaHeightEnum.Short).toBe('SHORT');
         expect(RbmMediaHeightEnum.Medium).toBe('MEDIUM');
         expect(RbmMediaHeightEnum.Tall).toBe('TALL');
+        expect(Object.values(RbmMediaHeightEnum)).toEqual(['SHORT', 'MEDIUM', 'TALL']);
     });
 });
diff --git a/tests/unit/models/rbm-open-url-enum.test.ts b/tests/unit/models/rbm-open-url-enum.test.ts
@@ -4,5 +4,6 @@ describe('RbmOpenUrlEnum', () => {
     test('should define the expected values', () => {
         expect(RbmOpenUrlEnum.Browser).toBe('BROWSER');
         expect(RbmOpenUrlEnum.Webview).toBe('WEBVIEW');
+        expect(Object.values(RbmOpenUrlEnum)).toEqual(['BROWSER', 'WEBVIEW']);
     });
 });
diff --git a/tests/unit/models/rbm-veb-view-enum.test.ts b/tests/unit/models/rbm-veb-view-enum.test.ts
@@ -5,5 +5,6 @@ describe('RbmWebViewEnum', () => {
         expect(RbmWebViewEnum.Full).toBe('FULL');
         expect(RbmWebViewEnum.Half).toBe('HALF');
         expect(RbmWebViewEnum.Tall).toBe('TALL');
+        expect(Object.values(RbmWebViewEnum)).toEqual(['FULL', 'HALF', 'TALL']);
     });
 });
diff --git a/tests/unit/models/recording-state-enum.test.ts b/tests/unit/models/recording-state-enum.test.ts
@@ -4,5 +4,6 @@ describe('RecordingStateEnum', () => {
     test('should define the expected values', () => {
         expect(RecordingStateEnum.Paused).toBe('paused');
         expect(RecordingStateEnum.Recording).toBe('recording');
+        expect(Object.values(RecordingStateEnum)).toEqual(['paused', 'recording']);
     });
 });
diff --git a/tests/unit/models/redirect-method-enum.test.ts b/tests/unit/models/redirect-method-enum.test.ts
@@ -4,5 +4,6 @@ describe('RedirectMethodEnum', () => {
     test('should define the expected values', () => {
         expect(RedirectMethodEnum.Get).toBe('GET');
         expect(RedirectMethodEnum.Post).toBe('POST');
+        expect(Object.values(RedirectMethodEnum)).toEqual(['GET', 'POST']);
     });
 });
diff --git a/tests/unit/models/standalone-card-orientation-enum.test.ts b/tests/unit/models/standalone-card-orientation-enum.test.ts
@@ -4,5 +4,6 @@ describe('StandaloneCardOrientationEnum', () => {
     test('should define the expected values', () => {
         expect(StandaloneCardOrientationEnum.Horizontal).toBe('HORIZONTAL');
         expect(StandaloneCardOrientationEnum.Vertical).toBe('VERTICAL');
+        expect(Object.values(StandaloneCardOrientationEnum)).toEqual(['HORIZONTAL', 'VERTICAL']);
     });
 });
diff --git a/tests/unit/models/status-callback-type-enum.test.ts b/tests/unit/models/status-callback-type-enum.test.ts
@@ -6,5 +6,6 @@ describe('StatusCallbackTypeEnum', () => {
         expect(StatusCallbackTypeEnum.MessageDelivered).toBe('message-delivered');
         expect(StatusCallbackTypeEnum.MessageFailed).toBe('message-failed');
         expect(StatusCallbackTypeEnum.MessageRead).toBe('message-read');
+        expect(Object.values(StatusCallbackTypeEnum)).toEqual(['message-sending', 'message-delivered', 'message-failed', 'message-read']);
     });
 });
diff --git a/tests/unit/models/tfv-callback-status-enum.test.ts b/tests/unit/models/tfv-callback-status-enum.test.ts
@@ -4,5 +4,6 @@ describe('TfvCallbackStatusEnum', () => {
     test('should define the expected values', () => {
         expect(TfvCallbackStatusEnum.Verified).toBe('VERIFIED');
         expect(TfvCallbackStatusEnum.Unverified).toBe('UNVERIFIED');
+        expect(Object.values(TfvCallbackStatusEnum)).toEqual(['VERIFIED', 'UNVERIFIED']);
     });
 });
diff --git a/tests/unit/models/tfv-status-enum.test.ts b/tests/unit/models/tfv-status-enum.test.ts
@@ -5,5 +5,6 @@ describe('TfvStatusEnum', () => {
         expect(TfvStatusEnum.Verified).toBe('VERIFIED');
         expect(TfvStatusEnum.Unverified).toBe('UNVERIFIED');
         expect(TfvStatusEnum.Pending).toBe('PENDING');
+        expect(Object.values(TfvStatusEnum)).toEqual(['VERIFIED', 'UNVERIFIED', 'PENDING']);
     });
 });
diff --git a/tests/unit/models/thumbnail-alignment-enum.test.ts b/tests/unit/models/thumbnail-alignment-enum.test.ts
@@ -3,5 +3,6 @@ describe('ThumbnailAlignmentEnum', () => {
     test('should define the expected values', () => {
         expect(ThumbnailAlignmentEnum.Left).toBe('LEFT');
         expect(ThumbnailAlignmentEnum.Right).toBe('RIGHT');
+        expect(Object.values(ThumbnailAlignmentEnum)).toEqual(['LEFT', 'RIGHT']);
     });
 });
diff --git a/tests/unit/models/webhook-subscription-type-enum.test.ts b/tests/unit/models/webhook-subscription-type-enum.test.ts
@@ -4,5 +4,6 @@ describe('WebhookSubscriptionTypeEnum', () => {
     test('should define the expected values', () => {
         expect(WebhookSubscriptionTypeEnum.TollfreeVerificationStatus).toBe('TOLLFREE_VERIFICATION_STATUS');
         expect(WebhookSubscriptionTypeEnum.MessagingPortoutApprovalStatus).toBe('MESSAGING_PORTOUT_APPROVAL_STATUS');
+        expect(Object.values(WebhookSubscriptionTypeEnum)).toEqual(['TOLLFREE_VERIFICATION_STATUS', 'MESSAGING_PORTOUT_APPROVAL_STATUS']);
     });
 });
