Beispiel #1
0
    def test_time_without_key_or_token(self):
        ably = AblyRest(Options(host=test_vars["host"],
                port=test_vars["port"],
                tls_port=test_vars["tls_port"],
                tls=test_vars["tls"]))

        ably.time()
 def test_enviroment(self):
     ably = AblyRest(token='token', environment='custom')
     with patch.object(Session, 'prepare_request',
                       wraps=ably.http._Http__session.prepare_request) as get_mock:
         try:
             ably.time()
         except AblyException:
             pass
         request = get_mock.call_args_list[0][0][0]
         self.assertEquals(request.url, 'https://custom-rest.ably.io:443/time')
Beispiel #3
0
 def test_enviroment(self):
     ably = AblyRest(token='token', environment='custom')
     with patch.object(
             Session,
             'prepare_request',
             wraps=ably.http._Http__session.prepare_request) as get_mock:
         try:
             ably.time()
         except AblyException:
             pass
         request = get_mock.call_args_list[0][0][0]
         assert request.url == 'https://custom-rest.ably.io:443/time'
Beispiel #4
0
    def test_time_accuracy(self):
        ably = AblyRest(Options.with_key(test_vars["keys"][0]["key_str"],
                host=test_vars["host"],
                port=test_vars["port"],
                tls_port=test_vars["tls_port"],
                tls=test_vars["tls"]))

        reported_time = ably.time()
        actual_time = time.time() * 1000.0

        self.assertLess(abs(actual_time - reported_time), 2000,
                msg="Time is not within 2 seconds")
    def test_time_without_key_or_token(self):
        ably = AblyRest(token='foo',
                        rest_host=test_vars["host"],
                        port=test_vars["port"],
                        tls_port=test_vars["tls_port"],
                        tls=test_vars["tls"],
                        use_binary_protocol=self.use_binary_protocol)

        reported_time = ably.time()
        actual_time = time.time() * 1000.0

        self.assertLess(abs(actual_time - reported_time), 2000,
                msg="Time is not within 2 seconds")
    def test_time_accuracy(self):
        ably = AblyRest(key=test_vars["keys"][0]["key_str"],
                        rest_host=test_vars["host"],
                        port=test_vars["port"],
                        tls_port=test_vars["tls_port"],
                        tls=test_vars["tls"],
                        use_binary_protocol=self.use_binary_protocol)

        reported_time = ably.time()
        actual_time = time.time() * 1000.0

        self.assertLess(abs(actual_time - reported_time), 2000,
                msg="Time is not within 2 seconds")
    def test_time_without_key_or_token(self):
        ably = AblyRest(token='foo',
                        rest_host=test_vars["host"],
                        port=test_vars["port"],
                        tls_port=test_vars["tls_port"],
                        tls=test_vars["tls"],
                        use_binary_protocol=self.use_binary_protocol)

        reported_time = ably.time()
        actual_time = time.time() * 1000.0

        self.assertLess(abs(actual_time - reported_time),
                        2000,
                        msg="Time is not within 2 seconds")
    def test_time_accuracy(self):
        ably = AblyRest(key=test_vars["keys"][0]["key_str"],
                        rest_host=test_vars["host"],
                        port=test_vars["port"],
                        tls_port=test_vars["tls_port"],
                        tls=test_vars["tls"],
                        use_binary_protocol=self.use_binary_protocol)

        reported_time = ably.time()
        actual_time = time.time() * 1000.0

        self.assertLess(abs(actual_time - reported_time),
                        2000,
                        msg="Time is not within 2 seconds")
