Beispiel #1
0
    def test_grant_read_and_write_to_channel(self):
        self.grant.channels('ch').read(True).write(True).ttl(7)

        self.assertEquals(self.grant.build_path(), Grant.GRANT_PATH % pnconf_pam.subscribe_key)

        pam_args = utils.prepare_pam_arguments({
            'r': '1',
            'w': '1',
            'ttl': '7',
            'timestamp': 123,
            'channel': 'ch',
            'pnsdk': sdk_name,
            'uuid': self.pubnub.uuid
        })
        sign_input = pnconf_pam.subscribe_key + "\n" + pnconf_pam.publish_key + "\n" + "grant\n" + pam_args
        self.assertEqual(self.grant.build_params_callback()({}), {
            'pnsdk': sdk_name,
            'uuid': self.pubnub.uuid,
            'r': '1',
            'w': '1',
            'ttl': '7',
            'timestamp': '123',
            'channel': 'ch',
            'signature': utils.sign_sha256(pnconf_pam.secret_key, sign_input)
        })
Beispiel #2
0
    def test_audit_channel_group(self):
        self.audit.channel_groups(['gr1', 'gr2'])

        self.assertEquals(self.audit.build_path(),
                          Audit.AUDIT_PATH % pnconf_pam.subscribe_key)

        self.assertEqual(
            self.audit.build_params_callback()({}), {
                'pnsdk':
                sdk_name,
                'uuid':
                self.pubnub.uuid,
                'timestamp':
                '123',
                'channel-group':
                'gr1,gr2',
                'signature':
                utils.sign_sha256(
                    pnconf_pam.secret_key, pnconf_pam.subscribe_key + "\n" +
                    pnconf_pam.publish_key + "\n" + "audit\n" +
                    utils.prepare_pam_arguments({
                        'timestamp': 123,
                        'channel-group': 'gr1,gr2',
                        'pnsdk': sdk_name,
                        'uuid': self.pubnub.uuid
                    }))
            })
Beispiel #3
0
    def test_revoke_to_channel(self):
        self.revoke.channels('ch')

        self.assertEquals(self.revoke.build_path(),
                          Revoke.GRANT_PATH % pnconf.subscribe_key)

        pam_args = utils.prepare_pam_arguments({
            'timestamp': 123,
            'channel': 'ch',
            'r': '0',
            'w': '0',
            'm': '0',
            'pnsdk': sdk_name,
            'uuid': self.pubnub.uuid
        })
        sign_input = pnconf.subscribe_key + "\n" + pnconf.publish_key + "\n" + "grant\n" + pam_args
        self.assertEqual(
            self.revoke.build_params_callback()({}), {
                'pnsdk': sdk_name,
                'uuid': self.pubnub.uuid,
                'timestamp': '123',
                'channel': 'ch',
                'r': '0',
                'w': '0',
                'm': '0',
                'signature': utils.sign_sha256(pnconf.secret_key, sign_input)
            })
    def test_grant_read_and_write_to_channel_group(self):
        self.revoke.channel_groups(['gr1', 'gr2'])

        self.assertEquals(self.revoke.build_path(), Revoke.GRANT_PATH % pnconf.subscribe_key)

        self.assertEqual(self.revoke.build_params_callback()({}), {
            'pnsdk': sdk_name,
            'uuid': self.pubnub.uuid,
            'r': '0',
            'w': '0',
            'm': '0',
            'timestamp': '123',
            'channel-group': 'gr1,gr2',
            'signature': utils.sign_sha256(pnconf.secret_key,
                                           pnconf.subscribe_key + "\n" + pnconf.publish_key + "\n" +
                                           "grant\n" + utils.prepare_pam_arguments({
                                               'r': '0',
                                               'w': '0',
                                               'm': '0',
                                               'timestamp': 123,
                                               'channel-group': 'gr1,gr2',
                                               'pnsdk': sdk_name,
                                               'uuid': self.pubnub.uuid
                                           }))
        })
Beispiel #5
0
    def test_grant_read_and_write_to_channel_group(self):
        self.revoke.channel_groups(['gr1', 'gr2'])

        self.assertEquals(self.revoke.build_path(), Revoke.GRANT_PATH % pnconf.subscribe_key)

        pam_args = utils.prepare_pam_arguments({
            'r': '0',
            'w': '0',
            'm': '0',
            'timestamp': 123,
            'channel-group': 'gr1,gr2',
            'pnsdk': sdk_name,
            'uuid': self.pubnub.uuid
        })
        sign_input = pnconf.subscribe_key + "\n" + pnconf.publish_key + "\n" + "grant\n" + pam_args
        self.assertEqual(self.revoke.build_params_callback()({}), {
            'pnsdk': sdk_name,
            'uuid': self.pubnub.uuid,
            'r': '0',
            'w': '0',
            'm': '0',
            'timestamp': '123',
            'channel-group': 'gr1,gr2',
            'signature': utils.sign_sha256(pnconf.secret_key, sign_input)
        })
