Example #1
0
def _update(resource, data=None, query_args={}, *args, **kwargs):
    """Generate a PUT request on a resource.

    Unlike other methods, any additional query args must be passed in
    using the 'query_args' parameter, since kwargs is used for the
    fields which will be sent.

    Review Board expects ``extra_data`` fields to be sent as
    ``extra_data.field_name``, which cannot be passed as a raw literal in
    Python. Fields like this would have to be added to a dict and splatted.
    However, this function also accepts keyword arguments of the form
    ``extra_data__field_name``, which will be rewritten to fields of the form
    ``extra_data.field_name``.
    """
    request = HttpRequest(resource._links['update']['href'], method='PUT',
                          query_args=query_args)

    if data is None:
        data = {}

    kwargs.update(data)

    for name, value in _preprocess_fields(kwargs):
        request.add_field(name, value)

    return request
Example #2
0
    def upload_diff(self,
                    diff,
                    parent_diff=None,
                    base_dir=None,
                    base_commit_id=None,
                    **kwargs):
        """Uploads a new diff.

        The diff and parent_diff arguments should be strings containing
        the diff output.
        """
        # TODO: This method should be unified with validate_diff() method of
        # ValidateDiffResource, since they both perform the same operation.
        request = HttpRequest(self._url, method=b'POST', query_args=kwargs)
        request.add_file('path', 'diff', diff)

        if parent_diff:
            request.add_file('parent_diff_path', 'parent_diff', parent_diff)

        if base_dir:
            request.add_field('basedir', base_dir)

        if base_commit_id:
            request.add_field('base_commit_id', base_commit_id)

        return request
Example #3
0
def _update(resource, data=None, query_args={}, *args, **kwargs):
    """Generate a PUT request on a resource.

    Unlike other methods, any additional query args must be passed in
    using the 'query_args' parameter, since kwargs is used for the
    fields which will be sent.

    Review Board expects ``extra_data`` fields to be sent as
    ``extra_data.field_name``, which cannot be passed as a raw literal in
    Python. Fields like this would have to be added to a dict and splatted.
    However, this function also accepts keyword arguments of the form
    ``extra_data__field_name``, which will be rewritten to fields of the form
    ``extra_data.field_name``.
    """
    request = HttpRequest(resource._links['update']['href'],
                          method='PUT',
                          query_args=query_args)

    if data is None:
        data = {}

    kwargs.update(data)

    for name, value in _preprocess_fields(kwargs):
        request.add_field(name, value)

    return request
Example #4
0
    def test_method_normalized(self):
        """Testing HttpRequest.method uses native string types"""
        request = HttpRequest(url='/')
        request.method = b'GET'
        self.assertIs(type(request.method), str)

        request.method = 'POST'
        self.assertIs(type(request.method), str)
Example #5
0
    def test_defaults(self):
        """Testing HttpRequest default attribute values"""
        request = HttpRequest('/')
        self.assertEqual(request.url, '/')
        self.assertEqual(request.method, 'GET')

        content_type, content = request.encode_multipart_formdata()
        self.assertIsNone(content_type)
        self.assertIsNone(content)
Example #6
0
    def test_encode_multipart_formdata_normalizes_string_types(self):
        """Testing HttpRequest.encode_multipart_formdata normalizes
        Unicode and byte strings
        """
        konnichiwa = '\u3053\u3093\u306b\u3061\u306f'

        request = HttpRequest(url='/', method='POST')
        request.add_field('foo', konnichiwa)
        request.add_field('bar', konnichiwa.encode('utf-8'))
        request.add_field('baz', b'\xff')

        self.spy_on(request._make_mime_boundary,
                    call_fake=lambda r: b'BOUNDARY')

        ctype, content = request.encode_multipart_formdata()

        self.assertEqual(ctype, 'multipart/form-data; boundary=BOUNDARY')
        self.assertEqual(
            content, b'--BOUNDARY\r\n'
            b'Content-Disposition: form-data; name="foo"\r\n'
            b'\r\n'
            b'\xe3\x81\x93\xe3\x82\x93\xe3\x81\xab\xe3\x81\xa1\xe3\x81\xaf'
            b'\r\n'
            b'--BOUNDARY\r\n'
            b'Content-Disposition: form-data; name="bar"\r\n'
            b'\r\n'
            b'\xe3\x81\x93\xe3\x82\x93\xe3\x81\xab\xe3\x81\xa1\xe3\x81\xaf'
            b'\r\n'
            b'--BOUNDARY\r\n'
            b'Content-Disposition: form-data; name="baz"\r\n'
            b'\r\n'
            b'\xff'
            b'\r\n'
            b'--BOUNDARY--\r\n\r\n')
