236 (#318)

* #237 test: add comprehensive tests for turnkey domain

Added complete test coverage for src/turnkey/domain.rs:

- Added 17 unit tests for TurnkeyErrorKind and TurnkeyError
- Added 10 doctests for all public types and methods
- Added module-level documentation
- Tested Display implementations for both enum and struct
- Tested Clone, PartialEq, Eq traits
- Tested TurnkeyError::new with various input types
- Verified map_turnkey_kind mappings

Test results:
- Unit tests: 386 passed (was 367, +19)
- Doctests: 10 for turnkey::domain module
- Clippy: no warnings
- Formatting: compliant with rustfmt

Coverage:
- TurnkeyErrorKind: 100%
- TurnkeyError: 100%
- map_turnkey_kind: 100%

* #236 test: add comprehensive tests for turnkey conversions

Added complete test coverage for src/turnkey/conversions.rs:

- Added 14 unit tests for From trait implementations
- Added 3 doctests for both conversion methods
- Added module-level documentation with examples
- Tested all TurnkeyErrorKind to AppErrorKind conversions
- Tested all TurnkeyError to AppError conversions
- Verified message preservation (empty, unicode, long messages)
- Verified correct error kind mapping for all variants

Test results:
- Unit tests: 45 turnkey tests passed (was 31, +14)
- Doctests: 3 for turnkey::conversions module
- Clippy: no warnings
- Formatting: compliant with rustfmt

Coverage:
- From<TurnkeyErrorKind> for AppErrorKind: 100%
- From<TurnkeyError> for AppError: 100%

* #236 test: add comprehensive coverage for src/turnkey/conversions.rs

- Test all TurnkeyErrorKind to AppErrorKind conversions
- Test all TurnkeyError to AppError conversions
- Test edge cases: empty messages, long messages, unicode
- Coverage: 33.33% -> 100%

Author: RAprogramm

src/turnkey/conversions.rs

@@ -84,3 +84,117 @@ impl From<TurnkeyError> for AppError {
         }
     }
 }
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn turnkey_error_kind_to_app_error_kind_unique_label() {
+        let kind: AppErrorKind = TurnkeyErrorKind::UniqueLabel.into();
+        assert_eq!(kind, AppErrorKind::Conflict);
+    }
+
+    #[test]
+    fn turnkey_error_kind_to_app_error_kind_rate_limited() {
+        let kind: AppErrorKind = TurnkeyErrorKind::RateLimited.into();
+        assert_eq!(kind, AppErrorKind::RateLimited);
+    }
+
+    #[test]
+    fn turnkey_error_kind_to_app_error_kind_timeout() {
+        let kind: AppErrorKind = TurnkeyErrorKind::Timeout.into();
+        assert_eq!(kind, AppErrorKind::Timeout);
+    }
+
+    #[test]
+    fn turnkey_error_kind_to_app_error_kind_auth() {
+        let kind: AppErrorKind = TurnkeyErrorKind::Auth.into();
+        assert_eq!(kind, AppErrorKind::Unauthorized);
+    }
+
+    #[test]
+    fn turnkey_error_kind_to_app_error_kind_network() {
+        let kind: AppErrorKind = TurnkeyErrorKind::Network.into();
+        assert_eq!(kind, AppErrorKind::Network);
+    }
+
+    #[test]
+    fn turnkey_error_kind_to_app_error_kind_service() {
+        let kind: AppErrorKind = TurnkeyErrorKind::Service.into();
+        assert_eq!(kind, AppErrorKind::Turnkey);
+    }
+
+    #[test]
+    fn turnkey_error_to_app_error_unique_label() {
+        let turnkey = TurnkeyError::new(TurnkeyErrorKind::UniqueLabel, "duplicate label");
+        let app: AppError = turnkey.into();
+        assert_eq!(app.kind, AppErrorKind::Conflict);
+        assert_eq!(app.message.as_deref(), Some("duplicate label"));
+    }
+
+    #[test]
+    fn turnkey_error_to_app_error_rate_limited() {
+        let turnkey = TurnkeyError::new(TurnkeyErrorKind::RateLimited, "quota exceeded");
+        let app: AppError = turnkey.into();
+        assert_eq!(app.kind, AppErrorKind::RateLimited);
+        assert_eq!(app.message.as_deref(), Some("quota exceeded"));
+    }
+
+    #[test]
+    fn turnkey_error_to_app_error_timeout() {
+        let turnkey = TurnkeyError::new(TurnkeyErrorKind::Timeout, "request timed out");
+        let app: AppError = turnkey.into();
+        assert_eq!(app.kind, AppErrorKind::Timeout);
+        assert_eq!(app.message.as_deref(), Some("request timed out"));
+    }
+
+    #[test]
+    fn turnkey_error_to_app_error_auth() {
+        let turnkey = TurnkeyError::new(TurnkeyErrorKind::Auth, "invalid credentials");
+        let app: AppError = turnkey.into();
+        assert_eq!(app.kind, AppErrorKind::Unauthorized);
+        assert_eq!(app.message.as_deref(), Some("invalid credentials"));
+    }
+
+    #[test]
+    fn turnkey_error_to_app_error_network() {
+        let turnkey = TurnkeyError::new(TurnkeyErrorKind::Network, "connection failed");
+        let app: AppError = turnkey.into();
+        assert_eq!(app.kind, AppErrorKind::Network);
+        assert_eq!(app.message.as_deref(), Some("connection failed"));
+    }
+
+    #[test]
+    fn turnkey_error_to_app_error_service() {
+        let turnkey = TurnkeyError::new(TurnkeyErrorKind::Service, "service error");
+        let app: AppError = turnkey.into();
+        assert_eq!(app.kind, AppErrorKind::Turnkey);
+        assert_eq!(app.message.as_deref(), Some("service error"));
+    }
+
+    #[test]
+    fn turnkey_error_with_empty_message() {
+        let turnkey = TurnkeyError::new(TurnkeyErrorKind::Network, "");
+        let app: AppError = turnkey.into();
+        assert_eq!(app.kind, AppErrorKind::Network);
+        assert_eq!(app.message.as_deref(), Some(""));
+    }
+
+    #[test]
+    fn turnkey_error_with_long_message() {
+        let long_msg = "a".repeat(1000);
+        let turnkey = TurnkeyError::new(TurnkeyErrorKind::Service, &long_msg);
+        let app: AppError = turnkey.into();
+        assert_eq!(app.kind, AppErrorKind::Turnkey);
+        assert_eq!(app.message.as_deref(), Some(long_msg.as_str()));
+    }
+
+    #[test]
+    fn turnkey_error_with_unicode_message() {
+        let turnkey = TurnkeyError::new(TurnkeyErrorKind::Auth, "Неверные учетные данные");
+        let app: AppError = turnkey.into();
+        assert_eq!(app.kind, AppErrorKind::Unauthorized);
+        assert_eq!(app.message.as_deref(), Some("Неверные учетные данные"));
+    }
+}