implement proper validation functions in countdown tests

Catrya · Catrya · commit 92481acdbf87 · 2025-07-18T15:41:29.000-06:00
diff --git a/test/shared/countdown_validation_test.dart b/test/shared/countdown_validation_test.dart
@@ -1,30 +1,73 @@
 import 'package:flutter_test/flutter_test.dart';
 
+// Validation functions to test real logic instead of constants
+bool isValidTimestamp(int? timestamp) {
+  return timestamp != null && timestamp > 0;
+}
+
+bool isValidExpirationHours(int hours) {
+  return hours > 0 && hours <= 168; // Between 1 hour and 1 week
+}
+
+bool isTimestampInFuture(DateTime timestamp, DateTime threshold) {
+  return timestamp.isAfter(threshold);
+}
+
+bool isExpirationTooFarInPast(DateTime expiration, DateTime threshold) {
+  return expiration.isBefore(threshold);
+}
+
+Duration calculateDurationComponents(int hours, int minutes, int seconds) {
+  return Duration(hours: hours, minutes: minutes, seconds: seconds);
+}
+
+int clampHours(int hours, int maxHours) {
+  return hours.clamp(0, maxHours);
+}
+
+String formatTime(int hours, int minutes, int seconds) {
+  return '${hours.toString().padLeft(2, '0')}:${minutes.toString().padLeft(2, '0')}:${seconds.toString().padLeft(2, '0')}';
+}
+
+int convertSecondsToMinutes(int seconds) {
+  return (seconds / 60).round();
+}
+
 void main() {
   group('Countdown Validation Tests', () {
     
     group('Timestamp Validation', () {
       test('should reject negative timestamps', () {
-        final timestamp = -1000;
-        expect(timestamp <= 0, isTrue);
+        expect(isValidTimestamp(-1000), isFalse);
       });
 
       test('should reject zero timestamps', () {
-        final timestamp = 0;
-        expect(timestamp <= 0, isTrue);
+        expect(isValidTimestamp(0), isFalse);
+      });
+
+      test('should reject null timestamps', () {
+        expect(isValidTimestamp(null), isFalse);
       });
 
       test('should accept valid timestamps', () {
         final timestamp = DateTime.now().millisecondsSinceEpoch;
-        expect(timestamp > 0, isTrue);
+        expect(isValidTimestamp(timestamp), isTrue);
       });
 
       test('should reject future timestamps beyond threshold', () {
         final now = DateTime.now();
         final futureTime = now.add(const Duration(minutes: 10));
         final threshold = now.add(const Duration(minutes: 5));
         
-        expect(futureTime.isAfter(threshold), isTrue);
+        expect(isTimestampInFuture(futureTime, threshold), isTrue);
+      });
+
+      test('should accept timestamps within threshold', () {
+        final now = DateTime.now();
+        final recentTime = now.add(const Duration(minutes: 2));
+        final threshold = now.add(const Duration(minutes: 5));
+        
+        expect(isTimestampInFuture(recentTime, threshold), isFalse);
       });
     });
 
@@ -34,88 +77,80 @@ void main() {
         final pastExpiration = now.subtract(const Duration(hours: 2));
         final threshold = now.subtract(const Duration(hours: 1));
         
-        expect(pastExpiration.isBefore(threshold), isTrue);
+        expect(isExpirationTooFarInPast(pastExpiration, threshold), isTrue);
       });
 
       test('should accept recent expiration times', () {
         final now = DateTime.now();
         final recentExpiration = now.subtract(const Duration(minutes: 30));
         final threshold = now.subtract(const Duration(hours: 1));
         
-        expect(recentExpiration.isAfter(threshold), isTrue);
+        expect(isExpirationTooFarInPast(recentExpiration, threshold), isFalse);
       });
 
       test('should validate expiration hours range', () {
-        expect(0 <= 0, isTrue); // Invalid: zero hours
-        expect(24 > 0 && 24 <= 168, isTrue); // Valid: 24 hours
-        expect(200 > 168, isTrue); // Invalid: over 1 week
+        expect(isValidExpirationHours(0), isFalse); // Invalid: zero hours
+        expect(isValidExpirationHours(24), isTrue); // Valid: 24 hours
+        expect(isValidExpirationHours(168), isTrue); // Valid: 1 week (max)
+        expect(isValidExpirationHours(200), isFalse); // Invalid: over 1 week
+        expect(isValidExpirationHours(-5), isFalse); // Invalid: negative hours
       });
     });
 
     group('Time Calculations', () {
-      test('should calculate hours correctly', () {
-        final duration = const Duration(hours: 5, minutes: 30, seconds: 45);
-        
-        final hours = duration.inHours;
-        final minutes = duration.inMinutes % 60;
-        final seconds = duration.inSeconds % 60;
+      test('should calculate duration components correctly', () {
+        final duration = calculateDurationComponents(5, 30, 45);
         
-        expect(hours, equals(5));
-        expect(minutes, equals(30));
-        expect(seconds, equals(45));
+        expect(duration.inHours, equals(5));
+        expect(duration.inMinutes % 60, equals(30));
+        expect(duration.inSeconds % 60, equals(45));
       });
 
       test('should clamp hours to maximum', () {
-        final maxHours = 24;
-        final duration = const Duration(hours: 30);
-        
-        final hoursLeft = duration.inHours.clamp(0, maxHours);
-        expect(hoursLeft, equals(24));
+        expect(clampHours(30, 24), equals(24));
+        expect(clampHours(10, 24), equals(10));
+        expect(clampHours(-5, 24), equals(0));
+        expect(clampHours(168, 24), equals(24));
       });
 
       test('should handle zero duration', () {
-        final duration = const Duration();
-        
-        final hours = duration.inHours;
-        final minutes = duration.inMinutes % 60;
-        final seconds = duration.inSeconds % 60;
+        final duration = calculateDurationComponents(0, 0, 0);
         
-        expect(hours, equals(0));
-        expect(minutes, equals(0));
-        expect(seconds, equals(0));
+        expect(duration.inHours, equals(0));
+        expect(duration.inMinutes, equals(0));
+        expect(duration.inSeconds, equals(0));
       });
 
       test('should format time correctly', () {
-        final hours = 5;
-        final minutes = 7;
-        final seconds = 9;
-        
-        final formattedTime = '${hours.toString().padLeft(2, '0')}:${minutes.toString().padLeft(2, '0')}:${seconds.toString().padLeft(2, '0')}';
-        
-        expect(formattedTime, equals('05:07:09'));
+        expect(formatTime(5, 7, 9), equals('05:07:09'));
+        expect(formatTime(0, 0, 0), equals('00:00:00'));
+        expect(formatTime(23, 59, 59), equals('23:59:59'));
+        expect(formatTime(100, 5, 3), equals('100:05:03'));
       });
     });
 
     group('Edge Cases', () {
       test('should handle null expiration timestamp', () {
-        final int? timestamp = null;
-        final isValid = timestamp != null && timestamp > 0;
-        
-        expect(isValid, isFalse);
+        expect(isValidTimestamp(null), isFalse);
       });
 
       test('should convert seconds to minutes correctly', () {
-        final expirationSeconds = 900; // 15 minutes
-        final expectedMinutes = (expirationSeconds / 60).round();
-        
-        expect(expectedMinutes, equals(15));
+        expect(convertSecondsToMinutes(900), equals(15)); // 15 minutes
+        expect(convertSecondsToMinutes(60), equals(1)); // 1 minute
+        expect(convertSecondsToMinutes(0), equals(0)); // 0 minutes
+        expect(convertSecondsToMinutes(3600), equals(60)); // 60 minutes
       });
 
       test('should handle fractional minute conversions', () {
-        final expirationSeconds = 930; // 15.5 minutes
-        final expectedMinutes = (expirationSeconds / 60).round();
-        
-        expect(expectedMinutes, equals(16)); // Rounded up
+        expect(convertSecondsToMinutes(930), equals(16)); // 15.5 minutes rounded up
+        expect(convertSecondsToMinutes(870), equals(15)); // 14.5 minutes rounded up
+        expect(convertSecondsToMinutes(450), equals(8)); // 7.5 minutes rounded up
+      });
+
+      test('should validate edge cases for expiration hours', () {
+        expect(isValidExpirationHours(1), isTrue); // Minimum valid
+        expect(isValidExpirationHours(168), isTrue); // Maximum valid
+        expect(isValidExpirationHours(169), isFalse); // Just over maximum
       });
     });
   });
