| /* |
| * |
| * Copyright 2015, Google Inc. |
| * All rights reserved. |
| * |
| * Redistribution and use in source and binary forms, with or without |
| * modification, are permitted provided that the following conditions are |
| * met: |
| * |
| * * Redistributions of source code must retain the above copyright |
| * notice, this list of conditions and the following disclaimer. |
| * * Redistributions in binary form must reproduce the above |
| * copyright notice, this list of conditions and the following disclaimer |
| * in the documentation and/or other materials provided with the |
| * distribution. |
| * * Neither the name of Google Inc. nor the names of its |
| * contributors may be used to endorse or promote products derived from |
| * this software without specific prior written permission. |
| * |
| * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS |
| * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT |
| * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR |
| * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT |
| * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, |
| * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT |
| * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, |
| * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY |
| * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT |
| * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE |
| * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. |
| * |
| */ |
| |
| #import "InteropTests.h" |
| |
| #include <grpc/status.h> |
| |
| #import <Cronet/Cronet.h> |
| #import <GRPCClient/GRPCCall+Tests.h> |
| #import <GRPCClient/GRPCCall+Cronet.h> |
| #import <ProtoRPC/ProtoRPC.h> |
| #import <RemoteTest/Empty.pbobjc.h> |
| #import <RemoteTest/Messages.pbobjc.h> |
| #import <RemoteTest/Test.pbobjc.h> |
| #import <RemoteTest/Test.pbrpc.h> |
| #import <RxLibrary/GRXBufferedPipe.h> |
| #import <RxLibrary/GRXWriter+Immediate.h> |
| |
| // Convenience constructors for the generated proto messages: |
| |
| @interface RMTStreamingOutputCallRequest (Constructors) |
| + (instancetype)messageWithPayloadSize:(NSNumber *)payloadSize |
| requestedResponseSize:(NSNumber *)responseSize; |
| @end |
| |
| @implementation RMTStreamingOutputCallRequest (Constructors) |
| + (instancetype)messageWithPayloadSize:(NSNumber *)payloadSize |
| requestedResponseSize:(NSNumber *)responseSize { |
| RMTStreamingOutputCallRequest *request = [self message]; |
| RMTResponseParameters *parameters = [RMTResponseParameters message]; |
| parameters.size = responseSize.intValue; |
| [request.responseParametersArray addObject:parameters]; |
| request.payload.body = [NSMutableData dataWithLength:payloadSize.unsignedIntegerValue]; |
| return request; |
| } |
| @end |
| |
| @interface RMTStreamingOutputCallResponse (Constructors) |
| + (instancetype)messageWithPayloadSize:(NSNumber *)payloadSize; |
| @end |
| |
| @implementation RMTStreamingOutputCallResponse (Constructors) |
| + (instancetype)messageWithPayloadSize:(NSNumber *)payloadSize { |
| RMTStreamingOutputCallResponse * response = [self message]; |
| response.payload.type = RMTPayloadType_Compressable; |
| response.payload.body = [NSMutableData dataWithLength:payloadSize.unsignedIntegerValue]; |
| return response; |
| } |
| @end |
| |
| #pragma mark Tests |
| |
| #ifdef GRPC_COMPILE_WITH_CRONET |
| static cronet_engine *cronetEngine = NULL; |
| #endif |
| |
| @implementation InteropTests { |
| RMTTestService *_service; |
| } |
| |
| + (NSString *)host { |
| return nil; |
| } |
| |
| - (void)setUp { |
| _service = self.class.host ? [RMTTestService serviceWithHost:self.class.host] : nil; |
| #ifdef GRPC_COMPILE_WITH_CRONET |
| if (cronetEngine == NULL) { |
| // Cronet setup |
| [Cronet setHttp2Enabled:YES]; |
| [Cronet start]; |
| cronetEngine = [Cronet getGlobalEngine]; |
| [GRPCCall useCronetWithEngine:cronetEngine]; |
| } |
| #endif |
| } |
| |
| - (void)testEmptyUnaryRPC { |
| XCTAssertNotNil(self.class.host); |
| __weak XCTestExpectation *expectation = [self expectationWithDescription:@"EmptyUnary"]; |
| |
| RMTEmpty *request = [RMTEmpty message]; |
| |
| [_service emptyCallWithRequest:request handler:^(RMTEmpty *response, NSError *error) { |
| XCTAssertNil(error, @"Finished with unexpected error: %@", error); |
| |
| id expectedResponse = [RMTEmpty message]; |
| XCTAssertEqualObjects(response, expectedResponse); |
| |
| [expectation fulfill]; |
| }]; |
| |
| [self waitForExpectationsWithTimeout:4 handler:nil]; |
| } |
| |
| - (void)testLargeUnaryRPC { |
| XCTAssertNotNil(self.class.host); |
| __weak XCTestExpectation *expectation = [self expectationWithDescription:@"LargeUnary"]; |
| |
| RMTSimpleRequest *request = [RMTSimpleRequest message]; |
| request.responseType = RMTPayloadType_Compressable; |
| request.responseSize = 314159; |
| request.payload.body = [NSMutableData dataWithLength:271828]; |
| |
| [_service unaryCallWithRequest:request handler:^(RMTSimpleResponse *response, NSError *error) { |
| XCTAssertNil(error, @"Finished with unexpected error: %@", error); |
| |
| RMTSimpleResponse *expectedResponse = [RMTSimpleResponse message]; |
| expectedResponse.payload.type = RMTPayloadType_Compressable; |
| expectedResponse.payload.body = [NSMutableData dataWithLength:314159]; |
| XCTAssertEqualObjects(response, expectedResponse); |
| |
| [expectation fulfill]; |
| }]; |
| |
| [self waitForExpectationsWithTimeout:16 handler:nil]; |
| } |
| |
| - (void)testClientStreamingRPC { |
| XCTAssertNotNil(self.class.host); |
| __weak XCTestExpectation *expectation = [self expectationWithDescription:@"ClientStreaming"]; |
| |
| RMTStreamingInputCallRequest *request1 = [RMTStreamingInputCallRequest message]; |
| request1.payload.body = [NSMutableData dataWithLength:27182]; |
| |
| RMTStreamingInputCallRequest *request2 = [RMTStreamingInputCallRequest message]; |
| request2.payload.body = [NSMutableData dataWithLength:8]; |
| |
| RMTStreamingInputCallRequest *request3 = [RMTStreamingInputCallRequest message]; |
| request3.payload.body = [NSMutableData dataWithLength:1828]; |
| |
| RMTStreamingInputCallRequest *request4 = [RMTStreamingInputCallRequest message]; |
| request4.payload.body = [NSMutableData dataWithLength:45904]; |
| |
| GRXWriter *writer = [GRXWriter writerWithContainer:@[request1, request2, request3, request4]]; |
| |
| [_service streamingInputCallWithRequestsWriter:writer |
| handler:^(RMTStreamingInputCallResponse *response, |
| NSError *error) { |
| XCTAssertNil(error, @"Finished with unexpected error: %@", error); |
| |
| RMTStreamingInputCallResponse *expectedResponse = [RMTStreamingInputCallResponse message]; |
| expectedResponse.aggregatedPayloadSize = 74922; |
| XCTAssertEqualObjects(response, expectedResponse); |
| |
| [expectation fulfill]; |
| }]; |
| |
| [self waitForExpectationsWithTimeout:8 handler:nil]; |
| } |
| |
| - (void)testServerStreamingRPC { |
| XCTAssertNotNil(self.class.host); |
| __weak XCTestExpectation *expectation = [self expectationWithDescription:@"ServerStreaming"]; |
| |
| NSArray *expectedSizes = @[@31415, @9, @2653, @58979]; |
| |
| RMTStreamingOutputCallRequest *request = [RMTStreamingOutputCallRequest message]; |
| for (NSNumber *size in expectedSizes) { |
| RMTResponseParameters *parameters = [RMTResponseParameters message]; |
| parameters.size = [size intValue]; |
| [request.responseParametersArray addObject:parameters]; |
| } |
| |
| __block int index = 0; |
| [_service streamingOutputCallWithRequest:request |
| eventHandler:^(BOOL done, |
| RMTStreamingOutputCallResponse *response, |
| NSError *error){ |
| XCTAssertNil(error, @"Finished with unexpected error: %@", error); |
| XCTAssertTrue(done || response, @"Event handler called without an event."); |
| |
| if (response) { |
| XCTAssertLessThan(index, 4, @"More than 4 responses received."); |
| id expected = [RMTStreamingOutputCallResponse messageWithPayloadSize:expectedSizes[index]]; |
| XCTAssertEqualObjects(response, expected); |
| index += 1; |
| } |
| |
| if (done) { |
| XCTAssertEqual(index, 4, @"Received %i responses instead of 4.", index); |
| [expectation fulfill]; |
| } |
| }]; |
| |
| [self waitForExpectationsWithTimeout:8 handler:nil]; |
| } |
| |
| - (void)testPingPongRPC { |
| XCTAssertNotNil(self.class.host); |
| __weak XCTestExpectation *expectation = [self expectationWithDescription:@"PingPong"]; |
| |
| NSArray *requests = @[@27182, @8, @1828, @45904]; |
| NSArray *responses = @[@31415, @9, @2653, @58979]; |
| |
| GRXBufferedPipe *requestsBuffer = [[GRXBufferedPipe alloc] init]; |
| |
| __block int index = 0; |
| |
| id request = [RMTStreamingOutputCallRequest messageWithPayloadSize:requests[index] |
| requestedResponseSize:responses[index]]; |
| [requestsBuffer writeValue:request]; |
| |
| [_service fullDuplexCallWithRequestsWriter:requestsBuffer |
| eventHandler:^(BOOL done, |
| RMTStreamingOutputCallResponse *response, |
| NSError *error) { |
| XCTAssertNil(error, @"Finished with unexpected error: %@", error); |
| XCTAssertTrue(done || response, @"Event handler called without an event."); |
| |
| if (response) { |
| XCTAssertLessThan(index, 4, @"More than 4 responses received."); |
| id expected = [RMTStreamingOutputCallResponse messageWithPayloadSize:responses[index]]; |
| XCTAssertEqualObjects(response, expected); |
| index += 1; |
| if (index < 4) { |
| id request = [RMTStreamingOutputCallRequest messageWithPayloadSize:requests[index] |
| requestedResponseSize:responses[index]]; |
| [requestsBuffer writeValue:request]; |
| } else { |
| [requestsBuffer writesFinishedWithError:nil]; |
| } |
| } |
| |
| if (done) { |
| XCTAssertEqual(index, 4, @"Received %i responses instead of 4.", index); |
| [expectation fulfill]; |
| } |
| }]; |
| [self waitForExpectationsWithTimeout:4 handler:nil]; |
| } |
| |
| #ifndef GRPC_COMPILE_WITH_CRONET |
| // TODO(makdharma@): Fix this test |
| - (void)testEmptyStreamRPC { |
| XCTAssertNotNil(self.class.host); |
| __weak XCTestExpectation *expectation = [self expectationWithDescription:@"EmptyStream"]; |
| [_service fullDuplexCallWithRequestsWriter:[GRXWriter emptyWriter] |
| eventHandler:^(BOOL done, |
| RMTStreamingOutputCallResponse *response, |
| NSError *error) { |
| XCTAssertNil(error, @"Finished with unexpected error: %@", error); |
| XCTAssert(done, @"Unexpected response: %@", response); |
| [expectation fulfill]; |
| }]; |
| [self waitForExpectationsWithTimeout:2 handler:nil]; |
| } |
| #endif |
| |
| - (void)testCancelAfterBeginRPC { |
| XCTAssertNotNil(self.class.host); |
| __weak XCTestExpectation *expectation = [self expectationWithDescription:@"CancelAfterBegin"]; |
| |
| // A buffered pipe to which we never write any value acts as a writer that just hangs. |
| GRXBufferedPipe *requestsBuffer = [[GRXBufferedPipe alloc] init]; |
| |
| GRPCProtoCall *call = |
| [_service RPCToStreamingInputCallWithRequestsWriter:requestsBuffer |
| handler:^(RMTStreamingInputCallResponse *response, |
| NSError *error) { |
| XCTAssertEqual(error.code, GRPC_STATUS_CANCELLED); |
| [expectation fulfill]; |
| }]; |
| XCTAssertEqual(call.state, GRXWriterStateNotStarted); |
| |
| [call start]; |
| XCTAssertEqual(call.state, GRXWriterStateStarted); |
| |
| [call cancel]; |
| XCTAssertEqual(call.state, GRXWriterStateFinished); |
| |
| [self waitForExpectationsWithTimeout:1 handler:nil]; |
| } |
| |
| - (void)testCancelAfterFirstResponseRPC { |
| XCTAssertNotNil(self.class.host); |
| __weak XCTestExpectation *expectation = [self expectationWithDescription:@"CancelAfterFirstResponse"]; |
| |
| // A buffered pipe to which we write a single value but never close |
| GRXBufferedPipe *requestsBuffer = [[GRXBufferedPipe alloc] init]; |
| |
| __block BOOL receivedResponse = NO; |
| |
| id request = [RMTStreamingOutputCallRequest messageWithPayloadSize:@21782 |
| requestedResponseSize:@31415]; |
| |
| [requestsBuffer writeValue:request]; |
| |
| __block GRPCProtoCall *call = |
| [_service RPCToFullDuplexCallWithRequestsWriter:requestsBuffer |
| eventHandler:^(BOOL done, |
| RMTStreamingOutputCallResponse *response, |
| NSError *error) { |
| if (receivedResponse) { |
| XCTAssert(done, @"Unexpected extra response %@", response); |
| XCTAssertEqual(error.code, GRPC_STATUS_CANCELLED); |
| [expectation fulfill]; |
| } else { |
| XCTAssertNil(error, @"Finished with unexpected error: %@", error); |
| XCTAssertFalse(done, @"Finished without response"); |
| XCTAssertNotNil(response); |
| receivedResponse = YES; |
| [call cancel]; |
| } |
| }]; |
| [call start]; |
| [self waitForExpectationsWithTimeout:8 handler:nil]; |
| } |
| |
| @end |