Skip to content

Commit 29b9367

Browse files
MacOMNIMacOMNI
authored
update utils coverage (#236)
* update utils coverage * update utils coverage
1 parent 9dd2740 commit 29b9367

File tree

6 files changed

+332
-14
lines changed

6 files changed

+332
-14
lines changed

‎Utils/Tests/UtilsTests/Crypto/BLSTests.swift‎

Lines changed: 89 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -65,4 +65,93 @@ import Testing
6565
)
6666
)
6767
}
68+
69+
@Test func BLSKeyInitialization() throws {
70+
let seed = Data32.random()
71+
let bls = try BLS.SecretKey(from: seed)
72+
#expect(bls.publicKey.data.data.count == Int(BLS_PUBLICKEY_SERIALIZED_SIZE))
73+
}
74+
75+
@Test func BLSSignatureSizeValidation() throws {
76+
let bls = try BLS.SecretKey(from: Data32.random())
77+
let message = Data("test".utf8)
78+
let signature = try bls.sign(message: message)
79+
#expect(signature.count == Int(BLS_SIGNATURE_SERIALIZED_SIZE))
80+
}
81+
82+
@Test func BLSPublicKeySerialization() throws {
83+
let bls = try BLS.SecretKey(from: Data32.random())
84+
let publicKey = bls.publicKey
85+
86+
// Encode and decode the public key
87+
let encoder = JSONEncoder()
88+
let encodedData = try encoder.encode(publicKey)
89+
let decoder = JSONDecoder()
90+
let decodedPublicKey = try decoder.decode(BLS.PublicKey.self, from: encodedData)
91+
92+
#expect(decodedPublicKey == publicKey)
93+
}
94+
95+
@Test func BLSPublicKeyEquality() throws {
96+
let key1 = try BLS.SecretKey(from: Data32.random()).publicKey
97+
let key2 = try BLS.SecretKey(from: Data32.random()).publicKey
98+
#expect(key1 != key2)
99+
}
100+
101+
@Test func PublicKeySerialization() throws {
102+
let key1 = try BLS.SecretKey(from: Data32.random()).publicKey.data
103+
let publicKey = try BLS.PublicKey(data: key1)
104+
105+
// Test encoding and decoding
106+
let encoder = JSONEncoder()
107+
let encoded = try encoder.encode(publicKey)
108+
109+
let decoder = JSONDecoder()
110+
let decodedPublicKey = try decoder.decode(BLS.PublicKey.self, from: encoded)
111+
112+
#expect(publicKey == decodedPublicKey)
113+
#expect(publicKey.description == decodedPublicKey.description)
114+
}
115+
116+
@Test func PublicKey() throws {
117+
let keyData1 = Data144.random()
118+
#expect(throws: Error.self) {
119+
_ = try BLS.PublicKey(data: keyData1)
120+
}
121+
}
122+
123+
@Test func PublicKeyVerifyValidSignature() throws {
124+
let bls = try BLS.SecretKey(from: Data32.random())
125+
let publicKey = bls.publicKey
126+
let message = Data("testMessage".utf8)
127+
let signature = try bls.sign(message: message)
128+
129+
// Test valid signature verification
130+
#expect(try publicKey.verify(signature: signature, message: message))
131+
}
132+
133+
@Test func PublicKeyVerifyInvalidSignature() throws {
134+
let bls = try BLS.SecretKey(from: Data32.random())
135+
let publicKey = bls.publicKey
136+
let message = Data("testMessage".utf8)
137+
let signature = try bls.sign(message: message)
138+
139+
// Corrupt the signature
140+
var invalidSignature = signature
141+
invalidSignature[0] ^= 0xFF // Flip a bit in the first byte
142+
143+
// Test invalid signature verification
144+
#expect(try !publicKey.verify(signature: invalidSignature, message: message))
145+
}
146+
147+
@Test func PublicKeyVerifyInvalidMessage() throws {
148+
let bls = try BLS.SecretKey(from: Data32.random())
149+
let publicKey = bls.publicKey
150+
let message = Data("testMessage".utf8)
151+
let invalidMessage = Data("invalidMessage".utf8)
152+
let signature = try bls.sign(message: message)
153+
154+
// Test verification with an invalid message
155+
#expect(try !publicKey.verify(signature: signature, message: invalidMessage))
156+
}
68157
}