Beispiel #6
0
    def test_grant_read_and_write_to_channel(self):
        self.grant.channels('ch').read(True).write(True).ttl(7)

        self.assertEquals(self.grant.build_path(), Grant.GRANT_PATH % pnconf_pam.subscribe_key)

        self.assertEqual(self.grant.build_params_callback()({}), {
            'pnsdk': sdk_name,
            'uuid': self.pubnub.uuid,
            'r': '1',
            'w': '1',
            'ttl': '7',
            'timestamp': '123',
            'channel': 'ch',
            'signature': utils.sign_sha256(pnconf_pam.secret_key,
                                           pnconf_pam.subscribe_key + "\n" + pnconf_pam.publish_key + "\n" +
                                           "grant\n" + utils.prepare_pam_arguments({
                                               'r': '1',
                                               'w': '1',
                                               'ttl': '7',
                                               'timestamp': 123,
                                               'channel': 'ch',
                                               'pnsdk': sdk_name,
                                               'uuid': self.pubnub.uuid
                                           }))
        })
Beispiel #7
0
    def test_audit_channel_group(self):
        self.audit.channel_groups(['gr1', 'gr2'])

        self.assertEqual(self.audit.build_path(),
                         Audit.AUDIT_PATH % pnconf_pam.subscribe_key)

        pam_args = utils.prepare_pam_arguments({
            'timestamp': 123,
            'channel-group': 'gr1,gr2',
            'pnsdk': sdk_name,
            'uuid': self.pubnub.uuid
        })
        sign_input = HttpMethod.string(self.audit.http_method()).upper() + "\n" + \
            pnconf_pam.publish_key + "\n" + \
            self.audit.build_path() + "\n" + \
            pam_args + "\n"
        self.assertEqual(
            self.audit.build_params_callback()({}), {
                'pnsdk':
                sdk_name,
                'uuid':
                self.pubnub.uuid,
                'timestamp':
                '123',
                'channel-group':
                'gr1,gr2',
                'signature':
                "v2." + utils.sign_sha256(pnconf_pam.secret_key,
                                          sign_input).rstrip("=")
            })
Beispiel #8
0
    def test_revoke_to_channel(self):
        self.revoke.channels('ch')

        self.assertEquals(self.revoke.build_path(), Revoke.GRANT_PATH % pnconf.subscribe_key)

        self.assertEqual(self.revoke.build_params_callback()({}), {
            'pnsdk': sdk_name,
            'uuid': self.pubnub.uuid,
            'timestamp': '123',
            'channel': 'ch',
            'r': '0',
            'w': '0',
            'm': '0',
            'signature': utils.sign_sha256(pnconf.secret_key,
                                           pnconf.subscribe_key + "\n" + pnconf.publish_key + "\n" +
                                           "grant\n" + utils.prepare_pam_arguments({
                                               'timestamp': 123,
                                               'channel': 'ch',
                                               'r': '0',
                                               'w': '0',
                                               'm': '0',
                                               'pnsdk': sdk_name,
                                               'uuid': self.pubnub.uuid
                                           }))
        })
    def test_prepare_pam_arguments(self):
        params = {
            'abc': True,
            'poq': 4,
            'def': False
        }

        result = utils.prepare_pam_arguments(params)
        assert result == 'abc=True&def=False&poq=4'
Beispiel #10
0
    def test_grant_read_and_write_to_channel_group(self):
        self.revoke.channel_groups(['gr1', 'gr2'])

        self.assertEqual(self.revoke.build_path(),
                         Revoke.GRANT_PATH % pnconf.subscribe_key)

        pam_args = utils.prepare_pam_arguments({
            'r': '0',
            'w': '0',
            'm': '0',
            'g': '0',
            'u': '0',
            'j': '0',
            'timestamp': 123,
            'channel-group': 'gr1,gr2',
            'pnsdk': sdk_name,
            'uuid': self.pubnub.uuid
        })
        sign_input = HttpMethod.string(self.revoke.http_method()).upper() + "\n" + \
            pnconf.publish_key + "\n" + \
            self.revoke.build_path() + "\n" + \
            pam_args + "\n"
        self.assertEqual(
            self.revoke.build_params_callback()({}), {
                'pnsdk':
                sdk_name,
                'uuid':
                self.pubnub.uuid,
                'r':
                '0',
                'w':
                '0',
                'm':
                '0',
                'g':
                '0',
                'u':
                '0',
                'j':
                '0',
                'timestamp':
                '123',
                'channel-group':
                'gr1,gr2',
                'signature':
                "v2." +
                utils.sign_sha256(pnconf.secret_key, sign_input).rstrip("=")
            })