Beispiel #9
0
class TestAuthAuthorize(BaseTestCase):

    def setUp(self):
        self.ably = AblyRest(key=test_vars["keys"][0]["key_str"],
                             rest_host=test_vars["host"],
                             port=test_vars["port"],
                             tls_port=test_vars["tls_port"],
                             tls=test_vars["tls"])

    def per_protocol_setup(self, use_binary_protocol):
        self.ably.options.use_binary_protocol = use_binary_protocol
        self.use_binary_protocol = use_binary_protocol

    def test_if_authorize_changes_auth_mechanism_to_token(self):

        self.assertEqual(Auth.Method.BASIC, self.ably.auth.auth_mechanism,
                         msg="Unexpected Auth method mismatch")

        self.ably.auth.authorise()

        self.assertEqual(Auth.Method.TOKEN, self.ably.auth.auth_mechanism,
                         msg="Authorise should change the Auth method")

    def test_authorize_shouldnt_create_token_if_not_expired(self):

        token = self.ably.auth.authorise()

        new_token = self.ably.auth.authorise()

        self.assertGreater(token.expires, time.time()*1000)

        self.assertIs(new_token, token)

    def test_authorize_should_create_new_token_if_forced(self):

        token = self.ably.auth.authorise()

        new_token = self.ably.auth.authorise(force=True)

        self.assertGreater(token.expires, time.time()*1000)

        self.assertIsNot(new_token, token)
        self.assertGreater(new_token.expires, token.expires)

        another_token = self.ably.auth.authorise(auth_options={'force': True})
        self.assertIsNot(new_token, another_token)

    def test_authorize_create_new_token_if_expired(self):

        token = self.ably.auth.authorise()

        with mock.patch('ably.types.tokendetails.TokenDetails.is_expired',
                        return_value=True):
            new_token = self.ably.auth.authorise()

        self.assertIsNot(token, new_token)

    def test_authorize_returns_a_token_details(self):

        token = self.ably.auth.authorise()

        self.assertIsInstance(token, TokenDetails)

    @dont_vary_protocol
    def test_authorize_adheres_to_request_token(self):
        token_params = {'ttl': 10, 'client_id': 'client_id'}
        auth_params = {'auth_url': 'somewhere.com', 'query_time': True}
        with mock.patch('ably.rest.auth.Auth.request_token') as request_mock:
            self.ably.auth.authorise(token_params, auth_params, force=True)

        token_called, auth_called = request_mock.call_args
        self.assertEqual(token_called[0], token_params)

        # Authorise may call request_token with some default auth_options.
        for arg, value in six.iteritems(auth_params):
            self.assertEqual(auth_called[arg], value,
                             "%s called with wrong value: %s" % (arg, value))

    def test_with_token_str_https(self):
        token = self.ably.auth.authorise()
        token = token.token
        ably = AblyRest(token=token, rest_host=test_vars["host"],
                        port=test_vars["port"], tls_port=test_vars["tls_port"],
                        tls=True, use_binary_protocol=self.use_binary_protocol)
        ably.channels.test_auth_with_token_str.publish('event', 'foo_bar')

    def test_with_token_str_http(self):
        token = self.ably.auth.authorise()
        token = token.token
        ably = AblyRest(token=token, rest_host=test_vars["host"],
                        port=test_vars["port"], tls_port=test_vars["tls_port"],
                        tls=False, use_binary_protocol=self.use_binary_protocol)
        ably.channels.test_auth_with_token_str.publish('event', 'foo_bar')

    def test_if_default_client_id_is_used(self):
        ably = AblyRest(key=test_vars["keys"][0]["key_str"],
                        rest_host=test_vars["host"],
                        port=test_vars["port"],
                        tls_port=test_vars["tls_port"],
                        tls=test_vars["tls"],
                        client_id='my_client_id',
                        use_binary_protocol=self.use_binary_protocol)
        token = ably.auth.authorise()
        self.assertEqual(token.client_id, 'my_client_id')

    def test_if_parameters_are_stored_and_used_as_defaults(self):
        self.ably.auth.authorise({'ttl': 555, 'client_id': 'new_id'},
                                 {'auth_headers': {'a_headers': 'a_value'}})
        with mock.patch('ably.rest.auth.Auth.request_token',
                        wraps=self.ably.auth.request_token) as request_mock:
            self.ably.auth.authorise(force=True)

        token_called, auth_called = request_mock.call_args
        self.assertEqual(token_called[0], {'ttl': 555, 'client_id': 'new_id'})
        self.assertEqual(auth_called['auth_headers'], {'a_headers': 'a_value'})

    def test_force_and_timestamp_are_not_stored(self):
        # authorise once with arbitrary defaults
        token_1 = self.ably.auth.authorise(
            {'ttl': 60 * 1000, 'client_id': 'new_id'},
            {'auth_headers': {'a_headers': 'a_value'}})
        self.assertIsInstance(token_1, TokenDetails)

        # call authorise again with force and timestamp set
        timestamp = self.ably.time()
        with mock.patch('ably.rest.auth.TokenRequest',
                        wraps=ably.types.tokenrequest.TokenRequest) as tr_mock:
            token_2 = self.ably.auth.authorise(
                {'ttl': 60 * 1000, 'client_id': 'new_id', 'timestamp': timestamp},
                {'auth_headers': {'a_headers': 'a_value'}, 'force': True})
        self.assertIsInstance(token_2, TokenDetails)
        self.assertNotEqual(token_1, token_2)
        self.assertEqual(tr_mock.call_args[1]['timestamp'], timestamp)

        # call authorise again with no params
        token_3 = self.ably.auth.authorise()
        self.assertIsInstance(token_3, TokenDetails)
        self.assertEqual(token_2, token_3)

        # call authorise again with force
        with mock.patch('ably.rest.auth.TokenRequest',
                        wraps=ably.types.tokenrequest.TokenRequest) as tr_mock:
            token_4 = self.ably.auth.authorise(force=True)
        self.assertIsInstance(token_4, TokenDetails)
        self.assertNotEqual(token_2, token_4)
        self.assertNotEqual(tr_mock.call_args[1]['timestamp'], timestamp)

    def test_client_id_precedence(self):
        client_id = uuid.uuid4().hex
        overridden_client_id = uuid.uuid4().hex
        ably = AblyRest(key=test_vars["keys"][0]["key_str"],
                        rest_host=test_vars["host"],
                        port=test_vars["port"],
                        tls_port=test_vars["tls_port"],
                        tls=test_vars["tls"],
                        use_binary_protocol=self.use_binary_protocol,
                        client_id=client_id,
                        default_token_params={'client_id': overridden_client_id})
        token = ably.auth.authorise()
        self.assertEqual(token.client_id, client_id)
        self.assertEqual(ably.auth.client_id, client_id)

        channel = ably.channels[
            self.protocol_channel_name('test_client_id_precedence')]
        channel.publish('test', 'data')
        self.assertEqual(channel.history().items[0].client_id, client_id)
