diff --git a/Tests/RSocketCoreTests/Frame Header/FrameHeaderTests.swift b/Tests/RSocketCoreTests/Frame Header/FrameHeaderTests.swift new file mode 100644 index 00000000..2b0ba59d --- /dev/null +++ b/Tests/RSocketCoreTests/Frame Header/FrameHeaderTests.swift @@ -0,0 +1,152 @@ +/* + * Copyright 2015-present the original author or authors. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +import NIO +import XCTest +@testable import RSocketCore + +final class FrameHeaderTests: XCTestCase { + + func testFrameHeaderType() { + let frameHeader = FrameHeader(streamId: 0, type: .cancel, flags: []) + XCTAssertEqual(frameHeader.type, .cancel) + } + + func testFrameHeaderStreamId() { + let frameHeader = FrameHeader(streamId: 2, type: .setup, flags: []) + XCTAssertEqual(frameHeader.streamId, 2) + } + + func testFrameHeaderFlags() { + let flags: FrameFlags = FrameFlags(rawValue: 24) + let frameHeader = FrameHeader(streamId: 2, type: .payload, flags: flags) + XCTAssertEqual(frameHeader.flags, flags) + } + + func testFrameHeaderPassValidation() { + let frameHeader = FrameHeader(streamId: 2, type: .setup, flags: []) + + XCTAssertNoThrow(try frameHeader.validate()) + } + + func testFrameHeaderFailValidation() { + let frameHeader = FrameHeader(streamId: -1, type: .setup, flags: []) + + XCTAssertThrowsError(try frameHeader.validate()) { error in + guard case Error.connectionError(let value) = error else { + return XCTFail("Unexpected error type") + } + + XCTAssertEqual(value, "streamId has to be equal or bigger than 0") + } + } + + func testFrameHeaderEncoder() { + let frameHeader = FrameHeader(streamId: 2, type: .cancel, flags: []) + + guard var byteBuffer = try? FrameHeaderEncoder().encode(header: frameHeader, using: ByteBufferAllocator()) else { + XCTFail("Expected byte buffer to be not nil") + return + } + + XCTAssertEqual(byteBuffer.readableBytes, 6) + XCTAssertEqual(byteBuffer.readBytes(length: byteBuffer.readableBytes), [0, 0, 0, 2, + 36, 0]) + } + + func testFrameHeaderDecoder() { + var byteBuffer = ByteBuffer(bytes: [0x00, 0x00, + 0x00, 0x02, + 0x05, 0x00]) + guard let decodedFrameHeader = try? FrameHeaderDecoder().decode(buffer: &byteBuffer) else { + XCTFail("Expected decoded frame header to be not nil") + return + } + + XCTAssertEqual(decodedFrameHeader.streamId, 2) + XCTAssertEqual(decodedFrameHeader.type, .setup) + XCTAssert(decodedFrameHeader.flags.rawValue & FrameFlags.metadata.rawValue != 0, "Expected metadata flag to be set") + } + + func testTypeAndFlags() { + let flags: FrameFlags = FrameFlags(rawValue: 0b1110110111) // 10 bits + let frameHeader = FrameHeader(streamId: 0, type: .requestFnf, flags: flags) + + guard var byteBuffer = try? FrameHeaderEncoder().encode(header: frameHeader, using: ByteBufferAllocator()) else { + XCTFail("Expected byte buffer to be not nil") + return + } + + guard let decodedFrameHeader = try? FrameHeaderDecoder().decode(buffer: &byteBuffer) else { + XCTFail("Expected decoded frame header to be not nil") + return + } + + XCTAssertEqual(decodedFrameHeader.flags, flags) + } + + func testFlagsTruncated() { + let flags: FrameFlags = FrameFlags(rawValue: 0b11111111111) // 11 bits + let frameHeader = FrameHeader(streamId: 0, type: .requestFnf, flags: flags) + + guard var byteBuffer = try? FrameHeaderEncoder().encode(header: frameHeader, using: ByteBufferAllocator()) else { + XCTFail("Expected byte buffer to be not nil") + return + } + + guard let decodedFrameHeader = try? FrameHeaderDecoder().decode(buffer: &byteBuffer) else { + XCTFail("Expected decoded frame header to be not nil") + return + } + + XCTAssertNotEqual(decodedFrameHeader.flags, flags) + XCTAssertEqual(decodedFrameHeader.flags, FrameFlags(rawValue: 0b1111111111)) + } + + func testMetadataFlag() { + let flags: FrameFlags = FrameFlags(rawValue: 0b0100000000) + let frameHeader = FrameHeader(streamId: 0, type: .requestFnf, flags: flags) + + guard var byteBuffer = try? FrameHeaderEncoder().encode(header: frameHeader, using: ByteBufferAllocator()) else { + XCTFail("Expected byte buffer to be not nil") + return + } + + guard let decodedFrameHeader = try? FrameHeaderDecoder().decode(buffer: &byteBuffer) else { + XCTFail("Expected decoded frame header to be not nil") + return + } + + XCTAssert(decodedFrameHeader.flags.rawValue & FrameFlags.metadata.rawValue != 0, "Expected metadata flag to be set") + } + + func testIgnoreFlag() { + let flags: FrameFlags = FrameFlags(rawValue: 0b1000000000) + let frameHeader = FrameHeader(streamId: 0, type: .ext, flags: flags) + + guard var byteBuffer = try? FrameHeaderEncoder().encode(header: frameHeader, using: ByteBufferAllocator()) else { + XCTFail("Expected byte buffer to be not nil") + return + } + + guard let decodedFrameHeader = try? FrameHeaderDecoder().decode(buffer: &byteBuffer) else { + XCTFail("Expected decoded frame header to be not nil") + return + } + + XCTAssert(decodedFrameHeader.flags.rawValue & FrameFlags.ignore.rawValue != 0, "Expected ignore flag to be set") + } +} diff --git a/Tests/RSocketCoreTests/Frames/CancelFrameTests.swift b/Tests/RSocketCoreTests/Frames/CancelFrameTests.swift new file mode 100644 index 00000000..39b257f7 --- /dev/null +++ b/Tests/RSocketCoreTests/Frames/CancelFrameTests.swift @@ -0,0 +1,105 @@ +/* + * Copyright 2015-present the original author or authors. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +import NIO +import XCTest +@testable import RSocketCore + +/* This class has tests for Cancel Frame. */ +final class CancelFrameTests: XCTestCase { + + static private let bytes: [UInt8] = [0, 0, 0, 0, + 36, 0] + + /* Test Cancel Frame initialisation with streamId. + * Verify that the frame is initialised with expected values. + */ + func testCancelFrameInit() { + let cancelFrame = CancelFrame(streamId: 0) + + XCTAssertEqual(cancelFrame.header.streamId, 0) + XCTAssertEqual(cancelFrame.header.type, .cancel, "Expected cancel frame type") + XCTAssertTrue(cancelFrame.header.flags.isEmpty, "Expected flags to be empty") + } + + /* Test Cancel Frame initialisation with FrameHeader. + * Verify that the frame is initialised with expected values. + */ + func testCancelFrameInitWithFrameHeader() { + let cancelFrame = CancelFrame(header: FrameHeader(streamId: 0, type: .cancel, flags: FrameFlags(rawValue: 6))) + + XCTAssertEqual(cancelFrame.header.streamId, 0) + XCTAssertEqual(cancelFrame.header.type, .cancel, "Expected cancel frame type") + XCTAssertEqual(cancelFrame.header.flags, FrameFlags(rawValue: 6), "Expected flags to be not empty") + } + + /* Test Cancel Frame Encoder. + * Encode a cancel frame with streamId and check the bytes in encoded byte buffer. + */ + func testCancelFrameHeaderEncoder() { + guard var byteBuffer = try? CancelFrameEncoder().encode(frame: CancelFrame(streamId: 0), using: ByteBufferAllocator()) else { + XCTFail("Expected byte buffer to be not nil") + return + } + + XCTAssertEqual(byteBuffer.readableBytes, 6) + XCTAssertEqual(byteBuffer.readBytes(length: byteBuffer.readableBytes), CancelFrameTests.bytes) + } + + /* Test for Cancel Frame Decoder. + * Verify that the decoded byte buffer is a cancel frame. + */ + func testCancelFrameHeaderDecoder() { + var byteBuffer = ByteBuffer(bytes: CancelFrameTests.bytes) + guard let decodedFrameHeader = try? FrameHeaderDecoder().decode(buffer: &byteBuffer) else { + XCTFail("Expected decoded frame header to be not nil") + return + } + + guard let decodedCancelFrame = try? CancelFrameDecoder().decode(header: decodedFrameHeader, buffer: &byteBuffer) else { + XCTFail("Expected decoded frame to be not nil") + return + } + + XCTAssertEqual(decodedCancelFrame.header.type, .cancel, "Expected cancel frame type") + XCTAssertTrue(decodedCancelFrame.header.flags.isEmpty, "Expected flags to be empty") + } + + /* Test for Cancel Frame Coding. + * This test encodes cancel frame and gets the byte buffer. + * Then decodes the byte buffer using cancel frame decoder. + * The decoded frame should be same as encoded frame. + */ + func testCancelFrameCoder() { + guard var byteBuffer = try? CancelFrameEncoder().encode(frame: CancelFrame(streamId: 0), using: ByteBufferAllocator()) else { + XCTFail("Expected byte buffer to be not nil") + return + } + + guard let decodedFrameHeader = try? FrameHeaderDecoder().decode(buffer: &byteBuffer) else { + XCTFail("Expected decoded frame header to be not nil") + return + } + + guard let decodedCancelFrame = try? CancelFrameDecoder().decode(header: decodedFrameHeader, buffer: &byteBuffer) else { + XCTFail("Expected decoded frame to be not nil") + return + } + + XCTAssertEqual(decodedCancelFrame.header.type, .cancel, "Expected cancel frame type") + XCTAssertTrue(decodedCancelFrame.header.flags.isEmpty, "Expected flags to be empty") + } +} diff --git a/Tests/RSocketCoreTests/Frames/ErrorFrameTests.swift b/Tests/RSocketCoreTests/Frames/ErrorFrameTests.swift new file mode 100644 index 00000000..4716185a --- /dev/null +++ b/Tests/RSocketCoreTests/Frames/ErrorFrameTests.swift @@ -0,0 +1,147 @@ +/* + * Copyright 2015-present the original author or authors. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +import NIO +import XCTest +@testable import RSocketCore + +final class ErrorFrameTests: XCTestCase { + + static private let bytes: [UInt8] = [0, 0, 0, 0, + 44, 6, 0, 0, + 0, 111, 116, 101, + 115, 116, 32, 101, + 114, 114, 111, 114] + + /* Test Error Frame initialisation with a streamId and error. + * Verify that the frame is initialised with expected values. + */ + func testErrorFrameInit() { + let error = Error.other(code: 111, message: "test error") + let errorFrame = ErrorFrame(streamId: 0, error: error) + + XCTAssertEqual(errorFrame.header.type, .error, "Expected error frame type") + XCTAssertEqual(errorFrame.header.streamId, 0) + XCTAssertTrue(errorFrame.header.flags.isEmpty) + XCTAssertEqual(errorFrame.error.code, error.code) + XCTAssertEqual(errorFrame.error.message, error.message) + + } + + /* Test Error Frame initialisation with FrameHeader. + * Verify that the frame is initialised with expected values. + */ + func testErrorFrameInitWithFrameHeader() { + let error = Error.other(code: 111, message: "test error") + let errorFrame = ErrorFrame(header: FrameHeader(streamId: 0, type: .error, flags: FrameFlags(rawValue: 6)), error: error) + + XCTAssertEqual(errorFrame.header.type, .error, "Expected error frame type") + XCTAssertEqual(errorFrame.header.streamId, 0) + XCTAssertEqual(errorFrame.header.flags, FrameFlags(rawValue: 6)) + XCTAssertEqual(errorFrame.error.code, error.code) + XCTAssertEqual(errorFrame.error.message, error.message) + } + + /* Test for valid Error Frame. */ + func testErrorFramePassValidation() { + let error = Error.applicationError(message: "test error") + let errorFrame = ErrorFrame(streamId: 2, error: error) + + XCTAssertNoThrow(try errorFrame.validate()) + } + + /* Test for invalid Error Frame. */ + func testErrorFrameFailValidation() { + let error = Error.other(code: 111, message: "test error") + let errorFrame = ErrorFrame(streamId: 0, error: error) + + XCTAssertThrowsError(try errorFrame.validate()) { error in + guard case Error.connectionError(let value) = error else { + return XCTFail("Unexpected error type") + } + + XCTAssertEqual(value, "The given error code is not valid for this streamId") + } + } + + /* Test Error Frame Encoder. + * Encode an error frame with streamId, flags and error. + * Verfiy that the encode bytes are as expected. + */ + func testErrorFrameHeaderEncoder() { + let error = Error.other(code: 111, message: "test error") + + guard var byteBuffer = try? ErrorFrameEncoder().encode(frame: ErrorFrame(header: FrameHeader(streamId: 0, type: .error, flags: FrameFlags(rawValue: 6)), error: error), using: ByteBufferAllocator()) else { + XCTFail("Expected byte buffer to be not nil") + return + } + + XCTAssertEqual(byteBuffer.readableBytes, 20) + XCTAssertEqual(byteBuffer.readBytes(length: byteBuffer.readableBytes), ErrorFrameTests.bytes) + } + + /* Test for Error Frame Decoder. + * Verify that the decoded byte buffer is an error frame. + * Verify that the error code and message is as expected. + */ + func testErrorFrameHeaderDecoder() { + var byteBuffer = ByteBuffer(bytes: ErrorFrameTests.bytes) + + guard let decodedFrameHeader = try? FrameHeaderDecoder().decode(buffer: &byteBuffer) else { + XCTFail("Expected decoded frame header to be not nil") + return + } + + guard let decodedErrorFrame = try? ErrorFrameDecoder().decode(header: decodedFrameHeader, buffer: &byteBuffer) else { + XCTFail("Expected decoded frame to be not nil") + return + } + + XCTAssertEqual(decodedErrorFrame.header.type, .error, "Expected error frame type") + XCTAssertEqual(decodedErrorFrame.header.streamId, 0) + XCTAssertEqual(decodedErrorFrame.error.code, 111) + XCTAssertEqual(decodedErrorFrame.error.message, "test error") + } + + /* Test for Error Frame Coding. + * This test encodes error frame and gets the byte buffer. + * Then decodes the byte buffer using error frame decoder. + * The decoded frame should be same as encoded frame. + */ + func testErrorFrameCoder() { + let error = Error.other(code: 111, message: "test") + + guard var byteBuffer = try? ErrorFrameEncoder().encode(frame: ErrorFrame(header: FrameHeader(streamId: 0, type: .error, flags: FrameFlags(rawValue: 6)), error: error), using: ByteBufferAllocator()) else { + XCTFail("Expected byte buffer to be not nil") + return + } + + guard let decodedFrameHeader = try? FrameHeaderDecoder().decode(buffer: &byteBuffer) else { + XCTFail("Expected decoded frame header to be not nil") + return + } + + guard let decodedErrorFrame = try? ErrorFrameDecoder().decode(header: decodedFrameHeader, buffer: &byteBuffer) else { + XCTFail("Expected decoded frame to be not nil") + return + } + + XCTAssertEqual(decodedErrorFrame.header.type, .error, "Expected error frame type") + XCTAssertEqual(decodedErrorFrame.header.streamId, 0) + XCTAssertEqual(decodedErrorFrame.error.code, 111) + XCTAssertEqual(decodedErrorFrame.error.message, "test") + } +} diff --git a/Tests/RSocketCoreTests/Frames/ExtensionFrameTests.swift b/Tests/RSocketCoreTests/Frames/ExtensionFrameTests.swift new file mode 100644 index 00000000..dc18f499 --- /dev/null +++ b/Tests/RSocketCoreTests/Frames/ExtensionFrameTests.swift @@ -0,0 +1,144 @@ +/* + * Copyright 2015-present the original author or authors. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +import NIO +import XCTest +@testable import RSocketCore + +final class ExtensionFrameTests: XCTestCase { + + static private let bytes: [UInt8] = [0, 0, 0, 0, + 63, 0, 0, 0, + 0, 7, 0, 0, + 1, 109, 100] + + /* Test Extension Frame initialisation with streamId, canBeIgnored, extendedType and payload. + * Verify that the frame is initialised with expected values. + */ + func testExtensionInit() { + let payloadMetadata = "test metadata".data(using: .utf8)! + let payloadData = "test data".data(using: .utf8)! + let extensionFrame = ExtensionFrame(streamId: 0, canBeIgnored: true, extendedType: 6, payload: Payload(metadata: payloadMetadata, data: payloadData)) + + XCTAssertEqual(extensionFrame.header.type, .ext, "Expected extension frame type") + XCTAssertEqual(extensionFrame.header.streamId, 0, "Expected steam id 0 in extension frame type") + XCTAssert(extensionFrame.header.flags.rawValue & FrameFlags.ignore.rawValue != 0, "Expected ignore flag to be set") + XCTAssert(extensionFrame.header.flags.rawValue & FrameFlags.metadata.rawValue != 0, "Expected metadata flag to be set") + XCTAssertEqual(extensionFrame.payload.metadata, payloadMetadata) + XCTAssertEqual(extensionFrame.payload.data, payloadData) + XCTAssertEqual(extensionFrame.extendedType, 6) + } + + /* Test for valid Extension Frame. */ + func testExtensionFramePassValidation() { + let payloadMetadata = "test metadata".data(using: .utf8)! + let payloadData = "test data".data(using: .utf8)! + let extensionFrame = ExtensionFrame(streamId: 0, canBeIgnored: true, extendedType: 6, payload: Payload(metadata: payloadMetadata, data: payloadData)) + + XCTAssertNoThrow(try extensionFrame.validate()) + } + + /* Test for invalid Extension Frame. */ + func testExtensionFrameFailValidation() { + let payloadMetadata = "test metadata".data(using: .utf8)! + let payloadData = "test data".data(using: .utf8)! + let extensionFrame = ExtensionFrame(streamId: 0, canBeIgnored: true, extendedType: -1, payload: Payload(metadata: payloadMetadata, data: payloadData)) + + XCTAssertThrowsError(try extensionFrame.validate()) { error in + guard case Error.connectionError(let value) = error else { + return XCTFail("Unexpected error type") + } + + XCTAssertEqual(value, "extendedType has to be equal or bigger than 0") + } + } + + /* Test Extension Frame Encoder. + * Encode an extension frame and verify that the bytes returned are as expected. + */ + func testExtensionEncoder() { + let payloadMetadata = "m".data(using: .utf8)! + let payloadData = "d".data(using: .utf8)! + let extensionFrame = ExtensionFrame(streamId: 0, canBeIgnored: true, extendedType: 7, payload: Payload(metadata: payloadMetadata, data: payloadData)) + + guard var byteBuffer = try? ExtensionFrameEncoder().encode(frame: extensionFrame, using: ByteBufferAllocator()) else { + XCTFail("Expected byte buffer to be not nil") + return + } + + XCTAssertEqual(byteBuffer.readableBytes, 15) + XCTAssertEqual(byteBuffer.readBytes(length: byteBuffer.readableBytes), ExtensionFrameTests.bytes) + } + + /* Test for Extension Frame Decoder. + * Verify that the decoded byte buffer is an extension frame. + */ + func testExtensionDecoder() { + var byteBuffer = ByteBuffer(bytes: ExtensionFrameTests.bytes) + + guard let decodedFrameHeader = try? FrameHeaderDecoder().decode(buffer: &byteBuffer) else { + XCTFail("Expected decoded frame header to be not nil") + return + } + + guard let decodedExtensionFrame = try? ExtensionFrameDecoder().decode(header: decodedFrameHeader, buffer: &byteBuffer)else { + XCTFail("Expected decoded frame to be not nil") + return + } + + XCTAssertEqual(decodedExtensionFrame.header.type, .ext, "Expected extension frame type") + XCTAssertEqual(decodedExtensionFrame.header.streamId, 0, "Expected steam id 0 in extension frame type") + XCTAssert(decodedExtensionFrame.header.flags.rawValue & FrameFlags.ignore.rawValue != 0, "Expected ignore flag to be set") + XCTAssert(decodedExtensionFrame.header.flags.rawValue & FrameFlags.metadata.rawValue != 0, "Expected metadata flag to be set") + XCTAssertEqual(decodedExtensionFrame.payload.metadata, "m".data(using: .utf8)!) + XCTAssertEqual(decodedExtensionFrame.payload.data, "d".data(using: .utf8)!) + XCTAssertEqual(decodedExtensionFrame.extendedType, 7) + } + + /* Test for Extension Frame Coding. + * This test encodes extension frame and gets the byte buffer. + * Then decodes the byte buffer using extension frame decoder. + * The decoded frame should be same as encoded frame. + */ + func testExtensionFrameCoder() { + let payloadMetadata = "test metadata".data(using: .utf8)! + let payloadData = "test data".data(using: .utf8)! + let extensionFrame = ExtensionFrame(streamId: 0, canBeIgnored: true, extendedType: 6, payload: Payload(metadata: payloadMetadata, data: payloadData)) + + guard var byteBuffer = try? ExtensionFrameEncoder().encode(frame: extensionFrame, using: ByteBufferAllocator()) else { + XCTFail("Expected byte buffer to be not nil") + return + } + + guard let decodedFrameHeader = try? FrameHeaderDecoder().decode(buffer: &byteBuffer) else { + XCTFail("Expected decoded frame header to be not nil") + return + } + + guard let decodedExtensionFrame = try? ExtensionFrameDecoder().decode(header: decodedFrameHeader, buffer: &byteBuffer)else { + XCTFail("Expected decoded frame to be not nil") + return + } + + XCTAssertEqual(decodedExtensionFrame.header.type, .ext, "Expected extension frame type") + XCTAssertEqual(decodedExtensionFrame.header.streamId, 0, "Expected steam id 0 in extension frame type") + XCTAssert(decodedExtensionFrame.header.flags.rawValue & FrameFlags.ignore.rawValue != 0, "Expected ignore flag to be set") + XCTAssert(decodedExtensionFrame.header.flags.rawValue & FrameFlags.metadata.rawValue != 0, "Expected metadata flag to be set") + XCTAssertEqual(decodedExtensionFrame.payload.metadata, payloadMetadata) + XCTAssertEqual(decodedExtensionFrame.payload.data, payloadData) + XCTAssertEqual(decodedExtensionFrame.extendedType, 6) + } +} diff --git a/Tests/RSocketCoreTests/Frames/KeepAliveFrameTests.swift b/Tests/RSocketCoreTests/Frames/KeepAliveFrameTests.swift new file mode 100644 index 00000000..663ec180 --- /dev/null +++ b/Tests/RSocketCoreTests/Frames/KeepAliveFrameTests.swift @@ -0,0 +1,176 @@ +/* + * Copyright 2015-present the original author or authors. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +import NIO +import XCTest +@testable import RSocketCore + +final class KeepAliveFrameTests: XCTestCase { + + static private let bytes: [UInt8] = [0, 0, 0, 0, + 12, 128, 0, 0, + 0, 0, 0, 0, + 0, 10, 100 ] + + /* Test Keep Alive Frame initialisation with respondWithKeepalive, lastReceivedPosition, data. + * Verify that the frame is initialised with expected values. + */ + func testKeepAliveInit() { + let frameData = "test data".data(using: .utf8)! + let keepAliveFrame = KeepAliveFrame(respondWithKeepalive: true, lastReceivedPosition: 10, data: frameData) + + XCTAssertEqual(keepAliveFrame.header.type, .keepalive, "Expected keep alive frame type") + XCTAssert(keepAliveFrame.header.flags.rawValue & FrameFlags.keepAliveRespond.rawValue != 0, "Expected respond flag to be set") + XCTAssertEqual(keepAliveFrame.lastReceivedPosition, 10) + } + + /* Test for valid Keep Alive Frame. + * The validation should pass if streamId is 0 and lastReceivedPosition >= 0; + */ + func testKeepAliveFramePassValidation() { + let frameData = "test data".data(using: .utf8)! + let keepAliveFrame = KeepAliveFrame(respondWithKeepalive: true, lastReceivedPosition: 10, data: frameData) + + XCTAssertNoThrow(try keepAliveFrame.validate()) + } + + /* Test for invalid Keep Alive Frame. + * The validation should fail if lastReceivedPosition is negative. + */ + func testKeepAliveFrameFailValidation() { + let frameData = "test data".data(using: .utf8)! + let keepAliveFrame = KeepAliveFrame(respondWithKeepalive: true, lastReceivedPosition: -1, data: frameData) + + XCTAssertThrowsError(try keepAliveFrame.validate()) { error in + guard case Error.connectionError(let value) = error else { + return XCTFail("Unexpected error type") + } + + XCTAssertEqual(value, "lastReceivedPosition has to be equal or bigger than 0") + } + } + + /* Test Keep Alive Frame Encoder. + * Encode a keep alive frame and ensure bytes returned are as expected. + */ + func testKeepAliveEncoder() { + let frameData = "d".data(using: .utf8)! + let keepAliveFrame = KeepAliveFrame(respondWithKeepalive: true, lastReceivedPosition: 10, data: frameData) + + guard var byteBuffer = try? KeepAliveFrameEncoder().encode(frame: keepAliveFrame, using: ByteBufferAllocator()) else { + XCTFail("Expected byte buffer to be not nil") + return + } + + XCTAssertEqual(byteBuffer.readableBytes, 15) + XCTAssertEqual(byteBuffer.readBytes(length: byteBuffer.readableBytes), KeepAliveFrameTests.bytes) + } + + /* Test for Keep Alive Frame Decoder. + * Verify that the decoded byte buffer is keep alive frame. + */ + func testKeepAliveDecoder() { + var byteBuffer = ByteBuffer(bytes: KeepAliveFrameTests.bytes) + + guard let decodedFrameHeader = try? FrameHeaderDecoder().decode(buffer: &byteBuffer) else { + XCTFail("Expected decoded frame header to be not nil") + return + } + + guard let decodedKeepAliveFrame = try? KeepAliveFrameDecoder().decode(header: decodedFrameHeader, buffer: &byteBuffer) else { + XCTFail("Expected decoded frame to be not nil") + return + } + + XCTAssertEqual(decodedKeepAliveFrame.header.type, .keepalive, "Expected keep alive frame type") + XCTAssert(decodedKeepAliveFrame.header.flags.rawValue & FrameFlags.keepAliveRespond.rawValue != 0, "Expected respond flag to be set") + XCTAssertEqual(decodedKeepAliveFrame.lastReceivedPosition, 10) + XCTAssertEqual(decodedKeepAliveFrame.data, "d".data(using: .utf8)!) + } + + /* Test for Keep Alive Frame Coding. + * This test encodes keep alive frame and gets the byte buffer. + * Then decodes the byte buffer using keep alive frame decoder. + * The decoded frame should be same as encoded frame. + */ + func testKeepAliveFrameCoder() { + let frameData = "test data".data(using: .utf8)! + let keepAliveFrame = KeepAliveFrame(respondWithKeepalive: false, lastReceivedPosition: 10, data: frameData) + + guard var byteBuffer = try? KeepAliveFrameEncoder().encode(frame: keepAliveFrame, using: ByteBufferAllocator()) else { + XCTFail("Expected byte buffer to be not nil") + return + } + + guard let decodedFrameHeader = try? FrameHeaderDecoder().decode(buffer: &byteBuffer) else { + XCTFail("Expected decoded frame header to be not nil") + return + } + + guard let decodedKeepAliveFrame = try? KeepAliveFrameDecoder().decode(header: decodedFrameHeader, buffer: &byteBuffer) else { + XCTFail("Expected decoded frame to be not nil") + return + } + + XCTAssertNotNil(decodedKeepAliveFrame) + XCTAssertEqual(decodedKeepAliveFrame.header.type, .keepalive, "Expected keep alive frame type") + XCTAssert(decodedKeepAliveFrame.header.flags.rawValue & FrameFlags.keepAliveRespond.rawValue == 0, "Expected respond flag to not be set") + XCTAssertEqual(decodedKeepAliveFrame.lastReceivedPosition, 10) + XCTAssertEqual(decodedKeepAliveFrame.data, frameData) + } + + /* Test for Keep Alive Frame respond flag. + * The respond flag should be set if respondWithKeepalive is true. + */ + func testKeepAliveFrameRespondFlagSet() { + let frameData = "d".data(using: .utf8)! + let keepAliveFrame = KeepAliveFrame(respondWithKeepalive: true, lastReceivedPosition: 10, data: frameData) + + guard var byteBuffer = try? KeepAliveFrameEncoder().encode(frame: keepAliveFrame, using: ByteBufferAllocator()) else { + XCTFail("Expected byte buffer to be not nil") + return + } + + guard let decodedFrameHeader = try? FrameHeaderDecoder().decode(buffer: &byteBuffer) else { + XCTFail("Expected decoded frame header to be not nil") + return + } + + XCTAssertEqual(decodedFrameHeader.type, .keepalive, "Expected keep alive frame type") + XCTAssert(decodedFrameHeader.flags.rawValue & FrameFlags.keepAliveRespond.rawValue != 0, "Expected respond flag to be set") + } + + /* Test for Keep Alive Frame respond flag not set. + * The respond flag should not be set if respondWithKeepalive is false. + */ + func testKeepAliveFrameRespondFlagNotSet() { + let frameData = "d".data(using: .utf8)! + let keepAliveFrame = KeepAliveFrame(respondWithKeepalive: false, lastReceivedPosition: 10, data: frameData) + + guard var byteBuffer = try? KeepAliveFrameEncoder().encode(frame: keepAliveFrame, using: ByteBufferAllocator()) else { + XCTFail("Expected byte buffer to be not nil") + return + } + + guard let decodedFrameHeader = try? FrameHeaderDecoder().decode(buffer: &byteBuffer) else { + XCTFail("Expected decoded frame header to be not nil") + return + } + + XCTAssertEqual(decodedFrameHeader.type, .keepalive, "Expected keep alive frame type") + XCTAssert(decodedFrameHeader.flags.rawValue & FrameFlags.keepAliveRespond.rawValue == 0, "Expected respond flag to not be set") + } +} diff --git a/Tests/RSocketCoreTests/Frames/LeaseFrameTests.swift b/Tests/RSocketCoreTests/Frames/LeaseFrameTests.swift new file mode 100644 index 00000000..e2db2c96 --- /dev/null +++ b/Tests/RSocketCoreTests/Frames/LeaseFrameTests.swift @@ -0,0 +1,160 @@ +/* + * Copyright 2015-present the original author or authors. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +import NIO +import XCTest +@testable import RSocketCore + +final class LeaseFrameTests: XCTestCase { + + static private let bytes: [UInt8] = [0, 0, 0, 0, + 9, 0, 0, 0, + 0, 100, 0, 0, + 0, 10, 109 ] + + /* Test Lease Frame initialisation with timeToLive, numberOfRequests and metadata. + * Verify that the frame is initialised with expected values. + */ + func testLeaseFrameInit() { + let metadata = "test metadata".data(using: .utf8)! + let leaseFrame = LeaseFrame(timeToLive: 100, numberOfRequests: 10, metadata: metadata) + + XCTAssertEqual(leaseFrame.header.type, .lease, "Expected lease frame type") + XCTAssert(leaseFrame.header.flags.rawValue & FrameFlags.metadata.rawValue != 0, "Expected metadata flag to be set") + XCTAssertEqual(leaseFrame.timeToLive, 100) + XCTAssertEqual(leaseFrame.numberOfRequests, 10) + XCTAssertEqual(leaseFrame.metadata, metadata) + } + + /* Test for valid Lease Frame. + * Validate should not throw if frame is valid. + */ + func testLeaseFramePassValidation() { + let metadata = "test metadata".data(using: .utf8)! + let leaseFrame = LeaseFrame(timeToLive: 100, numberOfRequests: 10, metadata: metadata) + + XCTAssertNoThrow(try leaseFrame.validate()) + } + + /* Test for invalid Lease Frame. */ + func testLeaseFrameFailValidation() { + let metadata = "test metadata".data(using: .utf8)! + let leaseFrame = LeaseFrame(timeToLive: 100, numberOfRequests: -1, metadata: metadata) + + XCTAssertThrowsError(try leaseFrame.validate()) { error in + guard case Error.connectionError(let value) = error else { + return XCTFail("Unexpected error type") + } + + XCTAssertEqual(value, "numberOfRequests has to be equal or bigger than 0") + } + } + + /* Test Lease Frame Encoder. + * Encode a lease frame and check the bytes in returned byte buffer. + */ + func testLeaseFrameEncoder() { + let metadata = "m".data(using: .utf8)! + let leaseFrame = LeaseFrame(timeToLive: 100, numberOfRequests: 10, metadata: metadata) + + guard var byteBuffer = try? LeaseFrameEncoder().encode(frame: leaseFrame, using: ByteBufferAllocator()) else { + XCTFail("Expected byte buffer to be not nil") + return + } + + XCTAssertEqual(byteBuffer.readableBytes, 15) + XCTAssertEqual(byteBuffer.readBytes(length: byteBuffer.readableBytes), LeaseFrameTests.bytes) + } + + /* Test for Lease Frame Decoder. + * Verify that the decoded byte buffer is lease frame. + */ + func testLeaseFrameDecoder() { + var byteBuffer = ByteBuffer(bytes: LeaseFrameTests.bytes) + + guard let decodedFrameHeader = try? FrameHeaderDecoder().decode(buffer: &byteBuffer) else { + XCTFail("Expected decoded frame header to be not nil") + return + } + + guard let decodedLeaseFrame = try? LeaseFrameDecoder().decode(header: decodedFrameHeader, buffer: &byteBuffer) else { + XCTFail("Expected decoded frame to be not nil") + return + } + + XCTAssertEqual(decodedLeaseFrame.header.type, .lease, "Expected lease frame type") + XCTAssert(decodedLeaseFrame.header.flags.rawValue & FrameFlags.metadata.rawValue != 0, "Expected metadata flag to be set") + XCTAssertEqual(decodedLeaseFrame.numberOfRequests, 10) + XCTAssertEqual(decodedLeaseFrame.timeToLive, 100) + XCTAssertEqual(decodedLeaseFrame.metadata, "m".data(using: .utf8)!) + } + + /* Test for Lease Frame Coding. + * This test encodes lease frame and gets the byte buffer. + * Then decodes the byte buffer using lease frame decoder. + * The decoded frame should be same as encoded frame. + */ + func testLeaseFrameCoder() { + let metadata = "test metadata".data(using: .utf8)! + let leaseFrame = LeaseFrame(timeToLive: 1100, numberOfRequests: 32, metadata: metadata) + + guard var byteBuffer = try? LeaseFrameEncoder().encode(frame: leaseFrame, using: ByteBufferAllocator()) else { + XCTFail("Expected byte buffer to be not nil") + return + } + + guard let decodedFrameHeader = try? FrameHeaderDecoder().decode(buffer: &byteBuffer) else { + XCTFail("Expected decoded frame header to be not nil") + return + } + + guard let decodedLeaseFrame = try? LeaseFrameDecoder().decode(header: decodedFrameHeader, buffer: &byteBuffer) else { + XCTFail("Expected decoded frame to be not nil") + return + } + + XCTAssertEqual(decodedLeaseFrame.header.type, .lease, "Expected lease frame type") + XCTAssert(decodedLeaseFrame.header.flags.rawValue & FrameFlags.metadata.rawValue != 0, "Expected metadata flag to be set") + XCTAssertEqual(decodedLeaseFrame.numberOfRequests, 32) + XCTAssertEqual(decodedLeaseFrame.timeToLive, 1100) + XCTAssertEqual(decodedLeaseFrame.metadata, metadata) + } + + /* If metadata is nil in encoded frame, it should be nil after encoding and decoding. */ + func testLeaseFrameNilMetadata() { + let leaseFrame = LeaseFrame(timeToLive: 1100, numberOfRequests: 32, metadata: nil) + + guard var byteBuffer = try? LeaseFrameEncoder().encode(frame: leaseFrame, using: ByteBufferAllocator()) else { + XCTFail("Expected byte buffer to be not nil") + return + } + + guard let decodedFrameHeader = try? FrameHeaderDecoder().decode(buffer: &byteBuffer) else { + XCTFail("Expected decoded frame header to be not nil") + return + } + + guard let decodedLeaseFrame = try? LeaseFrameDecoder().decode(header: decodedFrameHeader, buffer: &byteBuffer) else { + XCTFail("Expected decoded frame to be not nil") + return + } + + XCTAssertEqual(decodedLeaseFrame.header.type, .lease, "Expected lease frame type") + XCTAssert(decodedLeaseFrame.header.flags.rawValue & FrameFlags.metadata.rawValue == 0, "Expected metadata flag to not be set") + XCTAssertEqual(decodedLeaseFrame.metadata, nil) + + } +} diff --git a/Tests/RSocketCoreTests/Frames/MetadataPushFrameTests.swift b/Tests/RSocketCoreTests/Frames/MetadataPushFrameTests.swift new file mode 100644 index 00000000..59ccbc56 --- /dev/null +++ b/Tests/RSocketCoreTests/Frames/MetadataPushFrameTests.swift @@ -0,0 +1,113 @@ +/* + * Copyright 2015-present the original author or authors. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +import NIO +import XCTest +@testable import RSocketCore + +final class MetadataPushFrameTests: XCTestCase { + + static private let bytes: [UInt8] = [0, 0, 0, 0, + 49, 0, 109] + + /* Test Metadata Push Frame initialisation with metadata. + * Verify that the frame is initialised with expected header and metadata. + */ + func testMetadataPushInit() { + let metadata = "test metadata".data(using: .utf8)! + let metadataPushFrame = MetadataPushFrame(metadata: metadata) + + XCTAssertEqual(metadataPushFrame.header.type, .metadataPush, "Expected metadata push frame type") + XCTAssertEqual(metadataPushFrame.header.streamId, 0, "Expected steam id 0 in metadata push frame type") + XCTAssert(metadataPushFrame.header.flags.rawValue & FrameFlags.metadata.rawValue != 0, "Expected metadata flag to be set") + XCTAssertEqual(metadataPushFrame.metadata, metadata) + } + + func testMetadataPushFrameValidation() { + let metadata = "test metadata".data(using: .utf8)! + let metadataPushFrame = MetadataPushFrame(metadata: metadata) + + XCTAssertNoThrow(try metadataPushFrame.validate()) + } + + /* Test Metadata Push Frame Encoder. + * Encode a metadata push frame with metadata and check the bytes in encoded byte buffer. + */ + func testMetadataPushEncoder() { + let metadata = "m".data(using: .utf8)! + let metadataPushFrame = MetadataPushFrame(metadata: metadata) + + guard var byteBuffer = try? MetadataPushFrameEncoder().encode(frame: metadataPushFrame, using: ByteBufferAllocator()) else { + XCTFail("Expected byte buffer to be not nil") + return + } + + XCTAssertEqual(byteBuffer.readableBytes, 7) + XCTAssertEqual(byteBuffer.readBytes(length: byteBuffer.readableBytes), MetadataPushFrameTests.bytes) + } + + /* Test for Metadata Push Frame Decoder. + * Verify that the decoded byte buffer is metadata push frame. + */ + func testMetadataPushDecoder() { + var byteBuffer = ByteBuffer(bytes: MetadataPushFrameTests.bytes) + + guard let decodedFrameHeader = try? FrameHeaderDecoder().decode(buffer: &byteBuffer) else { + XCTFail("Expected decoded frame header to be not nil") + return + } + + guard let decodedMetadataPushFrame = try? MetadataPushFrameDecoder().decode(header: decodedFrameHeader, buffer: &byteBuffer) else { + XCTFail("Expected decoded frame to be not nil") + return + } + + XCTAssertEqual(decodedMetadataPushFrame.header.type, .metadataPush, "Expected metadata push frame type") + XCTAssertEqual(decodedMetadataPushFrame.header.streamId, 0, "Expected steam id 0 in metadata push frame type") + XCTAssert(decodedMetadataPushFrame.header.flags.rawValue & FrameFlags.metadata.rawValue != 0, "Expected metadata flag to be set") + XCTAssertEqual(decodedMetadataPushFrame.metadata, "m".data(using: .utf8)!) + } + + /* Test for Metadata Push Frame Coding. + * This test encodes metadata push frame and gets the byte buffer. + * Then decodes the byte buffer using metadata push frame decoder. + * The decoded frame should be same as encoded frame. + */ + func testMetadataPushFrameCoder() { + let metadata = "test metadata".data(using: .utf8)! + let metadataPushFrame = MetadataPushFrame(metadata: metadata) + + guard var byteBuffer = try? MetadataPushFrameEncoder().encode(frame: metadataPushFrame, using: ByteBufferAllocator()) else { + XCTFail("Expected byte buffer to be not nil") + return + } + + guard let decodedFrameHeader = try? FrameHeaderDecoder().decode(buffer: &byteBuffer) else { + XCTFail("Expected decoded frame header to be not nil") + return + } + + guard let decodedMetadataPushFrame = try? MetadataPushFrameDecoder().decode(header: decodedFrameHeader, buffer: &byteBuffer) else { + XCTFail("Expected decoded frame to be not nil") + return + } + + XCTAssertEqual(decodedMetadataPushFrame.header.type, .metadataPush, "Expected metadata push frame type") + XCTAssertEqual(decodedMetadataPushFrame.header.streamId, 0, "Expected steam id 0 in metadata push frame type") + XCTAssert(decodedMetadataPushFrame.header.flags.rawValue & FrameFlags.metadata.rawValue != 0, "Expected metadata flag to be set") + XCTAssertEqual(decodedMetadataPushFrame.metadata, metadata) + } +} diff --git a/Tests/RSocketCoreTests/Frames/PayloadFrameTests.swift b/Tests/RSocketCoreTests/Frames/PayloadFrameTests.swift new file mode 100644 index 00000000..cabd715b --- /dev/null +++ b/Tests/RSocketCoreTests/Frames/PayloadFrameTests.swift @@ -0,0 +1,198 @@ +/* + * Copyright 2015-present the original author or authors. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +import NIO +import XCTest +@testable import RSocketCore + +final class PayloadFrameTests: XCTestCase { + + static private let bytes: [UInt8] = [0, 0, 0, 1, + 41, 224, 0, 0, + 1, 109, 100] + + /* Test Payload Frame initialisation. + * Verify that the frame is initialised with expected header and payload. + */ + func testPayloadInit() { + let payloadMetadata = "test payload metadata".data(using: .utf8)! + let payloadData = "test payload data".data(using: .utf8)! + let payloadFrame = PayloadFrame(streamId: 1, fragmentsFollow: true, isCompletion: true, isNext: true, payload: Payload(metadata: payloadMetadata, data: payloadData)) + + XCTAssertEqual(payloadFrame.header.type, .payload, "Expected payload frame type") + XCTAssertEqual(payloadFrame.header.streamId, 1) + XCTAssert(payloadFrame.header.flags.rawValue & FrameFlags.payloadFollows.rawValue != 0, "Expected follows flag to be set") + XCTAssert(payloadFrame.header.flags.rawValue & FrameFlags.payloadComplete.rawValue != 0, "Expected complete flag to be set") + XCTAssert(payloadFrame.header.flags.rawValue & FrameFlags.payloadNext.rawValue != 0, "Expected next flag to be set") + XCTAssert(payloadFrame.header.flags.rawValue & FrameFlags.metadata.rawValue != 0, "Expected metadata flag to be set") + XCTAssertEqual(payloadFrame.payload.data, payloadData) + XCTAssertEqual(payloadFrame.payload.metadata, payloadMetadata) + } + + /* Test Payload Frame Encoder. + * Encode a payload frame and check the bytes in encoded byte buffer. + */ + func testPayloadEncoder() { + let payloadMetadata = "m".data(using: .utf8)! + let payloadData = "d".data(using: .utf8)! + let payloadFrame = PayloadFrame(streamId: 1, fragmentsFollow: true, isCompletion: true, isNext: true, payload: Payload(metadata: payloadMetadata, data: payloadData)) + + guard var byteBuffer = try? PayloadFrameEncoder().encode(frame: payloadFrame, using: ByteBufferAllocator()) else { + XCTFail("Expected byte buffer to be not nil") + return + } + + XCTAssertEqual(byteBuffer.readableBytes, 11) + XCTAssertEqual(byteBuffer.readBytes(length: byteBuffer.readableBytes), PayloadFrameTests.bytes) + } + + /* Test for Payload Frame Decoder. + * Verify that the decoded byte buffer is payload frame. + */ + func testPayloadFrameDecoder() { + var byteBuffer = ByteBuffer(bytes: PayloadFrameTests.bytes) + guard let decodedFrameHeader = try? FrameHeaderDecoder().decode(buffer: &byteBuffer) else { + XCTFail("Expected decoded frame header to be not nil") + return + } + + guard let decodedPayloadFrame = try? PayloadFrameDecoder().decode(header: decodedFrameHeader, buffer: &byteBuffer) else { + XCTFail("Expected decoded frame to be not nil") + return + } + + XCTAssertEqual(decodedPayloadFrame.header.type, .payload, "Expected payload frame type") + XCTAssertEqual(decodedPayloadFrame.header.streamId, 1) + XCTAssert(decodedPayloadFrame.header.flags.rawValue & FrameFlags.payloadFollows.rawValue != 0, "Expected follows flag to be set") + XCTAssert(decodedPayloadFrame.header.flags.rawValue & FrameFlags.payloadComplete.rawValue != 0, "Expected complete flag to be set") + XCTAssert(decodedPayloadFrame.header.flags.rawValue & FrameFlags.payloadNext.rawValue != 0, "Expected next flag to be set") + XCTAssert(decodedPayloadFrame.header.flags.rawValue & FrameFlags.metadata.rawValue != 0, "Expected metadata flag to be set") + XCTAssertEqual(decodedPayloadFrame.payload.data, "d".data(using: .utf8)!) + XCTAssertEqual(decodedPayloadFrame.payload.metadata, "m".data(using: .utf8)!) + } + + /* Test for Payload Frame Coding. + * This test encodes payload frame and gets the byte buffer. + * Then decodes the byte buffer using payload frame decoder. + * The decoded frame should be same as encoded frame. + */ + func testPayloadFrameCoder() { + let payloadMetadata = "test payload metadata".data(using: .utf8)! + let payloadData = "test payload data".data(using: .utf8)! + let payloadFrame = PayloadFrame(streamId: 2, fragmentsFollow: true, isCompletion: true, isNext: true, payload: Payload(metadata: payloadMetadata, data: payloadData)) + + guard var byteBuffer = try? PayloadFrameEncoder().encode(frame: payloadFrame, using: ByteBufferAllocator()) else { + XCTFail("Expected byte buffer to be not nil") + return + } + + guard let decodedFrameHeader = try? FrameHeaderDecoder().decode(buffer: &byteBuffer) else { + XCTFail("Expected decoded frame header to be not nil") + return + } + + guard let decodedPayloadFrame = try? PayloadFrameDecoder().decode(header: decodedFrameHeader, buffer: &byteBuffer) else { + XCTFail("Expected decoded frame to be not nil") + return + } + + XCTAssertEqual(decodedPayloadFrame.header.type, .payload, "Expected payload frame type") + XCTAssertEqual(decodedPayloadFrame.header.streamId, 2) + XCTAssert(decodedPayloadFrame.header.flags.rawValue & FrameFlags.payloadFollows.rawValue != 0, "Expected follows flag to be set") + XCTAssert(decodedPayloadFrame.header.flags.rawValue & FrameFlags.payloadComplete.rawValue != 0, "Expected complete flag to be set") + XCTAssert(decodedPayloadFrame.header.flags.rawValue & FrameFlags.payloadNext.rawValue != 0, "Expected next flag to be set") + XCTAssert(decodedPayloadFrame.header.flags.rawValue & FrameFlags.metadata.rawValue != 0, "Expected metadata flag to be set") + XCTAssertEqual(decodedPayloadFrame.payload.data, payloadData) + XCTAssertEqual(decodedPayloadFrame.payload.metadata, payloadMetadata) + } + + /* Test for Payload Frame follow flag set. + * Follow flag should be set if fragmentsFollow is true. + */ + func testPayloadFollowsFlagSet() { + let payloadData = "".data(using: .utf8)! + let payloadFrame = PayloadFrame(streamId: 1, fragmentsFollow: true, isCompletion: true, isNext: true, payload: Payload(data: payloadData)) + + XCTAssertEqual(payloadFrame.header.type, .payload, "Expected payload frame type") + XCTAssert(payloadFrame.header.flags.rawValue & FrameFlags.payloadFollows.rawValue != 0, "Expected follows flag to be set") + } + + func testPayloadFollowsFlagNotSet() { + let payloadData = "".data(using: .utf8)! + let payloadFrame = PayloadFrame(streamId: 1, fragmentsFollow: false, isCompletion: true, isNext: true, payload: Payload(data: payloadData)) + + XCTAssertEqual(payloadFrame.header.type, .payload, "Expected payload frame type") + XCTAssert(payloadFrame.header.flags.rawValue & FrameFlags.payloadFollows.rawValue == 0, "Expected follows flag to not be set") + } + + /* Test for Payload Frame metadata flag set. + * Metadata flag should be set if metadata is present in the payload. + */ + func testPayloadMetadata() { + let payloadMetadata = "m".data(using: .utf8)! + let payloadData = "d".data(using: .utf8)! + let payloadFrame = PayloadFrame(streamId: 1, fragmentsFollow: true, isCompletion: true, isNext: true, payload: Payload(metadata: payloadMetadata, data: payloadData)) + + XCTAssertEqual(payloadFrame.header.type, .payload, "Expected payload frame type") + XCTAssert(payloadFrame.header.flags.rawValue & FrameFlags.metadata.rawValue != 0, "Expected metadata flag to be set") + } + + func testPayloadMetadataNil() { + let payloadData = "d".data(using: .utf8)! + let payloadFrame = PayloadFrame(streamId: 1, fragmentsFollow: true, isCompletion: true, isNext: true, payload: Payload(data: payloadData)) + + XCTAssertEqual(payloadFrame.header.type, .payload, "Expected payload frame type") + XCTAssert(payloadFrame.header.flags.rawValue & FrameFlags.metadata.rawValue == 0, "Expected metadata flag to not be set") + } + + /* Test for Payload Frame complete flag set. + * Complete flag should be set if isCompletion is true. + */ + func testPayloadComplete() { + let payloadData = "d".data(using: .utf8)! + let payloadFrame = PayloadFrame(streamId: 1, fragmentsFollow: true, isCompletion: true, isNext: true, payload: Payload(data: payloadData)) + + XCTAssertEqual(payloadFrame.header.type, .payload, "Expected payload frame type") + XCTAssert(payloadFrame.header.flags.rawValue & FrameFlags.payloadComplete.rawValue != 0, "Expected complete flag to be set") + } + + func testPayloadCompleteFalse() { + let payloadData = "d".data(using: .utf8)! + let payloadFrame = PayloadFrame(streamId: 1, fragmentsFollow: true, isCompletion: false, isNext: true, payload: Payload(data: payloadData)) + + XCTAssertEqual(payloadFrame.header.type, .payload, "Expected payload frame type") + XCTAssert(payloadFrame.header.flags.rawValue & FrameFlags.payloadComplete.rawValue == 0, "Expected complete flag to not be set") + } + + /* Test for Payload Frame next flag set. + * Next flag should be set if isNext is true. + */ + func testPayloadNextFlagSet() { + let payloadData = "".data(using: .utf8)! + let payloadFrame = PayloadFrame(streamId: 1, fragmentsFollow: true, isCompletion: true, isNext: true, payload: Payload(data: payloadData)) + + XCTAssertEqual(payloadFrame.header.type, .payload, "Expected payload frame type") + XCTAssert(payloadFrame.header.flags.rawValue & FrameFlags.payloadNext.rawValue != 0, "Expected next flag to be set") + } + + func testPayloadNextFlagNotSet() { + let payloadData = "".data(using: .utf8)! + let payloadFrame = PayloadFrame(streamId: 1, fragmentsFollow: false, isCompletion: true, isNext: false, payload: Payload(data: payloadData)) + + XCTAssertEqual(payloadFrame.header.type, .payload, "Expected payload frame type") + XCTAssert(payloadFrame.header.flags.rawValue & FrameFlags.payloadNext.rawValue == 0, "Expected next flag to not be set") + } +} diff --git a/Tests/RSocketCoreTests/Frames/RequestChannelFrameTests.swift b/Tests/RSocketCoreTests/Frames/RequestChannelFrameTests.swift new file mode 100644 index 00000000..6c9ce440 --- /dev/null +++ b/Tests/RSocketCoreTests/Frames/RequestChannelFrameTests.swift @@ -0,0 +1,192 @@ +/* + * Copyright 2015-present the original author or authors. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +import NIO +import XCTest +@testable import RSocketCore + +final class RequestChannelFrameTests: XCTestCase { + + static private let bytes: [UInt8] = [0, 0, 0, 0, + 28, 192, 0, 0, + 0, 12, 100] + + /* Test Request Channel Frame initialisation with streamId, fragmentFollow, isCompletion, + * initialRequestN, payload. + * Verify that the frame is initialised with expected values. + */ + func testRequestChannelInit() { + let payloadMetadata = "test payload metadata".data(using: .utf8)! + let payloadData = "test payload data".data(using: .utf8)! + let requestChannelFrame = RequestChannelFrame(streamId: 0, fragmentsFollow: true, isCompletion: true, initialRequestN: 11, payload: Payload(metadata: payloadMetadata, data: payloadData)) + + XCTAssertEqual(requestChannelFrame.header.type, .requestChannel, "Expected request Channel frame type") + XCTAssert(requestChannelFrame.header.flags.rawValue & FrameFlags.requestChannelFollows.rawValue != 0, "Expected follows flag to be set") + XCTAssert(requestChannelFrame.header.flags.rawValue & FrameFlags.requestChannelComplete.rawValue != 0, "Expected complete flag to be set") + XCTAssert(requestChannelFrame.header.flags.rawValue & FrameFlags.metadata.rawValue != 0, "Expected metadata flag to be set") + XCTAssertEqual(requestChannelFrame.payload.data, payloadData) + XCTAssertEqual(requestChannelFrame.initialRequestN, 11) + } + + func testRequestChannelFramePassValidation() { + let payloadMetadata = "test payload metadata".data(using: .utf8)! + let payloadData = "test payload data".data(using: .utf8)! + let requestChannelFrame = RequestChannelFrame(streamId: 0, fragmentsFollow: true, isCompletion: true, initialRequestN: 11, payload: Payload(metadata: payloadMetadata, data: payloadData)) + + XCTAssertNoThrow(try requestChannelFrame.validate()) + } + + func testRequestChannelFrameFailValidation() { + let payloadMetadata = "test payload metadata".data(using: .utf8)! + let payloadData = "test payload data".data(using: .utf8)! + let requestChannelFrame = RequestChannelFrame(streamId: 0, fragmentsFollow: true, isCompletion: true, initialRequestN: 0, payload: Payload(metadata: payloadMetadata, data: payloadData)) + + XCTAssertThrowsError(try requestChannelFrame.validate()) { error in + guard case Error.connectionError(let value) = error else { + return XCTFail("Unexpected error type") + } + + XCTAssertEqual(value, "initialRequestN has to be bigger than 0") + } + } + + /* Test Request Channel Frame Encoder. + * Encode a request channel frame and check the bytes in encoded byte buffer. + */ + func testRequestChannelEncoder() { + let payloadData = "d".data(using: .utf8)! + let requestChannelFrame = RequestChannelFrame(streamId: 0, fragmentsFollow: true, isCompletion: true, initialRequestN: 12, payload: Payload(data: payloadData)) + + guard var byteBuffer = try? RequestChannelFrameEncoder().encode(frame: requestChannelFrame, using: ByteBufferAllocator()) else { + XCTFail("Expected byte buffer to be not nil") + return + } + + XCTAssertEqual(byteBuffer.readableBytes, 11) + XCTAssertEqual(byteBuffer.readBytes(length: byteBuffer.readableBytes), RequestChannelFrameTests.bytes) + } + + /* Test for Request Channel Frame Decoder. + * Verify that the decoded byte buffer is request channel frame. + */ + func testRequestChannelFrameDecoder() { + var byteBuffer = ByteBuffer(bytes: RequestChannelFrameTests.bytes) + + guard let decodedFrameHeader = try? FrameHeaderDecoder().decode(buffer: &byteBuffer) else { + XCTFail("Expected decoded frame header to be not nil") + return + } + + guard let decodedRequestChannelFrame = try? RequestChannelFrameDecoder().decode(header: decodedFrameHeader, buffer: &byteBuffer) else { + XCTFail("Expected decoded frame to be not nil") + return + } + + XCTAssertEqual(decodedRequestChannelFrame.header.type, .requestChannel, "Expected request Channel frame type") + XCTAssert(decodedRequestChannelFrame.header.flags.rawValue & FrameFlags.requestChannelFollows.rawValue != 0, "Expected follows flag to be set") + XCTAssert(decodedRequestChannelFrame.header.flags.rawValue & FrameFlags.requestChannelComplete.rawValue != 0, "Expected complete flag to be set") + XCTAssert(decodedRequestChannelFrame.header.flags.rawValue & FrameFlags.metadata.rawValue == 0, "Expected metadata flag to not be set") + XCTAssertEqual(decodedRequestChannelFrame.payload.data, "d".data(using: .utf8)!) + XCTAssertEqual(decodedRequestChannelFrame.initialRequestN, 12) + } + + /* Test for Request Channel Frame Coding. + * This test encodes request channel frame and gets the byte buffer. + * Then decodes the byte buffer using request channel frame decoder. + * The decoded frame should be same as encoded frame. + */ + func testRequestChannelFrameCoder() { + let payloadData = "test payload data".data(using: .utf8)! + let requestChannelFrame = RequestChannelFrame(streamId: 0, fragmentsFollow: true, isCompletion: true, initialRequestN: 15, payload: Payload(data: payloadData)) + + guard var byteBuffer = try? RequestChannelFrameEncoder().encode(frame: requestChannelFrame, using: ByteBufferAllocator()) else { + XCTFail("Expected byte buffer to be not nil") + return + } + + guard let decodedFrameHeader = try? FrameHeaderDecoder().decode(buffer: &byteBuffer) else { + XCTFail("Expected decoded frame header to be not nil") + return + } + + guard let decodedRequestChannelFrame = try? RequestChannelFrameDecoder().decode(header: decodedFrameHeader, buffer: &byteBuffer) else { + XCTFail("Expected decoded frame to be not nil") + return + } + + XCTAssertEqual(decodedRequestChannelFrame.header.type, .requestChannel, "Expected request Channel frame type") + XCTAssertEqual(decodedRequestChannelFrame.payload.data, payloadData) + XCTAssertEqual(decodedRequestChannelFrame.initialRequestN, 15) + } + + /* Test for Request Channel Frame follow flag set. + * Follow flag should be set if fragmentsFollow is true. + */ + func testRequestChannelFollowsFlagSet() { + let payloadData = "".data(using: .utf8)! + let requestChannelFrame = RequestChannelFrame(streamId: 0, fragmentsFollow: true, isCompletion: false, initialRequestN: 15, payload: Payload(data: payloadData)) + + XCTAssertEqual(requestChannelFrame.header.type, .requestChannel, "Expected request Channel frame type") + XCTAssert(requestChannelFrame.header.flags.rawValue & FrameFlags.requestChannelFollows.rawValue != 0, "Expected follows flag to be set") + } + + func testRequestChannelFollowsFlagNotSet() { + let payloadData = "".data(using: .utf8)! + let requestChannelFrame = RequestChannelFrame(streamId: 0, fragmentsFollow: false, isCompletion: false, initialRequestN: 15, payload: Payload(data: payloadData)) + + XCTAssertEqual(requestChannelFrame.header.type, .requestChannel, "Expected request Channel frame type") + XCTAssert(requestChannelFrame.header.flags.rawValue & FrameFlags.requestChannelFollows.rawValue == 0, "Expected follows flag to not be set") + } + + /* Test for Request Channel Frame metadata flag set. + * Metadata flag should be set if metadata is present in the payload. + */ + func testRequestChannelMetadata() { + let payloadMetadata = "m".data(using: .utf8)! + let payloadData = "d".data(using: .utf8)! + let requestChannelFrame = RequestChannelFrame(streamId: 0, fragmentsFollow: true, isCompletion: true, initialRequestN: 15, payload: Payload(metadata: payloadMetadata, data: payloadData)) + + XCTAssertEqual(requestChannelFrame.header.type, .requestChannel, "Expected request Channel frame type") + XCTAssert(requestChannelFrame.header.flags.rawValue & FrameFlags.metadata.rawValue != 0, "Expected metadata flag to be set") + } + + func testRequestChannelMetadataNil() { + let payloadData = "d".data(using: .utf8)! + let requestChannelFrame = RequestChannelFrame(streamId: 0, fragmentsFollow: true, isCompletion: true, initialRequestN: 15, payload: Payload(metadata: nil, data: payloadData)) + + XCTAssertEqual(requestChannelFrame.header.type, .requestChannel, "Expected request Channel frame type") + XCTAssert(requestChannelFrame.header.flags.rawValue & FrameFlags.metadata.rawValue == 0, "Expected metadata flag to not be set") + } + + /* Test for Request Channel Frame complete flag set. + * Complete flag should be set if isCompletion is true. + */ + func testRequestChannelComplete() { + let payloadData = "d".data(using: .utf8)! + let requestChannelFrame = RequestChannelFrame(streamId: 0, fragmentsFollow: false, isCompletion: true, initialRequestN: 15, payload: Payload(data: payloadData)) + + XCTAssertEqual(requestChannelFrame.header.type, .requestChannel, "Expected request Channel frame type") + XCTAssert(requestChannelFrame.header.flags.rawValue & FrameFlags.requestChannelComplete.rawValue != 0, "Expected complete flag to be set") + } + + func testRequestChannelCompleteFalse() { + let payloadData = "d".data(using: .utf8)! + let requestChannelFrame = RequestChannelFrame(streamId: 0, fragmentsFollow: false, isCompletion: false, initialRequestN: 15, payload: Payload(data: payloadData)) + + XCTAssertEqual(requestChannelFrame.header.type, .requestChannel, "Expected request Channel frame type") + XCTAssert(requestChannelFrame.header.flags.rawValue & FrameFlags.requestChannelComplete.rawValue == 0, "Expected complete flag to not be set") + } +} diff --git a/Tests/RSocketCoreTests/Frames/RequestFNFFrameTests.swift b/Tests/RSocketCoreTests/Frames/RequestFNFFrameTests.swift new file mode 100644 index 00000000..5d3a0cd2 --- /dev/null +++ b/Tests/RSocketCoreTests/Frames/RequestFNFFrameTests.swift @@ -0,0 +1,140 @@ +/* + * Copyright 2015-present the original author or authors. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +import NIO +import XCTest +@testable import RSocketCore + +final class RequestFNFFrameTests: XCTestCase { + + static private let bytes: [UInt8] = [0, 0, 0, 0, + 20, 128, 100] + + /* Test Request Fire and Forget Frame initialisation with streamId, + * fragementFollow and payload. + * Verify that the frame is initialised with expected values. + */ + func testRequestFNFInit() { + let payloadData = "test payload data".data(using: .utf8)! + let requestFNFFrame = RequestFireAndForgetFrame(streamId: 0, fragmentsFollow: true, payload: Payload(data: payloadData)) + + XCTAssertEqual(requestFNFFrame.header.type, .requestFnf, "Expected request FNF frame type") + XCTAssert(requestFNFFrame.header.flags.rawValue & FrameFlags.requestFireAndForgetFollows.rawValue != 0, "Expected follows flag to be set") + XCTAssertEqual(requestFNFFrame.payload.data, payloadData) + } + + /* Test Request Fire and Forget Frame Encoder. + * Encode a request fire and forget frame and check the bytes in encoded byte buffer. + */ + func testRequestFNFEncoder() { + let payloadData = "d".data(using: .utf8)! + let requestFNFFrame = RequestFireAndForgetFrame(streamId: 0, fragmentsFollow: true, payload: Payload(data: payloadData)) + + guard var byteBuffer = try? RequestFireAndForgetFrameEncoder().encode(frame: requestFNFFrame, using: ByteBufferAllocator()) else { + XCTFail("Expected byte buffer to be not nil") + return + } + + XCTAssertEqual(byteBuffer.readableBytes, 7) + XCTAssertEqual(byteBuffer.readBytes(length: byteBuffer.readableBytes), RequestFNFFrameTests.bytes) + } + + /* Test for Request Fire and Forget Frame Decoder. + * Verify that the decoded byte buffer is request fire and forget frame. + */ + func testRequestFNFFrameDecoder() { + var byteBuffer = ByteBuffer(bytes: RequestFNFFrameTests.bytes) + guard let decodedFrameHeader = try? FrameHeaderDecoder().decode(buffer: &byteBuffer) else { + XCTFail("Expected decoded frame header to be not nil") + return + } + + guard let decodedRequestFNFFrame = try? RequestFireAndForgetFrameDecoder().decode(header: decodedFrameHeader, buffer: &byteBuffer) else { + XCTFail("Expected decoded frame to be not nil") + return + } + + XCTAssertEqual(decodedRequestFNFFrame.header.type, .requestFnf, "Expected request FNF frame type") + XCTAssertEqual(decodedRequestFNFFrame.payload.data, "d".data(using: .utf8)!) + } + + /* Test for Request Fire and Forget Frame Coding. + * This test encodes request fire and forget frame and gets the byte buffer. + * Then decodes the byte buffer using request fire and forget frame decoder. + * The decoded frame should be same as encoded frame. + */ + func testRequestFNFFrameCoder() { + let payloadData = "test payload data".data(using: .utf8)! + let requestFNFFrame = RequestFireAndForgetFrame(streamId: 0, fragmentsFollow: false, payload: Payload(data: payloadData)) + + guard var byteBuffer = try? RequestFireAndForgetFrameEncoder().encode(frame: requestFNFFrame, using: ByteBufferAllocator()) else { + XCTFail("Expected byte buffer to be not nil") + return + } + + guard let decodedFrameHeader = try? FrameHeaderDecoder().decode(buffer: &byteBuffer) else { + XCTFail("Expected decoded frame header to be not nil") + return + } + + guard let decodedRequestFNFFrame = try? RequestFireAndForgetFrameDecoder().decode(header: decodedFrameHeader, buffer: &byteBuffer) else { + XCTFail("Expected decoded frame to be not nil") + return + } + + XCTAssertEqual(decodedRequestFNFFrame.header.type, .requestFnf, "Expected request FNF frame type") + XCTAssertEqual(decodedRequestFNFFrame.payload.data, payloadData) + } + + /* Test for Request Fire and Forget Frame follow flag set. + * Follow flag should be set if fragmentsFollow is true. + */ + func testRequestFNFFollowsFlagSet() { + let payloadData = "".data(using: .utf8)! + let requestFNFFrame = RequestFireAndForgetFrame(streamId: 0, fragmentsFollow: true, payload: Payload(data: payloadData)) + + XCTAssertEqual(requestFNFFrame.header.type, .requestFnf, "Expected request FNF frame type") + XCTAssert(requestFNFFrame.header.flags.rawValue & FrameFlags.requestFireAndForgetFollows.rawValue != 0, "Expected follows flag to be set") + } + + func testRequestFNFFollowsFlagNotSet() { + let payloadData = "".data(using: .utf8)! + let requestFNFFrame = RequestFireAndForgetFrame(streamId: 0, fragmentsFollow: false, payload: Payload(data: payloadData)) + + XCTAssertEqual(requestFNFFrame.header.type, .requestFnf, "Expected request FNF frame type") + XCTAssert(requestFNFFrame.header.flags.rawValue & FrameFlags.requestFireAndForgetFollows.rawValue == 0, "Expected follows flag to not be set") + } + + /* Test for Request Fire and Forget Frame metadata flag set. + * Metadata flag should be set if metadata is present. + */ + func testRequestFNFMetadata() { + let payloadMetadata = "m".data(using: .utf8)! + let payloadData = "d".data(using: .utf8)! + let requestFNFFrame = RequestFireAndForgetFrame(streamId: 0, fragmentsFollow: true, payload: Payload(metadata: payloadMetadata, data: payloadData)) + + XCTAssertEqual(requestFNFFrame.header.type, .requestFnf, "Expected request FNF frame type") + XCTAssert(requestFNFFrame.header.flags.rawValue & FrameFlags.metadata.rawValue != 0, "Expected metadata flag to be set") + } + + func testRequestFNFMetadataNil() { + let payloadData = "d".data(using: .utf8)! + let requestFNFFrame = RequestFireAndForgetFrame(streamId: 0, fragmentsFollow: true, payload: Payload(metadata: nil, data: payloadData)) + + XCTAssertEqual(requestFNFFrame.header.type, .requestFnf, "Expected request FNF frame type") + XCTAssert(requestFNFFrame.header.flags.rawValue & FrameFlags.metadata.rawValue == 0, "Expected metadata flag to not be set") + } +} diff --git a/Tests/RSocketCoreTests/Frames/RequestNFrameTests.swift b/Tests/RSocketCoreTests/Frames/RequestNFrameTests.swift new file mode 100644 index 00000000..b9cc9496 --- /dev/null +++ b/Tests/RSocketCoreTests/Frames/RequestNFrameTests.swift @@ -0,0 +1,114 @@ +/* + * Copyright 2015-present the original author or authors. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +import NIO +import XCTest +@testable import RSocketCore + +final class RequestNFrameTests: XCTestCase { + + static private let bytes: [UInt8] = [0, 0, 0, 1, + 32, 0, 0, 0, + 0, 12] + + /* Test Request N Frame initialisation with streamId and requestN. + * Verify that the frame is initialised with expected values. + */ + func testRequestNInit() { + let requestNFrame = RequestNFrame(streamId: 1, requestN: 11) + + XCTAssertEqual(requestNFrame.header.type, .requestN, "Expected request N frame type") + XCTAssertEqual(requestNFrame.requestN, 11) + } + + func testRequestNFramePassValidation() { + let requestNFrame = RequestNFrame(streamId: 1, requestN: 11) + + XCTAssertNoThrow(try requestNFrame.validate()) + } + + func testRequestNFrameFailValidation() { + let requestNFrame = RequestNFrame(streamId: 1, requestN: 0) + + XCTAssertThrowsError(try requestNFrame.validate()) { error in + guard case Error.connectionError(let value) = error else { + return XCTFail("Unexpected error type") + } + + XCTAssertEqual(value, "requestN has to be bigger than 0") + } + } + + /* Test Request N Frame Encoder. + * Encode a request N frame and check the bytes in encoded byte buffer. + */ + func testRequestNEncoder() { + let requestNFrame = RequestNFrame(streamId: 1, requestN: 12) + + guard var byteBuffer = try? RequestNFrameEncoder().encode(frame: requestNFrame, using: ByteBufferAllocator()) else { + XCTFail("Expected byte buffer to be not nil") + return + } + XCTAssertEqual(byteBuffer.readableBytes, 10) + XCTAssertEqual(byteBuffer.readBytes(length: byteBuffer.readableBytes), RequestNFrameTests.bytes) + } + + /* Test for Request N Frame Decoder. + * Verify that the decoded byte buffer is request N frame. + */ + func testRequestNFrameDecoder() { + var byteBuffer = ByteBuffer(bytes: RequestNFrameTests.bytes) + guard let decodedFrameHeader = try? FrameHeaderDecoder().decode(buffer: &byteBuffer) else { + XCTFail("Expected decoded frame header to be not nil") + return + } + + guard let decodedRequestNFrame = try? RequestNFrameDecoder().decode(header: decodedFrameHeader, buffer: &byteBuffer) else { + XCTFail("Expected decoded frame to be not nil") + return + } + + XCTAssertEqual(decodedRequestNFrame.header.type, .requestN, "Expected request N frame type") + XCTAssertEqual(decodedRequestNFrame.requestN, 12) + } + + /* Test for Request N Frame Coding. + * This test encodes request N frame and gets the byte buffer. + * Then decodes the byte buffer using request N frame decoder. + * The decoded frame should be same as encoded frame. + */ + func testRequestNFrameCoder() { + let requestNFrame = RequestNFrame(streamId: 1, requestN: 14) + + guard var byteBuffer = try? RequestNFrameEncoder().encode(frame: requestNFrame, using: ByteBufferAllocator()) else { + XCTFail("Expected byte buffer to be not nil") + return + } + + guard let decodedFrameHeader = try? FrameHeaderDecoder().decode(buffer: &byteBuffer) else { + XCTFail("Expected decoded frame header to be not nil") + return + } + + guard let decodedRequestNFrame = try? RequestNFrameDecoder().decode(header: decodedFrameHeader, buffer: &byteBuffer) else { + XCTFail("Expected decoded frame to be not nil") + return + } + + XCTAssertEqual(decodedRequestNFrame.header.type, .requestN, "Expected request N frame type") + XCTAssertEqual(decodedRequestNFrame.requestN, 14) + } +} diff --git a/Tests/RSocketCoreTests/Frames/RequestResponseFrameTests.swift b/Tests/RSocketCoreTests/Frames/RequestResponseFrameTests.swift new file mode 100644 index 00000000..b7ec6639 --- /dev/null +++ b/Tests/RSocketCoreTests/Frames/RequestResponseFrameTests.swift @@ -0,0 +1,132 @@ +/* + * Copyright 2015-present the original author or authors. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +import NIO +import XCTest +@testable import RSocketCore + +final class RequestResponseFrameTests: XCTestCase { + + static private let bytes: [UInt8] = [0, 0, 0, 0, + 16, 128, 100] + + /* Test Request Response Frame initialisation with streamId, fragmentsFollow and payload. + * Verify that the frame is initialised with expected values. + */ + func testRequestResponseInit() { + let payloadData = "test payload data".data(using: .utf8)! + let requestResponseFrame = RequestResponseFrame(streamId: 0, fragmentsFollow: true, payload: Payload(data: payloadData)) + + XCTAssertEqual(requestResponseFrame.header.type, .requestResponse, "Expected request response frame type") + XCTAssert(requestResponseFrame.header.flags.rawValue & FrameFlags.requestResponseFollows.rawValue != 0, "Expected follows flag to be set") + XCTAssertEqual(requestResponseFrame.payload.data, payloadData) + } + + /* Test Request Response Frame Encoder. + * Encode a request response frame and check the bytes in encoded byte buffer. + */ + func testRequestResponseEncoder() { + let payloadData = "d".data(using: .utf8)! + let requestResponseFrame = RequestResponseFrame(streamId: 0, fragmentsFollow: true, payload: Payload(data: payloadData)) + + guard var byteBuffer = try? RequestResponseFrameEncoder().encode(frame: requestResponseFrame, using: ByteBufferAllocator()) else { + XCTFail("Expected byte buffer to be not nil") + return + } + XCTAssertEqual(byteBuffer.readableBytes, 7) + XCTAssertEqual(byteBuffer.readBytes(length: byteBuffer.readableBytes), RequestResponseFrameTests.bytes) + } + + /* Test for Request Response Frame Decoder. + * Verify that the decoded byte buffer is request response frame. + */ + func testRequestResponseFrameDecoder() { + var byteBuffer = ByteBuffer(bytes: RequestResponseFrameTests.bytes) + guard let decodedFrameHeader = try? FrameHeaderDecoder().decode(buffer: &byteBuffer) else { + XCTFail("Expected decoded frame header to be not nil") + return + } + + guard let decodedRequestResponseFrame = try? RequestResponseFrameDecoder().decode(header: decodedFrameHeader, buffer: &byteBuffer) else { + XCTFail("Expected decoded frame to be not nil") + return + } + + XCTAssertEqual(decodedRequestResponseFrame.header.type, .requestResponse, "Expected request response frame type") + XCTAssertEqual(decodedRequestResponseFrame.payload.data, "d".data(using: .utf8)!) + } + + /* Test for Request Response Frame Coding. + * This test encodes request response frame and gets the byte buffer. + * Then decodes the byte buffer using request response frame decoder. + * The decoded frame should be same as encoded frame. + */ + func testRequestResponseFrameCoder() { + let payloadData = "test payload data".data(using: .utf8)! + let requestResponseFrame = RequestResponseFrame(streamId: 0, fragmentsFollow: false, payload: Payload(data: payloadData)) + + guard var byteBuffer = try? RequestResponseFrameEncoder().encode(frame: requestResponseFrame, using: ByteBufferAllocator()) else { + XCTFail("Expected byte buffer to be not nil") + return + } + + guard let decodedFrameHeader = try? FrameHeaderDecoder().decode(buffer: &byteBuffer) else { + XCTFail("Expected decoded frame header to be not nil") + return + } + + guard let decodedRequestResponseFrame = try? RequestResponseFrameDecoder().decode(header: decodedFrameHeader, buffer: &byteBuffer) else { + XCTFail("Expected decoded frame to be not nil") + return + } + + XCTAssertEqual(decodedRequestResponseFrame.header.type, .requestResponse, "Expected request response frame type") + XCTAssertEqual(decodedRequestResponseFrame.payload.data, payloadData) + } + + func testRequestResponseFollowsFlagSet() { + let payloadData = "".data(using: .utf8)! + let requestResponseFrame = RequestResponseFrame(streamId: 0, fragmentsFollow: true, payload: Payload(data: payloadData)) + + XCTAssertEqual(requestResponseFrame.header.type, .requestResponse, "Expected request response frame type") + XCTAssert(requestResponseFrame.header.flags.rawValue & FrameFlags.requestResponseFollows.rawValue != 0, "Expected follows flag to be set") + } + + func testRequestResponseFollowsFlagNotSet() { + let payloadData = "".data(using: .utf8)! + let requestResponseFrame = RequestResponseFrame(streamId: 0, fragmentsFollow: false, payload: Payload(data: payloadData)) + + XCTAssertEqual(requestResponseFrame.header.type, .requestResponse, "Expected request response frame type") + XCTAssert(requestResponseFrame.header.flags.rawValue & FrameFlags.requestResponseFollows.rawValue == 0, "Expected follows flag to not be set") + } + + func testRequestResponseMetadata() { + let payloadMetadata = "m".data(using: .utf8)! + let payloadData = "d".data(using: .utf8)! + let requestResponseFrame = RequestResponseFrame(streamId: 0, fragmentsFollow: true, payload: Payload(metadata: payloadMetadata, data: payloadData)) + + XCTAssertEqual(requestResponseFrame.header.type, .requestResponse, "Expected request response frame type") + XCTAssert(requestResponseFrame.header.flags.rawValue & FrameFlags.metadata.rawValue != 0, "Expected metadata flag to be set") + } + + func testRequestResponseMetadataNil() { + let payloadData = "d".data(using: .utf8)! + let requestResponseFrame = RequestResponseFrame(streamId: 0, fragmentsFollow: true, payload: Payload(metadata: nil, data: payloadData)) + + XCTAssertEqual(requestResponseFrame.header.type, .requestResponse, "Expected request response frame type") + XCTAssert(requestResponseFrame.header.flags.rawValue & FrameFlags.metadata.rawValue == 0, "Expected metadata flag to not be set") + } +} diff --git a/Tests/RSocketCoreTests/Frames/RequestStreamFrameTests.swift b/Tests/RSocketCoreTests/Frames/RequestStreamFrameTests.swift new file mode 100644 index 00000000..1cea69da --- /dev/null +++ b/Tests/RSocketCoreTests/Frames/RequestStreamFrameTests.swift @@ -0,0 +1,158 @@ +/* + * Copyright 2015-present the original author or authors. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +import NIO +import XCTest +@testable import RSocketCore + +final class RequestStreamFrameTests: XCTestCase { + + static private let bytes: [UInt8] = [0, 0, 0, 0, + 24, 128, 0, 0, + 0, 12, 100] + + /* Test Request Stream Frame initialisation with streamId, fragementsFollow, initialRequestN + * and payload. + * Verify that the frame is initialised with expected values. + */ + func testRequestStreamInit() { + let payloadData = "test payload data".data(using: .utf8)! + let requestStreamFrame = RequestStreamFrame(streamId: 0, fragmentsFollow: true, initialRequestN: 11, payload: Payload(data: payloadData)) + + XCTAssertEqual(requestStreamFrame.header.type, .requestStream, "Expected request Stream frame type") + XCTAssert(requestStreamFrame.header.flags.rawValue & FrameFlags.requestStreamFollows.rawValue != 0, "Expected follows flag to be set") + XCTAssertEqual(requestStreamFrame.payload.data, payloadData) + XCTAssertEqual(requestStreamFrame.initialRequestN, 11) + } + + func testRequestStreamFramePassValidation() { + let payloadData = "test payload data".data(using: .utf8)! + let requestStreamFrame = RequestStreamFrame(streamId: 0, fragmentsFollow: true, initialRequestN: 11, payload: Payload(data: payloadData)) + + XCTAssertNoThrow(try requestStreamFrame.validate()) + } + + func testRequestStreamFrameFailValidation() { + let payloadData = "test payload data".data(using: .utf8)! + let requestStreamFrame = RequestStreamFrame(streamId: 0, fragmentsFollow: true, initialRequestN: 0, payload: Payload(data: payloadData)) + + XCTAssertThrowsError(try requestStreamFrame.validate()) { error in + guard case Error.connectionError(let value) = error else { + return XCTFail("Unexpected error type") + } + + XCTAssertEqual(value, "initialRequestN has to be bigger than 0") + } + } + + /* Test Request Stream Frame Encoder. + * Encode a request stream frame and check the bytes in encoded byte buffer. + */ + func testRequestStreamEncoder() { + let payloadData = "d".data(using: .utf8)! + let requestStreamFrame = RequestStreamFrame(streamId: 0, fragmentsFollow: true, initialRequestN: 12, payload: Payload(data: payloadData)) + + guard var byteBuffer = try? RequestStreamFrameEncoder().encode(frame: requestStreamFrame, using: ByteBufferAllocator()) else { + XCTFail("Expected byte buffer to be not nil") + return + } + XCTAssertEqual(byteBuffer.readableBytes, 11) + XCTAssertEqual(byteBuffer.readBytes(length: byteBuffer.readableBytes), RequestStreamFrameTests.bytes) + } + + /* Test for Request Stream Frame Decoder. + * Verify that the decoded byte buffer is request stream frame. + */ + func testRequestStreamFrameDecoder() { + var byteBuffer = ByteBuffer(bytes: RequestStreamFrameTests.bytes) + + guard let decodedFrameHeader = try? FrameHeaderDecoder().decode(buffer: &byteBuffer) else { + XCTFail("Expected decoded frame header to be not nil") + return + } + + guard let decodedRequestStreamFrame = try? RequestStreamFrameDecoder().decode(header: decodedFrameHeader, buffer: &byteBuffer) else { + XCTFail("Expected decoded frame to be not nil") + return + } + + XCTAssertEqual(decodedRequestStreamFrame.header.type, .requestStream, "Expected request Stream frame type") + XCTAssertEqual(decodedRequestStreamFrame.payload.data, "d".data(using: .utf8)!) + XCTAssertEqual(decodedRequestStreamFrame.initialRequestN, 12) + } + + /* Test for Request Stream Frame Coding. + * This test encodes request stream frame and gets the byte buffer. + * Then decodes the byte buffer using request stream frame decoder. + * The decoded frame should be same as encoded frame. + */ + func testRequestStreamFrameCoder() { + let payloadData = "test payload data".data(using: .utf8)! + let requestStreamFrame = RequestStreamFrame(streamId: 0, fragmentsFollow: false, initialRequestN: 15, payload: Payload(data: payloadData)) + + guard var byteBuffer = try? RequestStreamFrameEncoder().encode(frame: requestStreamFrame, using: ByteBufferAllocator()) else { + XCTFail("Expected byte buffer to be not nil") + return + } + + guard let decodedFrameHeader = try? FrameHeaderDecoder().decode(buffer: &byteBuffer) else { + XCTFail("Expected decoded frame header to be not nil") + return + } + + guard let decodedRequestStreamFrame = try? RequestStreamFrameDecoder().decode(header: decodedFrameHeader, buffer: &byteBuffer) else { + XCTFail("Expected decoded frame to be not nil") + return + } + + XCTAssertEqual(decodedRequestStreamFrame.header.type, .requestStream, "Expected request Stream frame type") + XCTAssertEqual(decodedRequestStreamFrame.payload.data, payloadData) + XCTAssertEqual(decodedRequestStreamFrame.initialRequestN, 15) + } + + func testRequestStreamFollowsFlagSet() { + let payloadData = "".data(using: .utf8)! + let requestStreamFrame = RequestStreamFrame(streamId: 0, fragmentsFollow: true, initialRequestN: 15, payload: Payload(data: payloadData)) + + XCTAssertEqual(requestStreamFrame.header.type, .requestStream, "Expected request Stream frame type") + XCTAssert(requestStreamFrame.header.flags.rawValue & FrameFlags.requestStreamFollows.rawValue != 0, "Expected follows flag to be set") + } + + func testRequestStreamFollowsFlagNotSet() { + let payloadData = "".data(using: .utf8)! + let requestStreamFrame = RequestStreamFrame(streamId: 0, fragmentsFollow: false, initialRequestN: 15, payload: Payload(data: payloadData)) + + XCTAssertEqual(requestStreamFrame.header.type, .requestStream, "Expected request Stream frame type") + XCTAssert(requestStreamFrame.header.flags.rawValue & FrameFlags.requestStreamFollows.rawValue == 0, "Expected follows flag to not be set") + } + + func testRequestStreamMetadata() { + let payloadMetadata = "m".data(using: .utf8)! + let payloadData = "d".data(using: .utf8)! + let requestStreamFrame = RequestStreamFrame(streamId: 0, fragmentsFollow: true, initialRequestN: 15, payload: Payload(metadata: payloadMetadata, data: payloadData)) + + XCTAssertEqual(requestStreamFrame.header.type, .requestStream, "Expected request Stream frame type") + XCTAssert(requestStreamFrame.header.flags.rawValue & FrameFlags.metadata.rawValue != 0, "Expected metadata flag to be set") + } + + func testRequestStreamMetadataNil() { + let payloadData = "d".data(using: .utf8)! + let requestStreamFrame = RequestStreamFrame(streamId: 0, fragmentsFollow: true, initialRequestN: 15, payload: Payload(metadata: nil, data: payloadData)) + + XCTAssertEqual(requestStreamFrame.header.type, .requestStream, "Expected request Stream frame type") + XCTAssert(requestStreamFrame.header.flags.rawValue & FrameFlags.metadata.rawValue == 0, "Expected metadata flag to not be set") + } +} diff --git a/Tests/RSocketCoreTests/Frames/ResumeFrameTests.swift b/Tests/RSocketCoreTests/Frames/ResumeFrameTests.swift new file mode 100644 index 00000000..770dfaca --- /dev/null +++ b/Tests/RSocketCoreTests/Frames/ResumeFrameTests.swift @@ -0,0 +1,145 @@ +/* + * Copyright 2015-present the original author or authors. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +import NIO +import XCTest +@testable import RSocketCore + +final class ResumeFrameTests: XCTestCase { + + static private let bytes: [UInt8] = [0, 0, 0, 0, + 52, 0, 0, 1, + 0, 2, 0, 1, + 114, 0, 0, 0, + 0, 0, 0, 0, + 4, 0, 0, 0, + 0, 0, 0, 0, + 5] + + /* Test Resume Frame initialisation with majorVersion, minorVersion, + * resumeIdentificationToken, lastReceivedServerPosition and firstAvailableClientPosition. + * Verify that the frame is initialised with expected values. + */ + func testResumeInit() { + let resumeIdentificationToken = "resumeIdentificationToken".data(using: .utf8)! + let resumeFrame = ResumeFrame(majorVersion: 1, minorVersion: 2, resumeIdentificationToken: resumeIdentificationToken, lastReceivedServerPosition: 4, firstAvailableClientPosition: 5) + + XCTAssertEqual(resumeFrame.header.type, .resume, "Expected resume frame type") + XCTAssertEqual(resumeFrame.header.streamId, 0, "Expected steam id 0 in resume frame type") + XCTAssertTrue(resumeFrame.header.flags.isEmpty, "Expected flags to be empty") + XCTAssertEqual(resumeFrame.majorVersion, 1) + XCTAssertEqual(resumeFrame.minorVersion, 2) + XCTAssertEqual(resumeFrame.resumeIdentificationToken, resumeIdentificationToken) + XCTAssertEqual(resumeFrame.lastReceivedServerPosition, 4) + XCTAssertEqual(resumeFrame.firstAvailableClientPosition, 5) + } + + func testResumeFramePassValidation() { + let resumeIdentificationToken = "resumeIdentificationToken".data(using: .utf8)! + let resumeFrame = ResumeFrame(majorVersion: 1, minorVersion: 2, resumeIdentificationToken: resumeIdentificationToken, lastReceivedServerPosition: 4, firstAvailableClientPosition: 5) + + XCTAssertNoThrow(try resumeFrame.validate()) + } + + func testResumeFrameFailValidation() { + let resumeIdentificationToken = "resumeIdentificationToken".data(using: .utf8)! + let resumeFrame = ResumeFrame(majorVersion: 1, minorVersion: 2, resumeIdentificationToken: resumeIdentificationToken, lastReceivedServerPosition: 4, firstAvailableClientPosition: -1) + + XCTAssertThrowsError(try resumeFrame.validate()) { error in + guard case Error.connectionError(let value) = error else { + return XCTFail("Unexpected error type") + } + + XCTAssertEqual(value, "firstAvailableClientPosition has to be equal or bigger than 0") + } + } + + /* Test Resume Frame Encoder. + * Encode a resume frame and check the bytes in encoded byte buffer. + */ + func testResumeEncoder() { + let resumeIdentificationToken = "r".data(using: .utf8)! + let resumeFrame = ResumeFrame(majorVersion: 1, minorVersion: 2, resumeIdentificationToken: resumeIdentificationToken, lastReceivedServerPosition: 4, firstAvailableClientPosition: 5) + + guard var byteBuffer = try? ResumeFrameEncoder().encode(frame: resumeFrame, using: ByteBufferAllocator()) else { + XCTFail("Expected byte buffer to be not nil") + return + } + + XCTAssertEqual(byteBuffer.readableBytes, 29) + XCTAssertEqual(byteBuffer.readBytes(length: byteBuffer.readableBytes), ResumeFrameTests.bytes) + } + + /* Test for Resume Frame Decoder. + * Verify that the decoded byte buffer is resume frame. + */ + func testResumeDecoder() { + var byteBuffer = ByteBuffer(bytes: ResumeFrameTests.bytes) + + guard let decodedFrameHeader = try? FrameHeaderDecoder().decode(buffer: &byteBuffer) else { + XCTFail("Expected decoded frame header to be not nil") + return + } + + guard let decodedResumeFrame = try? ResumeFrameDecoder().decode(header: decodedFrameHeader, buffer: &byteBuffer) else { + XCTFail("Expected decoded frame to be not nil") + return + } + + XCTAssertEqual(decodedResumeFrame.header.type, .resume, "Expected resume frame type") + XCTAssertEqual(decodedResumeFrame.header.streamId, 0, "Expected steam id 0 in resume frame type") + XCTAssertTrue(decodedResumeFrame.header.flags.isEmpty, "Expected flags to be empty") + XCTAssertEqual(decodedResumeFrame.majorVersion, 1) + XCTAssertEqual(decodedResumeFrame.minorVersion, 2) + XCTAssertEqual(decodedResumeFrame.resumeIdentificationToken, "r".data(using: .utf8)!) + XCTAssertEqual(decodedResumeFrame.lastReceivedServerPosition, 4) + XCTAssertEqual(decodedResumeFrame.firstAvailableClientPosition, 5) + } + + /* Test for Resume Frame Coding. + * This test encodes resume frame and gets the byte buffer. + * Then decodes the byte buffer using resume frame decoder. + * The decoded frame should be same as encoded frame. + */ + func testResumeFrameCoder() { + let resumeIdentificationToken = "resumeIdentificationToken".data(using: .utf8)! + let resumeFrame = ResumeFrame(majorVersion: 1, minorVersion: 2, resumeIdentificationToken: resumeIdentificationToken, lastReceivedServerPosition: 4, firstAvailableClientPosition: 5) + + guard var byteBuffer = try? ResumeFrameEncoder().encode(frame: resumeFrame, using: ByteBufferAllocator()) else { + XCTFail("Expected byte buffer to be not nil") + return + } + + guard let decodedFrameHeader = try? FrameHeaderDecoder().decode(buffer: &byteBuffer) else { + XCTFail("Expected decoded frame header to be not nil") + return + } + + guard let decodedResumeFrame = try? ResumeFrameDecoder().decode(header: decodedFrameHeader, buffer: &byteBuffer) else { + XCTFail("Expected decoded frame to be not nil") + return + } + + XCTAssertEqual(decodedResumeFrame.header.type, .resume, "Expected resume frame type") + XCTAssertEqual(decodedResumeFrame.header.streamId, 0, "Expected steam id 0 in resume frame type") + XCTAssertTrue(decodedResumeFrame.header.flags.isEmpty, "Expected flags to be empty") + XCTAssertEqual(decodedResumeFrame.majorVersion, 1) + XCTAssertEqual(decodedResumeFrame.minorVersion, 2) + XCTAssertEqual(decodedResumeFrame.resumeIdentificationToken, resumeIdentificationToken) + XCTAssertEqual(decodedResumeFrame.lastReceivedServerPosition, 4) + XCTAssertEqual(decodedResumeFrame.firstAvailableClientPosition, 5) + } +} diff --git a/Tests/RSocketCoreTests/Frames/ResumeOkFrameTests.swift b/Tests/RSocketCoreTests/Frames/ResumeOkFrameTests.swift new file mode 100644 index 00000000..3086dfdf --- /dev/null +++ b/Tests/RSocketCoreTests/Frames/ResumeOkFrameTests.swift @@ -0,0 +1,122 @@ +/* + * Copyright 2015-present the original author or authors. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +import NIO +import XCTest +@testable import RSocketCore + +final class ResumeOkFrameTests: XCTestCase { + + static private let bytes: [UInt8] = [0, 0, 0, 0, + 56, 0, 0, 0, + 0, 0, 0, 0, + 0, 6] + + /* Test Resume Ok Frame initialisation with lastReceivedClientPosition. + * Verify that the frame is initialised with expected values. + */ + func testResumeOkInit() { + let resumeOkFrame = ResumeOkFrame(lastReceivedClientPosition: 5) + + XCTAssertEqual(resumeOkFrame.header.type, .resumeOk, "Expected resume Ok frame type") + XCTAssertEqual(resumeOkFrame.header.streamId, 0, "Expected steam id 0 in resume Ok frame type") + XCTAssertTrue(resumeOkFrame.header.flags.isEmpty, "Expected flags to be empty") + XCTAssertEqual(resumeOkFrame.lastReceivedClientPosition, 5) + } + + func testResumeOkFramePassValidation() { + let resumeOkFrame = ResumeOkFrame(lastReceivedClientPosition: 5) + + XCTAssertNoThrow(try resumeOkFrame.validate()) + } + + func testResumeOkFrameFailValidation() { + let resumeOkFrame = ResumeOkFrame(lastReceivedClientPosition: -1) + + XCTAssertThrowsError(try resumeOkFrame.validate()) { error in + guard case Error.connectionError(let value) = error else { + return XCTFail("Unexpected error type") + } + + XCTAssertEqual(value, "lastReceivedClientPosition has to be equal or bigger than 0") + } + } + + /* Test Resume Ok Frame Encoder. + * Encode a resume ok frame and check the bytes in encoded byte buffer. + */ + func testResumeOkEncoder() { + let resumeOkFrame = ResumeOkFrame(lastReceivedClientPosition: 6) + + guard var byteBuffer = try? ResumeOkFrameEncoder().encode(frame: resumeOkFrame, using: ByteBufferAllocator()) else { + XCTFail("Expected byte buffer to be not nil") + return + } + XCTAssertEqual(byteBuffer.readableBytes, 14) + XCTAssertEqual(byteBuffer.readBytes(length: byteBuffer.readableBytes), ResumeOkFrameTests.bytes) + } + + /* Test for Resume Ok Frame Decoder. + * Verify that the decoded byte buffer is resume ok frame. + */ + func testResumeOkDecoder() { + var byteBuffer = ByteBuffer(bytes: ResumeOkFrameTests.bytes) + + guard let decodedFrameHeader = try? FrameHeaderDecoder().decode(buffer: &byteBuffer) else { + XCTFail("Expected decoded frame header to be not nil") + return + } + + guard let decodedResumeOkFrame = try? ResumeOkFrameDecoder().decode(header: decodedFrameHeader, buffer: &byteBuffer) else { + XCTFail("Expected decoded frame to be not nil") + return + } + + XCTAssertEqual(decodedResumeOkFrame.header.type, .resumeOk, "Expected resume Ok frame type") + XCTAssertEqual(decodedResumeOkFrame.header.streamId, 0, "Expected steam id 0 in resume Ok frame type") + XCTAssertTrue(decodedResumeOkFrame.header.flags.isEmpty, "Expected flags to be empty") + XCTAssertEqual(decodedResumeOkFrame.lastReceivedClientPosition, 6) + } + + /* Test for Resume Ok Frame Coding. + * This test encodes resume ok frame and gets the byte buffer. + * Then decodes the byte buffer using resume ok frame decoder. + * The decoded frame should be same as encoded frame. + */ + func testResumeOkFrameCoder() { + let resumeOkFrame = ResumeOkFrame(lastReceivedClientPosition: 5) + + guard var byteBuffer = try? ResumeOkFrameEncoder().encode(frame: resumeOkFrame, using: ByteBufferAllocator()) else { + XCTFail("Expected byte buffer to be not nil") + return + } + + guard let decodedFrameHeader = try? FrameHeaderDecoder().decode(buffer: &byteBuffer) else { + XCTFail("Expected decoded frame header to be not nil") + return + } + + guard let decodedResumeOkFrame = try? ResumeOkFrameDecoder().decode(header: decodedFrameHeader, buffer: &byteBuffer) else { + XCTFail("Expected decoded frame to be not nil") + return + } + + XCTAssertEqual(decodedResumeOkFrame.header.type, .resumeOk, "Expected resume Ok frame type") + XCTAssertEqual(decodedResumeOkFrame.header.streamId, 0, "Expected steam id 0 in resume Ok frame type") + XCTAssertTrue(decodedResumeOkFrame.header.flags.isEmpty, "Expected flags to be empty") + XCTAssertEqual(decodedResumeOkFrame.lastReceivedClientPosition, 5) + } +} diff --git a/Tests/RSocketCoreTests/Frames/SetupFrameTests.swift b/Tests/RSocketCoreTests/Frames/SetupFrameTests.swift new file mode 100644 index 00000000..d9559480 --- /dev/null +++ b/Tests/RSocketCoreTests/Frames/SetupFrameTests.swift @@ -0,0 +1,161 @@ +/* + * Copyright 2015-present the original author or authors. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +import NIO +import XCTest +@testable import RSocketCore + +final class SetupFrameTests: XCTestCase { + + static private let bytes: [UInt8] = [0, 0, 0, 0, + 5, 64, 0, 1, + 0, 1, 0, 0, + 0, 10, 0, 0, + 0, 10, 10, 116, + 101, 120, 116, 47, + 112, 108, 97, 105, + 110, 10, 116, 101, + 120, 116, 47, 112, + 108, 97, 105, 110, + 0, 0, 1, 109, + 100] + + /* Test Setup Frame initialisation with honorsLease, majorVersion, minorVersion, + * timeBetweenKeepaliveFrames, maxLifetime, resumeIdentificationToken, + * metadataEncodingMimeType, dataEncodingMimeType and payload. + * Verify that the frame is initialised with expected values. + */ + func testSetupFrameInit() { + let resumeIdentificationToken = "resumeIdentificationToken".data(using: .utf8)! + let payloadData = "test payload data".data(using: .utf8)! + let payloadMetadata = "test payload metadata".data(using: .utf8)! + + let setupFrame = SetupFrame(honorsLease: true, majorVersion: 2, minorVersion: 0, timeBetweenKeepaliveFrames: 10, maxLifetime: 10, resumeIdentificationToken: resumeIdentificationToken, metadataEncodingMimeType: "text/plain", dataEncodingMimeType: "text/plain", payload: Payload(metadata: payloadMetadata, data: payloadData)) + + XCTAssertEqual(setupFrame.header.type, .setup, "Expected setup frame type") + XCTAssert(setupFrame.header.flags.rawValue & FrameFlags.setupLease.rawValue != 0, "Expected lease flag to be set") + XCTAssert(setupFrame.header.flags.rawValue & FrameFlags.metadata.rawValue != 0, "Expected metadata flag to be set") + XCTAssert(setupFrame.header.flags.rawValue & FrameFlags.setupResume.rawValue != 0, "Expected resume flag to be set") + XCTAssertEqual(setupFrame.majorVersion, 2) + XCTAssertEqual(setupFrame.minorVersion, 0) + XCTAssertEqual(setupFrame.timeBetweenKeepaliveFrames, 10) + XCTAssertEqual(setupFrame.maxLifetime, 10) + XCTAssertEqual(setupFrame.dataEncodingMimeType, "text/plain") + XCTAssertEqual(setupFrame.metadataEncodingMimeType, "text/plain") + XCTAssertEqual(setupFrame.payload.data, payloadData) + XCTAssertEqual(setupFrame.payload.metadata, payloadMetadata) + } + + /* Test Setup Frame Encoder. + * Encode a setup frame and check the bytes in encoded byte buffer. + */ + func testSetupFrameHeaderEncoder() { + let payloadData = "d".data(using: .utf8)! + let payloadMetadata = "m".data(using: .utf8)! + + let setupFrame = SetupFrame(honorsLease: true, majorVersion: 1, minorVersion: 1, timeBetweenKeepaliveFrames: 10, maxLifetime: 10, resumeIdentificationToken: nil, metadataEncodingMimeType: "text/plain", dataEncodingMimeType: "text/plain", payload: Payload(metadata: payloadMetadata, data: payloadData)) + + guard var byteBuffer = try? SetupFrameEncoder().encode(frame: setupFrame, using: ByteBufferAllocator()) else { + XCTFail("Expected byte buffer to be not nil") + return + } + XCTAssertEqual(byteBuffer.readableBytes, 45) + XCTAssertEqual(byteBuffer.readBytes(length: byteBuffer.readableBytes), SetupFrameTests.bytes) + } + + /* Test for Setup Frame Decoder. + * Verify that the decoded byte buffer is setup frame. + */ + func testSetupFrameHeaderDecoder() { + var byteBuffer = ByteBuffer(bytes: SetupFrameTests.bytes) + + guard let decodedFrameHeader = try? FrameHeaderDecoder().decode(buffer: &byteBuffer) else { + XCTFail("Expected decoded frame header to be not nil") + return + } + + guard let decodedSetupFrame = try? SetupFrameDecoder().decode(header: decodedFrameHeader, buffer: &byteBuffer) else { + XCTFail("Expected decoded frame to be not nil") + return + } + + XCTAssertEqual(decodedSetupFrame.header.type, .setup, "Expected setup frame type") + XCTAssertTrue(decodedSetupFrame.header.flags.rawValue & FrameFlags.setupLease.rawValue != 0, "Expected lease flag to be set") + XCTAssertEqual(decodedSetupFrame.header.flags.rawValue & FrameFlags.setupResume.rawValue, 0, "Expected resume flag to not be set") + XCTAssertEqual(decodedSetupFrame.majorVersion, 1) + XCTAssertEqual(decodedSetupFrame.minorVersion, 1) + XCTAssertEqual(decodedSetupFrame.timeBetweenKeepaliveFrames, 10) + XCTAssertEqual(decodedSetupFrame.maxLifetime, 10) + XCTAssertEqual(decodedSetupFrame.dataEncodingMimeType, "text/plain") + XCTAssertEqual(decodedSetupFrame.metadataEncodingMimeType, "text/plain") + XCTAssertEqual(decodedSetupFrame.payload.data, "d".data(using: .utf8)!) + XCTAssertEqual(decodedSetupFrame.payload.metadata, "m".data(using: .utf8)!) + } + + /* Test for Setup Frame Coding. + * This test encodes setup frame and gets the byte buffer. + * Then decodes the byte buffer using setup frame decoder. + * The decoded frame should be same as encoded frame. + */ + func testSetupFrameCoder() { + let resumeIdentificationToken = "resumeIdentificationToken".data(using: .utf8)! + let payloadData = "test payload data".data(using: .utf8)! + let payloadMetadata = "test payload metadata".data(using: .utf8)! + + let setupFrame = SetupFrame(honorsLease: true, majorVersion: 2, minorVersion: 0, timeBetweenKeepaliveFrames: 10, maxLifetime: 10, resumeIdentificationToken: resumeIdentificationToken, metadataEncodingMimeType: "text/plain", dataEncodingMimeType: "text/plain", payload: Payload(metadata: payloadMetadata, data: payloadData)) + + guard var byteBuffer = try? SetupFrameEncoder().encode(frame: setupFrame, using: ByteBufferAllocator()) else { + XCTFail("Expected byte buffer to be not nil") + return + } + + guard let decodedFrameHeader = try? FrameHeaderDecoder().decode(buffer: &byteBuffer) else { + XCTFail("Expected decoded frame header to be not nil") + return + } + + guard let decodedSetupFrame = try? SetupFrameDecoder().decode(header: decodedFrameHeader, buffer: &byteBuffer) else { + XCTFail("Expected decoded frame to be not nil") + return + } + + XCTAssertEqual(decodedSetupFrame.header.type, .setup, "Expected Setup frame type") + XCTAssertEqual(decodedSetupFrame.timeBetweenKeepaliveFrames, 10) + XCTAssertEqual(decodedSetupFrame.payload.metadata, payloadMetadata) + } + + func testSetupFrameHonorsLeaseFalse() { + let resumeIdentificationToken = "resumeIdentificationToken".data(using: .utf8)! + let payloadData = "test payload data".data(using: .utf8)! + let payloadMetadata = "test payload metadata".data(using: .utf8)! + + let setupFrame = SetupFrame(honorsLease: false, majorVersion: 2, minorVersion: 0, timeBetweenKeepaliveFrames: 10, maxLifetime: 10, resumeIdentificationToken: resumeIdentificationToken, metadataEncodingMimeType: "text/plain", dataEncodingMimeType: "text/plain", payload: Payload(metadata: payloadMetadata, data: payloadData)) + + XCTAssertEqual(setupFrame.header.type, .setup, "Expected setup frame type") + XCTAssert(setupFrame.header.flags.rawValue & FrameFlags.setupLease.rawValue == 0, "Expected lease flag to not be set") + } + + func testSetupFrameResumeIdTokenNil() { + let payloadData = "test payload data".data(using: .utf8)! + let payloadMetadata = "test payload metadata".data(using: .utf8)! + + let setupFrame = SetupFrame(honorsLease: false, majorVersion: 2, minorVersion: 0, timeBetweenKeepaliveFrames: 10, maxLifetime: 10, resumeIdentificationToken: nil, metadataEncodingMimeType: "text/plain", dataEncodingMimeType: "text/plain", payload: Payload(metadata: payloadMetadata, data: payloadData)) + + XCTAssertEqual(setupFrame.header.type, .setup, "Expected setup frame type") + XCTAssert(setupFrame.header.flags.rawValue & FrameFlags.setupResume.rawValue == 0, "Expected lease flag to not be set") + XCTAssertEqual(setupFrame.resumeIdentificationToken, nil, "Expected resume identification token to be nil") + } +}