def test_arbitrary_string(self):
     actual = data_utils.arbitrary_string()
     self.assertEqual(actual, "test")
     actual = data_utils.arbitrary_string(size=30, base_text="abc")
     self.assertEqual(actual, "abc" * int(30 / len("abc")))
     actual = data_utils.arbitrary_string(size=5, base_text="deadbeaf")
     self.assertEqual(actual, "deadb")

 def test_create_subscriptions_with_invalid_body(self):
     # Missing subscriber parameter in body
     message_ttl = data_utils.\
         rand_int_id(start=60, end=CONF.messaging.max_message_ttl)
     key = data_utils.arbitrary_string(size=20, base_text='MessagingKey')
     value = data_utils.arbitrary_string(size=20,
                                         base_text='MessagingValue')
     option_body = {key: value}
     rbody = {'options': option_body, 'ttl': message_ttl}
     self.assertRaises(lib_exc.BadRequest,
                       self.create_subscription, self.queue_name, rbody)

    def generate_message_body(cls, repeat=1):
        """Wrapper utility that sets the metadata of a queue."""
        message_ttl = data_utils.\
            rand_int_id(start=60, end=CONF.messaging.max_message_ttl)

        key = data_utils.arbitrary_string(size=20, base_text='MessagingKey')
        value = data_utils.arbitrary_string(size=20,
                                            base_text='MessagingValue')
        message_body = {key: value}

        rbody = ([{'body': message_body, 'ttl': message_ttl}] * repeat)
        return rbody

 def test_create_subscriptions_with_non_integer_value_for_ttl(self):
     # The subscriber type of subscription must be supported in the list
     # ['http', 'https', 'mailto']
     message_ttl = "123"
     key = data_utils.arbitrary_string(size=20, base_text='MessagingKey')
     value = data_utils.arbitrary_string(size=20,
                                         base_text='MessagingValue')
     option_body = {key: value}
     subscriber = 'http://fake:8080'
     rbody = {'options': option_body, 'ttl': message_ttl,
              'subscriber': subscriber}
     self.assertRaises(lib_exc.BadRequest,
                       self.create_subscription, self.queue_name, rbody)

    def generate_subscription_body(cls):
        message_ttl = data_utils.\
            rand_int_id(start=60, end=CONF.messaging.max_message_ttl)

        key = data_utils.arbitrary_string(size=20, base_text='MessagingKey')
        value = data_utils.arbitrary_string(size=20,
                                            base_text='MessagingValue')
        option_body = {key: value}
        subscribers = ['http://fake:8080', 'https://fake:8080',
                       'mailto:[email protected]']
        rbody = [{'options': option_body, 'ttl': message_ttl,
                  'subscriber': subscriber} for subscriber in subscribers]
        return rbody

    def test_post_messages_without_TTL(self):
        # TTL for a message may not exceed 1209600 seconds, and
        # must be at least 60 seconds long.
        queue_name = self.queues[data_utils.rand_int_id(0,
                                                        len(self.queues) - 1)]
        key = data_utils.arbitrary_string(size=20, base_text='MessagingKey')
        value = data_utils.arbitrary_string(size=20,
                                            base_text='MessagingValue')
        message_body = {key: value}

        rbody = ([{'body': message_body}] * 1)

        self.assertRaises(lib_exc.BadRequest,
                          self.client.post_messages, queue_name, rbody)

 def test_create_subscriptions_with_invalid_subscriber(self):
     # The subscriber type of subscription must be supported in the list
     # ['http', 'https', 'mailto']
     message_ttl = data_utils.\
         rand_int_id(start=60, end=CONF.messaging.max_message_ttl)
     key = data_utils.arbitrary_string(size=20, base_text='MessagingKey')
     value = data_utils.arbitrary_string(size=20,
                                         base_text='MessagingValue')
     option_body = {key: value}
     subscriber = 'fake'
     rbody = {'options': option_body, 'ttl': message_ttl,
              'subscriber': subscriber}
     self.assertRaises(lib_exc.BadRequest,
                       self.create_subscription, self.queue_name, rbody)

    def test_post_messages_with_invalid_body_size(self):
        # Maximum number of queue message per page
        # while posting messages is 20
        queue_name = self.queues[data_utils.rand_int_id(0,
                                                        len(self.queues) - 1)]
        key = data_utils.arbitrary_string(size=20, base_text='MessagingKey')
        value = data_utils.arbitrary_string(size=20,
                                            base_text='MessagingValue')
        message_ttl = data_utils.\
            rand_int_id(start=60, end=CONF.messaging.max_message_ttl)

        message_body = {key: value}
        rbody = ([{'body': message_body, 'ttl': message_ttl}] * 21)
        self.assertRaises(lib_exc.BadRequest,
                          self.client.post_messages, queue_name, rbody)

    def test_upload_valid_object(self):
        object_name = data_utils.rand_name(name="TestObject")
        data = data_utils.arbitrary_string()
        resp, _ = self.object_client.create_object(self.container_name,
                                                   object_name, data)

        self.assertHeaders(resp, 'Object', 'PUT')

    def verify_metadata(self):
        if self.run_ssh and CONF.compute_feature_enabled.metadata_service:
            # Verify metadata service
            md_url = 'http://169.254.169.254/latest/meta-data/public-ipv4'

            def exec_cmd_and_verify_output():
                cmd = 'curl ' + md_url
                result = self.ssh_client.exec_command(cmd)
                if result:
                    msg = ('Failed while verifying metadata on server. Result '
                           'of command "%s" is NOT "%s".' % (cmd, self.fip))
                    self.assertEqual(self.fip, result, msg)
                    return 'Verification is successful!'

            if not test_utils.call_until_true(exec_cmd_and_verify_output,
                                              CONF.compute.build_timeout,
                                              CONF.compute.build_interval):
                raise exceptions.TimeoutException('Timed out while waiting to '
                                                  'verify metadata on server. '
                                                  '%s is empty.' % md_url)

            # Also, test a POST
            md_url = 'http://169.254.169.254/openstack/2013-10-17/password'
            data = data_utils.arbitrary_string(100)
            cmd = 'curl -X POST -d ' + data + ' ' + md_url
            self.ssh_client.exec_command(cmd)
            result = self.servers_client.show_password(self.instance['id'])
            self.assertEqual(data, result['password'])

 def test_create_node_resource_class_long(self):
     """Create new node with specified longest name of resource class."""
     res_class_long_name = data_utils.arbitrary_string(80)
     _, body = self.create_node(
         self.chassis['uuid'],
         resource_class=res_class_long_name)
     self.assertEqual(res_class_long_name, body['resource_class'])

 def upload_object_to_container(self, container_name):
     obj_name = data_utils.rand_name('swift-scenario-object')
     obj_data = data_utils.arbitrary_string()
     self.object_client.create_object(container_name, obj_name, obj_data)
     self.addCleanup(self.object_client.delete_object,
                     container_name,
                     obj_name)
     return obj_name

    def test_post_messages_with_TTL_less_than_60(self):
        # TTL for a message may not exceed 1209600 seconds,
        # and must be at least 60 seconds long.
        queue_name = self.queues[data_utils.rand_int_id(0,
                                                        len(self.queues) - 1)]
        message_ttl = data_utils.\
            rand_int_id(start=0, end=60)

        key = data_utils.arbitrary_string(size=20, base_text='MessagingKey')
        value = data_utils.arbitrary_string(size=20,
                                            base_text='MessagingValue')
        message_body = {key: value}

        rbody = ([{'body': message_body, 'ttl': message_ttl}] * 1)

        self.assertRaises(lib_exc.BadRequest,
                          self.client.post_messages, queue_name, rbody)

    def test_create_a_subscription_without_a_token(self):
        # X-Auth-Token is not provided
        message_ttl = data_utils.\
            rand_int_id(start=60, end=CONF.messaging.max_message_ttl)
        key = data_utils.arbitrary_string(size=20, base_text='MessagingKey')
        value = data_utils.arbitrary_string(size=20,
                                            base_text='MessagingValue')
        option_body = {key: value}
        subscriber = 'http://fake:8080'
        rbody = {'options': option_body, 'ttl': message_ttl,
                 'subscriber': subscriber}

        self.client.auth_provider.set_alt_auth_data(
            request_part='headers',
            auth_data=None
        )
        self.assertRaises(lib_exc.Unauthorized,
                          self.create_subscription, self.queue_name, rbody)

 def test_list_nodes_by_resource_class_old_api(self):
     """Try to list nodes with resource class using older api version."""
     resource_class = data_utils.arbitrary_string()
     self.assertRaises(
         lib_exc.UnexpectedResponseCode,
         self.client.list_nodes, resource_class=resource_class)
     self.assertRaises(
         lib_exc.UnexpectedResponseCode,
         self.client.list_nodes_detail, resource_class=resource_class)

    def _create_object(self, container_name, object_name=None):
        # setup object
        if object_name is None:
            object_name = data_utils.rand_name(name='TestObject')
        data = data_utils.arbitrary_string()
        self.object_client.create_object(container_name,
                                         object_name,
                                         data)

        return object_name

 def test_create_container_name_exceeds_max_length(self):
     # Attempts to create a container name that is longer than max
     max_length = self.constraints['max_container_name_length']
     # create a container with long name
     container_name = data_utils.arbitrary_string(size=max_length + 1)
     ex = self.assertRaises(exceptions.BadRequest,
                            self.container_client.create_container,
                            container_name)
     self.assertIn('Container name length of ' + str(max_length + 1) +
                   ' longer than ' + str(max_length), str(ex))

 def test_create_container_metadata_value_exceeds_max_length(self):
     # Attempts to create container with metadata value
     # that is longer than max.
     max_length = self.constraints['max_meta_value_length']
     container_name = data_utils.rand_name(name='TestContainer')
     metadata_value = data_utils.arbitrary_string(size=max_length + 1)
     metadata = {'animal': metadata_value}
     ex = self.assertRaises(exceptions.BadRequest,
                            self.container_client.create_container,
                            container_name, metadata=metadata)
     self.assertIn('Metadata value longer than ' + str(max_length), str(ex))

    def _upload_segments(self):
        # create object
        object_name = data_utils.rand_name(name='LObject')
        data = data_utils.arbitrary_string()
        segments = 10
        data_segments = [data + str(i) for i in range(segments)]
        # uploading segments
        for i in range(segments):
            self.object_client.create_object_segments(
                self.container_name, object_name, i, data_segments[i])

        return object_name, data_segments

    def create_object(cls, container_name, object_name=None,
                      data=None, metadata=None):
        # wrapper that returns a test object
        if object_name is None:
            object_name = data_utils.rand_name(name='TestObject')
        if data is None:
            data = data_utils.arbitrary_string()
        cls.object_client.create_object(container_name,
                                        object_name,
                                        data,
                                        metadata=metadata)

        return object_name, data