Merge branch 'master' into develop

6 files changed, 893 insertions, 145 deletions

diff --git a/python-tornado/tests/benchmark.py b/python-tornado/tests/benchmark.py
index 9d1840e..748fe3b 100644
--- a/python-tornado/tests/benchmark.py
+++ b/python-tornado/tests/benchmark.py
@@ -12,10 +12,7 @@
 import sys
 import datetime
 import tornado
-sys.path.append('./')
-sys.path.append('../')
-sys.path.append('../common')
-from Pubnub import Pubnub
+from Pubnub import PubnubTwisted as Pubnub
 
 publish_key   = len(sys.argv) > 1 and sys.argv[1] or 'demo'
 subscribe_key = len(sys.argv) > 2 and sys.argv[2] or 'demo'
diff --git a/python-tornado/tests/delivery.py b/python-tornado/tests/delivery.py
index f3633e6..0181403 100644
--- a/python-tornado/tests/delivery.py
+++ b/python-tornado/tests/delivery.py
@@ -1,4 +1,4 @@
-## www.pubnub.com - PubNub Real-time push service in the cloud. 
+## www.pubnub.com - PubNub Real-time push service in the cloud.
 # coding=utf8
 
 ## PubNub Real-time Push APIs and Notifications Framework
@@ -14,98 +14,104 @@ import datetime
 import time
 import math
 
-sys.path.append('../')
-from Pubnub import Pubnub
+from Pubnub import PubnubTwisted as Pubnub
 
 ## -----------------------------------------------------------------------
 ## Configuration
 ## -----------------------------------------------------------------------
-publish_key   = len(sys.argv) > 1 and sys.argv[1] or 'demo'
+publish_key = len(sys.argv) > 1 and sys.argv[1] or 'demo'
 subscribe_key = len(sys.argv) > 2 and sys.argv[2] or 'demo'
-secret_key    = len(sys.argv) > 3 and sys.argv[3] or 'demo'
-cipher_key    = len(sys.argv) > 4 and sys.argv[4] or 'demo'
-ssl_on        = len(sys.argv) > 5 and bool(sys.argv[5]) or False
-origin        = len(sys.argv) > 6 and sys.argv[6] or 'pubsub.pubnub.com'
+secret_key = len(sys.argv) > 3 and sys.argv[3] or 'demo'
+cipher_key = len(sys.argv) > 4 and sys.argv[4] or 'demo'
+ssl_on = len(sys.argv) > 5 and bool(sys.argv[5]) or False
+origin = len(sys.argv) > 6 and sys.argv[6] or 'pubsub.pubnub.com'
 
 ## -----------------------------------------------------------------------
 ## Analytics
 ## -----------------------------------------------------------------------
 analytics = {
-    'publishes'            : 0,   ## Total Send Requests
-    'received'             : 0,   ## Total Received Messages (Deliveries)
-    'queued'               : 0,   ## Total Unreceived Queue (UnDeliveries)
-    'successful_publishes' : 0,   ## Confirmed Successful Publish Request
-    'failed_publishes'     : 0,   ## Confirmed UNSuccessful Publish Request
-    'failed_deliveries'    : 0,   ## (successful_publishes - received)
-    'deliverability'       : 0    ## Percentage Delivery
+    'publishes': 0,  # Total Send Requests
+    'received': 0,  # Total Received Messages (Deliveries)
+    'queued': 0,  # Total Unreceived Queue (UnDeliveries)
+    'successful_publishes': 0,  # Confirmed Successful Publish Request
+    'failed_publishes': 0,  # Confirmed UNSuccessful Publish Request
+    'failed_deliveries': 0,  # (successful_publishes - received)
+    'deliverability': 0  # Percentage Delivery
 }
 
 trips = {
-    'last'    : None,
-    'current' : None,
-    'max'     : 0,
-    'avg'     : 0
+    'last': None,
+    'current': None,
+    'max': 0,
+    'avg': 0
 }
 
 ## -----------------------------------------------------------------------
 ## Initiat Class
 ## -----------------------------------------------------------------------
 channel = 'deliverability-' + str(time.time())
