def setUp(self):
        self.sms = ServiceBusManagementService(
            credentials.getSubscriptionId(),
            credentials.getManagementCertFile())
        set_service_options(self.sms)

        self.sb_namespace = getUniqueName('uts')
    def test_sas_signed_identifier(self):
        # Arrange
        si = SignedIdentifier()
        si.id = 'testid'
        si.access_policy.start = '2011-10-11'
        si.access_policy.expiry = '2018-10-12'
        si.access_policy.permission = QueueSharedAccessPermissions.READ
        identifiers = SignedIdentifiers()
        identifiers.signed_identifiers.append(si)

        resp = self.qs.set_queue_acl(self.test_queues[0], identifiers)

        self.qs.put_message(self.test_queues[0], 'message1')

        token = self.qs.generate_shared_access_signature(
            self.test_queues[0],
            SharedAccessPolicy(signed_identifier=si.id),
        )

        # Act
        service = QueueService(credentials.getStorageServicesName(),
                               sas_token=token)
        set_service_options(service)
        result = service.peek_messages(self.test_queues[0])

        # Assert
        self.assertIsNotNone(result)
        self.assertEqual(1, len(result))
        message = result[0]
        self.assertIsNotNone(message)
        self.assertNotEqual('', message.message_id)
        self.assertEqual('message1', message.message_text)
Exemple #3
0
    def setUp(self):
        self.sms = ServiceBusManagementService(
            credentials.getSubscriptionId(),
            credentials.getManagementCertFile())
        set_service_options(self.sms)

        self.sb_namespace = getUniqueName('uts')
    def test_sas_update(self):
        # Arrange
        self.qs.put_message(self.test_queues[0], 'message1')
        token = self.qs.generate_shared_access_signature(
            self.test_queues[0],
            self._get_shared_access_policy(
                QueueSharedAccessPermissions.UPDATE),
        )
        result = self.qs.get_messages(self.test_queues[0])

        # Act
        service = QueueService(credentials.getStorageServicesName(),
                               sas_token=token)
        set_service_options(service)
        service.update_message(
            self.test_queues[0],
            result[0].message_id,
            'updatedmessage1',
            result[0].pop_receipt,
            visibilitytimeout=0,
        )

        # Assert
        result = self.qs.get_messages(self.test_queues[0])
        self.assertEqual('updatedmessage1', result[0].message_text)
    def setUp(self):
        self.sms = ServiceManagementService(
            credentials.getSubscriptionId(),
            credentials.getManagementCertFile())
        set_service_options(self.sms)

        self.certificate_thumbprints = []
    def setUp(self):
        self.sms = ServiceManagementService(
            credentials.getSubscriptionId(),
            credentials.getManagementCertFile())
        set_service_options(self.sms)

        self.storage_account_name = getUniqueName('utstor')
    def test_sas_signed_identifier(self):
        # Arrange
        si = SignedIdentifier()
        si.id = "testid"
        si.access_policy.start = "2011-10-11"
        si.access_policy.expiry = "2018-10-12"
        si.access_policy.permission = QueueSharedAccessPermissions.READ
        identifiers = SignedIdentifiers()
        identifiers.signed_identifiers.append(si)

        resp = self.qs.set_queue_acl(self.test_queues[0], identifiers)

        self.qs.put_message(self.test_queues[0], "message1")

        token = self.qs.generate_shared_access_signature(
            self.test_queues[0], SharedAccessPolicy(signed_identifier=si.id)
        )

        # Act
        service = QueueService(credentials.getStorageServicesName(), sas_token=token)
        set_service_options(service)
        result = service.peek_messages(self.test_queues[0])

        # Assert
        self.assertIsNotNone(result)
        self.assertEqual(1, len(result))
        message = result[0]
        self.assertIsNotNone(message)
        self.assertNotEqual("", message.message_id)
        self.assertEqual("message1", message.message_text)
    def setUp(self):
        self.ts = TableService(credentials.getStorageServicesName(),
                               credentials.getStorageServicesKey())
        set_service_options(self.ts)

        self.table_name = getUniqueName('uttable')
        self.additional_table_names = []
    def setUp(self):
        self.sms = ServiceManagementService(credentials.getSubscriptionId(),
                                            credentials.getManagementCertFile())
        set_service_options(self.sms)

        self.affinity_group_name = getUniqueName('utaffgrp')
        self.hosted_service_name = None
        self.storage_account_name = None
    def setUp(self):
        self.sms = ServiceManagementService(
            credentials.getSubscriptionId(),
            credentials.getManagementCertFile())
        set_service_options(self.sms)

        self.affinity_group_name = getUniqueName('utaffgrp')
        self.hosted_service_name = None
        self.storage_account_name = None
    def setUp(self):
        self.sbs = ServiceBusService(
            credentials.getEventHubNamespace(),
            shared_access_key_name=credentials.getEventHubSasKeyName(),
            shared_access_key_value=credentials.getEventHubSasKeyValue(),
            )

        set_service_options(self.sbs)

        self.event_hub_name = getUniqueName('uthub')
    def setUp(self):
        self.sbs = ServiceBusService(credentials.getServiceBusNamespace(), 
                                     credentials.getServiceBusKey(), 
                                     'owner')
        set_service_options(self.sbs)

        self.queue_name = getUniqueName('utqueue')
        self.topic_name = getUniqueName('uttopic')

        self.additional_queue_names = []
        self.additional_topic_names = []
    def setUp(self):
        self.qs = QueueService(credentials.getStorageServicesName(), 
                               credentials.getStorageServicesKey())
        set_service_options(self.qs)

        self.test_queues = []
        self.creatable_queues = []
        for i in range(10):
            self.test_queues.append(getUniqueName(TEST_QUEUE_PREFIX + str(i)))
        for i in range(4):
            self.creatable_queues.append(getUniqueName('mycreatablequeue' + str(i)))
        for queue_name in self.test_queues:
            self.qs.create_queue(queue_name)
    def test_sas_add(self):
        # Arrange
        token = self.qs.generate_shared_access_signature(
            self.test_queues[0], self._get_shared_access_policy(QueueSharedAccessPermissions.ADD)
        )

        # Act
        service = QueueService(credentials.getStorageServicesName(), sas_token=token)
        set_service_options(service)
        result = service.put_message(self.test_queues[0], "addedmessage")

        # Assert
        result = self.qs.get_messages(self.test_queues[0])
        self.assertEqual("addedmessage", result[0].message_text)