Example #7
0
    def upload_screenshot(self, filename, content, caption=None, **kwargs):
        """Uploads a new screenshot.

        The content argument should contain the body of the screenshot
        to be uploaded, in string format.
        """
        request = HttpRequest(self.url, method='POST', query_args=kwargs)
        request.add_file('path', filename, content)

        if caption:
            request.add_field('caption', caption)

        return request
Example #8
0
    def upload_attachment(self, filename, content, caption=None, **kwargs):
        """Uploads a new attachment.

        The content argument should contain the body of the file to be
        uploaded, in string format.
        """
        request = HttpRequest(self._url, method="POST", query_args=kwargs)
        request.add_file("path", filename, content)

        if caption:
            request.add_field("caption", caption)

        return request
Example #9
0
def _update(resource, data={}, query_args={}, *args, **kwargs):
    """Generate a PUT request on a resource.

    Unlike other methods, any additional query args must be passed in
    using the 'query_args' parameter, since kwargs is used for the
    fields which will be sent.
    """
    request = HttpRequest(resource._links['update']['href'], method='PUT',
                          query_args=query_args)

    data.update(kwargs)

    for name, value in data.iteritems():
        request.add_field(name, value)

    return request
Example #10
0
    def __init__(self, payload, url, token=None, **kwargs):
        self.url = url
        self._token = token
        self._payload = payload
        self._excluded_attrs = self._excluded_attrs + _EXCLUDE_ATTRS

        # Determine where the links live in the payload. This
        # can either be at the root, or inside the resources
        # token.
        if LINKS_TOK in self._payload:
            self._links = self._payload[LINKS_TOK]
        elif (token and isinstance(self._payload[token], dict) and
              LINKS_TOK in self._payload[token]):
            self._links = self._payload[token][LINKS_TOK]
        else:
            self._payload[LINKS_TOK] = {}
            self._links = {}

        # Add a method for each supported REST operation, and
        # retrieving 'self'.
        for link, method in SPECIAL_LINKS.iteritems():
            if link in self._links and method[1]:
                setattr(self, method[0],
                    lambda resource=self, meth=method[1], **kwargs:
                    meth(resource, **kwargs))

        # Generate request methods for any additional links
        # the resource has.
        for link, body in self._links.iteritems():
            if link not in SPECIAL_LINKS:
                setattr(self, "get_%s" % (link),
                        lambda url=body['href'], **kwargs: HttpRequest(
                            url, query_args=kwargs))
Example #11
0
 def get_patch(self, **kwargs):
     """Retrieves the actual diff file contents."""
     return HttpRequest(self._url,
                        query_args=kwargs,
                        headers={
                            'Accept': 'text/x-patch',
                        })
Example #12
0
    def test_encode_query_args(self):
        """Testing the encoding of query arguments"""
        request = HttpRequest(
            url='/',
            method='GET',
            query_args={
                'long_arg': 'long',
                'float': 1.2,
                'int': 5,
                'byte': b'binary',
                'true': True,
                'false': False,
            })

        query_args = dict(parse_qsl(urlparse(request.url).query))

        self.assertEqual(
            query_args,
            {
                'long-arg': 'long',
                'float': '1.2',
                'int': '5',
                'byte': 'binary',
                'true': '1',
                'false': '0',
            })

        for key, value in six.iteritems(query_args):
            self.assertIsInstance(key, str)
            self.assertIsInstance(value, str)
Example #13
0
def _update(resource, data={}, query_args={}, *args, **kwargs):
    """Generate a PUT request on a resource.

    Unlike other methods, any additional query args must be passed in
    using the 'query_args' parameter, since kwargs is used for the
    fields which will be sent.
    """
    request = HttpRequest(resource._links['update']['href'], method='PUT',
                          query_args=query_args)

    data.update(kwargs)

    for name, value in data.iteritems():
        request.add_field(name, value)

    return request
Example #14
0
    def test_url_includes_normalized_query_args(self):
        """Testing HttpRequest.url includes normalized query arguments"""
        request = HttpRequest(url='/', query_args={
            b'a_b': 'c',
            'd-e': b'f',
        })

        self.assertEqual(request.url, '/?a-b=c&d-e=f')