‎Utils/Tests/UtilsTests/Crypto/BandersnatchTest.swift‎

Lines changed: 25 additions & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -20,12 +20,36 @@ import Testing
2020
let verifier = Bandersnatch.Verifier(ctx: ctx, commitment: commitment)
2121

2222
for (i, key) in keys.enumerated() {
23-
let prover = Bandersnatch.Prover(sercret: key, ring: keys.map(\.publicKey), proverIdx: UInt(i), ctx: ctx)
23+
let prover = Bandersnatch.Prover(
24+
sercret: key, ring: keys.map(\.publicKey), proverIdx: UInt(i), ctx: ctx
25+
)
2426
let vrfInputData = Data(repeating: UInt8(i), count: 32)
2527
let sig = try prover.ringVRFSign(vrfInputData: vrfInputData)
2628
let output = try verifier.ringVRFVerify(vrfInputData: vrfInputData, signature: sig)
2729
let vrfOutput = try keys[i].getOutput(vrfInputData: vrfInputData)
2830
#expect(output == vrfOutput)
2931
}
3032
}
33+
34+
@Test func testInitialization() throws {
35+
let secret = try Bandersnatch.SecretKey(from: Data32.random())
36+
37+
let publicKey = try Bandersnatch.PublicKey(data: secret.publicKey.data)
38+
#expect(publicKey.data == secret.publicKey.data)
39+
}
40+
41+
@Test func testEncodingAndDecoding() throws {
42+
let secret = try Bandersnatch.SecretKey(from: Data32.random())
43+
44+
let publicKey = try Bandersnatch.PublicKey(data: secret.publicKey.data)
45+
let encoder = JSONEncoder()
46+
let encoded = try encoder.encode(publicKey.data)
47+
48+
let decoder = JSONDecoder()
49+
let decodedPublicKey = try decoder.decode(Bandersnatch.PublicKey.self, from: encoded)
50+
51+
#expect(decodedPublicKey == publicKey)
52+
#expect(decodedPublicKey.data == publicKey.data)
53+
#expect(publicKey.description == decodedPublicKey.description)
54+
}
3155
}

‎Utils/Tests/UtilsTests/Crypto/Ed25519Tests.swift‎

Lines changed: 87 additions & 13 deletions
Original file line numberDiff line numberDiff line change
@@ -4,23 +4,97 @@ import Testing
44
@testable import Utils
55