Beispiel #10
0
class TestAuthAuthorize(BaseTestCase):

    def setUp(self):
        self.ably = AblyRest(key=test_vars["keys"][0]["key_str"],
                             rest_host=test_vars["host"],
                             port=test_vars["port"],
                             tls_port=test_vars["tls_port"],
                             tls=test_vars["tls"])

    def per_protocol_setup(self, use_binary_protocol):
        self.ably.options.use_binary_protocol = use_binary_protocol
        self.use_binary_protocol = use_binary_protocol

    def test_if_authorize_changes_auth_mechanism_to_token(self):

        self.assertEqual(Auth.Method.BASIC, self.ably.auth.auth_mechanism,
                         msg="Unexpected Auth method mismatch")

        self.ably.auth.authorize()

        self.assertEqual(Auth.Method.TOKEN, self.ably.auth.auth_mechanism,
                         msg="Authorise should change the Auth method")

    # RSA10a
    @dont_vary_protocol
    def test_authorize_always_creates_new_token(self):
        self.ably.auth.authorize({'capability': {'test': ['publish']}})
        self.ably.channels.test.publish('event', 'data')

        self.ably.auth.authorize({'capability': {'test': ['subscribe']}})
        with self.assertRaises(AblyAuthException):
            self.ably.channels.test.publish('event', 'data')

    def test_authorize_create_new_token_if_expired(self):

        token = self.ably.auth.authorize()

        with mock.patch('ably.types.tokendetails.TokenDetails.is_expired',
                        return_value=True):
            new_token = self.ably.auth.authorize()

        self.assertIsNot(token, new_token)

    def test_authorize_returns_a_token_details(self):

        token = self.ably.auth.authorize()

        self.assertIsInstance(token, TokenDetails)

    @dont_vary_protocol
    def test_authorize_adheres_to_request_token(self):
        token_params = {'ttl': 10, 'client_id': 'client_id'}
        auth_params = {'auth_url': 'somewhere.com', 'query_time': True}
        with mock.patch('ably.rest.auth.Auth.request_token') as request_mock:
            self.ably.auth.authorize(token_params, auth_params)

        token_called, auth_called = request_mock.call_args
        self.assertEqual(token_called[0], token_params)

        # Authorise may call request_token with some default auth_options.
        for arg, value in six.iteritems(auth_params):
            self.assertEqual(auth_called[arg], value,
                             "%s called with wrong value: %s" % (arg, value))

    def test_with_token_str_https(self):
        token = self.ably.auth.authorize()
        token = token.token
        ably = AblyRest(token=token, rest_host=test_vars["host"],
                        port=test_vars["port"], tls_port=test_vars["tls_port"],
                        tls=True, use_binary_protocol=self.use_binary_protocol)
        ably.channels.test_auth_with_token_str.publish('event', 'foo_bar')

    def test_with_token_str_http(self):
        token = self.ably.auth.authorize()
        token = token.token
        ably = AblyRest(token=token, rest_host=test_vars["host"],
                        port=test_vars["port"], tls_port=test_vars["tls_port"],
                        tls=False, use_binary_protocol=self.use_binary_protocol)
        ably.channels.test_auth_with_token_str.publish('event', 'foo_bar')

    def test_if_default_client_id_is_used(self):
        ably = AblyRest(key=test_vars["keys"][0]["key_str"],
                        rest_host=test_vars["host"],
                        port=test_vars["port"],
                        tls_port=test_vars["tls_port"],
                        tls=test_vars["tls"],
                        client_id='my_client_id',
                        use_binary_protocol=self.use_binary_protocol)
        token = ably.auth.authorize()
        self.assertEqual(token.client_id, 'my_client_id')

    # RSA10j
    def test_if_parameters_are_stored_and_used_as_defaults(self):
        # Define some parameters
        auth_options = dict(self.ably.auth.auth_options.auth_options)
        auth_options['auth_headers'] = {'a_headers': 'a_value'}
        self.ably.auth.authorize({'ttl': 555}, auth_options)
        with mock.patch('ably.rest.auth.Auth.request_token',
                        wraps=self.ably.auth.request_token) as request_mock:
            self.ably.auth.authorize()

        token_called, auth_called = request_mock.call_args
        self.assertEqual(token_called[0], {'ttl': 555})
        self.assertEqual(auth_called['auth_headers'], {'a_headers': 'a_value'})

        # Different parameters, should completely replace the first ones, not merge
        auth_options = dict(self.ably.auth.auth_options.auth_options)
        auth_options['auth_headers'] = None
        self.ably.auth.authorize({}, auth_options)
        with mock.patch('ably.rest.auth.Auth.request_token',
                        wraps=self.ably.auth.request_token) as request_mock:
            self.ably.auth.authorize()

        token_called, auth_called = request_mock.call_args
        self.assertEqual(token_called[0], {})
        self.assertEqual(auth_called['auth_headers'], None)

    # RSA10g
    def test_timestamp_is_not_stored(self):
        # authorize once with arbitrary defaults
        auth_options = dict(self.ably.auth.auth_options.auth_options)
        auth_options['auth_headers'] = {'a_headers': 'a_value'}
        token_1 = self.ably.auth.authorize(
            {'ttl': 60 * 1000, 'client_id': 'new_id'},
            auth_options)
        self.assertIsInstance(token_1, TokenDetails)

        # call authorize again with timestamp set
        timestamp = self.ably.time()
        with mock.patch('ably.rest.auth.TokenRequest',
                        wraps=ably.types.tokenrequest.TokenRequest) as tr_mock:
            auth_options = dict(self.ably.auth.auth_options.auth_options)
            auth_options['auth_headers'] = {'a_headers': 'a_value'}
            token_2 = self.ably.auth.authorize(
                {'ttl': 60 * 1000, 'client_id': 'new_id', 'timestamp': timestamp},
                auth_options)
        self.assertIsInstance(token_2, TokenDetails)
        self.assertNotEqual(token_1, token_2)
        self.assertEqual(tr_mock.call_args[1]['timestamp'], timestamp)

        # call authorize again with no params
        with mock.patch('ably.rest.auth.TokenRequest',
                        wraps=ably.types.tokenrequest.TokenRequest) as tr_mock:
            token_4 = self.ably.auth.authorize()
        self.assertIsInstance(token_4, TokenDetails)
        self.assertNotEqual(token_2, token_4)
        self.assertNotEqual(tr_mock.call_args[1]['timestamp'], timestamp)

    def test_client_id_precedence(self):
        client_id = uuid.uuid4().hex
        overridden_client_id = uuid.uuid4().hex
        ably = AblyRest(key=test_vars["keys"][0]["key_str"],
                        rest_host=test_vars["host"],
                        port=test_vars["port"],
                        tls_port=test_vars["tls_port"],
                        tls=test_vars["tls"],
                        use_binary_protocol=self.use_binary_protocol,
                        client_id=client_id,
                        default_token_params={'client_id': overridden_client_id})
        token = ably.auth.authorize()
        self.assertEqual(token.client_id, client_id)
        self.assertEqual(ably.auth.client_id, client_id)

        channel = ably.channels[
            self.protocol_channel_name('test_client_id_precedence')]
        channel.publish('test', 'data')
        self.assertEqual(channel.history().items[0].client_id, client_id)

    # RSA10l
    @dont_vary_protocol
    def test_authorise(self):
        with warnings.catch_warnings(record=True) as w:
            # Cause all warnings to always be triggered
            warnings.simplefilter("always")

            token = self.ably.auth.authorise()
            self.assertIsInstance(token, TokenDetails)

            # Verify warning is raised
            self.assertEqual(len(w), 1)
            self.assertTrue(issubclass(w[-1].category, DeprecationWarning))
