Synnefo » ./kamaki

# Copyright 2013 GRNET S.A. All rights reserved.

#

# Redistribution and use in source and binary forms, with or

# without modification, are permitted provided that the following

# conditions are met:

#

#   1. Redistributions of source code must retain the above

#      copyright notice, this list of conditions and the following

#      disclaimer.

#

#   2. Redistributions in binary form must reproduce the above

#      copyright notice, this list of conditions and the following

#      disclaimer in the documentation and/or other materials

#      provided with the distribution.

#

# THIS SOFTWARE IS PROVIDED BY GRNET S.A. ``AS IS'' AND ANY EXPRESS

# OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED

# WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR

# PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL GRNET S.A OR

# CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,

# SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT

# LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF

# USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED

# AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT

# LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN

# ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE

# POSSIBILITY OF SUCH DAMAGE.

#

# The views and conclusions contained in the software and

# documentation are those of the authors and should not be

# interpreted as representing official policies, either expressed

# or implied, of GRNET S.A.

from unittest import TestCase

from mock import patch, call

from tempfile import NamedTemporaryFile

from os import urandom

from itertools import product

from random import randint

try:

    from collections import OrderedDict

except ImportError:

    from kamaki.clients.utils.ordereddict import OrderedDict

from kamaki.clients import pithos, ClientError

rest_pkg = 'kamaki.clients.pithos.rest_api.PithosRestClient'

pithos_pkg = 'kamaki.clients.pithos.PithosClient'

user_id = 'ac0un7-1d-5tr1ng'

obj = 'obj3c7N4m3'

account_info = {

    'content-language': 'en-us',

    'content-type': 'text/html; charset=utf-8',

    'date': 'Wed, 06 Mar 2013 13:25:51 GMT',

    'last-modified': 'Mon, 04 Mar 2013 18:22:31 GMT',

    'server': 'gunicorn/0.14.5',

    'vary': 'Accept-Language',

    'x-account-bytes-used': '751615526',

    'x-account-container-count': 7,

    'x-account-policy-quota': 53687091200,

    'x-account-policy-versioning': 'auto'}

container_info = {

    'content-language': 'en-us',

    'content-type': 'text/html; charset=utf-8',

    'date': 'Wed, 06 Mar 2013 15:11:05 GMT',

    'last-modified': 'Wed, 27 Feb 2013 15:56:13 GMT',

    'server': 'gunicorn/0.14.5',

    'vary': 'Accept-Language',

    'x-container-block-hash': 'sha256',

    'x-container-block-size': 4194304,

    'x-container-bytes-used': 309528938,

    'x-container-object-count': 14,

    'x-container-object-meta': '',

    'x-container-policy-quota': 53687091200,

    'x-container-policy-versioning': 'auto'}

object_info = {

    'content-language': 'en-us',

    'content-length': 254965,

    'content-type': 'application/octet-stream',

    'date': 'Thu, 07 Mar 2013 13:27:43 GMT',

    'etag': '',

    'last-modified': 'Mon, 04 Mar 2013 18:22:31 GMT',

    'server': 'gunicorn/0.14.5',

    'vary': 'Accept-Language',

    'x-object-hash': 'obj3c7h45h1s0bj3c7h45h411r34dY',

    'x-object-uuid': 'd0c747ca-34bd-49e0-8e98-1d07d8b0cbc7',

    'x-object-version': '525996',

    'x-object-version-timestamp': 'Mon, 04 Mar 2013 18:22:31 GMT',

    'x-object-meta-k1': 'v1',

    'x-object-meta-k2': 'v2'}

container_list = [

    dict(

        count=2,

        last_modified="2013-02-27T11:56:09.893033+00:00",

        bytes=677076979,

        name="pithos",

        x_container_policy=dict(quota="21474836480", versioning="auto")),

    dict(

        count=0,

        last_modified="2012-10-23T12:25:17.229187+00:00",

        bytes=0,

        name="trash",

        x_container_policy=dict(quota="21474836480", versioning="auto"))]