Beispiel #11
0
        def callback(params_to_merge):
            custom_params = self.custom_params()
            custom_params.update(params_to_merge)

            custom_params['pnsdk'] = self.pubnub.sdk_name
            custom_params['uuid'] = self.pubnub.uuid

            if self.is_auth_required(
            ) and self.pubnub.config.auth_key is not None:
                custom_params['auth'] = self.pubnub.config.auth_key

            if self.pubnub.config.secret_key is not None:
                custom_params['timestamp'] = str(self.pubnub.timestamp())
                signed_input = (self.pubnub.config.subscribe_key + "\n" +
                                self.pubnub.config.publish_key + "\n")

                operation_type = self.operation_type()
                if operation_type == PNOperationType.PNAccessManagerAudit:
                    signed_input += 'audit\n'
                elif operation_type == PNOperationType.PNAccessManagerGrant or\
                        operation_type == PNOperationType.PNAccessManagerRevoke:
                    signed_input += 'grant\n'
                else:
                    signed_input += self.build_path() + "\n"

                _custom_params = custom_params.copy()
                if custom_params.get('channel'):
                    _custom_params['channel'] = six.moves.urllib.parse.unquote(
                        _custom_params['channel'])
                signed_input += utils.prepare_pam_arguments(_custom_params)
                signature = utils.sign_sha256(self.pubnub.config.secret_key,
                                              signed_input)

                # REVIEW: add encoder map to not hardcode encoding here
                if operation_type == PNOperationType.PNPublishOperation and 'meta' in custom_params:
                    custom_params['meta'] = utils.url_encode(
                        custom_params['meta'])
                if operation_type == PNOperationType.PNSetStateOperation and 'state' in custom_params:
                    custom_params['state'] = utils.url_encode(
                        custom_params['state'])

                custom_params['signature'] = signature

            # reassign since pnsdk should be signed unencoded
            custom_params['pnsdk'] = utils.url_encode(self.pubnub.sdk_name)

            return custom_params
Beispiel #12
0
        def callback(params_to_merge):
            operation_type = self.operation_type()
            custom_params = self.custom_params()
            custom_params.update(params_to_merge)

            custom_params['pnsdk'] = self.pubnub.sdk_name
            custom_params['uuid'] = self.pubnub.uuid

            for query_key, query_value in self.pubnub._telemetry_manager.operation_latencies(
            ).items():
                custom_params[query_key] = query_value

            if self.is_auth_required(
            ) and self.pubnub.config.auth_key is not None:
                custom_params['auth'] = self.pubnub.config.auth_key

            if self.pubnub.config.secret_key is not None:
                custom_params['timestamp'] = str(self.pubnub.timestamp())
                signed_input = (self.pubnub.config.subscribe_key + "\n" +
                                self.pubnub.config.publish_key + "\n")

                if operation_type == PNOperationType.PNAccessManagerAudit:
                    signed_input += 'audit\n'
                elif operation_type == PNOperationType.PNAccessManagerGrant or \
                        operation_type == PNOperationType.PNAccessManagerRevoke:
                    signed_input += 'grant\n'
                else:
                    signed_input += self.build_path() + "\n"

                signed_input += utils.prepare_pam_arguments(custom_params)
                signature = utils.sign_sha256(self.pubnub.config.secret_key,
                                              signed_input)

                custom_params['signature'] = signature

            # REVIEW: add encoder map to not hardcode encoding here
            if operation_type == PNOperationType.PNPublishOperation and 'meta' in custom_params:
                custom_params['meta'] = utils.url_encode(custom_params['meta'])
            if operation_type == PNOperationType.PNSetStateOperation and 'state' in custom_params:
                custom_params['state'] = utils.url_encode(
                    custom_params['state'])

            # reassign since pnsdk should be signed unencoded
            custom_params['pnsdk'] = utils.url_encode(self.pubnub.sdk_name)

            return custom_params