class TestAuthAuthorize(BaseTestCase):

    def setUp(self):
        self.ably = AblyRest(key=test_vars["keys"][0]["key_str"],
                             rest_host=test_vars["host"],
                             port=test_vars["port"],
                             tls_port=test_vars["tls_port"],
                             tls=test_vars["tls"])

    def per_protocol_setup(self, use_binary_protocol):
        self.ably.options.use_binary_protocol = use_binary_protocol
        self.use_binary_protocol = use_binary_protocol

    def test_if_authorize_changes_auth_mechanism_to_token(self):

        self.assertEqual(Auth.Method.BASIC, self.ably.auth.auth_mechanism,
                         msg="Unexpected Auth method mismatch")

        self.ably.auth.authorise()

        self.assertEqual(Auth.Method.TOKEN, self.ably.auth.auth_mechanism,
                         msg="Authorise should change the Auth method")

    def test_authorize_shouldnt_create_token_if_not_expired(self):

        token = self.ably.auth.authorise()

        new_token = self.ably.auth.authorise()

        self.assertGreater(token.expires, time.time()*1000)

        self.assertIs(new_token, token)

    def test_authorize_should_create_new_token_if_forced(self):

        token = self.ably.auth.authorise()

        new_token = self.ably.auth.authorise(force=True)

        self.assertGreater(token.expires, time.time()*1000)

        self.assertIsNot(new_token, token)
        self.assertGreater(new_token.expires, token.expires)

        another_token = self.ably.auth.authorise(auth_options={'force': True})
        self.assertIsNot(new_token, another_token)

    def test_authorize_create_new_token_if_expired(self):

        token = self.ably.auth.authorise()

        with mock.patch('ably.types.tokendetails.TokenDetails.is_expired',
                        return_value=True):
            new_token = self.ably.auth.authorise()

        self.assertIsNot(token, new_token)

    def test_authorize_returns_a_token_details(self):

        token = self.ably.auth.authorise()

        self.assertIsInstance(token, TokenDetails)

    @dont_vary_protocol
    def test_authorize_adheres_to_request_token(self):
        token_params = {'ttl': 10, 'client_id': 'client_id'}
        auth_params = {'auth_url': 'somewhere.com', 'query_time': True}
        with mock.patch('ably.rest.auth.Auth.request_token') as request_mock:
            self.ably.auth.authorise(token_params, auth_params, force=True)

        token_called, auth_called = request_mock.call_args
        self.assertEqual(token_called[0], token_params)

        # Authorise may call request_token with some default auth_options.
        for arg, value in six.iteritems(auth_params):
            self.assertEqual(auth_called[arg], value,
                             "%s called with wrong value: %s" % (arg, value))

    def test_with_token_str_https(self):
        token = self.ably.auth.authorise()
        token = token.token
        ably = AblyRest(token=token, rest_host=test_vars["host"],
                        port=test_vars["port"], tls_port=test_vars["tls_port"],
                        tls=True, use_binary_protocol=self.use_binary_protocol)
        ably.channels.test_auth_with_token_str.publish('event', 'foo_bar')

    def test_with_token_str_http(self):
        token = self.ably.auth.authorise()
        token = token.token
        ably = AblyRest(token=token, rest_host=test_vars["host"],
                        port=test_vars["port"], tls_port=test_vars["tls_port"],
                        tls=False, use_binary_protocol=self.use_binary_protocol)
        ably.channels.test_auth_with_token_str.publish('event', 'foo_bar')

    def test_if_default_client_id_is_used(self):
        ably = AblyRest(key=test_vars["keys"][0]["key_str"],
                        rest_host=test_vars["host"],
                        port=test_vars["port"],
                        tls_port=test_vars["tls_port"],
                        tls=test_vars["tls"],
                        client_id='my_client_id',
                        use_binary_protocol=self.use_binary_protocol)
        token = ably.auth.authorise()
        self.assertEqual(token.client_id, 'my_client_id')

    def test_if_parameters_are_stored_and_used_as_defaults(self):
        self.ably.auth.authorise({'ttl': 555, 'client_id': 'new_id'},
                                 {'auth_headers': {'a_headers': 'a_value'}})
        with mock.patch('ably.rest.auth.Auth.request_token',
                        wraps=self.ably.auth.request_token) as request_mock:
            self.ably.auth.authorise(force=True)

        token_called, auth_called = request_mock.call_args
        self.assertEqual(token_called[0], {'ttl': 555, 'client_id': 'new_id'})
        self.assertEqual(auth_called['auth_headers'], {'a_headers': 'a_value'})

    def test_force_and_timestamp_are_not_stored(self):
        # authorise once with arbitrary defaults
        token_1 = self.ably.auth.authorise(
            {'ttl': 60 * 1000, 'client_id': 'new_id'},
            {'auth_headers': {'a_headers': 'a_value'}})
        self.assertIsInstance(token_1, TokenDetails)

        # call authorise again with force and timestamp set
        timestamp = self.ably.time()
        with mock.patch('ably.rest.auth.TokenRequest',
                        wraps=ably.types.tokenrequest.TokenRequest) as tr_mock:
            token_2 = self.ably.auth.authorise(
                {'ttl': 60 * 1000, 'client_id': 'new_id', 'timestamp': timestamp},
                {'auth_headers': {'a_headers': 'a_value'}, 'force': True})
        self.assertIsInstance(token_2, TokenDetails)
        self.assertNotEqual(token_1, token_2)
        self.assertEqual(tr_mock.call_args[1]['timestamp'], timestamp)

        # call authorise again with no params
        token_3 = self.ably.auth.authorise()
        self.assertIsInstance(token_3, TokenDetails)
        self.assertEqual(token_2, token_3)

        # call authorise again with force
        with mock.patch('ably.rest.auth.TokenRequest',
                        wraps=ably.types.tokenrequest.TokenRequest) as tr_mock:
            token_4 = self.ably.auth.authorise(force=True)
        self.assertIsInstance(token_4, TokenDetails)
        self.assertNotEqual(token_2, token_4)
        self.assertNotEqual(tr_mock.call_args[1]['timestamp'], timestamp)