-pubnub  = Pubnub(
+pubnub = Pubnub(
     publish_key,
     subscribe_key,
-    secret_key = secret_key,
-    cipher_key = cipher_key,
-    ssl_on = ssl_on,
-    origin = origin
+    secret_key=secret_key,
+    cipher_key=cipher_key,
+    ssl_on=ssl_on,
+    origin=origin
 )
 
 ## -----------------------------------------------------------------------
 ## BENCHMARK
 ## -----------------------------------------------------------------------
-def publish_sent(info = None):
-    if info and info[0]: analytics['successful_publishes']   += 1
-    else:                analytics['failed_publishes']       += 1
+
+
+def publish_sent(info=None):
+    if info and info[0]:
+        analytics['successful_publishes'] += 1
+    else:
+        analytics['failed_publishes'] += 1
 
     analytics['publishes'] += 1
-    analytics['queued']    += 1
+    analytics['queued'] += 1
+
+    pubnub.timeout(send, 0.1)
 
-    pubnub.timeout( send, 0.1 )
 
 def send():
     if analytics['queued'] > 100:
         analytics['queued'] -= 10
-        return pubnub.timeout( send, 10 )
+        return pubnub.timeout(send, 10)
 
     pubnub.publish({
-        'channel'  : channel,
-        'callback' : publish_sent,
-        'message'  : "1234567890"
+        'channel': channel,
+        'callback': publish_sent,
+        'message': "1234567890"
     })
 
+
 def received(message):
-    analytics['queued']   -= 1
+    analytics['queued'] -= 1
     analytics['received'] += 1
     current_trip = trips['current'] = str(datetime.datetime.now())[0:19]
-    last_trip    = trips['last']    = str(
+    last_trip = trips['last'] = str(
         datetime.datetime.now() - datetime.timedelta(seconds=1)
     )[0:19]
 
     ## New Trip Span (1 Second)
-    if not trips.has_key(current_trip) :
+    if current_trip not in trips:
         trips[current_trip] = 0
 
         ## Average
-        if trips.has_key(last_trip):
+        if last_trip in trips:
             trips['avg'] = (trips['avg'] + trips[last_trip]) / 2
 
     ## Increment Trip Counter
     trips[current_trip] = trips[current_trip] + 1
 
     ## Update Max
-    if trips[current_trip] > trips['max'] :
+    if trips[current_trip] > trips['max']:
         trips['max'] = trips[current_trip]
 
+
 def show_status():
     ## Update Failed Deliveries
     analytics['failed_deliveries'] = \
@@ -114,45 +120,46 @@ def show_status():
 
     ## Update Deliverability
     analytics['deliverability'] = (
-        float(analytics['received']) / \
+        float(analytics['received']) /
         float(analytics['successful_publishes'] or 1.0)
     ) * 100.0
 
     ## Print Display
-    print( (
-       "max:%(max)03d/sec  "                  + \
-       "avg:%(avg)03d/sec  "                  + \
-       "pubs:%(publishes)05d  "               + \
-       "received:%(received)05d  "            + \
-       "spub:%(successful_publishes)05d  "    + \
-       "fpub:%(failed_publishes)05d  "        + \
-       "failed:%(failed_deliveries)05d  "     + \
-       "queued:%(queued)03d  "                + \
-       "delivery:%(deliverability)03f%%  "    + \
-       ""
-    ) % {
-        'max'                  : trips['max'],
-        'avg'                  : trips['avg'],
-        'publishes'            : analytics['publishes'],
-        'received'             : analytics['received'],
-        'successful_publishes' : analytics['successful_publishes'],
-        'failed_publishes'     : analytics['failed_publishes'],
-        'failed_deliveries'    : analytics['failed_deliveries'],
-        'publishes'            : analytics['publishes'],
-        'deliverability'       : analytics['deliverability'],
-        'queued'               : analytics['queued']
-    } )
-    pubnub.timeout( show_status, 1 )
+    print((
+          "max:%(max)03d/sec  " +
+          "avg:%(avg)03d/sec  " +
+          "pubs:%(publishes)05d  " +
+          "received:%(received)05d  " +
+          "spub:%(successful_publishes)05d  " +
+          "fpub:%(failed_publishes)05d  " +
+          "failed:%(failed_deliveries)05d  " +
+          "queued:%(queued)03d  " +
+          "delivery:%(deliverability)03f%%  " +
+          ""
+          ) % {
+          'max': trips['max'],
+          'avg': trips['avg'],
+          'publishes': analytics['publishes'],
+          'received': analytics['received'],
+          'successful_publishes': analytics['successful_publishes'],
+          'failed_publishes': analytics['failed_publishes'],
+          'failed_deliveries': analytics['failed_deliveries'],
+          'publishes': analytics['publishes'],
+          'deliverability': analytics['deliverability'],
+          'queued': analytics['queued']
+          })
+    pubnub.timeout(show_status, 1)
+
 
 def connected():
     show_status()
-    pubnub.timeout( send, 1 )
+    pubnub.timeout(send, 1)
 
-print( "Connected: %s\n" % origin )
+print("Connected: %s\n" % origin)
 pubnub.subscribe({
-    'channel'  : channel,
-    'connect'  : connected,
-    'callback' : received
+    'channel': channel,
+    'connect': connected,
+    'callback': received
 })
 
 ## -----------------------------------------------------------------------
diff --git a/python-tornado/tests/subscribe-test.py b/python-tornado/tests/subscribe-test.py
new file mode 100755
index 0000000..bcbbc7e
--- /dev/null
+++ b/python-tornado/tests/subscribe-test.py
@@ -0,0 +1,154 @@
+## www.pubnub.com - PubNub Real-time push service in the cloud.
+# coding=utf8
+
+## PubNub Real-time Push APIs and Notifications Framework
+## Copyright (c) 2010 Stephen Blum
+## http://www.pubnub.com/
+
+## -----------------------------------
+## PubNub 3.1 Real-time Push Cloud API
+## -----------------------------------
+
+import sys
+import datetime
+from Pubnub import PubnubTwisted as Pubnub
+from functools import partial
+from threading import current_thread
+import threading
+publish_key = len(sys.argv) > 1 and sys.argv[1] or 'demo'
+subscribe_key = len(sys.argv) > 2 and sys.argv[2] or 'demo'
+secret_key = len(sys.argv) > 3 and sys.argv[3] or 'demo'
+cipher_key = len(sys.argv) > 4 and sys.argv[4] or None
+ssl_on = len(sys.argv) > 5 and bool(sys.argv[5]) or False
+
+## -----------------------------------------------------------------------
+## Initiate Pubnub State
+## -----------------------------------------------------------------------
+#pubnub = Pubnub( publish_key, subscribe_key, secret_key, cipher_key, ssl_on )
+pubnub = Pubnub(publish_key, subscribe_key, secret_key, ssl_on)
+crazy = 'hello_world'
+
+current = -1
+
+errors = 0
+received = 0
+
+## -----------------------------------------------------------------------
+## Subscribe Example
+## -----------------------------------------------------------------------
+
+
+def message_received(message):
+    print(message)
+
+
+def check_received(message):
+    global current
+    global errors
+    global received
+    print(message)
+    print(current)
+    if message <= current:
+        print('ERROR')
+        #sys.exit()
+        errors += 1
+    else:
+        received += 1
+    print('active thread count : ' + str(threading.activeCount()))
+    print('errors = ' + str(errors))
+    print(current_thread().getName() + ' , ' + 'received = ' + str(received))
+
+    if received != message:
+        print('********** MISSED **************** ' + str(message - received))
+    current = message
+
+
+def connected_test(ch):
+    print('Connected ' + ch)
+
+
+def connected(ch):
+    pass
+
+
+'''
+pubnub.subscribe({
+    'channel'  : 'abcd1',
+    'connect'  : connected,
+    'callback' : message_received
+})
+'''
+
+
+def cb1():
+    pubnub.subscribe({
+        'channel': 'efgh1',
+        'connect': connected,
+        'callback': message_received
+    })
+
+
+def cb2():
+    pubnub.subscribe({
+        'channel': 'dsm-test',
+        'connect': connected_test,
+        'callback': check_received
+    })
+
+
+def cb3():
+    pubnub.unsubscribe({'channel': 'efgh1'})
+
+
+def cb4():
+    pubnub.unsubscribe({'channel': 'abcd1'})
+
+
+def subscribe(channel):
+    pubnub.subscribe({
+        'channel': channel,
+        'connect': connected,
+        'callback': message_received
+    })
+
+
+pubnub.timeout(15, cb1)
+
+pubnub.timeout(30, cb2)
+
+
+pubnub.timeout(45, cb3)
+
+pubnub.timeout(60, cb4)
+
+#'''
+for x in range(1, 1000):
+    #print x
+    def y(t):
+        subscribe('channel-' + str(t))
+
+    def z(t):
+        pubnub.unsubscribe({'channel': 'channel-' + str(t)})
+
+    pubnub.timeout(x + 5, partial(y, x))
+    pubnub.timeout(x + 25, partial(z, x))
+    x += 10
+#'''
+
+'''
+for x in range(1,1000):
+    def cb(r): print r , ' : ', threading.activeCount()
+    def y(t):
+        pubnub.publish({
+            'message' : t,
+            'callback' : cb,
+            'channel' : 'dsm-test'
+        })
+
+
+    pubnub.timeout(x + 1, partial(y,x))
+    x += 1
+'''
+
+
+pubnub.start()
diff --git a/python-tornado/tests/test_grant_async.py b/python-tornado/tests/test_grant_async.py
new file mode 100644
index 0000000..b51b275
--- /dev/null
+++ b/python-tornado/tests/test_grant_async.py
@@ -0,0 +1,359 @@
+
+
+from Pubnub import PubnubTornado as Pubnub
+import time
+
+pubnub = Pubnub("demo","demo")
+pubnub_pam = Pubnub("pub-c-c077418d-f83c-4860-b213-2f6c77bde29a", 
+	"sub-c-e8839098-f568-11e2-a11a-02ee2ddab7fe", "sec-c-OGU3Y2Q4ZWUtNDQwMC00NTI1LThjNWYtNWJmY2M4OGIwNjEy")
+
+
+
+# Grant permission read true, write true, on channel ( Async Mode )
+def test_1():
+
+	def _callback(resp, ch= None):
+		assert resp == {
+									'message': u'Success',
+									'payload': {u'auths': {u'abcd': {u'r': 1, u'w': 1}},
+									u'subscribe_key': u'sub-c-e8839098-f568-11e2-a11a-02ee2ddab7fe',
+									u'level': u'user', u'channel': u'abcd', u'ttl': 1} 
+								}
+
+	def _error(response):
+		assert False
+
+	pubnub_pam.grant(channel="abcd", auth_key="abcd", read=True, write=True, ttl=1, callback=_callback, error=_error)
+							
+
+# Grant permission read false, write false, on channel ( Async Mode )
+def test_2():
+	
+	def _callback(resp, ch=None):
+		assert resp == {
+									'message': u'Success',
+									'payload': {u'auths': {u'abcd': {u'r': 0, u'w': 0}},
+									u'subscribe_key': u'sub-c-e8839098-f568-11e2-a11a-02ee2ddab7fe',
+									u'level': u'user', u'channel': u'abcd', u'ttl': 1}
+								}
+
+	def _error(response):
+		assert False
+
+	pubnub_pam.grant(channel="abcd", auth_key="abcd", read=False, write=False, ttl=1, callback=_callback, error=_error)
+
+
+# Grant permission read True, write false, on channel ( Async Mode )
+def test_3():
+
+	def _callback(resp, ch=None):
+		assert resp == {
+									'message': u'Success',
+									'payload': {u'auths': {u'abcd': {u'r': 1, u'w': 0}},
+									u'subscribe_key': u'sub-c-e8839098-f568-11e2-a11a-02ee2ddab7fe',
+									u'level': u'user', u'channel': u'abcd', u'ttl': 1}
+								}
+
+	def _error(response):
+		assert False
+
+	pubnub_pam.grant(channel="abcd", auth_key="abcd", read=True, write=False, ttl=1, callback=_callback, error=_error)
+
+
+# Grant permission read False, write True, on channel ( Async Mode )
+def test_4():
+
+	def _callback(resp, ch=None):
+		assert resp == {
+									'message': u'Success',
+									'payload': {u'auths': {u'abcd': {u'r': 0, u'w': 1}},
+									u'subscribe_key': u'sub-c-e8839098-f568-11e2-a11a-02ee2ddab7fe',
+									u'level': u'user', u'channel': u'abcd', u'ttl': 1}
+								}
+
+	def _error(response):
+		assert False
+
+	pubnub_pam.grant(channel="abcd", auth_key="abcd", read=False, write=True, ttl=1, callback=_callback, error=_error)
+
+
+# Grant permission read False, write True, on channel ( Async Mode ), TTL 10
+def test_5():
+
+	def _callback(resp,ch=None):
+		assert resp == {
+									'message': u'Success',
+									'payload': {u'auths': {u'abcd': {u'r': 0, u'w': 1}},
+									u'subscribe_key': u'sub-c-e8839098-f568-11e2-a11a-02ee2ddab7fe',
+									u'level': u'user', u'channel': u'abcd', u'ttl': 10}
+								}
+
+
+	def _error(response):
+		assert False
+
+	pubnub_pam.grant(channel="abcd", auth_key="abcd", read=False, write=True, ttl=10, callback=_callback, error=_error)
+
+
+# Grant permission read False, write True, without channel ( Async Mode ), TTL 10
+def test_6():
+	def _callback(resp, ch=None):
+		assert resp == {
+										'message': u'Success',
+										'payload': { u'r': 0, u'w': 1,
+										u'subscribe_key': u'sub-c-e8839098-f568-11e2-a11a-02ee2ddab7fe',
+										u'level': u'subkey', u'ttl': 10}
+									}
+
+	def _error(response):
+		assert False
+
+	pubnub_pam.grant(auth_key="abcd", read=False, write=True, ttl=10, callback=_callback, error=_error)
+
+
+
+# Grant permission read False, write False, without channel ( Async Mode )
+def test_7():
+
+	def _callback(resp, ch=None):
+		assert resp == {
+										'message': u'Success',
+										'payload': { u'r': 0, u'w': 0,
+										u'subscribe_key': u'sub-c-e8839098-f568-11e2-a11a-02ee2ddab7fe',
+										u'level': u'subkey', u'ttl': 1}
+									}
+
+	def _error(response):
+		resp['response'] = response
+
+	pubnub_pam.grant(auth_key="abcd", read=False, write=False, callback=_callback, error=_error)
+
+
+# Complete flow , try publish on forbidden channel, grant permission to subkey and try again. ( Sync Mode)
+
+def test_8():
+	channel = "test_8-" + str(time.time())
+	message = "Hello World"
+	auth_key = "auth-" + channel
+	pubnub_pam.set_auth_key(auth_key)
+
+	def _cb1(resp, ch=None):
+		assert False
+	def _err1(resp):
+		assert resp['message'] == 'Forbidden'
+		assert resp['payload'] == {u'channels': [channel]}
+		def _cb2(resp, ch=None):
+			assert resp == 		{
+								'message': u'Success',
+								'payload': {u'auths': {auth_key : {u'r': 1, u'w': 1}},
+								u'subscribe_key': u'sub-c-e8839098-f568-11e2-a11a-02ee2ddab7fe',
+								u'level': u'user', u'channel': channel, u'ttl': 10}
+							}
+			def _cb3(resp, ch=None):
+				assert resp[0] == 1
+			def _err3(resp):
+				assert False
+
+			pubnub_pam.publish(channel=channel,message=message, callback=_cb3, error=_err3)
+		def _err2(resp):
+			assert False
+
+
+		pubnub_pam.grant(channel=channel, read=True, write=True, auth_key=auth_key, ttl=10, callback=_cb2, error=_err2)
+
+	pubnub_pam.publish(channel=channel,message=message, callback=_cb1, error=_err1)
+
+
+# Complete flow , try publish on forbidden channel, grant permission to authkey and try again. 
+# then revoke and try again
+def test_9():
+	channel = "test_9-" + str(time.time())
+	message = "Hello World"
+	auth_key = "auth-" + channel
+	pubnub_pam.set_auth_key(auth_key)
+
+	def _cb1(resp, ch=None):
+		assert False
+	def _err1(resp):
+		assert resp['message'] == 'Forbidden'
+		assert resp['payload'] == {u'channels': [channel]}
+		def _cb2(resp, ch=None):
+			assert resp == 		{
+								'message': u'Success',
+								'payload': {u'auths': {auth_key : {u'r': 1, u'w': 1}},
+								u'subscribe_key': u'sub-c-e8839098-f568-11e2-a11a-02ee2ddab7fe',
+								u'level': u'user', u'channel': channel, u'ttl': 10}
+							}
+			def _cb3(resp, ch=None):
+				assert resp[0] == 1
+				def _cb4(resp, ch=None):
+					assert resp == 		{
+								'message': u'Success',
+								'payload': {u'auths': {auth_key : {u'r': 0, u'w': 0}},
+								u'subscribe_key': u'sub-c-e8839098-f568-11e2-a11a-02ee2ddab7fe',
+								u'level': u'user', u'channel': channel, u'ttl': 1}
+							}
+
+					def _cb5(resp, ch=None):
+						assert False
+					def _err5(resp):
+						assert resp['message'] == 'Forbidden'
+						assert resp['payload'] == {u'channels': [channel]}
+
+					pubnub_pam.publish(channel=channel,message=message, callback=_cb5, error=_err5)
+				def _err4(resp):
+					assert False
+				pubnub_pam.revoke(channel=channel, auth_key=auth_key, callback=_cb4, error=_err4)
+			def _err3(resp):
+				assert False
+
+			pubnub_pam.publish(channel=channel,message=message, callback=_cb3, error=_err3)
+		def _err2(resp):
+			assert False
+
+
+		pubnub_pam.grant(channel=channel, read=True, write=True, auth_key=auth_key, ttl=10, callback=_cb2, error=_err2)
+
+	pubnub_pam.publish(channel=channel,message=message, callback=_cb1, error=_err1)
+
+
+# Complete flow , try publish on forbidden channel, grant permission channel level for subkey and try again.
+# then revoke and try again
+def test_10():
+	channel = "test_10-" + str(time.time())
+	message = "Hello World"
+	auth_key = "auth-" + channel
+	pubnub_pam.set_auth_key(auth_key)
+
+	def _cb1(resp, ch=None):
+		assert False
+	def _err1(resp):
+		assert resp['message'] == 'Forbidden'
+		assert resp['payload'] == {u'channels': [channel]}
+		def _cb2(resp, ch=None):
+			assert resp == 		{
+									'message': u'Success',
+									'payload': { u'channels': {channel: {u'r': 1, u'w': 1}},
+									u'subscribe_key': u'sub-c-e8839098-f568-11e2-a11a-02ee2ddab7fe',
+									u'level': u'channel', u'ttl': 10}
+								}
+			def _cb3(resp, ch=None):
+				assert resp[0] == 1
+				def _cb4(resp, ch=None):
+					assert resp == 		{
+												'message': u'Success',
+												'payload': { u'channels': {channel : {u'r': 0, u'w': 0}},
+												u'subscribe_key': u'sub-c-e8839098-f568-11e2-a11a-02ee2ddab7fe',
+												u'level': u'channel', u'ttl': 1}
+											}
+
+					def _cb5(resp, ch=None):
+						assert False
+					def _err5(resp):
+						assert resp['message'] == 'Forbidden'
+						assert resp['payload'] == {u'channels': [channel]}
+
+					pubnub_pam.publish(channel=channel,message=message, callback=_cb5, error=_err5)
+				def _err4(resp):
+					assert False
+				pubnub_pam.revoke(channel=channel, callback=_cb4, error=_err4)
+			def _err3(resp):
+				assert False
+
+			pubnub_pam.publish(channel=channel,message=message, callback=_cb3, error=_err3)
+		def _err2(resp):
+			assert False
+
+
+		pubnub_pam.grant(channel=channel, read=True, write=True, ttl=10, callback=_cb2, error=_err2)
+
+	pubnub_pam.publish(channel=channel,message=message, callback=_cb1, error=_err1)
+
+
+
+
+
+
+# Complete flow , try publish on forbidden channel, grant permission subkey level for subkey and try again.
+# then revoke and try again
+def test_11():
+	channel = "test_11-" + str(time.time())
+	message = "Hello World"
+	auth_key = "auth-" + channel
+	pubnub_pam.set_auth_key(auth_key)
+
+	def _cb1(resp, ch=None):
+		assert False
+	def _err1(resp):
+		assert resp['message'] == 'Forbidden'
+		assert resp['payload'] == {u'channels': [channel]}
+		def _cb2(resp, ch=None):
+			assert resp == 		{
+									'message': u'Success',
+									'payload': { u'r': 1, u'w': 1,
+									u'subscribe_key': u'sub-c-e8839098-f568-11e2-a11a-02ee2ddab7fe',
+									u'level': u'subkey', u'ttl': 10}
+								}
+			def _cb3(resp, ch=None):
+				assert resp[0] == 1
+				def _cb4(resp, ch=None):
+					assert resp == 		{
+									'message': u'Success',
+									'payload': {u'r': 0, u'w': 0,
+									u'subscribe_key': u'sub-c-e8839098-f568-11e2-a11a-02ee2ddab7fe',
+									u'level': u'subkey', u'ttl': 1}
+								}
+
+					def _cb5(resp, ch=None):
+						assert False
+					def _err5(resp):
+						assert resp['message'] == 'Forbidden'
+						assert resp['payload'] == {u'channels': [channel]}
+
+					pubnub_pam.publish(channel=channel,message=message, callback=_cb5, error=_err5)
+				def _err4(resp):
+					assert False
+				pubnub_pam.revoke(callback=_cb4, error=_err4)
+			def _err3(resp):
+				assert False
+
+			pubnub_pam.publish(channel=channel,message=message, callback=_cb3, error=_err3)
+		def _err2(resp):
+			assert False
+
+
+		pubnub_pam.grant(read=True, write=True, ttl=10, callback=_cb2, error=_err2)
+
+	pubnub_pam.publish(channel=channel,message=message, callback=_cb1, error=_err1)
+
+
+x = 5
+def run_test(t):
+	global x
+	x += 5
+	i = (x / 5) - 1
+	def _print():
+		print('Running test ' + str(i))
+	pubnub.timeout(x, _print)
+	pubnub.timeout(x + 1,t)
+
+def stop():
+	pubnub.stop()
+
+run_test(test_1)
+run_test(test_2)
+run_test(test_3)
+run_test(test_4)
+run_test(test_5)
+run_test(test_6)
+run_test(test_7)
+run_test(test_8)
+run_test(test_9)
+run_test(test_10)
+run_test(test_11)
+run_test(stop)
+
+
+pubnub_pam.start()
+
+
diff --git a/python-tornado/tests/test_publish_async.py b/python-tornado/tests/test_publish_async.py
new file mode 100644
index 0000000..391297d
--- /dev/null
+++ b/python-tornado/tests/test_publish_async.py
@@ -0,0 +1,304 @@
+
+
+from Pubnub import PubnubTwisted as Pubnub
+import time
+
+pubnub = Pubnub("demo","demo")
+pubnub_enc = Pubnub("demo", "demo", cipher_key="enigma")
+pubnub_pam = Pubnub("pub-c-c077418d-f83c-4860-b213-2f6c77bde29a", 
+	"sub-c-e8839098-f568-11e2-a11a-02ee2ddab7fe", "sec-c-OGU3Y2Q4ZWUtNDQwMC00NTI1LThjNWYtNWJmY2M4OGIwNjEy")
+
+
+
+# Publish and receive string
+def test_1():
+
+	channel = "test_1-" + str(time.time())
+	message = "I am a string"
+
+	def _cb(resp, ch=None):
+		assert resp == message
+		pubnub.unsubscribe(channel)
+
+	def _connect(resp):
+		def _cb1(resp,ch=None):
+			assert resp[0] == 1
+		def _err1(resp):
+			assert False
+		pubnub.publish(channel,message, callback=_cb1, error=_err1)
+
+	def _error(resp):
+		assert False
+
+	pubnub.subscribe(channel, callback=_cb, connect=_connect, error=_error)
+
+# Publish and receive array
+def test_2():
+
+	channel = "test_2-" + str(time.time())
+	message = [1,2]
+
+	def _cb(resp, ch=None):
+		assert resp == message
+		pubnub.unsubscribe(channel)
+
+	def _connect(resp):
+		def _cb1(resp,ch=None):
+			assert resp[0] == 1
+		def _err1(resp):
+			assert False
+		pubnub.publish(channel,message, callback=_cb1, error=_err1)
+
+	def _error(resp):
+		assert False
+
+	pubnub.subscribe(channel, callback=_cb, connect=_connect, error=_error)
+
+# Publish and receive json object
+def test_3():
+
+	channel = "test_2-" + str(time.time())
+	message = { "a" : "b" }
+
+	def _cb(resp, ch=None):
+		assert resp == message
+		pubnub.unsubscribe(channel)
+
+	def _connect(resp):
+		def _cb1(resp,ch=None):
+			assert resp[0] == 1
+		def _err1(resp):
+			assert False
+		pubnub.publish(channel,message, callback=_cb1, error=_err1)
+
+	def _error(resp):
+		assert False
+
+	pubnub.subscribe(channel, callback=_cb, connect=_connect, error=_error)
+
+# Publish and receive number
+def test_4():
+
+	channel = "test_2-" + str(time.time())
+	message = 100
+
+	def _cb(resp, ch=None):
+		assert resp == message
+		pubnub.unsubscribe(channel)
+
+	def _connect(resp):
+		def _cb1(resp,ch=None):
+			assert resp[0] == 1
+		def _err1(resp):
+			assert False
+		pubnub.publish(channel,message, callback=_cb1, error=_err1)
+
+	def _error(resp):
+		assert False
+
+	pubnub.subscribe(channel, callback=_cb, connect=_connect, error=_error)
+
+# Publish and receive number string
+def test_5():
+
+	channel = "test_5-" + str(time.time())
+	message = "100"
+
+	def _cb(resp, ch=None):
+		assert resp == message
+		pubnub.unsubscribe(channel)
+
+	def _connect(resp):
+		def _cb1(resp,ch=None):
+			assert resp[0] == 1
+		def _err1(resp):
+			assert False
+		pubnub.publish(channel,message, callback=_cb1, error=_err1)
+
+	def _error(resp):
+		assert False
+
+	pubnub.subscribe(channel, callback=_cb, connect=_connect, error=_error)
+
+
+# Publish and receive string (Encryption enabled)
+def test_6():
+
+	channel = "test_6-" + str(time.time())
+	message = "I am a string"
+
+	def _cb(resp, ch=None):
+		assert resp == message
+		pubnub_enc.unsubscribe(channel)
+
+	def _connect(resp):
+		def _cb1(resp,ch=None):
+			assert resp[0] == 1
+		def _err1(resp):
+			assert False
+		pubnub_enc.publish(channel,message, callback=_cb1, error=_err1)
+
+	def _error(resp):
+		assert False
+
+	pubnub_enc.subscribe(channel, callback=_cb, connect=_connect, error=_error)
+
+# Publish and receive array (Encryption enabled)
+def test_7():
+
+	channel = "test_7-" + str(time.time())
+	message = [1,2]
+
+	def _cb(resp, ch=None):
+		assert resp == message
+		pubnub_enc.unsubscribe(channel)
+
+	def _connect(resp):
+		def _cb1(resp,ch=None):
+			assert resp[0] == 1
+		def _err1(resp):
+			assert False
+		pubnub_enc.publish(channel,message, callback=_cb1, error=_err1)
+
+	def _error(resp):
+		assert False
+
+	pubnub_enc.subscribe(channel, callback=_cb, connect=_connect, error=_error)
+
+# Publish and receive json object (Encryption enabled)
+def test_8():
+
+	channel = "test_8-" + str(time.time())
+	message = { "a" : "b" }
+
+	def _cb(resp, ch=None):
+		assert resp == message
+		pubnub_enc.unsubscribe(channel)
+
+	def _connect(resp):
+		def _cb1(resp,ch=None):
+			assert resp[0] == 1
+		def _err1(resp):
+			assert False
+		pubnub_enc.publish(channel,message, callback=_cb1, error=_err1)
+
+	def _error(resp):
+		assert False
+
+	pubnub_enc.subscribe(channel, callback=_cb, connect=_connect, error=_error)
+
+# Publish and receive number (Encryption enabled)
+def test_9():
+
+	channel = "test_9-" + str(time.time())
+	message = 100
+
+	def _cb(resp, ch=None):
+		assert resp == message
+		pubnub_enc.unsubscribe(channel)
+
+	def _connect(resp):
+		def _cb1(resp,ch=None):
+			assert resp[0] == 1
+		def _err1(resp):
+			assert False
+		pubnub_enc.publish(channel,message, callback=_cb1, error=_err1)
+
+	def _error(resp):
+		assert False
+
+	pubnub_enc.subscribe(channel, callback=_cb, connect=_connect, error=_error)
+
+# Publish and receive number string (Encryption enabled)
+def test_10():
+
+	channel = "test_10-" + str(time.time())
+	message = "100"
+
+	def _cb(resp, ch=None):
+		assert resp == message
+		pubnub_enc.unsubscribe(channel)
+
+	def _connect(resp):
+		def _cb1(resp,ch=None):
+			assert resp[0] == 1
+		def _err1(resp):
+			assert False
+		pubnub_enc.publish(channel,message, callback=_cb1, error=_err1)
+
+	def _error(resp):
+		assert False
+
+	pubnub_enc.subscribe(channel, callback=_cb, connect=_connect, error=_error)
+
+# Publish and receive object string (Encryption enabled)
+def test_11():
+
+	channel = "test_11-" + str(time.time())
+	message = '{"a" : "b"}'
+
+	def _cb(resp, ch=None):
+		assert resp == message
+		pubnub_enc.unsubscribe(channel)
+
+	def _connect(resp):
+		def _cb1(resp,ch=None):
+			assert resp[0] == 1
+		def _err1(resp):
+			assert False
+		pubnub_enc.publish(channel,message, callback=_cb1, error=_err1)
+
+	def _error(resp):
+		assert False
+
+	pubnub_enc.subscribe(channel, callback=_cb, connect=_connect, error=_error)
+
+# Publish and receive array string (Encryption enabled)
+def test_12():
+
+	channel = "test_12-" + str(time.time())
+	message = '[1,2]'
+
+	def _cb(resp, ch=None):
+		assert resp == message
+		pubnub_enc.unsubscribe(channel)
+
+	def _connect(resp):
+		def _cb1(resp,ch=None):
+			assert resp[0] == 1
+		def _err1(resp):
+			assert False
+		pubnub_enc.publish(channel,message, callback=_cb1, error=_err1)
+
+	def _error(resp):
+		assert False
+
+	pubnub_enc.subscribe(channel, callback=_cb, connect=_connect, error=_error)
+
+x = 5
+def run_test(t):
+	global x
+	x += 5
+	i = (x / 5) - 1
+	def _print():
+		print('Running test ' + str(i))
+	pubnub.timeout(x, _print)
+	pubnub.timeout(x + 1,t)
+
+def stop():
+	pubnub.stop()
+
+run_test(test_1)
+run_test(test_2)
+run_test(test_3)
+run_test(test_4)
+run_test(test_5)
+run_test(test_6)
+run_test(test_7)
+run_test(test_8)
+run_test(test_9)
+run_test(test_10)
+run_test(test_11)
+run_test(stop)
+
+pubnub_enc.start()
diff --git a/python-tornado/tests/unit-tests.py b/python-tornado/tests/unit-tests.py
deleted file mode 100644
index fdaa194..0000000
--- a/python-tornado/tests/unit-tests.py
+++ /dev/null
@@ -1,73 +0,0 @@
-
-import sys
-
-sys.path.append('../../common')
-sys.path.append('..')
-sys.path.append('../common')
-sys.path.append('.')
-
-from PubnubUnitTest import Suite
-from Pubnub import Pubnub
-
-pubnub = Pubnub("demo","demo")
-
-tests_count = 1 + 2
-test_suite = Suite(pubnub,tests_count)
-
-tests = []
-
-
-def test_publish():
-	name = "Publish Test"
-	def success(r):
-		test_suite.test(r[0] == 1, name)
-
-	def fail(e):
-		test_suite.test(False, msg , e)
-
-
-	pubnub.publish({
-		'channel' : 'hello',
-		'message' : 'hi',
-		'callback' : success,
-		'error' : fail
-	})
-tests.append(test_publish)
-
-
-def test_subscribe_publish():
-	channel = "hello"
-	name = "Subscribe Publish Test"
-	publish_msg = "This is Pubnub Python-Twisted"
-	def connect():
-		def success(r):
-			test_suite.test(r[0] == 1, name, "publish success")
-
-		def fail(e):
-			test_suite.test(False, name , "Publish Failed", e)
-
-		pubnub.publish({
-			'channel' : channel,
-			'message' : publish_msg,
-			'callback' : success,
-			'error' : fail
-		})
-
-	def callback(r):
-		test_suite.test(r == publish_msg, name, "message received")
-
-	pubnub.subscribe({
-		'channel' : channel,
-		'callback' : callback,
-		'connect' : connect
-	})
-tests.append(test_subscribe_publish)
-
-
-
-
-
-for t in tests:
-	t()
-
-pubnub.start()