object_list = [

    dict(hash="",

        name="The_Secret_Garden.zip",

        x_object_public="/public/wdp9p",

        bytes=203304947,

        x_object_version_timestamp="1360237915.7027509",

        x_object_uuid="s0m3uu1df0r0bj0n3",

        last_modified="2013-02-07T11:51:55.702751+00:00",

        content_type="application/octet-stream",

        x_object_hash="0afdf29f71cd53126225c3f54ca",

        x_object_version=17737,

        x_object_modified_by=user_id),

    dict(hash="",

        name="The_Revealed_Garden.zip",

        x_object_public="/public/wpd7p",

        bytes=20330947,

        x_object_version_timestamp="13602915.7027509",

        x_object_uuid="s0m3uu1df0r0bj70w",

        last_modified="2013-02-07T11:51:55.702751+00:00",

        content_type="application/octet-stream",

        x_object_hash="0afdf29f71cd53126225c3f54ca",

        x_object_version=17737,

        x_object_modified_by=user_id)]

object_hashmap = dict(

    block_hash="sha256", block_size=4194304, bytes=33554432,

    hashes=[

        "4988438cc1c0292c085d289649b28cf547ba3db71c6efaac9f2df7e193d4d0af",

        "b214244aa56df7d1df7c6cac066e7cef268d9c2beb4dcf7ce68af667b0626f91",

        "17f365f25e0682565ded30576066bb13377a3d306967e4d74e06bb6bbc20f75f",

        "2524ae208932669fff89adf8a2fc0df3b67736ca0d3aadce7a2ce640f142af37",

        "5d807a2129d2fcd3c221c3da418ed52af3fc48d0817b62e0bb437acffccd3514",

        "609de22ce842d997f645fc49d5f14e0e3766dd51a6cbe66383b2bab82c8dfcd0",

        "3102851ac168c78be70e35ff5178c7b1ebebd589e5106d565ca1094d1ca8ff59",

        "bfe306dd24e92a8d85caf7055643f250fd319e8c4cdd4755ddabbf3ff97e83c7"])

sharers = [

    dict(last_modified="2013-01-29T16:50:06.084674+00:00", name="0b1a-82d5"),

    dict(last_modified="2013-01-29T16:50:06.084674+00:00", name="0b2a-f2d5"),

    dict(last_modified="2013-01-29T16:50:06.084674+00:00", name="2b1a-82d6")]

class FR(object):

    """FR stands for Fake Response"""

    json = dict()

    headers = dict()

    content = json

    status = None

    status_code = 200