Example #15
0
 def get_diff_data(self, **kwargs):
     """Retrieves the actual raw diff data for the file."""
     return HttpRequest(
         self._url,
         query_args=kwargs,
         headers={
             'Accept': 'application/vnd.reviewboard.org.diff.data+json',
         })
Example #16
0
    def get_path(self, path, *args, **kwargs):
        if path[-1] != '/':
            path = path + '/'

        if path[0] == '/':
            path = path[1:]

        return self._execute_request(
            HttpRequest(self.server.url + path, query_args=kwargs))
Example #17
0
    def get_path(self, path, *args, **kwargs):
        if not path.endswith('/'):
            path = path + '/'

        if path.startswith('/'):
            path = path[1:]

        return self._execute_request(
            HttpRequest(self.server.url + path, query_args=kwargs))
Example #18
0
def _update(resource, data=None, query_args={}, *args, **kwargs):
    """Generate a PUT request on a resource.

    Unlike other methods, any additional query args must be passed in
    using the 'query_args' parameter, since kwargs is used for the
    fields which will be sent.
    """
    request = HttpRequest(resource._links["update"]["href"], method="PUT", query_args=query_args)

    if data is None:
        data = {}

    kwargs.update(data)

    for name, value in kwargs.iteritems():
        request.add_field(name, value)

    return request
Example #19
0
def _create(resource, data=None, query_args={}, *args, **kwargs):
    """Generate a POST request on a resource.

    Unlike other methods, any additional query args must be passed in
    using the 'query_args' parameter, since kwargs is used for the
    fields which will be sent.
    """
    request = HttpRequest(resource._links['create']['href'], method=b'POST',
                          query_args=query_args)

    if data is None:
        data = {}

    kwargs.update(data)

    for name, value in six.iteritems(kwargs):
        request.add_field(name, value)

    return request
Example #20
0
    def test_encode_query_args_invalid(self):
        """Testing the encoding of query arguments with invalid keys and
        values
        """
        with self.assertRaises(ValueError):
            HttpRequest(
                url='/',
                method='GET',
                query_args={
                    1: 'value',
                })

        with self.assertRaises(ValueError):
            HttpRequest(
                url='/',
                method='GET',
                query_args={
                    1.2: 'value',
                })

        with self.assertRaises(ValueError):
            HttpRequest(
                url='/',
                method='GET',
                query_args={
                    True: 'value',
                })

        with self.assertRaises(ValueError):
            HttpRequest(
                url='/',
                method='GET',
                query_args={
                    'key': {'adsf': 'jkl;'},
                })

        with self.assertRaises(ValueError):
            HttpRequest(
                url='/',
                method='GET',
                query_args={
                    'key': ['a', 'b', 'c'],
                })
Example #21
0
    def finalize_commit_series(self,
                               cumulative_diff,
                               validation_info,
                               parent_diff=None):
        """Finalize a commit series.

        Args:
            cumulative_diff (bytes):
                The cumulative diff of the entire commit series.

            validation_info (unicode):
                The validation information returned by validatin the last
                commit in the series with the
                :py:class:`ValidateDiffCommitResource`.

            parent_diff (bytes, optional):
                An optional parent diff.

                This will be the same parent diff uploaded with each commit.

        Returns:
            DiffItemResource:
            The finalized diff resource.
        """
        if not isinstance(cumulative_diff, bytes):
            raise TypeError('cumulative_diff must be byte string, not %s' %
                            type(cumulative_diff))

        if parent_diff is not None and not isinstance(parent_diff, bytes):
            raise TypeError('parent_diff must be byte string, not %s' %
                            type(cumulative_diff))

        request = HttpRequest(self.links['self']['href'], method='PUT')

        request.add_field('finalize_commit_series', True)
        request.add_file('cumulative_diff', 'cumulative_diff', cumulative_diff)
        request.add_field('validation_info', validation_info)

        if parent_diff is not None:
            request.add_file('parent_diff', 'parent_diff', parent_diff)

        return request
Example #22
0
    def create_empty(self, base_commit_id=None, **kwargs):
        """Create an empty DiffSet that commits can be added to.

        Args:
            base_commit_id (unicode, optional):
                The base commit ID of the diff.

            **kwargs (dict):
                Keyword arguments to encode into the querystring of the request
                URL.
        Returns:
            DiffItemResource:
            The created resource.
        """
        request = HttpRequest(self._url, method=b'POST', query_args=kwargs)

        if base_commit_id:
            request.add_field('base_commit_id', base_commit_id)

        return request