66
@Suite struct Ed25519Tests {
7-
@Test func testEd25519Signature() throws {
8-
let ed25519 = try Ed25519.SecretKey(from: Data32.random())
9-
let publicKey = ed25519.publicKey
7+
@Test func validateSignature() throws {
8+
let secretKey = try Ed25519.SecretKey(from: Data32.random())
9+
let publicKey = secretKey.publicKey
1010

1111
let message = Data("test".utf8)
12-
let signature = try ed25519.sign(message: message)
12+
let signature = try secretKey.sign(message: message)
13+
1314
#expect(publicKey.verify(signature: signature, message: message))
15+
}
16+
17+
@Test func rejectInvalidMessage() throws {
18+
let secretKey = try Ed25519.SecretKey(from: Data32.random())
19+
let publicKey = secretKey.publicKey
1420

21+
let message = Data("test".utf8)
22+
let signature = try secretKey.sign(message: message)
1523
let invalidMessage = Data("tests".utf8)
16-
#expect(
17-
!publicKey.verify(signature: signature, message: invalidMessage)
18-
)
19-
20-
var invalidSignature = signature.data
21-
invalidSignature.replaceSubrange(0 ... 1, with: [10, 12])
22-
#expect(
23-
!publicKey.verify(signature: Data64(invalidSignature)!, message: message)
24-
)
24+
25+
#expect(!publicKey.verify(signature: signature, message: invalidMessage))
26+
}
27+
28+
@Test func rejectTamperedSignature() throws {
29+
let secretKey = try Ed25519.SecretKey(from: Data32.random())
30+
let publicKey = secretKey.publicKey
31+
32+
let message = Data("test".utf8)
33+
let signature = try secretKey.sign(message: message)
34+
35+
var tamperedSignature = signature.data
36+
tamperedSignature.replaceSubrange(0 ... 1, with: [10, 12])
37+
38+
#expect(!publicKey.verify(signature: Data64(tamperedSignature)!, message: message))
39+
}
40+
41+
@Test func initializeFromData() throws {
42+
let randomData = Data32.random()
43+
let publicKey = try Ed25519.PublicKey(from: randomData)
44+
#expect(publicKey.data == randomData)
45+
}
46+
47+
@Test func encodeAndDecode() throws {
48+
let originalData = Data32.random()
49+
let originalKey = try Ed25519.PublicKey(from: originalData)
50+
51+
let encoder = JSONEncoder()
52+
let encodedData = try encoder.encode(originalKey)
53+
54+
let decoder = JSONDecoder()
55+
let decodedKey = try decoder.decode(Ed25519.PublicKey.self, from: encodedData)
56+
57+
#expect(decodedKey == originalKey)
58+
}
59+
60+
@Test func hashAndEquality() throws {
61+
let data1 = Data32.random()
62+
let data2 = Data32.random()
63+
64+
let publicKey1 = try Ed25519.PublicKey(from: data1)
65+
let publicKey2 = try Ed25519.PublicKey(from: data1)
66+
let publicKey3 = try Ed25519.PublicKey(from: data2)
67+
68+
var hashSet: Set<Ed25519.PublicKey> = []
69+
hashSet.insert(publicKey1)
70+
71+
#expect(publicKey1 == publicKey2)
72+
#expect(publicKey1 != publicKey3)
73+
#expect(hashSet.contains(publicKey2))
74+
#expect(!hashSet.contains(publicKey3))
75+
}
76+
77+
@Test func descriptionCheck() throws {
78+
let randomData = Data32.random()
79+
let publicKey = try Ed25519.PublicKey(from: randomData)
80+
81+
#expect(publicKey.description == randomData.description)
82+
}
83+
84+
@Test func signatureVerification() throws {
85+
let secretKey = try Ed25519.SecretKey(from: Data32.random())
86+
let publicKey = secretKey.publicKey
87+
88+
let message = Data("test message".utf8)
89+
let signature = try secretKey.sign(message: message)
90+
91+
#expect(publicKey.verify(signature: signature, message: message))
92+
93+
let invalidMessage = Data("tampered message".utf8)
94+
#expect(!publicKey.verify(signature: signature, message: invalidMessage))
95+
96+
var tamperedSignature = signature.data
97+
tamperedSignature[0] ^= 0xFF
98+
#expect(!publicKey.verify(signature: Data64(tamperedSignature)!, message: message))
2599
}
26100
}

‎Utils/Tests/UtilsTests/ErasureCodeTest.swift‎

Lines changed: 16 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -44,6 +44,22 @@ struct ErasureCodeTests {
4444
}
4545
}
4646

