Skip to content

Commit 540aef1

Browse files
fabianfettfabianfett
committed
Use Swift Testing in LambdaRequestIDTests
1 parent 435033e commit 540aef1

File tree

1 file changed

+98
-77
lines changed

1 file changed

+98
-77
lines changed

‎Tests/AWSLambdaRuntimeCoreTests/LambdaRequestIDTests.swift

Lines changed: 98 additions & 77 deletions
Original file line numberDiff line numberDiff line change
@@ -13,62 +13,74 @@
1313
//===----------------------------------------------------------------------===//
1414

1515
import NIOCore
16-
import XCTest
16+
import Testing
1717

1818
@testable import AWSLambdaRuntimeCore
1919

20-
final class LambdaRequestIDTest: XCTestCase {
20+
#if canImport(FoundationEssentials)
21+
import FoundationEssentials
22+
#else
23+
import Foundation
24+
#endif
25+
26+
@Suite("LambdaRequestID tests")
27+
struct LambdaRequestIDTest {
28+
@Test
2129
func testInitFromStringSuccess() {
2230
let string = "E621E1F8-C36C-495A-93FC-0C247A3E6E5F"
2331
var buffer = ByteBuffer(string: string)
2432

2533
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)
34+
#expect(buffer.readerIndex == 36)
35+
#expect(buffer.readableBytes == 0)
36+
#expect(requestID?.uuidString == UUID(uuidString: string)?.uuidString)
37+
#expect(requestID?.uppercased == string)
3038
}
3139

40+
@Test
3241
func testInitFromLowercaseStringSuccess() {
3342
let string = "E621E1F8-C36C-495A-93FC-0C247A3E6E5F".lowercased()
3443
var originalBuffer = ByteBuffer(string: string)
3544

3645
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)
46+
#expect(originalBuffer.readerIndex == 36)
47+
#expect(originalBuffer.readableBytes == 0)
48+
#expect(requestID?.uuidString == UUID(uuidString: string)?.uuidString)
49+
#expect(requestID?.lowercased == string)
4150

4251
var newBuffer = ByteBuffer()
4352
originalBuffer.moveReaderIndex(to: 0)
44-
XCTAssertNoThrow(try newBuffer.writeRequestID(XCTUnwrap(requestID)))
45-
XCTAssertEqual(newBuffer, originalBuffer)
53+
#expect(throws: Never.self) { try newBuffer.writeRequestID(#require(requestID)) }
54+
#expect(newBuffer == originalBuffer)
4655
}
4756

57+
@Test
4858
func testInitFromStringMissingCharacterAtEnd() {
4959
let string = "E621E1F8-C36C-495A-93FC-0C247A3E6E5"
5060
var buffer = ByteBuffer(string: string)
5161

5262
let readableBeforeRead = buffer.readableBytes
5363
let requestID = buffer.readRequestID()
54-
XCTAssertNil(requestID)
55-
XCTAssertEqual(buffer.readerIndex, 0)
56-
XCTAssertEqual(buffer.readableBytes, readableBeforeRead)
64+
#expect(requestID == nil)
65+
#expect(buffer.readerIndex == 0)
66+
#expect(buffer.readableBytes == readableBeforeRead)
5767
}
5868

69+
@Test
5970
func testInitFromStringInvalidCharacterAtEnd() {
6071
let string = "E621E1F8-C36C-495A-93FC-0C247A3E6E5H"
6172
var buffer = ByteBuffer(string: string)
6273

6374
let readableBeforeRead = buffer.readableBytes
6475
let requestID = buffer.readRequestID()
65-
XCTAssertNil(requestID)
66-
XCTAssertEqual(buffer.readerIndex, 0)
67-
XCTAssertEqual(buffer.readableBytes, readableBeforeRead)
76+
#expect(requestID == nil)
77+
#expect(buffer.readerIndex == 0)
78+
#expect(buffer.readableBytes == readableBeforeRead)
6879
}
6980

