ably · tcard · May 2, 2016 · Apr 27, 2016 · Apr 27, 2016 · Apr 29, 2016
diff --git a/Source/ARTRealtime+Private.h b/Source/ARTRealtime+Private.h
@@ -21,13 +21,22 @@
 
 ART_ASSUME_NONNULL_BEGIN
 
-@interface ARTRealtime ()
+@interface ARTRealtime () <ARTRealtimeTransportDelegate>
 
 @property (readonly, strong, nonatomic) __GENERIC(ARTEventEmitter, NSNumber *, ARTConnectionStateChange *) *eventEmitter;
 @property (readonly, strong, nonatomic) __GENERIC(ARTEventEmitter, NSNull *, NSNull *) *reconnectedEventEmitter;
 
 + (NSString *)protocolStr:(ARTProtocolMessageAction)action;
 
+// State properties
+- (BOOL)shouldSendEvents;
+- (BOOL)shouldQueueEvents;
+- (ARTStatus *)defaultError;
+
+// Message sending
+- (void)sendQueuedMessages;
+- (void)failQueuedMessages:(ARTStatus *)error;
+
 @end
 
 /// ARTRealtime private methods that are used for whitebox testing.

diff --git a/Source/ARTRealtime.m b/Source/ARTRealtime.m
@@ -29,23 +29,6 @@
 #import "ARTConnectionDetails.h"
 #import "ARTStats.h"
 