Example #23
0
    def create_empty(self, base_commit_id=None, **kwargs):
        """Create an empty DiffSet that commits can be added to.

        Args:
            base_commit_id (unicode, optional):
                The base commit ID of the diff.

            **kwargs (dict):
                Keyword arguments to encode into the querystring of the request
                URL.
        Returns:
            DiffItemResource:
            The created resource.
        """
        request = HttpRequest(self._url, method=b'POST', query_args=kwargs)

        if base_commit_id:
            request.add_field('base_commit_id', base_commit_id)

        return request
Example #24
0
    def test_headers_normalized(self):
        """Testing HttpRequest.headers uses native string types"""
        request = HttpRequest(url='/', headers={
            b'a': 'b',
            'c': b'd',
        })

        keys = list(six.iterkeys(request.headers))
        self.assertIs(type(keys[0]), str)
        self.assertIs(type(keys[1]), str)
        self.assertIs(type(request.headers[keys[0]]), str)
        self.assertIs(type(request.headers[keys[1]]), str)
Example #25
0
    def prepare_upload_diff_request(self, diff, parent_diff=None,
                                    base_dir=None, base_commit_id=None,
                                    **kwargs):
        """Create a request that can be used to upload a diff.

        The diff and parent_diff arguments should be strings containing the
        diff output.
        """
        request = HttpRequest(self._url, method='POST', query_args=kwargs)
        request.add_file('path', 'diff', diff)

        if parent_diff:
            request.add_file('parent_diff_path', 'parent_diff', parent_diff)

        if base_dir:
            request.add_field('basedir', base_dir)

        if base_commit_id:
            request.add_field('base_commit_id', base_commit_id)

        return request
Example #26
0
    def validate_diff(self, repository, diff, parent_diff=None,
                      base_dir=None, **kwargs):
        """Validates a diff.

        The diff and parent_diff arguments should be strings containing
        the diff output.
        """

        # TODO: This method should be unified with upload_diff() method of
        # DiffListResource, since they both perform the same operation.
        request = HttpRequest(self._url, method=b'POST', query_args=kwargs)
        request.add_field('repository', repository)
        request.add_file('path', 'diff', diff)

        if parent_diff:
            request.add_file('parent_diff_path', 'parent_diff', parent_diff)

        if base_dir:
            request.add_field('basedir', base_dir)

        return request
Example #27
0
    def upload_diff(self, diff, parent_diff=None, base_dir=None, base_commit_id=None, **kwargs):
        """Uploads a new diff.

        The diff and parent_diff arguments should be strings containing
        the diff output.
        """
        request = HttpRequest(self._url, method="POST", query_args=kwargs)
        request.add_file("path", "diff", diff)

        if parent_diff:
            request.add_file("parent_diff_path", "parent_diff", parent_diff)

        if base_dir:
            request.add_field("basedir", base_dir)

        if base_commit_id:
            request.add_field("base_commit_id", base_commit_id)

        return request
Example #28
0
    def test_post_unicode_data(self):
        """Testing the encoding of multipart form data with unicode and binary
        field data
        """
        konnichiwa = '\u3053\u3093\u306b\u3061\u306f'

        request = HttpRequest('/', 'POST')
        request.add_field('foo', konnichiwa)
        request.add_field('bar', konnichiwa.encode('utf-8'))
        request.add_field('baz', b'\xff')

        ctype, content = request.encode_multipart_formdata()

        fields = self._get_fields_as_dict(ctype, content)

        self.assertTrue('foo' in fields)
        self.assertEqual(fields['foo'], konnichiwa.encode('utf-8'))
        self.assertEqual(fields['bar'], konnichiwa.encode('utf-8'))
        self.assertEqual(fields['baz'], b'\xff')
Example #29
0
    def upload_diff(self, diff, parent_diff=None, base_dir=None, **kwargs):
        """Uploads a new diff.

        The diff and parent_diff arguments should be strings containing
        the diff output.
        """
        request = HttpRequest(self.url, method='POST', query_args=kwargs)
        request.add_file('path', 'diff', diff)

        if parent_diff:
            request.add_file('parent_diff_path', 'parent_diff', parent_diff)

        if base_dir:
            request.add_field("basedir", base_dir)

        return request