70-
func testInitFromStringInvalidSeparatorCharacter() {
71-
let invalid = [
81+
@Test(
82+
"Init from String with invalid separator character",
83+
arguments: [
7284
// with _ instead of -
7385
"E621E1F8-C36C-495A-93FC_0C247A3E6E5F",
7486
"E621E1F8-C36C-495A_93FC-0C247A3E6E5F",
@@ -81,18 +93,19 @@ final class LambdaRequestIDTest: XCTestCase {
8193
"E621E1F8-C36C0495A-93FC-0C247A3E6E5F",
8294
"E621E1F80C36C-495A-93FC-0C247A3E6E5F",
8395
]
96+
)
97+
func testInitFromStringInvalidSeparatorCharacter(_ input: String) {
8498

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

88-
let readableBeforeRead = buffer.readableBytes
89-
let requestID = buffer.readRequestID()
90-
XCTAssertNil(requestID)
91-
XCTAssertEqual(buffer.readerIndex, 0)
92-
XCTAssertEqual(buffer.readableBytes, readableBeforeRead)
93-
}
101+
let readableBeforeRead = buffer.readableBytes
102+
let requestID = buffer.readRequestID()
103+
#expect(requestID == nil)
104+
#expect(buffer.readerIndex == 0)
105+
#expect(buffer.readableBytes == readableBeforeRead)
94106
}
95107

108+
@Test
96109
func testInitFromNSStringSuccess() {
97110
let nsString = NSMutableString(capacity: 16)
98111
nsString.append("E621E1F8")
@@ -110,93 +123,99 @@ final class LambdaRequestIDTest: XCTestCase {
110123
// achieve this though at the moment
111124
// XCTAssertFalse((nsString as String).isContiguousUTF8)
112125
let requestID = LambdaRequestID(uuidString: nsString as String)
113-
XCTAssertEqual(requestID?.uuidString, LambdaRequestID(uuidString: nsString as String)?.uuidString)
114-
XCTAssertEqual(requestID?.uppercased, nsString as String)
126+
#expect(requestID?.uuidString == LambdaRequestID(uuidString: nsString as String)?.uuidString)
127+
#expect(requestID?.uppercased == nsString as String)
115128
}
116129

130+
@Test
117131
func testUnparse() {
118132
let string = "E621E1F8-C36C-495A-93FC-0C247A3E6E5F"
119133
let requestID = LambdaRequestID(uuidString: string)
120-
XCTAssertEqual(string.lowercased(), requestID?.lowercased)
134+
#expect(string.lowercased() == requestID?.lowercased)
121135
}
122136

137+
@Test
123138
func testDescription() {
124139
let requestID = LambdaRequestID()
125140
let fduuid = UUID(uuid: requestID.uuid)
126141

127-
XCTAssertEqual(fduuid.description, requestID.description)
128-
XCTAssertEqual(fduuid.debugDescription, requestID.debugDescription)
142+
#expect(fduuid.description == requestID.description)
143+
#expect(fduuid.debugDescription == requestID.debugDescription)
129144
}
130145

146+
@Test
131147
func testFoundationInteropFromFoundation() {
132148
let fduuid = UUID()
133149
let requestID = LambdaRequestID(uuid: fduuid.uuid)
134150

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)
151+
#expect(fduuid.uuid.0 == requestID.uuid.0)
152+
#expect(fduuid.uuid.1 == requestID.uuid.1)
153+
#expect(fduuid.uuid.2 == requestID.uuid.2)
154+
#expect(fduuid.uuid.3 == requestID.uuid.3)
155+
#expect(fduuid.uuid.4 == requestID.uuid.4)
156+
#expect(fduuid.uuid.5 == requestID.uuid.5)
157+
#expect(fduuid.uuid.6 == requestID.uuid.6)
158+
#expect(fduuid.uuid.7 == requestID.uuid.7)
159+
#expect(fduuid.uuid.8 == requestID.uuid.8)
160+
#expect(fduuid.uuid.9 == requestID.uuid.9)
161+
#expect(fduuid.uuid.10 == requestID.uuid.10)
162+
#expect(fduuid.uuid.11 == requestID.uuid.11)
163+
#expect(fduuid.uuid.12 == requestID.uuid.12)
164+
#expect(fduuid.uuid.13 == requestID.uuid.13)
165+
#expect(fduuid.uuid.14 == requestID.uuid.14)
166+
#expect(fduuid.uuid.15 == requestID.uuid.15)
151167
}
152168

169+
@Test
153170
func testFoundationInteropToFoundation() {
154171
let requestID = LambdaRequestID()
155172
let fduuid = UUID(uuid: requestID.uuid)
156173

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)
174+
#expect(fduuid.uuid.0 == requestID.uuid.0)
175+
#expect(fduuid.uuid.1 == requestID.uuid.1)
176+
#expect(fduuid.uuid.2 == requestID.uuid.2)
177+
#expect(fduuid.uuid.3 == requestID.uuid.3)
178+
#expect(fduuid.uuid.4 == requestID.uuid.4)
179+
#expect(fduuid.uuid.5 == requestID.uuid.5)
180+
#expect(fduuid.uuid.6 == requestID.uuid.6)
181+
#expect(fduuid.uuid.7 == requestID.uuid.7)
182+
#expect(fduuid.uuid.8 == requestID.uuid.8)
183+
#expect(fduuid.uuid.9 == requestID.uuid.9)
184+
#expect(fduuid.uuid.10 == requestID.uuid.10)
185+
#expect(fduuid.uuid.11 == requestID.uuid.11)
186+
#expect(fduuid.uuid.12 == requestID.uuid.12)
187+
#expect(fduuid.uuid.13 == requestID.uuid.13)
188+
#expect(fduuid.uuid.14 == requestID.uuid.14)
189+
#expect(fduuid.uuid.15 == requestID.uuid.15)
173190
}
174191

192+
@Test
175193
func testHashing() {
176194
let requestID = LambdaRequestID()
177195
let fduuid = UUID(uuid: requestID.uuid)
178-
XCTAssertEqual(fduuid.hashValue, requestID.hashValue)
196+
#expect(fduuid.hashValue == requestID.hashValue)
179197

180198
var _uuid = requestID.uuid
181199
_uuid.0 = _uuid.0 > 0 ? _uuid.0 - 1 : 1
182-
XCTAssertNotEqual(UUID(uuid: _uuid).hashValue, requestID.hashValue)
200+
#expect(UUID(uuid: _uuid).hashValue != requestID.hashValue)
183201
}
184202

185-
func testEncoding() {
203+
@Test
204+
func testEncoding() throws {
186205
struct Test: Codable {
187206
let requestID: LambdaRequestID
188207
}
189208
let requestID = LambdaRequestID()
190209
let test = Test(requestID: requestID)
191210

192211
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)"}"#
212+
#expect(throws: Never.self) { data = try JSONEncoder().encode(test) }
213+
#expect(
214+
try String(decoding: #require(data), as: Unicode.UTF8.self) == #"{"requestID":"\#(requestID.uuidString)"}"#
197215
)
198216
}
199217

218+
@Test
200219
func testDecodingSuccess() {
201220
struct Test: Codable {
202221
let requestID: LambdaRequestID
@@ -205,10 +224,11 @@ final class LambdaRequestIDTest: XCTestCase {
205224
let data = #"{"requestID":"\#(requestID.uuidString)"}"#.data(using: .utf8)
206225

207226
var result: Test?
208-
XCTAssertNoThrow(result = try JSONDecoder().decode(Test.self, from: XCTUnwrap(data)))
209-
XCTAssertEqual(result?.requestID, requestID)
227+
#expect(throws: Never.self) { result = try JSONDecoder().decode(Test.self, from: #require(data)) }
228+
#expect(result?.requestID == requestID)
210229
}
211230

231+
@Test
212232
func testDecodingFailure() {
213233
struct Test: Codable {
214234
let requestID: LambdaRequestID
@@ -218,12 +238,13 @@ final class LambdaRequestIDTest: XCTestCase {
218238
_ = requestIDString.removeLast()
219239
let data = #"{"requestID":"\#(requestIDString)"}"#.data(using: .utf8)
220240

221-
XCTAssertThrowsError(try JSONDecoder().decode(Test.self, from: XCTUnwrap(data))) { error in
222-
XCTAssertNotNil(error as? DecodingError)
241+
#expect(throws: DecodingError.self) {
242+
try JSONDecoder().decode(Test.self, from: #require(data))
223243
}
224244
}
225245

246+
@Test
226247
func testStructSize() {
227-
XCTAssertEqual(MemoryLayout<LambdaRequestID>.size, 16)
248+
#expect(MemoryLayout<LambdaRequestID>.size == 16)
228249
}
229250
}

0 commit comments

Comments
 (0)