-@interface ARTRealtime () <ARTRealtimeTransportDelegate> {
-    Class _transportClass;
-    id<ARTRealtimeTransport> _transport;
-}
-
-// State properties
-- (BOOL)shouldSendEvents;
-- (BOOL)shouldQueueEvents;
-- (ARTStatus *)defaultError;
-
-// Message sending
-- (void)sendQueuedMessages;
-- (void)failQueuedMessages:(ARTStatus *)error;
-
-@end
-
-
 #pragma mark - ARTRealtime implementation
 
 @implementation ARTRealtime {
@@ -54,6 +37,8 @@ @implementation ARTRealtime {
     __GENERIC(ARTEventEmitter, NSNull *, ARTErrorInfo *) *_pingEventEmitter;
     NSDate *_startedReconnection;
     NSTimeInterval _connectionStateTtl;
+    Class _transportClass;
+    id<ARTRealtimeTransport> _transport;
 }
 
 - (instancetype)initWithKey:(NSString *)key {
@@ -410,11 +395,27 @@ - (void)onConnected:(ARTProtocolMessage *)message {
 }
 
 - (void)onDisconnected {
+    [self onDisconnected:nil];
+}
+
+- (void)onDisconnected:(ARTProtocolMessage *)message {
     [self.logger info:@"ARTRealtime disconnected"];
     switch (self.connection.state) {
-        case ARTRealtimeConnected:
-            [self transition:ARTRealtimeDisconnected];
+        case ARTRealtimeConnected: {
+            ARTErrorInfo *error;
+            if (message) {
+                error = message.error;
+            }
+            if (!_renewingToken && error && error.statusCode == 401 && error.code >= 40140 && error.code < 40150 && [self isTokenRenewable]) {
+                [self connectWithRenewedToken];
+                return;
+            }
+            if (error) {
+
+            }
+            [self transition:ARTRealtimeDisconnected withErrorInfo:error];
             break;
+        }
         default:
             NSAssert(false, @"Invalid Realtime state transitioning to Disconnected: expected Connected");
             break;
@@ -457,8 +458,10 @@ - (BOOL)isTokenRenewable {
 
 - (void)connectWithRenewedToken {
     _renewingToken = true;
-    [self.transport close];
-    [self.transport connectForcingNewToken:true];
+    [_transport close];
+    _transport = [[_transportClass alloc] initWithRest:self.rest options:self.options resumeKey:_transport.resumeKey connectionSerial:_transport.connectionSerial];
+    _transport.delegate = self;
+    [_transport connectForcingNewToken:true];
 }
 
 - (void)onAck:(ARTProtocolMessage *)message {
@@ -676,7 +679,7 @@ - (void)realtimeTransport:(id)transport didReceiveMessage:(ARTProtocolMessage *)
             [self onConnected:message];
             break;
         case ARTProtocolMessageDisconnected:
-            [self onDisconnected];
+            [self onDisconnected:message];
             break;
         case ARTProtocolMessageAck:
             [self onAck:message];

diff --git a/Source/ARTRealtimeTransport.h b/Source/ARTRealtimeTransport.h
@@ -13,6 +13,8 @@
 @class ARTProtocolMessage;
 @class ARTStatus;
 @class ARTErrorInfo;
+@class ARTClientOptions;
+@class ARTRest;
 
 ART_ASSUME_NONNULL_BEGIN
 
@@ -34,6 +36,11 @@ ART_ASSUME_NONNULL_BEGIN
 
 @protocol ARTRealtimeTransport
 
+- (instancetype)initWithRest:(ARTRest *)rest options:(ARTClientOptions *)options resumeKey:(NSString *)resumeKey connectionSerial:(NSNumber *)connectionSerial;
+
+@property (readonly, strong, nonatomic) NSString *resumeKey;
+@property (readonly, strong, nonatomic) NSNumber *connectionSerial;
+
 @property (readwrite, weak, nonatomic) id<ARTRealtimeTransportDelegate> delegate;
 - (void)send:(ARTProtocolMessage *)msg;
 - (void)receive:(ARTProtocolMessage *)msg;

diff --git a/Source/ARTWebSocketTransport.h b/Source/ARTWebSocketTransport.h
@@ -20,8 +20,9 @@ ART_ASSUME_NONNULL_BEGIN
 @interface ARTWebSocketTransport : NSObject <ARTRealtimeTransport>
 
 - (instancetype)init UNAVAILABLE_ATTRIBUTE;
-- (instancetype)initWithRest:(ARTRest *)rest options:(ARTClientOptions *)options resumeKey:(NSString *)resumeKey connectionSerial:(NSNumber *)connectionSerial;
 
+@property (readonly, strong, nonatomic) NSString *resumeKey;
+@property (readonly, strong, nonatomic) NSNumber *connectionSerial;
 @property (readwrite, weak, nonatomic) id<ARTRealtimeTransportDelegate> delegate;
 
 @property (readonly, getter=getIsConnected) BOOL isConnected;

diff --git a/Source/ARTWebSocketTransport.m b/Source/ARTWebSocketTransport.m
@@ -48,8 +48,6 @@ @interface ARTWebSocketTransport () <WebSocketDelegate>
 @property (readonly, strong, nonatomic) ARTLog *logger;
 @property (readonly, strong, nonatomic) ARTAuth *auth;
 @property (readonly, strong, nonatomic) ARTClientOptions *options;
-@property (readonly, strong, nonatomic) NSString *resumeKey;
-@property (readonly, strong, nonatomic) NSNumber *connectionSerial;
 
 @end
 

diff --git a/Spec/RealtimeClientConnection.swift b/Spec/RealtimeClientConnection.swift
@@ -1459,7 +1459,10 @@ class RealtimeClientConnection: QuickSpec {
                         client.close()
                     }
 
-                    var transport: TestProxyTransport!
+                    client.connect()
+                    let firstTransport = client.transport as! TestProxyTransport
+                    expect(client.transport).toEventuallyNot(beIdenticalTo(firstTransport), timeout: testTimeout)
+                    let newTransport = client.transport as! TestProxyTransport
 
                     waitUntil(timeout: testTimeout) { done in
                         client.connection.on { stateChange in
@@ -1480,11 +1483,9 @@ class RealtimeClientConnection: QuickSpec {
                                 break
                             }
                         }
-                        client.connect()
-                        transport = client.transport as! TestProxyTransport
                     }
 
-                    let failures = transport.protocolMessagesReceived.filter({ $0.action == .Error })
+                    let failures = firstTransport.protocolMessagesReceived.filter({ $0.action == .Error }) + newTransport.protocolMessagesReceived.filter({ $0.action == .Error })
 
                     if failures.count != 2 {
                         fail("Should have two connection request fail")
@@ -2040,6 +2041,163 @@ class RealtimeClientConnection: QuickSpec {
                     expect(channel.errorReason!.message).to(contain("Unable to recover connection"))
                 }
 
+                // RTN15h
+                context("DISCONNECTED message contains a token error") {
+
+                    it("if the token is renewable then error should not be emitted") {
+                        let options = AblyTests.commonAppSetup()
+                        options.autoConnect = false
+                        options.authCallback = { tokenParams, callback in
+                            callback(getTestTokenDetails(key: options.key, capability: tokenParams.capability, ttl: tokenParams.ttl), nil)
+                        }
+                        let tokenTtl = 10.0
+                        options.token = getTestToken(key: options.key, ttl: tokenTtl)
+
+                        let client = ARTRealtime(options: options)
+                        client.setTransportClass(TestProxyTransport.self)
+                        defer {
+                            client.dispose()
+                            client.close()
+                        }
+
+                        client.connect()
+                        expect(client.connection.state).toEventually(equal(ARTRealtimeConnectionState.Connected), timeout: testTimeout)
+                        let firstTransport = client.transport as! TestProxyTransport
+
+                        client.connection.on { stateChange in
+                            fail("Should not be called, was called with \(stateChange)")
+                        }
+
+                        let protocolMessage = ARTProtocolMessage()
+                        protocolMessage.action = .Disconnected
+                        protocolMessage.error = ARTErrorInfo.createWithCode(40142, status: 401, message: "test error")
+                        client.realtimeTransport(firstTransport, didReceiveMessage: protocolMessage)
+
+                        expect(client.connection.state).to(equal(ARTRealtimeConnectionState.Connected))
+                        expect(client.connection.errorReason).to(beNil())
+                        expect(client.transport).toNot(beIdenticalTo(firstTransport))
+
+                        waitUntil(timeout: testTimeout) { done in 
+                            client.ping { error in
+                                expect(error).to(beNil())
+                                expect((client.transport as! TestProxyTransport).protocolMessagesReceived.filter({ $0.action == .Connected })).to(haveCount(1))
+                                done()
+                            }
+                        }                        
+                    }
+
+                    it("should transition to Failed when the token renewal fails") {
+                        let options = AblyTests.commonAppSetup()
+                        options.autoConnect = false
+                        let tokenTtl = 1.0
+                        let tokenDetails = getTestTokenDetails(key: options.key, capability: nil, ttl: tokenTtl)!
+                        options.token = tokenDetails.token
+                        options.authCallback = { tokenParams, callback in
+                            // Let the token expire.
+                            delay(tokenTtl) {
+                                callback(tokenDetails, nil) // Return the same expired token again.
+                            }
+                        }
+
+                        let client = ARTRealtime(options: options)
+                        client.setTransportClass(TestProxyTransport.self)
+                        defer {
+                            client.dispose()
+                            client.close()
+                        }
+
+                        client.connect()
+                        expect(client.connection.state).toEventually(equal(ARTRealtimeConnectionState.Connected), timeout: testTimeout)
+                        let firstTransport = client.transport as! TestProxyTransport
+                        var newTransport: TestProxyTransport!
+
+                        waitUntil(timeout: testTimeout) { done in
+                            client.connection.on { stateChange in
+                                let stateChange = stateChange!
+                                let state = stateChange.current
+                                let errorInfo = stateChange.reason
+                                switch state {
+                                case .Connected:
+                                    fail("Should not be connected")
+                                    done()
+                                case .Failed, .Disconnected, .Suspended:
+                                    guard let errorInfo = errorInfo else {
+                                        fail("ErrorInfo is nil"); done(); return
+                                    }
+                                    expect(errorInfo.code).to(equal(40142)) //Token expired
+                                    done()
+                                default:
+                                    break
+                                }
+                            }
+
+                            let protocolMessage = ARTProtocolMessage()
+                            protocolMessage.action = .Disconnected
+                            protocolMessage.error = ARTErrorInfo.createWithCode(40142, status: 401, message: "test error")
+                            client.realtimeTransport(firstTransport, didReceiveMessage: protocolMessage)
+
+                            expect(client.connection.state).to(equal(ARTRealtimeConnectionState.Connected))
+                            expect(client.connection.errorReason).to(beNil())
+                            expect(client.transport).toNot(beIdenticalTo(firstTransport))
+                            newTransport = client.transport as! TestProxyTransport
+                        }
+
+                        let failures = newTransport.protocolMessagesReceived.filter({ $0.action == .Error })
+
+                        if failures.count != 1 {
+                            fail("Should have one connection request fail")
+                            return
+                        }
+
+                        expect(failures[0].error!.code).to(equal(40142))
+                    }
+
+                    it("if the token is not renewable or token creation fails then error should be emitted") {
+                        let options = AblyTests.commonAppSetup()
+                        options.autoConnect = false
+                        options.key = nil
+                        let tokenTtl = 10.0
+                        let tokenDetails = getTestTokenDetails(key: options.key, capability: nil, ttl: tokenTtl)!
+                        options.token = tokenDetails.token
+
+                        let client = ARTRealtime(options: options)
+                        client.setTransportClass(TestProxyTransport.self)
+                        defer {
+                            client.dispose()
+                            client.close()
+                        }
+
+                        client.connect()
+                        expect(client.connection.state).toEventually(equal(ARTRealtimeConnectionState.Connected), timeout: testTimeout)
+
+                        waitUntil(timeout: testTimeout) { done in
+                            client.connection.on { stateChange in
+                                let stateChange = stateChange!
+                                let state = stateChange.current
+                                let errorInfo = stateChange.reason
+                                switch state {
+                                case .Connected:
+                                    fail("Should not be connected")
+                                    done()
+                                case .Failed, .Disconnected, .Suspended:
+                                    guard let errorInfo = errorInfo else {
+                                        fail("ErrorInfo is nil"); done(); return
+                                    }
+                                    expect(errorInfo.code).to(equal(40142)) //Token expired
+                                    done()
+                                default:
+                                    break
+                                }
+                            }
+
+                            let protocolMessage = ARTProtocolMessage()
+                            protocolMessage.action = .Disconnected
+                            protocolMessage.error = ARTErrorInfo.createWithCode(40142, status: 401, message: "test error")
+                            client.realtimeTransport(client.transport, didReceiveMessage: protocolMessage)
+                        }
+                    }
+                }
+
             }
 
             // RTN16