Example #30
0
    def get_self(self, **kwargs):
        """Generate an GET request for the resource list.

        This will return an HttpRequest to retrieve the list resource
        which this resource is a count for. Any query arguments used
        in the request for the count will still be present, only the
        'counts-only' argument will be removed
        """
        # TODO: Fix this. It is generating a new request
        # for a URL with 'counts-only' set to False, but
        # RB treats the  argument being set to any value
        # as true.
        kwargs.update({'counts_only': False})
        return HttpRequest(self._url, query_args=kwargs)
Example #31
0
    def finalize_commit_series(self, cumulative_diff, validation_info,
                               parent_diff=None):
        """Finalize a commit series.

        Args:
            cumulative_diff (bytes):
                The cumulative diff of the entire commit series.

            validation_info (unicode):
                The validation information returned by validatin the last
                commit in the series with the
                :py:class:`ValidateDiffCommitResource`.

            parent_diff (bytes, optional):
                An optional parent diff.

                This will be the same parent diff uploaded with each commit.

        Returns:
            DiffItemResource:
            The finalized diff resource.
        """
        if not isinstance(cumulative_diff, bytes):
            raise TypeError('cumulative_diff must be byte string, not %s'
                            % type(cumulative_diff))

        if parent_diff is not None and not isinstance(parent_diff, bytes):
            raise TypeError('parent_diff must be byte string, not %s'
                            % type(cumulative_diff))

        request = HttpRequest(self.links['self']['href'],
                              method='PUT')

        request.add_field('finalize_commit_series', True)
        request.add_file('cumulative_diff', 'cumulative_diff',
                         cumulative_diff)
        request.add_field('validation_info', validation_info)

        if parent_diff is not None:
            request.add_file('parent_diff', 'parent_diff', parent_diff)

        return request
Example #32
0
    def validate_diff(self, repository, diff, parent_diff=None,
                      base_dir=None, **kwargs):
        """Validates a diff.

        The diff and parent_diff arguments should be strings containing
        the diff output.
        """

        # TODO: This method should be unified with upload_diff() method of
        # DiffListResource, since they both perform the same operation.
        request = HttpRequest(self._url, method='POST', query_args=kwargs)
        request.add_field('repository', repository)
        request.add_file('path', 'diff', diff)

        if parent_diff:
            request.add_file('parent_diff_path', 'parent_diff', parent_diff)

        if base_dir:
            request.add_field('basedir', base_dir)

        return request
Example #33
0
    def upload_diff(self, diff, parent_diff=None, base_dir=None,
                    base_commit_id=None, **kwargs):
        """Uploads a new diff.

        The diff and parent_diff arguments should be strings containing
        the diff output.
        """
        # TODO: This method should be unified with validate_diff() method of
        # ValidateDiffResource, since they both perform the same operation.
        request = HttpRequest(self._url, method='POST', query_args=kwargs)
        request.add_file('path', 'diff', diff)

        if parent_diff:
            request.add_file('parent_diff_path', 'parent_diff', parent_diff)

        if base_dir:
            request.add_field("basedir", base_dir)

        if base_commit_id:
            request.add_field('base_commit_id', base_commit_id)

        return request
Example #34
0
    def test_post_unicode_data(self):
        """Testing the encoding of multipart form data with unicode and binary
        field data
        """
        konnichiwa = '\u3053\u3093\u306b\u3061\u306f'

        request = HttpRequest('/', 'POST')
        request.add_field('foo', konnichiwa)
        request.add_field('bar', konnichiwa.encode('utf-8'))
        request.add_field('baz', b'\xff')

        ctype, content = request.encode_multipart_formdata()

        fields = self._get_fields_as_dict(ctype, content)

        self.assertTrue('foo' in fields)
        self.assertEqual(fields['foo'], konnichiwa.encode('utf-8'))
        self.assertEqual(fields['bar'], konnichiwa.encode('utf-8'))
        self.assertEqual(fields['baz'], b'\xff')
Example #35
0
    def upload_diff(self, diff, parent_diff=None, base_dir=None, **kwargs):
        """Uploads a new diff.

        The diff and parent_diff arguments should be strings containing
        the diff output.
        """
        request = HttpRequest(self.url, method='POST', query_args=kwargs)
        request.add_file('path', 'diff', diff)

        if parent_diff:
            request.add_file('parent_diff_path', 'parent_diff', parent_diff)

        if base_dir:
            request.add_field("basedir", base_dir)

        return request