Beispiel #13
0
    def test_audit_channel_group(self):
        self.audit.channel_groups(['gr1', 'gr2'])

        self.assertEquals(self.audit.build_path(), Audit.AUDIT_PATH % pnconf_pam.subscribe_key)

        self.assertEqual(self.audit.build_params_callback()({}), {
            'pnsdk': sdk_name,
            'uuid': self.pubnub.uuid,
            'timestamp': '123',
            'channel-group': 'gr1,gr2',
            'signature': utils.sign_sha256(pnconf_pam.secret_key,
                                           pnconf_pam.subscribe_key + "\n" + pnconf_pam.publish_key + "\n" +
                                           "audit\n" + utils.prepare_pam_arguments({
                                               'timestamp': 123,
                                               'channel-group': 'gr1,gr2',
                                               'pnsdk': sdk_name,
                                               'uuid': self.pubnub.uuid
                                           }))
        })
Beispiel #14
0
    def test_audit_channel(self):
        self.audit.channels('ch')

        self.assertEquals(self.audit.build_path(), Audit.AUDIT_PATH % pnconf_pam.subscribe_key)

        pam_args = utils.prepare_pam_arguments({
            'timestamp': 123,
            'channel': 'ch',
            'pnsdk': sdk_name,
            'uuid': self.pubnub.uuid
        })
        sign_input = pnconf_pam.subscribe_key + "\n" + pnconf_pam.publish_key + "\n" + "audit\n" + pam_args
        self.assertEqual(self.audit.build_params_callback()({}), {
            'pnsdk': sdk_name,
            'uuid': self.pubnub.uuid,
            'timestamp': '123',
            'channel': 'ch',
            'signature': utils.sign_sha256(pnconf_pam.secret_key, sign_input)
        })
Beispiel #15
0
        def callback(params_to_merge):
            operation_type = self.operation_type()
            custom_params = self.custom_params()
            custom_params.update(params_to_merge)

            custom_params['pnsdk'] = self.pubnub.sdk_name
            custom_params['uuid'] = self.pubnub.uuid

            for query_key, query_value in self.pubnub._telemetry_manager.operation_latencies().items():
                custom_params[query_key] = query_value

            if self.is_auth_required() and self.pubnub.config.auth_key is not None:
                custom_params['auth'] = self.pubnub.config.auth_key

            if self.pubnub.config.secret_key is not None:
                custom_params['timestamp'] = str(self.pubnub.timestamp())
                signed_input = (self.pubnub.config.subscribe_key + "\n" + self.pubnub.config.publish_key + "\n")

                if operation_type == PNOperationType.PNAccessManagerAudit:
                    signed_input += 'audit\n'
                elif operation_type == PNOperationType.PNAccessManagerGrant or \
                        operation_type == PNOperationType.PNAccessManagerRevoke:
                    signed_input += 'grant\n'
                else:
                    signed_input += self.build_path() + "\n"

                signed_input += utils.prepare_pam_arguments(custom_params)
                signature = utils.sign_sha256(self.pubnub.config.secret_key, signed_input)

                custom_params['signature'] = signature

            # REVIEW: add encoder map to not hardcode encoding here
            if operation_type == PNOperationType.PNPublishOperation and 'meta' in custom_params:
                custom_params['meta'] = utils.url_encode(custom_params['meta'])
            if operation_type == PNOperationType.PNSetStateOperation and 'state' in custom_params:
                custom_params['state'] = utils.url_encode(custom_params['state'])

            # reassign since pnsdk should be signed unencoded
            custom_params['pnsdk'] = utils.url_encode(self.pubnub.sdk_name)

            return custom_params
Beispiel #16
0
    def test_grant_read_and_write_to_channel(self):
        self.grant.channels('ch').read(True).write(True).ttl(7)

        self.assertEqual(self.grant.build_path(),
                         Grant.GRANT_PATH % pnconf_pam.subscribe_key)

        pam_args = utils.prepare_pam_arguments({
            'r': '1',
            'w': '1',
            'ttl': '7',
            'timestamp': 123,
            'channel': 'ch',
            'pnsdk': sdk_name,
            'uuid': self.pubnub.uuid
        })
        sign_input = HttpMethod.string(self.grant.http_method()).upper() + "\n" + \
            pnconf_pam.publish_key + "\n" + \
            self.grant.build_path() + "\n" + \
            pam_args + "\n"
        self.assertEqual(
            self.grant.build_params_callback()({}), {
                'pnsdk':
                sdk_name,
                'uuid':
                self.pubnub.uuid,
                'r':
                '1',
                'w':
                '1',
                'ttl':
                '7',
                'timestamp':
                '123',
                'channel':
                'ch',
                'signature':
                "v2." + utils.sign_sha256(pnconf_pam.secret_key,
                                          sign_input).rstrip("=")
            })