tests++

mickeyl · mickeyl · commit d7792e23ab29 · 2025-08-11T12:15:51.000+02:00
diff --git a/.claude/settings.local.json b/.claude/settings.local.json
@@ -0,0 +1,9 @@
+{
+  "permissions": {
+    "allow": [
+      "Bash(swift test)",
+      "Bash(swift test:*)"
+    ],
+    "deny": []
+  }
+}
diff --git a/CLAUDE.md b/CLAUDE.md
@@ -0,0 +1,98 @@
+# CLAUDE.md
+
+This file provides guidance to Claude Code (claude.ai/code) when working with code in this repository.
+
+## Project Overview
+
+CornucopiaCore is a Swift Package Manager library providing essential utilities for Swift developers across Apple platforms (iOS 14+, macOS 12+, tvOS 14+, watchOS 8+). It's a collection of extensions, utilities, and helper classes designed to augment Foundation and platform-specific frameworks.
+
+## Build System & Commands
+
+This project uses Swift Package Manager with the following commands:
+
+- **Build**: `swift build`
+- **Test**: `swift test`
+- **Clean**: `swift package clean`
+
+The project targets Swift 5.10+ and has continuous integration via GitHub Actions that runs on both Ubuntu and macOS.
+
+## Dependencies
+
+The project has three external dependencies:
+- `swift-crypto` (3.0.0+): Apple's cryptographic library
+- `SWCompression` (4.8.5+): Compression utilities  
+- `AnyCodable` (0.6.6+): Type-erased Codable support (re-exported at module level)
+
+## Code Architecture
+
+### Module Structure
+The main module `CornucopiaCore` is organized into several logical groups:
+
+#### Core Namespace
+All public APIs are nested under `Cornucopia.Core` namespace. The main entry point is `Sources/CornucopiaCore/CornucopiaCore.swift` which defines the namespace and re-exports `AnyCodable`.
+
+#### Major Component Categories
+
+1. **Extensions** (`Extensions/`): Platform and Foundation type extensions
+   - Organized by type (Array, String, Data, etc.)
+   - Follow `CC_` prefix convention for public methods
+   - Cover networking, data manipulation, validation, and utility functions
+
+2. **Features** (`Features/`): Standalone functionality modules
+   - `DeviceInfo`: Cross-platform device identification with UUID persistence
+   - `JWT`: JSON Web Token support
+   - `Benchmarking`: Performance measurement utilities
+   - `Concurrency`: Async/await utilities and timeout mechanisms
+   - `Environment`: Environment variable handling
+
+3. **Logging** (`Logging/`): Flexible logging system
+   - `Logger`: Main logging interface with configurable sinks
+   - Supports multiple output targets (print, syslog, file, OSLog)
+   - Environment/UserDefaults configurable via `LOGLEVEL` and `LOGSINK`
+   - Thread-safe with background dispatch queue
+
+4. **PropertyWrappers** (`PropertyWrappers/`): Utility property wrappers
+   - `@Default`: Codable with default values
+   - `@Clamped`: Value constraints
+   - `@HexEncoded`: Automatic hex encoding/decoding
+   - `@Protected`: Thread-safe property access
+
+5. **Storage** (`Storage/`): Data persistence abstractions
+   - `Keychain`: Secure storage interface
+   - `ExtendedFileAttributes`: File metadata handling
+   - Storage backend protocol for pluggable backends
+
+6. **Networking** (`Networking/`): HTTP utilities
+   - HTTP constants and status codes
+   - Networking helper functions
+
+### Naming Conventions
+
+- Public extension methods use `CC_` prefix
+- Internal static constants use descriptive names
+- Property wrappers follow Swift conventions
+- Logger categories derived from `#fileID` by default
+
+### Platform Considerations
+
+The codebase includes extensive platform-specific compilation conditions:
+- `#if canImport(ObjectiveC)` for Apple vs. Linux differentiation  
+- Platform-specific imports (`UIKit`, `WatchKit`, etc.)
+- Conditional feature availability (syslog not available on watchOS)
+- Architecture-specific code paths in DeviceInfo
+
+### Testing Structure
+
+Tests mirror the source structure under `Tests/CornucopiaCoreTests/` and cover:
+- Extension functionality
+- Property wrapper behavior
+- Core features like logging and device info
+- Cross-platform compatibility
+
+## Development Practices
+
+- All files include copyright header: `// Cornucopia – (C) Dr. Lauer Information Technology`
+- Extensions are organized by the type they extend
+- Comprehensive `#if` conditions ensure cross-platform compatibility
+- Property wrappers follow Codable protocols where applicable
+- Logger uses background queue for thread safety
diff --git a/Tests/CornucopiaCoreTests/Extensions/Data/DataArrayConversionTests.swift b/Tests/CornucopiaCoreTests/Extensions/Data/DataArrayConversionTests.swift
@@ -0,0 +1,99 @@
+//
+//  Cornucopia – (C) Dr. Lauer Information Technology
+//
+import XCTest
+@testable import CornucopiaCore
+
+final class DataArrayConversionTests: XCTestCase {
+    
+    func testDataFromUInt8Array() {
+        let bytes: [UInt8] = [0x01, 0x02, 0x03, 0x04]
+        let data = Data.CC_fromArray(bytes)
+        XCTAssertEqual(data.count, 4)
+        XCTAssertEqual(Array(data), [0x01, 0x02, 0x03, 0x04])
+    }
+    
+    func testDataFromUInt16Array() {
+        let values: [UInt16] = [0x0102, 0x0304]
+        let data = Data.CC_fromArray(values)
+        XCTAssertEqual(data.count, 4)
+    }
+    
+    func testDataFromUInt32Array() {
+        let values: [UInt32] = [0x01020304, 0x05060708]
+        let data = Data.CC_fromArray(values)
+        XCTAssertEqual(data.count, 8)
+    }
+    
+    func testDataFromInt32Array() {
+        let values: [Int32] = [-1, 0, 1]
+        let data = Data.CC_fromArray(values)
+        XCTAssertEqual(data.count, 12)
+    }
+    
+    func testDataFromEmptyArray() {
+        let empty: [UInt8] = []
+        let data = Data.CC_fromArray(empty)
+        XCTAssertEqual(data.count, 0)
+        XCTAssertTrue(data.isEmpty)
+    }
+    
+    func testDataToUInt8Array() {
+        let data = Data([0x01, 0x02, 0x03, 0x04])
+        let result: [UInt8] = data.CC_toArray(of: UInt8.self)
+        XCTAssertEqual(result, [0x01, 0x02, 0x03, 0x04])
+    }
+    
+    func testDataToUInt16Array() {
+        let data = Data([0x01, 0x02, 0x03, 0x04])
+        let result: [UInt16] = data.CC_toArray(of: UInt16.self)
+        XCTAssertEqual(result.count, 2)
+    }
+    
+    func testDataToUInt32Array() {
+        let data = Data([0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08])
+        let result: [UInt32] = data.CC_toArray(of: UInt32.self)
+        XCTAssertEqual(result.count, 2)
+    }
+    
+    func testDataToInt8Array() {
+        let data = Data([0xFF, 0x00, 0x7F])
+        let result: [Int8] = data.CC_toArray(of: Int8.self)
+        XCTAssertEqual(result, [-1, 0, 127])
+    }
+    
+    func testDataToEmptyArray() {
+        let data = Data()
+        let result: [UInt8] = data.CC_toArray(of: UInt8.self)
+        XCTAssertTrue(result.isEmpty)
+    }
+    
+    func testDataPartialConversion() {
+        // Test with data that doesn't align perfectly with target type
+        let data = Data([0x01, 0x02, 0x03]) // 3 bytes
+        let result: [UInt16] = data.CC_toArray(of: UInt16.self) // Should produce 1 UInt16 (2 bytes used)
+        XCTAssertEqual(result.count, 1)
+    }
+    
+    func testRoundTripConversion() {
+        let original: [UInt32] = [0x12345678, 0x9ABCDEF0, 0x11223344]
+        let data = Data.CC_fromArray(original)
+        let converted: [UInt32] = data.CC_toArray(of: UInt32.self)
+        XCTAssertEqual(converted, original)
+    }
+    
+    func testDataNumbersConversion() {
+        let data = Data([0x01, 0x02, 0x03])
+        let numbers = data.CC_numbers
+        XCTAssertEqual(numbers.count, 3)
+        XCTAssertEqual(numbers[0].uint8Value, 0x01)
+        XCTAssertEqual(numbers[1].uint8Value, 0x02)
+        XCTAssertEqual(numbers[2].uint8Value, 0x03)
+    }
+    
+    func testDataNumbersEmptyData() {
+        let data = Data()
+        let numbers = data.CC_numbers
+        XCTAssertTrue(numbers.isEmpty)
+    }
+}
diff --git a/Tests/CornucopiaCoreTests/Extensions/URL/URLExtensionsTests.swift b/Tests/CornucopiaCoreTests/Extensions/URL/URLExtensionsTests.swift
@@ -0,0 +1,111 @@
+//
+//  Cornucopia – (C) Dr. Lauer Information Technology
+//
+import XCTest
+@testable import CornucopiaCore
+
+final class URLExtensionsTests: XCTestCase {
+    
+    func testURLBasename() throws {
+        let fileURL = URL(fileURLWithPath: "/path/to/file.txt")
+        XCTAssertEqual(fileURL.CC_basename, "file.txt")
+        
+        let directoryURL = URL(fileURLWithPath: "/path/to/directory/")
+        XCTAssertEqual(directoryURL.CC_basename, "directory")
+        
+        let httpURL = try XCTUnwrap(URL(string: "https://example.com/path/to/file.html"))
+        XCTAssertEqual(httpURL.CC_basename, "file.html")
+        
+        let rootURL = URL(fileURLWithPath: "/")
+        XCTAssertEqual(rootURL.CC_basename, "file:")
+        
+        let noExtensionURL = URL(fileURLWithPath: "/path/to/filename")
+        XCTAssertEqual(noExtensionURL.CC_basename, "filename")
+    }
+    
+    func testURLBasenameWithQueryParameters() throws {
+        let urlWithQuery = try XCTUnwrap(URL(string: "https://example.com/file.html?param=value"))
+        XCTAssertEqual(urlWithQuery.CC_basename, "file.html?param=value")
+    }
+    
+    func testURLBasenameWithFragment() throws {
+        let urlWithFragment = try XCTUnwrap(URL(string: "https://example.com/file.html#section"))
+        XCTAssertEqual(urlWithFragment.CC_basename, "file.html#section")
+    }
+}
+
+final class URLRequestAuthorizationTests: XCTestCase {
+    
+    func testSetBasicAuthorizationHeader() {
+        var request = URLRequest(url: URL(string: "https://example.com")!)
+        request.CC_setBasicAuthorizationHeader(username: "user", password: "pass")
+        
+        let expectedCredentials = "user:pass".data(using: .utf8)!.base64EncodedString()
+        let expectedHeader = "Basic \(expectedCredentials)"
+        
+        XCTAssertEqual(request.value(forHTTPHeaderField: "Authorization"), expectedHeader)
+    }
+    
+    func testSetBasicAuthorizationHeaderWithSpecialCharacters() {
+        var request = URLRequest(url: URL(string: "https://example.com")!)
+        request.CC_setBasicAuthorizationHeader(username: "user@domain.com", password: "p@ss:word!")
+        
+        let expectedCredentials = "user@domain.com:p@ss:word!".data(using: .utf8)!.base64EncodedString()
+        let expectedHeader = "Basic \(expectedCredentials)"
+        
+        XCTAssertEqual(request.value(forHTTPHeaderField: "Authorization"), expectedHeader)
+    }
+    
+    func testSetBearerAuthorizationHeaderWithBase64() {
+        var request = URLRequest(url: URL(string: "https://example.com")!)
+        let token = "eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9"
+        request.CC_setBearerAuthorizationHeader(base64: token)
+        
+        let expectedHeader = "Bearer \(token)"
+        XCTAssertEqual(request.value(forHTTPHeaderField: "Authorization"), expectedHeader)
+    }
+    
+    func testOverwriteExistingAuthorizationHeader() {
+        var request = URLRequest(url: URL(string: "https://example.com")!)
+        
+        // Set initial authorization
+        request.setValue("Initial Auth", forHTTPHeaderField: "Authorization")
+        XCTAssertEqual(request.value(forHTTPHeaderField: "Authorization"), "Initial Auth")
+        
+        // Overwrite with basic auth
+        request.CC_setBasicAuthorizationHeader(username: "user", password: "pass")
+        
+        let expectedCredentials = "user:pass".data(using: .utf8)!.base64EncodedString()
+        let expectedHeader = "Basic \(expectedCredentials)"
+        XCTAssertEqual(request.value(forHTTPHeaderField: "Authorization"), expectedHeader)
+    }
+    
+    func testMultipleAuthorizationUpdates() {
+        var request = URLRequest(url: URL(string: "https://example.com")!)
+        
+        // Set basic auth
+        request.CC_setBasicAuthorizationHeader(username: "user1", password: "pass1")
+        let basicAuth = request.value(forHTTPHeaderField: "Authorization")
+        XCTAssertTrue(basicAuth?.starts(with: "Basic ") == true)
+        
+        // Switch to bearer auth
+        request.CC_setBearerAuthorizationHeader(base64: "token123")
+        XCTAssertEqual(request.value(forHTTPHeaderField: "Authorization"), "Bearer token123")
+        
+        // Switch back to basic auth with different credentials
+        request.CC_setBasicAuthorizationHeader(username: "user2", password: "pass2")
+        let newBasicAuth = request.value(forHTTPHeaderField: "Authorization")
+        XCTAssertTrue(newBasicAuth?.starts(with: "Basic ") == true)
+        XCTAssertNotEqual(newBasicAuth, basicAuth)
+    }
+    
+    func testEmptyCredentials() {
+        var request = URLRequest(url: URL(string: "https://example.com")!)
+        request.CC_setBasicAuthorizationHeader(username: "", password: "")
+        
+        let expectedCredentials = ":".data(using: .utf8)!.base64EncodedString()
+        let expectedHeader = "Basic \(expectedCredentials)"
+        
+        XCTAssertEqual(request.value(forHTTPHeaderField: "Authorization"), expectedHeader)
+    }
+}
diff --git a/Tests/CornucopiaCoreTests/Logging/FileLogger.swift b/Tests/CornucopiaCoreTests/Logging/FileLogger.swift
@@ -4,28 +4,49 @@ import CornucopiaCore
 
 class FileLogger: XCTestCase {
 
-    func testFilelogger() {
+    override func tearDown() {
+        // Reset to print logger to avoid affecting other tests
+        let printLogger = Cornucopia.Core.PrintLogger()
+        Cornucopia.Core.Logger.overrideSink(printLogger, level: "INFO")
+        super.tearDown()
+    }
 
-        let logFileURL: URL = "file:///tmp/logfile.log"
+    func testFilelogger() {
+        // Use a unique filename for each test run to avoid race conditions
+        let logFileName = "logfile-\(UUID().uuidString).log"
+        let logFileURL: URL = "file:///tmp/\(logFileName)"
         let helloWorld = "Hello World!"
 
-        try? FileManager.default.removeItem(at: logFileURL) // might fail, if not present…
-        let logFile = Cornucopia.Core.FileLogger(url: logFileURL)
+        // Clean up any existing file
+        try? FileManager.default.removeItem(at: logFileURL)
 
+        // Test FileLogger directly without using the global Logger to avoid static state issues
+        let fileLogger = Cornucopia.Core.FileLogger(url: logFileURL)
+        
+        // Create log entry directly 
         let entry = Cornucopia.Core.LogEntry(
-            level: .info,
+            level: .trace,
             app: "CornucopiaCoreTests",
-            subsystem: "Test",
+            subsystem: "CornucopiaCoreTests",
             category: "FileLogger",
-            thread: 1,
+            thread: 0,
             message: helloWorld
         )
-        logFile.log(entry)
+        
+        fileLogger.log(entry)
 
+        // Verify the file was created and contains expected content
+        XCTAssertTrue(FileManager.default.fileExists(atPath: logFileURL.path), "Log file should exist")
+        
         let data = try! Data(contentsOf: logFileURL)
         let string = data.CC_string
-        XCTAssertTrue(string.contains("Test:FileLogger"))
-        XCTAssertTrue(string.contains("1"))
-        XCTAssertTrue(string.contains(helloWorld))
+        
+        XCTAssertTrue(string.contains("CornucopiaCoreTests"), "Should contain CornucopiaCoreTests, but got: '\(string)'")
+        XCTAssertTrue(string.contains("FileLogger"), "Should contain FileLogger, but got: '\(string)'")
+        XCTAssertFalse(string.contains("FileLogger.swift"), "Should not contain FileLogger.swift, but got: '\(string)'")
+        XCTAssertTrue(string.contains(helloWorld), "Should contain '\(helloWorld)', but got: '\(string)'")
+        
+        // Clean up
+        try? FileManager.default.removeItem(at: logFileURL)
     }
 }
diff --git a/Tests/CornucopiaCoreTests/Networking/HTTPStatusCodeTests.swift b/Tests/CornucopiaCoreTests/Networking/HTTPStatusCodeTests.swift
diff --git a/Tests/CornucopiaCoreTests/PropertyWrappers/DefaultValueProvidersTests.swift b/Tests/CornucopiaCoreTests/PropertyWrappers/DefaultValueProvidersTests.swift