Example #36
0
class HttpRequestTests(TestCase):
    def setUp(self):
        self.request = HttpRequest('/')

    def test_default_values(self):
        """Testing the default values."""
        self.assertEqual(self.request.url, '/')
        self.assertEqual(self.request.method, 'GET')
        content_type, content = self.request.encode_multipart_formdata()
        self.assertTrue(content_type is None)
        self.assertTrue(content is None)

    def test_post_form_data(self):
        """Testing the multipart form data generation."""
        request = HttpRequest('/', 'POST')
        request.add_field('foo', 'bar')
        request.add_field('bar', 42)
        request.add_field('err', 'must-be-deleted')
        request.add_field('name', 'somestring')
        request.del_field('err')

        ctype, content = request.encode_multipart_formdata()
        m = re.match(b'^multipart/form-data; boundary=(.*)$', ctype)
        self.assertFalse(m is None)
        fields = [l.strip() for l in content.split(b'--' + m.group(1))][1:-1]

        d = {}

        disposition_re = re.compile(
            b'Content-Disposition: form-data; name="(.*?)"$')

        for f in fields:
            lst = f.split(b'\r\n\r\n')
            self.assertEqual(len(lst), 2)
            k, v = lst

            m = disposition_re.match(k)
            self.assertFalse(m is None)
            d[m.group(1)] = v

        self.assertEqual(d, {
            b'foo': b'bar',
            b'bar': b'42',
            b'name': b'somestring'
        })
Example #37
0
    def get_patch(self, **kwargs):
        """Retrieve the actual diff file contents.

        Args:
            **kwargs (dict):
                Query args to pass to
                :py:meth:`~rbtools.api.request.HttpRequest.__init__`.

        Returns:
            ItemResource:
            A resource payload whose :py:attr:`~ItemResource.data` attribute is
            the requested patch.
        """
        return HttpRequest(self._url,
                           query_args=kwargs,
                           headers={
                               'Accept': 'text/x-patch',
                           })
Example #38
0
    def _get_template_request(self, url_template, values={}, **kwargs):
        """Generate an HttpRequest from a uri-template.

        This will replace each '{variable}' in the template with the
        value from kwargs['variable'], or if it does not exist, the
        value from values['variable']. The resulting url is used to
        create an HttpRequest.
        """
        def get_template_value(m):
            try:
                return str(
                    kwargs.pop(m.group('key'), None) or values[m.group('key')])
            except KeyError:
                raise ValueError('Template was not provided a value for "%s"' %
                                 m.group('key'))

        url = self._TEMPLATE_PARAM_RE.sub(get_template_value, url_template)
        return HttpRequest(url, query_args=kwargs)
Example #39
0
    def upload_screenshot(self, filename, content, caption=None, **kwargs):
        """Uploads a new screenshot.

        The content argument should contain the body of the screenshot
        to be uploaded, in string format.
        """
        request = HttpRequest(self._url, method='POST', query_args=kwargs)
        request.add_file('path', filename, content)

        if caption:
            request.add_field('caption', caption)

        return request
Example #40
0
    def upload_attachment(self,
                          filename,
                          content,
                          caption=None,
                          attachment_history=None,
                          **kwargs):
        """Uploads a new attachment.

        The content argument should contain the body of the file to be
        uploaded, in string format.
        """
        request = HttpRequest(self._url, method='POST', query_args=kwargs)
        request.add_file('path', filename, content)

        if caption:
            request.add_field('caption', caption)

        if attachment_history:
            request.add_field('attachment_history', attachment_history)

        return request
Example #41
0
class HttpRequestTests(TestCase):
    def setUp(self):
        self.request = HttpRequest('/')

    def test_default_values(self):
        """Testing the default values."""
        self.assertEqual(self.request.url, '/')
        self.assertEqual(self.request.method, 'GET')
        content_type, content = self.request.encode_multipart_formdata()
        self.assertTrue(content_type is None)
        self.assertTrue(content is None)

    def test_post_form_data(self):
        """Testing the multipart form data generation."""
        request = HttpRequest('/', 'POST')
        request.add_field('foo', 'bar')
        request.add_field('bar', 42)
        request.add_field('err', 'must-be-deleted')
        request.add_field('name', 'somestring')
        request.del_field('err')

        ctype, content = request.encode_multipart_formdata()
        m = re.match(b'^multipart/form-data; boundary=(.*)$', ctype)
        self.assertFalse(m is None)
        fields = [l.strip() for l in content.split(b'--' + m.group(1))][1:-1]

        d = {}

        disposition_re = re.compile(
            b'Content-Disposition: form-data; name="(.*?)"$')

        for f in fields:
            lst = f.split(b'\r\n\r\n')
            self.assertEqual(len(lst), 2)
            k, v = lst

            m = disposition_re.match(k)
            self.assertFalse(m is None)
            d[m.group(1)] = v

        self.assertEqual(
            d, {b'foo': b'bar', b'bar': b'42', b'name': b'somestring'})