Exemple #15
0
    def setUp(self):
        self.qs = QueueService(credentials.getStorageServicesName(),
                               credentials.getStorageServicesKey())
        set_service_options(self.qs)

        self.test_queues = []
        self.creatable_queues = []
        for i in range(10):
            self.test_queues.append(getUniqueName(TEST_QUEUE_PREFIX + str(i)))
        for i in range(4):
            self.creatable_queues.append(
                getUniqueName('mycreatablequeue' + str(i)))
        for queue_name in self.test_queues:
            self.qs.create_queue(queue_name)
    def setUp(self):
        session = None
        if credentials.getUseRequestsLibrary():
            from requests import Session
            session = Session()

        self.sbs = ServiceBusService(
            credentials.getEventHubNamespace(),
            shared_access_key_name=credentials.getEventHubSasKeyName(),
            shared_access_key_value=credentials.getEventHubSasKeyValue(),
            request_session=session,
        )

        set_service_options(self.sbs)

        self.event_hub_name = getUniqueName('uthub')
    def test_sas_add(self):
        # Arrange
        token = self.qs.generate_shared_access_signature(
            self.test_queues[0],
            self._get_shared_access_policy(QueueSharedAccessPermissions.ADD),
        )

        # Act
        service = QueueService(credentials.getStorageServicesName(),
                               sas_token=token)
        set_service_options(service)
        result = service.put_message(self.test_queues[0], 'addedmessage')

        # Assert
        result = self.qs.get_messages(self.test_queues[0])
        self.assertEqual('addedmessage', result[0].message_text)
    def setUp(self):
        session = None
        if credentials.getUseRequestsLibrary():
            from requests import Session
            session = Session()

        self.sbs = ServiceBusService(
            credentials.getEventHubNamespace(),
            shared_access_key_name=credentials.getEventHubSasKeyName(),
            shared_access_key_value=credentials.getEventHubSasKeyValue(),
            request_session=session,
        )

        set_service_options(self.sbs)

        self.event_hub_name = getUniqueName('uthub')
    def test_sas_update(self):
        # Arrange
        self.qs.put_message(self.test_queues[0], "message1")
        token = self.qs.generate_shared_access_signature(
            self.test_queues[0], self._get_shared_access_policy(QueueSharedAccessPermissions.UPDATE)
        )
        result = self.qs.get_messages(self.test_queues[0])

        # Act
        service = QueueService(credentials.getStorageServicesName(), sas_token=token)
        set_service_options(service)
        service.update_message(
            self.test_queues[0], result[0].message_id, "updatedmessage1", result[0].pop_receipt, visibilitytimeout=0
        )

        # Assert
        result = self.qs.get_messages(self.test_queues[0])
        self.assertEqual("updatedmessage1", result[0].message_text)
    def test_sas_process(self):
        # Arrange
        self.qs.put_message(self.test_queues[0], "message1")
        token = self.qs.generate_shared_access_signature(
            self.test_queues[0], self._get_shared_access_policy(QueueSharedAccessPermissions.PROCESS)
        )

        # Act
        service = QueueService(credentials.getStorageServicesName(), sas_token=token)
        set_service_options(service)
        result = service.get_messages(self.test_queues[0])

        # Assert
        self.assertIsNotNone(result)
        self.assertEqual(1, len(result))
        message = result[0]
        self.assertIsNotNone(message)
        self.assertNotEqual("", message.message_id)
        self.assertEqual("message1", message.message_text)
    def test_sas_read(self):
        # Arrange
        self.qs.put_message(self.test_queues[0], 'message1')
        token = self.qs.generate_shared_access_signature(
            self.test_queues[0],
            self._get_shared_access_policy(QueueSharedAccessPermissions.READ),
        )

        # Act
        service = QueueService(credentials.getStorageServicesName(),
                               sas_token=token)
        set_service_options(service)
        result = service.peek_messages(self.test_queues[0])

        # Assert
        self.assertIsNotNone(result)
        self.assertEqual(1, len(result))
        message = result[0]
        self.assertIsNotNone(message)
        self.assertNotEqual('', message.message_id)
        self.assertEqual('message1', message.message_text)
    def setUp(self):
        self.sms = ServiceManagementService(credentials.getSubscriptionId(),
                                            credentials.getManagementCertFile())
        set_service_options(self.sms)

        self.certificate_thumbprints = []
    def setUp(self):
        self.sms = ServiceManagementService(credentials.getSubscriptionId(),
                                            credentials.getManagementCertFile())
        set_service_options(self.sms)

        self.storage_account_name = getUniqueName('utstor')