class PithosRestClient(TestCase):

    def setUp(self):

        self.url = 'https://www.example.com/pithos'

        self.token = 'p17h0570k3n'

        self.client = pithos.PithosRestClient(self.url, self.token)

        self.client.account = user_id

        self.client.container = 'c0nt@1n3r_i'

    def tearDown(self):

        FR.headers = dict()

        FR.json = dict()

        FR.content = FR.json

    @patch('%s.set_param' % rest_pkg)

    @patch('%s.set_header' % rest_pkg)

    @patch('%s.head' % rest_pkg, return_value=FR())

    def test_account_head(self, head, SH, SP):

        for params in product(

                (None, '50m3-d473'),

                (None, '50m3-07h3r-d473'),

                (None, 'y37-4n7h3r-d473'),

                ((), ('someval',), ('v1', 'v2',)),

                (dict(), dict(success=200), dict(k='v', v='k'))):

            args, kwargs = params[-2], params[-1]

            params = params[:-2]

            self.client.account_head(*(params + args), **kwargs)

            unt = params[0]

            self.assertEqual(SP.mock_calls[-1], call('until', unt, iff=unt))

            IMS, IUS = params[1], params[2]

            self.assertEqual(SH.mock_calls[-2:], [

                call('If-Modified-Since', IMS),

                call('If-Unmodified-Since', IUS)])

            self.assertEqual(head.mock_calls[-1], call(

                '/%s' % self.client.account,

                *args,

                success=kwargs.pop('success', 204),

                **kwargs))

    @patch('%s.set_param' % rest_pkg)

    @patch('%s.set_header' % rest_pkg)

    @patch('%s.get' % rest_pkg, return_value=FR())

    def test_account_get(self, get, SH, SP):

        keys = ('limit', 'marker', 'format', 'shared', 'public', 'until')

        for params in product(

                (None, 42),

                (None, 'X'),

                ('json', 'xml'),

                (False, True),

                (False, True),

                (None, '50m3-d473'),

                (None, '50m3-07h3r-d473'),

                (None, 'y37-4n7h3r-d473'),

                ((), ('someval',), ('v1', 'v2',)),

                (dict(), dict(success=200), dict(k='v', v='k'))):

            args, kwargs = params[-2], params[-1]

            params = params[:-2]

            self.client.account_get(*(params + args), **kwargs)

            self.assertEqual(SP.mock_calls[-6:],

                [call(keys[i], iff=X) if (i in (3, 4)) else call(

                    keys[i], X, iff=X) for i, X in enumerate(params[:6])])

            IMS, IUS = params[6], params[7]

            self.assertEqual(SH.mock_calls[-2:], [

                call('If-Modified-Since', IMS),

                call('If-Unmodified-Since', IUS)])

            self.assertEqual(get.mock_calls[-1], call(

                '/%s' % self.client.account,

                *args,

                success=kwargs.pop('success', (200, 204)),

                **kwargs))

    @patch('%s.set_param' % rest_pkg)

    @patch('%s.set_header' % rest_pkg)

    @patch('%s.post' % rest_pkg, return_value=FR())

    def test_account_post(self, post, SH, SP):

        #keys = ('update', 'groups', 'metadata', 'quota', 'versioning')

        for pm in product(

                (True, False),

                ({}, dict(g=['u1', 'u2']), dict(g1=[], g2=['u1', 'u2'])),

                (None, dict(k1='v1', k2='v2', k3='v2'), dict(k='v')),

                (None, 42),

                (None, 'v3r510n1ng'),

                ((), ('someval',), ('v1', 'v2',)),

                (dict(), dict(success=200), dict(k='v', v='k'))):

            args, kwargs = pm[-2:]

            pm = pm[:-2]

            self.client.account_post(*(pm + args), **kwargs)

            upd = pm[0]

            self.assertEqual(SP.mock_calls[-1], call('update', '', iff=upd))

            expected = []

            if pm[1]:

                expected += [

                call('X-Account-Group-%s' % k, v) for k, v in pm[1].items()]

            if pm[2]:

                expected = [

                call('X-Account-Meta-%s' % k, v) for k, v in pm[2].items()]

            expected = [

                call('X-Account-Policy-Quota', pm[3]),

                call('X-Account-Policy-Versioning', pm[4])]

            self.assertEqual(SH.mock_calls[- len(expected):], expected)

            self.assertEqual(post.mock_calls[-1], call(

                '/%s' % self.client.account,

                *args,

                success=kwargs.pop('success', 202),

                **kwargs))

    @patch('%s.set_param' % rest_pkg)

    @patch('%s.set_header' % rest_pkg)

    @patch('%s.head' % rest_pkg, return_value=FR())

    def test_container_head(self, head, SH, SP):

        for pm in product(

                (None, '4-d473'),

                (None, '47h3r-d473'),

                (None, 'y37-4n47h3r'),

                ((), ('someval',)),

                (dict(), dict(success=200), dict(k='v', v='k'))):

            args, kwargs = pm[-2:]

            pm = pm[:-2]

            self.client.container_head(*(pm + args), **kwargs)

            unt, ims, ius = pm[0:3]

            self.assertEqual(SP.mock_calls[-1], call('until', unt, iff=unt))

            self.assertEqual(SH.mock_calls[-2:], [

                call('If-Modified-Since', ims),

                call('If-Unmodified-Since', ius)])

            self.assertEqual(head.mock_calls[-1], call(

                '/%s/%s' % (self.client.account, self.client.container),

                *args,

                success=kwargs.pop('success', 204),

                **kwargs))

    @patch('%s.set_param' % rest_pkg)

    @patch('%s.set_header' % rest_pkg)

    @patch('%s.get' % rest_pkg, return_value=FR())

    def test_container_get(self, get, SH, SP):

        for pm in product(

                (None, 42),

                (None, 'X'),

                (None, 'some/prefix'),

                (None, 'delimiter'),

                (None, '/some/path'),

                ('json', 'some-format'),

                ([], ['k1', 'k2', 'k3']),

                (False, True),

                (False, True),

                (None, 'unt1l-d473'),

                (None, 'y37-4n47h3r'),

                (None, '4n47h3r-d473'),

                ((), ('someval',)),

                (dict(), dict(success=400), dict(k='v', v='k'))):

            args, kwargs = pm[-2:]

            pm = pm[:-2]

            self.client.container_get(*(pm + args), **kwargs)

            lmt, mrk, prfx, dlm, path, frmt, meta, shr, pbl, unt = pm[:-2]

            exp = [call('limit', lmt, iff=lmt), call('marker', mrk, iff=mrk)]

            exp += [call('path', path)] if path else [

                call('prefix', prfx, iff=prfx),

                call('delimiter', dlm, iff=dlm)]

            exp += [

                call('format', frmt, iff=frmt),

                call('shared', iff=shr),

                call('public', iff=pbl)]

            if meta:

                exp += [call('meta', ','.join(meta))]

            exp += [call('until', unt, iff=unt)]

            self.assertEqual(SP.mock_calls[- len(exp):], exp)

            ims, ius = pm[-2:]

            self.assertEqual(SH.mock_calls[-2:], [

                call('If-Modified-Since', ims),

                call('If-Unmodified-Since', ius)])

            self.assertEqual(get.mock_calls[-1], call(

                '/%s/%s' % (self.client.account, self.client.container),

                *args,

                success=kwargs.pop('success', 200),

                **kwargs))

    @patch('%s.set_header' % rest_pkg)

    @patch('%s.put' % rest_pkg, return_value=FR())

    def test_container_put(self, put, SH):

        for pm in product(

                (None, 42),

                (None, 'v3r51on1ng'),

                (dict(), dict(k1='v2'), dict(k2='v2', k3='v3')),

                ((), ('someval',)),

                (dict(), dict(success=400), dict(k='v', v='k'))):

            args, kwargs = pm[-2:]

            pm = pm[:-2]

            self.client.container_put(*(pm + args), **kwargs)

            quota, versioning, metas = pm[-3:]

            exp = [

                call('X-Container-Policy-Quota', quota),

                call('X-Container-Policy-Versioning', versioning)] + [

                call('X-Container-Meta-%s' % k, v) for k, v in metas.items()]

            self.assertEqual(SH.mock_calls[- len(exp):], exp)

            self.assertEqual(put.mock_calls[-1], call(

                '/%s/%s' % (self.client.account, self.client.container),

                *args,

                success=kwargs.pop('success', (201, 202)),

                **kwargs))

    @patch('%s.set_param' % rest_pkg)

    @patch('%s.set_header' % rest_pkg)

    @patch('%s.post' % rest_pkg, return_value=FR())

    def test_container_post(self, post, SH, SP):

        for pm in product(

                (True, False),

                ('json', 'some-format'),

                (None, 'quota'),

                (None, 'v3r51on1ng'),

                (dict(), dict(k1='v2'), dict(k2='v2', k3='v3')),

                (None, 'content-type'),

                (None, 42),

                (None, 'transfer-encoding'),

                ((), ('someval',)),

                (dict(), dict(success=400), dict(k='v', v='k'))):

            args, kwargs = pm[-2:]

            pm = pm[:-2]

            self.client.container_post(*(pm + args), **kwargs)

            upd, frmt = pm[:2]

            self.assertEqual(SP.mock_calls[-2:], [

                call('update', '', iff=upd),

                call('format', frmt, iff=frmt)])

            qta, vrs, metas, ctype, clen, trenc = pm[2:]

            prfx = 'X-Container-Meta-'

            exp = [

                call('X-Container-Policy-Quota', qta),

                call('X-Container-Policy-Versioning', vrs)] + [

                call('%s%s' % (prfx, k), v) for k, v in metas.items()] + [

                call('Content-Type', ctype),

                call('Content-Length', clen),

                call('Transfer-Encoding', trenc)]

            self.assertEqual(SH.mock_calls[- len(exp):], exp)

            ims, ius = pm[-2:]

            self.assertEqual(post.mock_calls[-1], call(

                '/%s/%s' % (self.client.account, self.client.container),

                *args,

                success=kwargs.pop('success', 202),

                **kwargs))

    @patch('%s.set_param' % rest_pkg)

    @patch('%s.delete' % rest_pkg, return_value=FR())

    def test_container_delete(self, delete, SP):

        for pm in product(

                (None, 'd473'),

                (None, 'd3l1m'),

                ((), ('someval',)),

                (dict(), dict(success=400), dict(k='v', v='k'))):

            args, kwargs = pm[-2:]

            pm = pm[:-2]

            self.client.container_delete(*(pm + args), **kwargs)

            unt, dlm = pm[-2:]

            self.assertEqual(SP.mock_calls[-2:], [

                call('until', unt, iff=unt),

                call('delimiter', dlm, iff=dlm)])

            self.assertEqual(delete.mock_calls[-1], call(

                '/%s/%s' % (self.client.account, self.client.container),

                *args,

                success=kwargs.pop('success', 204),

                **kwargs))

    @patch('%s.set_param' % rest_pkg)

    @patch('%s.set_header' % rest_pkg)

    @patch('%s.head' % rest_pkg, return_value=FR())

    def test_object_head(self, head, SH, SP):

        for pm in product(

                (None, 'v3r510n'),

                (None, '1f-374g'),

                (None, '1f-n0-74g'),

                (None, '1f-m0d-51nc3'),

                (None, '1f-unm0d-51nc3'),

                ((), ('someval',)),

                (dict(), dict(success=400), dict(k='v', v='k'))):

            args, kwargs = pm[-2:]

            pm = pm[:-2]

            self.client.object_head(obj, *(pm + args), **kwargs)

            vrs, etag, netag, ims, ius = pm[:5]

            self.assertEqual(

                SP.mock_calls[-1],

                call('version', vrs, iff=vrs))

            self.assertEqual(SH.mock_calls[-4:], [

                call('If-Match', etag),

                call('If-None-Match', netag),

                call('If-Modified-Since', ims),

                call('If-Unmodified-Since', ius)])

            acc, cont = self.client.account, self.client.container

            self.assertEqual(head.mock_calls[-1], call(

                '/%s/%s/%s' % (acc, cont, obj),

                *args,

                success=kwargs.pop('success', 200),

                **kwargs))

    @patch('%s.set_param' % rest_pkg)

    @patch('%s.set_header' % rest_pkg)

    @patch('%s.get' % rest_pkg, return_value=FR())

    def test_object_get(self, get, SH, SP):

        for pm in product(

                ('json', 'f0rm47'),

                (False, True),

                (None, 'v3r510n'),

                (None, 'range=74-63'),

                (False, True),

                (None, '3746'),

                (None, 'non-3746'),

                (None, '1f-m0d'),

                (None, '1f-unm0d'),

                ((), ('someval',)),

                (dict(), dict(success=400), dict(k='v', v='k'))):

            args, kwargs = pm[-2:]

            pm = pm[:-2]

            self.client.object_get(obj, *(pm + args), **kwargs)

            format, hashmap, version = pm[:3]

            self.assertEqual(SP.mock_calls[-3:], [

                call('format', format, iff=format),

                call('hashmap', hashmap, iff=hashmap),

                call('version', version, iff=version)])

            rng, ifrng, im, inm, ims, ius = pm[-6:]

            self.assertEqual(SH.mock_calls[-6:], [

                call('Range', rng),

                call('If-Range', '', ifrng and rng),

                call('If-Match', im),

                call('If-None-Match', inm),

                call('If-Modified-Since', ims),

                call('If-Unmodified-Since', ius)])

            acc, cont = self.client.account, self.client.container

            self.assertEqual(get.mock_calls[-1], call(

                '/%s/%s/%s' % (acc, cont, obj),

                *args,

                success=kwargs.pop('success', 200),

                **kwargs))

    @patch('%s.set_param' % rest_pkg)

    @patch('%s.set_header' % rest_pkg)

    @patch('%s.put' % rest_pkg, return_value=FR())

    def test_object_put(self, put, SH, SP):

        for pm in product(

                ('json', 'f0rm47'),

                (False, True),

                (None, 'delim',),

                (dict(), dict(read=['u1', 'g2'], write=['u1'])),

                (False, True),

                (dict(), dict(k2='v2', k3='v3')),

                ((), ('someval',)),

                (dict(), dict(success=400), dict(k='v', v='k'))):

            args, kwargs = pm[-2:]

            pm = pm[:-2]

            terms = [None] * 13

            for i in range(len(terms)):

                if randint(0, 2):

                    terms[i] = 'val_%s' % randint(13, 1024)

            self.client.object_put(

                obj,

                *(pm[:3] + tuple(terms) + pm[3:] + args),

                **kwargs)

            format, hashmap, delimiter = pm[:3]

            self.assertEqual(SP.mock_calls[-3:], [

                call('format', format, iff=format),

                call('hashmap', hashmap, iff=hashmap),

                call('delimiter', delimiter, iff=delimiter)])

            (

                im, inm, etag, clen, ctype, trenc,

                cp, mv, srcacc, srcvrs, conenc, condis, mnf) = terms

            perms, public, metas = pm[3:]

            exp = [

                call('If-Match', im),

                call('If-None-Match', inm),

                call('ETag', etag),

                call('Content-Length', clen),

                call('Content-Type', ctype),

                call('Transfer-Encoding', trenc),

                call('X-Copy-From', cp),

                call('X-Move-From', mv),

                call('X-Source-Account', srcacc),

                call('X-Source-Version', srcvrs),

                call('Content-Encoding', conenc),

                call('Content-Disposition', condis),

                call('X-Object-Manifest', mnf)]

            if perms:

                perm_str = ''

                for ptype, pval in perms.items():

                    if pval:

                        perm_str += ';' if perm_str else ''

                        perm_str += '%s=%s' % (ptype, ','.join(pval))

                exp += [call('X-Object-Sharing', perm_str)]

            exp += [call('X-Object-Public', public, public is not None)]

            for k, v in metas.items():

                exp += [call('X-Object-Meta-%s' % k, v)]

            self.assertEqual(SH.mock_calls[- len(exp):], exp)

            acc, cont = self.client.account, self.client.container

            self.assertEqual(put.mock_calls[-1], call(

                '/%s/%s/%s' % (acc, cont, obj),

                *args,

                success=kwargs.pop('success', 201),

                **kwargs))

    @patch('%s.set_param' % rest_pkg)

    @patch('%s.set_header' % rest_pkg)

    @patch('%s.copy' % rest_pkg, return_value=FR())

    def test_object_copy(self, copy, SH, SP):

        dest = 'dest1n4710n'

        for pm in product(

                ('json', 'f0rm47'),

                (False, True),

                (None, 'ifmatch'),

                (None, 'ifnonematch'),

                (None, 'destinationaccount'),

                (None, 'content-type'),

                (None, 'content-encoding'),

                (None, 'content-disp'),

                (None, 'source-version'),

                (dict(), dict(read=['u1', 'g2'], write=['u1'])),

                (False, True),

                (dict(), dict(k2='v2', k3='v3')),

                ((), ('someval',)),

                (dict(), dict(success=400), dict(k='v', v='k'))):

            args, kwargs = pm[-2:]

            pm = pm[:-2]

            self.client.object_copy(obj, dest, *(pm + args), **kwargs)

            format, ict = pm[:2]

            self.assertEqual(SP.mock_calls[-2:], [

                call('format', format, iff=format),

                call('ignore_content_type', iff=ict)])

            im, inm, da, ct, ce, cd, sv, perms, public, metas = pm[2:]

            exp = [call('If-Match', im),

                call('If-None-Match', inm),

                call('Destination', dest),

                call('Destination-Account', da),

                call('Content-Type', ct),

                call('Content-Encoding', ce),

                call('Content-Disposition', cd),

                call('X-Source-Version', sv)]

            if perms:

                perm_str = ''

                for ptype, pval in perms.items():

                    if pval:

                        perm_str += ';' if perm_str else ''

                        perm_str += '%s=%s' % (ptype, ','.join(pval))

                exp += [call('X-Object-Sharing', perm_str)]

            exp += [call('X-Object-Public', public, public is not None)]

            for k, v in metas.items():

                exp += [call('X-Object-Meta-%s' % k, v)]

            self.assertEqual(SH.mock_calls[- len(exp):], exp)

            acc, cont = self.client.account, self.client.container

            self.assertEqual(copy.mock_calls[-1], call(

                '/%s/%s/%s' % (acc, cont, obj),

                *args,

                success=kwargs.pop('success', 201),

                **kwargs))

    @patch('%s.set_param' % rest_pkg)

    @patch('%s.set_header' % rest_pkg)

    @patch('%s.move' % rest_pkg, return_value=FR())

    def test_object_move(self, move, SH, SP):

        for pm in product(

                ('json', 'f0rm47'),

                (False, True),

                (None, 'ifmatch'),

                (None, 'ifnonematch'),

                (None, 'destination'),

                (None, 'destinationaccount'),

                (None, 'content-type'),

                (None, 'content-encoding'),

                (None, 'content-disp'),

                (dict(), dict(read=['u1', 'g2'], write=['u1'])),

                (False, True),

                (dict(), dict(k2='v2', k3='v3')),

                ((), ('someval',)),

                (dict(), dict(success=400), dict(k='v', v='k'))):

            args, kwargs = pm[-2:]

            pm = pm[:-2]

            self.client.object_move(obj, *(pm + args), **kwargs)

            format, ict = pm[:2]

            self.assertEqual(SP.mock_calls[-2:], [

                call('format', format, iff=format),

                call('ignore_content_type', iff=ict)])

            im, inm, d, da, ct, ce, cd, perms, public, metas = pm[2:]

            exp = [call('If-Match', im),

                call('If-None-Match', inm),

                call('Destination', d),

                call('Destination-Account', da),

                call('Content-Type', ct),

                call('Content-Encoding', ce),

                call('Content-Disposition', cd)]

            if perms:

                perm_str = ''

                for ptype, pval in perms.items():

                    if pval:

                        perm_str += ';' if perm_str else ''

                        perm_str += '%s=%s' % (ptype, ','.join(pval))

                exp += [call('X-Object-Sharing', perm_str, iff=perms)]

            else:

                exp += [call('X-Object-Sharing', '', iff={})]

            exp += [call('X-Object-Public', public, public is not None)]

            for k, v in metas.items():

                exp += [call('X-Object-Meta-%s' % k, v)]

            self.assertEqual(SH.mock_calls[- len(exp):], exp)

            acc, cont = self.client.account, self.client.container

            self.assertEqual(move.mock_calls[-1], call(

                '/%s/%s/%s' % (acc, cont, obj),

                *args,

                success=kwargs.pop('success', 201),

                **kwargs))

    @patch('%s.set_param' % rest_pkg)

    @patch('%s.set_header' % rest_pkg)

    @patch('%s.post' % rest_pkg, return_value=FR())

    def test_object_post(self, post, SH, SP):

        for pm in product(

                ('json', 'f0rm47'),

                (False, True),

                (dict(), dict(read=['u1', 'g2'], write=['u1'])),