Example #42
0
    def get_url(self, url, *args, **kwargs):
        if not url.endswith('/'):
            url = url + '/'

        return self._execute_request(HttpRequest(url, query_args=kwargs))
Example #43
0
    def validate_commit(self, repository, diff, commit_id, parent_id,
                        parent_diff=None, base_commit_id=None,
                        validation_info=None, **kwargs):
        """Validate the diff for a commit.

        Args:
            repository (unicode):
                The name of the repository.

            diff (bytes):
                The contents of the diff to validate.

            commit_id (unicode):
                The ID of the commit being validated.

            parent_id (unicode):
                The ID of the parent commit.

            parent_diff (bytes, optional):
                The contents of the parent diff.

            base_commit_id (unicode, optional):
                The base commit ID.

            validation_info (unicode, optional):
                Validation information from a previous call to this resource.

            **kwargs (dict):
                Keyword arguments used to build the querystring.

        Returns:
            ValidateDiffCommitResource:
            The validation result.
        """
        request = HttpRequest(self._url, method=b'POST', query_args=kwargs)
        request.add_file('diff', 'diff', diff)
        request.add_field('repository', repository)
        request.add_field('commit_id', commit_id)
        request.add_field('parent_id', parent_id)

        if parent_diff:
            request.add_file('parent_diff', 'parent_diff', parent_diff)

        if base_commit_id:
            request.add_field('base_commit_id', base_commit_id)

        if validation_info:
            request.add_field('validation_info', validation_info)

        return request
Example #44
0
 def get_root(self):
     return self._execute_request(HttpRequest(self.server.url))
Example #45
0
 def get_diff_data(self, **kwargs):
     """Retrieves the actual raw diff data for the file."""
     request = HttpRequest(self.url, query_args=kwargs)
     request.headers['Accept'] = \
         'application/vnd.reviewboard.org.diff.data+json'
     return request
Example #46
0
    def upload_commit(self, validation_info, diff, commit_id, parent_id,
                      author_name, author_email, author_date, commit_message,
                      committer_name=None, committer_email=None,
                      committer_date=None, parent_diff=None, **kwargs):
        """Upload a commit.

        Args:
            validation_info (unicode):
                The validation info, or ``None`` if this is the first commit in
                a series.

            diff (bytes):
                The diff contents.

            commit_id (unicode):
                The ID of the commit being uploaded.

            parent_id (unicode):
                The ID of the parent commit.

            author_name (unicode):
                The name of the author.

            author_email (unicode):
                The e-mail address of the author.

            author_date (unicode):
                The date and time the commit was authored in ISO 8601 format.

            committer_name (unicode, optional):
                The name of the committer (if applicable).

            committer_email (unicode, optional):
                The e-mail address of the committer (if applicable).

            committer_date (unicode, optional):
                The date and time the commit was committed in ISO 8601 format
                (if applicable).

            parent_diff (bytes, optional):
                The contents of the parent diff.

            **kwargs (dict):
                Keyword argument used to build the querystring for the request
                URL.

        Returns:
            DraftDiffCommitItemResource:
            The created resource.

        Raises:
            rbtools.api.errors.APIError:
                An error occurred while uploading the commit.
        """
        request = HttpRequest(self._url, method=b'POST', query_args=kwargs)

        request.add_file('diff', 'diff', diff)
        request.add_field('commit_id', commit_id)
        request.add_field('parent_id', parent_id)
        request.add_field('commit_message', commit_message)
        request.add_field('author_name', author_name)
        request.add_field('author_email', author_email)
        request.add_field('author_date', author_date)

        if validation_info:
            request.add_field('validation_info', validation_info)

        if committer_name and committer_email and committer_date:
            request.add_field('committer_name', committer_name)
            request.add_field('committer_email', committer_email)
            request.add_field('committer_date', committer_date)
        elif committer_name or committer_email or committer_name:
            logging.warning(
                'Either all or none of committer_name, committer_email, and '
                'committer_date must be provided to upload_commit. None of '
                'these fields will be submitted.'
            )

        if parent_diff:
            request.add_file('parent_diff', 'parent_diff', parent_diff)

        return request
