Synnefo » ./kamaki

            self, obj, destination,

        path = path4url(self.account, self.container, obj)

    @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)]

            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))