47+
@Test
48+
func constructWithSegments() throws {
49+
let segments: [Segment] = []
50+
let encoder = SubShardEncoder()
51+
let result = encoder.construct(segments: segments)
52+
if case let .failure(constructFailed) = result {
53+
#expect(constructFailed == ErasureCodeError.constructFailed)
54+
}
55+
}
56+
57+
@Test
58+
func constructWithIncorrectSegmentSize() throws {
59+
let incorrectData = Data(repeating: 0xFF, count: Int(SEGMENT_SIZE) - 1)
60+
#expect(Segment(data: incorrectData, index: 0) == nil)
61+
}
62+
4763
@Test(arguments: try loadTests())
4864
func testReconstruct(testCase: ECTestCase) throws {
4965
// Convert segment_ec data back to bytes and prepare subshards

‎Utils/Tests/UtilsTests/EventBus/DispatcherMiddlewareTests.swift‎

Lines changed: 77 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,77 @@
1+
import bls
2+
import Foundation
3+
import Testing
4+
5+
@testable import Utils
6+
7+
final class MiddlewareTests {
8+
actor OrderManager {
9+
private(set) var order: [Int] = []
10+
11+
func appendOrder(_ value: Int) {
12+
order.append(value)
13+
}
14+
}
15+
16+
@Test func testParallelDispatcher() async throws {
17+
let orderManager = OrderManager()
18+
19+
let firstMiddleware = Middleware.noop
20+
let secondMiddleware = Middleware.noop
21+
22+
let parallelMiddleware = Middleware.parallel(firstMiddleware, secondMiddleware)
23+
24+
let handler: MiddlewareHandler<Void> = { _ in
25+
await orderManager.appendOrder(2)
26+
}
27+
28+
try await parallelMiddleware.handle((), next: {
29+
await orderManager.appendOrder(1)
30+
})
31+
32+
let order = await orderManager.order
33+
#expect(order.count == 2)
34+
}
35+
36+
@Test func testSerialDispatcher() async throws {
37+
let orderManager = OrderManager()
38+
39+
let firstMiddleware = Middleware.noop
40+
let secondMiddleware = Middleware.noop
41+
42+
let serialMiddleware = Middleware.serial(firstMiddleware, secondMiddleware)
43+
44+
let handler: MiddlewareHandler<Void> = { _ in
45+
await orderManager.appendOrder(2)
46+
}
47+
48+
try await serialMiddleware.handle((), next: {
49+
await orderManager.appendOrder(1)
50+
try await handler(())
51+
})
52+
53+
let order = await orderManager.order
54+
#expect(order == [1, 2])
55+
}
56+
57+
@Test func testMiddlewareChain() async throws {
58+
let orderManager = OrderManager()
59+
60+
let middleware1 = Middleware.noop
61+
let middleware2 = Middleware.noop
62+
63+
let middlewareChain = Middleware.serial(middleware1, middleware2)
64+
65+
let handler: MiddlewareHandler<Void> = { _ in
66+
await orderManager.appendOrder(2)
67+
}
68+
69+
try await middlewareChain.handle((), next: {
70+
await orderManager.appendOrder(1)
71+
try await handler(())
72+
})
73+
74+
let order = await orderManager.order
75+
#expect(order == [1, 2])
76+
}
77+
}

‎Utils/Tests/UtilsTests/OptionalTests.swift‎

Lines changed: 38 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,38 @@
1+
import Foundation
2+
import Testing
3+
4+
@testable import Utils
5+
6+
struct OptionalTests {
7+
@Test func testUnwrapSuccess() throws {
8+
let optionalValue: Int? = 42
9+
10+
let result = try optionalValue.unwrap()
11+
12+
#expect(result == 42)
13+
}
14+
15+
@Test func testUnwrapFailure() throws {
16+
let optionalValue: Int? = nil
17+
18+
#expect(throws: OptionalError.nilValue) {
19+
_ = try optionalValue.unwrap()
20+
}
21+
}
22+
23+
@Test func testUnwrapOrErrorSuccess() throws {
24+
let optionalValue: Int? = 42
25+
26+
let result = try optionalValue.unwrap(orError: NSError(domain: "", code: 1))
27+
28+
#expect(result == 42)
29+
}
30+
31+
@Test func testExpectSuccess() throws {
32+
let optionalValue: Int? = 42
33+
34+
let result = optionalValue.expect("Value should be present")
35+
36+
#expect(result == 42)
37+
}
38+
}

0 commit comments

Comments
 (0)