Example #47
0
 def get_patch(self, **kwargs):
     """Retrieves the actual diff file contents."""
     request = HttpRequest(self.url, query_args=kwargs)
     request.headers['Accept'] = 'text/x-patch'
     return request
Example #48
0
    def test_post_form_data(self):
        """Testing the multipart form data generation."""
        request = HttpRequest('/', 'POST')
        request.add_field('foo', 'bar')
        request.add_field('bar', 42)
        request.add_field('err', 'must-be-deleted')
        request.add_field('name', 'somestring')
        request.del_field('err')

        ctype, content = request.encode_multipart_formdata()

        d = self._get_fields_as_dict(ctype, content)

        self.assertEqual(
            d, {b'foo': b'bar', b'bar': b'42', b'name': b'somestring'})
Example #49
0
 def setUp(self):
     self.request = HttpRequest('/')
Example #50
0
    def test_post_form_data(self):
        """Test the multipart form data generation."""
        request = HttpRequest('/', 'POST')
        request.add_field('foo', 'bar')
        request.add_field('bar', 42)
        request.add_field('err', 'must-be-deleted')
        request.add_field('name', 'somestring')
        request.del_field('err')

        ctype, content = request.encode_multipart_formdata()
        m = re.match('^multipart/form-data; boundary=(.*)$', ctype)
        self.assertFalse(m is None)
        fields = [l.strip() for l in content.split('--' + m.group(1))][1:-1]

        d = {}

        for f in fields:
            lst = f.split('\r\n\r\n')
            self.assertEquals(len(lst), 2)
            k, v = lst

            m = re.match('Content-Disposition: form-data; name="(.*?)"$', k)
            self.assertFalse(m is None)
            d[m.group(1)] = v

        self.assertEquals(d, {'foo': 'bar', 'bar': '42', 'name': 'somestring'})
Example #51
0
class HttpRequestTests(TestCase):
    def setUp(self):
        self.request = HttpRequest('/')

    def test_default_values(self):
        """Testing the default values."""
        self.assertEqual(self.request.url, '/')
        self.assertEqual(self.request.method, 'GET')
        content_type, content = self.request.encode_multipart_formdata()
        self.assertTrue(content_type is None)
        self.assertTrue(content is None)

    def _get_fields_as_dict(self, ctype, content):
        """Extract the fields of a HTTP multipart request as a dictionary."""
        m = re.match(b'^multipart/form-data; boundary=(.*)$', ctype)
        self.assertFalse(m is None)
        fields = [l.strip() for l in content.split(b'--' + m.group(1))][1:-1]

        d = {}

        disposition_re = re.compile(
            b'Content-Disposition: form-data; name="(.*?)"$')

        for f in fields:
            lst = f.split(b'\r\n\r\n')
            self.assertEqual(len(lst), 2)
            k, v = lst

            m = disposition_re.match(k)
            self.assertFalse(m is None)
            d[m.group(1)] = v

        return d

    def test_post_form_data(self):
        """Testing the multipart form data generation."""
        request = HttpRequest('/', 'POST')
        request.add_field('foo', 'bar')
        request.add_field('bar', 42)
        request.add_field('err', 'must-be-deleted')
        request.add_field('name', 'somestring')
        request.del_field('err')

        ctype, content = request.encode_multipart_formdata()

        d = self._get_fields_as_dict(ctype, content)

        self.assertEqual(
            d, {b'foo': b'bar', b'bar': b'42', b'name': b'somestring'})

    def test_post_unicode_data(self):
        """Testing the encoding of multipart form data with unicode and binary
        field data
        """
        konnichiwa = '\u3053\u3093\u306b\u3061\u306f'

        request = HttpRequest('/', 'POST')
        request.add_field('foo', konnichiwa)
        request.add_field('bar', konnichiwa.encode('utf-8'))
        request.add_field('baz', b'\xff')

        ctype, content = request.encode_multipart_formdata()

        fields = self._get_fields_as_dict(ctype, content)

        self.assertTrue('foo' in fields)
        self.assertEqual(fields['foo'], konnichiwa.encode('utf-8'))
        self.assertEqual(fields['bar'], konnichiwa.encode('utf-8'))
        self.assertEqual(fields['baz'], b'\xff')