Skip to content

Commit 757815b

Browse files
fabianfettfabianfett
authored
Use Swift Testing in LambdaRequestIDTests (#360)
1 parent dd77e81 commit 757815b

File tree

1 file changed

+93
-77
lines changed

1 file changed

+93
-77
lines changed

‎Tests/AWSLambdaRuntimeCoreTests/LambdaRequestIDTests.swift‎

Lines changed: 93 additions & 77 deletions
Original file line numberDiff line numberDiff line change
@@ -12,63 +12,70 @@
1212
//
1313
//===----------------------------------------------------------------------===//
1414

15+
import Foundation
1516
import NIOCore
16-
import XCTest
17+
import Testing
1718

1819
@testable import AWSLambdaRuntimeCore
1920

20-
final class LambdaRequestIDTest: XCTestCase {
21+
@Suite("LambdaRequestID tests")
22+
struct LambdaRequestIDTest {
23+
@Test
2124
func testInitFromStringSuccess() {
2225
let string = "E621E1F8-C36C-495A-93FC-0C247A3E6E5F"
2326
var buffer = ByteBuffer(string: string)
2427

2528
let requestID = buffer.readRequestID()
26-
XCTAssertEqual(buffer.readerIndex, 36)
27-
XCTAssertEqual(buffer.readableBytes, 0)
28-
XCTAssertEqual(requestID?.uuidString, UUID(uuidString: string)?.uuidString)
29-
XCTAssertEqual(requestID?.uppercased, string)
29+
#expect(buffer.readerIndex == 36)
30+
#expect(buffer.readableBytes == 0)
31+
#expect(requestID?.uuidString == UUID(uuidString: string)?.uuidString)
32+
#expect(requestID?.uppercased == string)
3033
}
3134

35+
@Test
3236
func testInitFromLowercaseStringSuccess() {
3337
let string = "E621E1F8-C36C-495A-93FC-0C247A3E6E5F".lowercased()
3438
var originalBuffer = ByteBuffer(string: string)
3539

3640
let requestID = originalBuffer.readRequestID()
37-
XCTAssertEqual(originalBuffer.readerIndex, 36)
38-
XCTAssertEqual(originalBuffer.readableBytes, 0)
39-
XCTAssertEqual(requestID?.uuidString, UUID(uuidString: string)?.uuidString)
40-
XCTAssertEqual(requestID?.lowercased, string)
41+
#expect(originalBuffer.readerIndex == 36)
42+
#expect(originalBuffer.readableBytes == 0)
43+
#expect(requestID?.uuidString == UUID(uuidString: string)?.uuidString)
44+
#expect(requestID?.lowercased == string)
4145

4246
var newBuffer = ByteBuffer()
4347
originalBuffer.moveReaderIndex(to: 0)
44-
XCTAssertNoThrow(try newBuffer.writeRequestID(XCTUnwrap(requestID)))
45-
XCTAssertEqual(newBuffer, originalBuffer)
48+
#expect(throws: Never.self) { try newBuffer.writeRequestID(#require(requestID)) }
49+
#expect(newBuffer == originalBuffer)
4650
}
4751

52+
@Test
4853
func testInitFromStringMissingCharacterAtEnd() {
4954
let string = "E621E1F8-C36C-495A-93FC-0C247A3E6E5"
5055
var buffer = ByteBuffer(string: string)
5156

5257
let readableBeforeRead = buffer.readableBytes
5358
let requestID = buffer.readRequestID()
54-
XCTAssertNil(requestID)
55-
XCTAssertEqual(buffer.readerIndex, 0)
56-
XCTAssertEqual(buffer.readableBytes, readableBeforeRead)
59+
#expect(requestID == nil)
60+
#expect(buffer.readerIndex == 0)
61+
#expect(buffer.readableBytes == readableBeforeRead)
5762
}
5863

64+
@Test
5965
func testInitFromStringInvalidCharacterAtEnd() {
6066
let string = "E621E1F8-C36C-495A-93FC-0C247A3E6E5H"
6167
var buffer = ByteBuffer(string: string)
6268

6369
let readableBeforeRead = buffer.readableBytes
6470
let requestID = buffer.readRequestID()
65-
XCTAssertNil(requestID)
66-
XCTAssertEqual(buffer.readerIndex, 0)
67-
XCTAssertEqual(buffer.readableBytes, readableBeforeRead)
71+
#expect(requestID == nil)
72+
#expect(buffer.readerIndex == 0)
73+
#expect(buffer.readableBytes == readableBeforeRead)
6874
}
6975

70-
func testInitFromStringInvalidSeparatorCharacter() {
71-
let invalid = [
76+
@Test(
77+
"Init from String with invalid separator character",
78+
arguments: [
7279
// with _ instead of -
7380
"E621E1F8-C36C-495A-93FC_0C247A3E6E5F",
7481
"E621E1F8-C36C-495A_93FC-0C247A3E6E5F",
@@ -81,18 +88,19 @@ final class LambdaRequestIDTest: XCTestCase {
8188
"E621E1F8-C36C0495A-93FC-0C247A3E6E5F",
8289
"E621E1F80C36C-495A-93FC-0C247A3E6E5F",
8390
]
91+
)
92+
func testInitFromStringInvalidSeparatorCharacter(_ input: String) {
8493

85-
for string in invalid {
86-
var buffer = ByteBuffer(string: string)
94+
var buffer = ByteBuffer(string: input)
8795

88-
let readableBeforeRead = buffer.readableBytes
89-
let requestID = buffer.readRequestID()
90-
XCTAssertNil(requestID)
91-
XCTAssertEqual(buffer.readerIndex, 0)
92-
XCTAssertEqual(buffer.readableBytes, readableBeforeRead)
93-
}
96+
let readableBeforeRead = buffer.readableBytes
97+
let requestID = buffer.readRequestID()
98+
#expect(requestID == nil)
99+
#expect(buffer.readerIndex == 0)
100+
#expect(buffer.readableBytes == readableBeforeRead)
94101
}
95102

103+
@Test
96104
func testInitFromNSStringSuccess() {
97105
let nsString = NSMutableString(capacity: 16)
98106
nsString.append("E621E1F8")
@@ -110,93 +118,99 @@ final class LambdaRequestIDTest: XCTestCase {
110118
// achieve this though at the moment
111119
// XCTAssertFalse((nsString as String).isContiguousUTF8)
112120
let requestID = LambdaRequestID(uuidString: nsString as String)
113-
XCTAssertEqual(requestID?.uuidString, LambdaRequestID(uuidString: nsString as String)?.uuidString)
114-
XCTAssertEqual(requestID?.uppercased, nsString as String)
121+
#expect(requestID?.uuidString == LambdaRequestID(uuidString: nsString as String)?.uuidString)
122+
#expect(requestID?.uppercased == nsString as String)
115123
}
116124

125+
@Test
117126
func testUnparse() {
118127
let string = "E621E1F8-C36C-495A-93FC-0C247A3E6E5F"
119128
let requestID = LambdaRequestID(uuidString: string)
120-
XCTAssertEqual(string.lowercased(), requestID?.lowercased)
129+
#expect(string.lowercased() == requestID?.lowercased)
121130
}
122131

132+
@Test
123133
func testDescription() {
124134
let requestID = LambdaRequestID()
125135
let fduuid = UUID(uuid: requestID.uuid)
126136

127-
XCTAssertEqual(fduuid.description, requestID.description)
128-
XCTAssertEqual(fduuid.debugDescription, requestID.debugDescription)
137+
#expect(fduuid.description == requestID.description)
138+
#expect(fduuid.debugDescription == requestID.debugDescription)
129139
}
130140

141+
@Test
131142
func testFoundationInteropFromFoundation() {
132143
let fduuid = UUID()
133144
let requestID = LambdaRequestID(uuid: fduuid.uuid)
134145

135-
XCTAssertEqual(fduuid.uuid.0, requestID.uuid.0)
136-
XCTAssertEqual(fduuid.uuid.1, requestID.uuid.1)
137-
XCTAssertEqual(fduuid.uuid.2, requestID.uuid.2)
138-
XCTAssertEqual(fduuid.uuid.3, requestID.uuid.3)
139-
XCTAssertEqual(fduuid.uuid.4, requestID.uuid.4)
140-
XCTAssertEqual(fduuid.uuid.5, requestID.uuid.5)
141-
XCTAssertEqual(fduuid.uuid.6, requestID.uuid.6)
142-
XCTAssertEqual(fduuid.uuid.7, requestID.uuid.7)
143-
XCTAssertEqual(fduuid.uuid.8, requestID.uuid.8)
144-
XCTAssertEqual(fduuid.uuid.9, requestID.uuid.9)
145-
XCTAssertEqual(fduuid.uuid.10, requestID.uuid.10)
146-
XCTAssertEqual(fduuid.uuid.11, requestID.uuid.11)
147-
XCTAssertEqual(fduuid.uuid.12, requestID.uuid.12)
148-
XCTAssertEqual(fduuid.uuid.13, requestID.uuid.13)
149-
XCTAssertEqual(fduuid.uuid.14, requestID.uuid.14)
150-
XCTAssertEqual(fduuid.uuid.15, requestID.uuid.15)
146+
#expect(fduuid.uuid.0 == requestID.uuid.0)
147+
#expect(fduuid.uuid.1 == requestID.uuid.1)
148+
#expect(fduuid.uuid.2 == requestID.uuid.2)
149+
#expect(fduuid.uuid.3 == requestID.uuid.3)
150+
#expect(fduuid.uuid.4 == requestID.uuid.4)
151+
#expect(fduuid.uuid.5 == requestID.uuid.5)
152+
#expect(fduuid.uuid.6 == requestID.uuid.6)
153+
#expect(fduuid.uuid.7 == requestID.uuid.7)
154+
#expect(fduuid.uuid.8 == requestID.uuid.8)
155+
#expect(fduuid.uuid.9 == requestID.uuid.9)
156+
#expect(fduuid.uuid.10 == requestID.uuid.10)
157+
#expect(fduuid.uuid.11 == requestID.uuid.11)
158+
#expect(fduuid.uuid.12 == requestID.uuid.12)
159+
#expect(fduuid.uuid.13 == requestID.uuid.13)
160+
#expect(fduuid.uuid.14 == requestID.uuid.14)
161+
#expect(fduuid.uuid.15 == requestID.uuid.15)
151162
}
152163

164+
@Test
153165
func testFoundationInteropToFoundation() {
154166
let requestID = LambdaRequestID()
155167
let fduuid = UUID(uuid: requestID.uuid)
156168

157-
XCTAssertEqual(fduuid.uuid.0, requestID.uuid.0)
158-
XCTAssertEqual(fduuid.uuid.1, requestID.uuid.1)
159-
XCTAssertEqual(fduuid.uuid.2, requestID.uuid.2)
160-
XCTAssertEqual(fduuid.uuid.3, requestID.uuid.3)
161-
XCTAssertEqual(fduuid.uuid.4, requestID.uuid.4)
162-
XCTAssertEqual(fduuid.uuid.5, requestID.uuid.5)
163-
XCTAssertEqual(fduuid.uuid.6, requestID.uuid.6)
164-
XCTAssertEqual(fduuid.uuid.7, requestID.uuid.7)
165-
XCTAssertEqual(fduuid.uuid.8, requestID.uuid.8)
166-
XCTAssertEqual(fduuid.uuid.9, requestID.uuid.9)
167-
XCTAssertEqual(fduuid.uuid.10, requestID.uuid.10)
168-
XCTAssertEqual(fduuid.uuid.11, requestID.uuid.11)
169-
XCTAssertEqual(fduuid.uuid.12, requestID.uuid.12)
170-
XCTAssertEqual(fduuid.uuid.13, requestID.uuid.13)
171-
XCTAssertEqual(fduuid.uuid.14, requestID.uuid.14)
172-
XCTAssertEqual(fduuid.uuid.15, requestID.uuid.15)
169+
#expect(fduuid.uuid.0 == requestID.uuid.0)
170+
#expect(fduuid.uuid.1 == requestID.uuid.1)
171+
#expect(fduuid.uuid.2 == requestID.uuid.2)
172+
#expect(fduuid.uuid.3 == requestID.uuid.3)
173+
#expect(fduuid.uuid.4 == requestID.uuid.4)
174+
#expect(fduuid.uuid.5 == requestID.uuid.5)
175+
#expect(fduuid.uuid.6 == requestID.uuid.6)
176+
#expect(fduuid.uuid.7 == requestID.uuid.7)
177+
#expect(fduuid.uuid.8 == requestID.uuid.8)
178+
#expect(fduuid.uuid.9 == requestID.uuid.9)
179+
#expect(fduuid.uuid.10 == requestID.uuid.10)
180+
#expect(fduuid.uuid.11 == requestID.uuid.11)
181+
#expect(fduuid.uuid.12 == requestID.uuid.12)
182+
#expect(fduuid.uuid.13 == requestID.uuid.13)
183+
#expect(fduuid.uuid.14 == requestID.uuid.14)
184+
#expect(fduuid.uuid.15 == requestID.uuid.15)
173185
}
174186

187+
@Test
175188
func testHashing() {
176189
let requestID = LambdaRequestID()
177190
let fduuid = UUID(uuid: requestID.uuid)
178-
XCTAssertEqual(fduuid.hashValue, requestID.hashValue)
191+
#expect(fduuid.hashValue == requestID.hashValue)
179192

180193
var _uuid = requestID.uuid
181194
_uuid.0 = _uuid.0 > 0 ? _uuid.0 - 1 : 1
182-
XCTAssertNotEqual(UUID(uuid: _uuid).hashValue, requestID.hashValue)
195+
#expect(UUID(uuid: _uuid).hashValue != requestID.hashValue)
183196
}
184197

185-
func testEncoding() {
198+
@Test
199+
func testEncoding() throws {
186200
struct Test: Codable {
187201
let requestID: LambdaRequestID
188202
}
189203
let requestID = LambdaRequestID()
190204
let test = Test(requestID: requestID)
191205

192206
var data: Data?
193-
XCTAssertNoThrow(data = try JSONEncoder().encode(test))
194-
XCTAssertEqual(
195-
try String(decoding: XCTUnwrap(data), as: Unicode.UTF8.self),
196-
#"{"requestID":"\#(requestID.uuidString)"}"#
207+
#expect(throws: Never.self) { data = try JSONEncoder().encode(test) }
208+
#expect(
209+
try String(decoding: #require(data), as: Unicode.UTF8.self) == #"{"requestID":"\#(requestID.uuidString)"}"#
197210
)
198211
}
199212

213+
@Test
200214
func testDecodingSuccess() {
201215
struct Test: Codable {
202216
let requestID: LambdaRequestID
@@ -205,10 +219,11 @@ final class LambdaRequestIDTest: XCTestCase {
205219
let data = #"{"requestID":"\#(requestID.uuidString)"}"#.data(using: .utf8)
206220

207221
var result: Test?
208-
XCTAssertNoThrow(result = try JSONDecoder().decode(Test.self, from: XCTUnwrap(data)))
209-
XCTAssertEqual(result?.requestID, requestID)
222+
#expect(throws: Never.self) { result = try JSONDecoder().decode(Test.self, from: #require(data)) }
223+
#expect(result?.requestID == requestID)
210224
}
211225

226+
@Test
212227
func testDecodingFailure() {
213228
struct Test: Codable {
214229
let requestID: LambdaRequestID
@@ -218,12 +233,13 @@ final class LambdaRequestIDTest: XCTestCase {
218233
_ = requestIDString.removeLast()
219234
let data = #"{"requestID":"\#(requestIDString)"}"#.data(using: .utf8)
220235

221-
XCTAssertThrowsError(try JSONDecoder().decode(Test.self, from: XCTUnwrap(data))) { error in
222-
XCTAssertNotNil(error as? DecodingError)
236+
#expect(throws: DecodingError.self) {
237+
try JSONDecoder().decode(Test.self, from: #require(data))
223238
}
224239
}
225240

241+
@Test
226242
func testStructSize() {
227-
XCTAssertEqual(MemoryLayout<LambdaRequestID>.size, 16)
243+
#expect(MemoryLayout<LambdaRequestID>.size == 16)
228244
}
229245
}

0 commit comments

Comments
 (0)