def test_upload_wrong_content_type(self):
        request = unit_test_utils.get_fake_request()
        request.headers['Content-Type'] = 'application/json'
        request.body = b'YYYYY'
        self.assertRaises(webob.exc.HTTPUnsupportedMediaType,
                          self.deserializer.upload, request)

        request = unit_test_utils.get_fake_request()
        request.headers['Content-Type'] = 'application/octet-st'
        request.body = b'YYYYY'
        self.assertRaises(webob.exc.HTTPUnsupportedMediaType,
                          self.deserializer.upload, request)

    def setUp(self):
        super(TestTaskFactoryProxy, self).setUp()
        factory = xmonitor.domain.TaskFactory()
        self.context = xmonitor.context.RequestContext(tenant=TENANT1)
        self.context_owner_is_none = xmonitor.context.RequestContext()
        self.task_factory = authorization.TaskFactoryProxy(
            factory,
            self.context
        )
        self.task_type = 'import'
        self.task_input = '{"loc": "fake"}'
        self.owner = 'foo'

        self.request1 = unittest_utils.get_fake_request(tenant=TENANT1)
        self.request2 = unittest_utils.get_fake_request(tenant=TENANT2)

 def test_index_with_limit(self):
     path = '/tasks'
     limit = 2
     request = unit_test_utils.get_fake_request(path, is_admin=True)
     output = self.controller.index(request, limit=limit)
     actual = set([task.task_id for task in output['tasks']])
     self.assertEqual(limit, len(actual))

 def test_upload_no_size(self):
     request = unit_test_utils.get_fake_request()
     image = FakeImage('abcd')
     self.image_repo.result = image
     self.controller.upload(request, unit_test_utils.UUID2, 'YYYY', None)
     self.assertEqual('YYYY', image.data)
     self.assertIsNone(image.size)

 def test_create_duplicate_tag_ignored(self):
     request = unit_test_utils.get_fake_request()
     self.controller.update(request, unit_test_utils.UUID1, 'dink')
     self.controller.update(request, unit_test_utils.UUID1, 'dink')
     context = request.context
     tags = self.db.image_tag_get_all(context, unit_test_utils.UUID1)
     self.assertEqual(1, len([tag for tag in tags if tag == 'dink']))

 def test_create_task_unauthorized(self):
     rules = {"add_task": False}
     self.policy.set_rules(rules)
     request = unit_test_utils.get_fake_request()
     task = {'type': 'import', 'input': {"import_from": "fake"}}
     self.assertRaises(webob.exc.HTTPForbidden, self.controller.create,
                       request, task)

    def test_create_with_live_time(self, mock_validate_location_uri,
                                   mock_get_image_data_iter):
        request = unit_test_utils.get_fake_request()
        task = {
            "type": "import",
            "input": {
                "import_from": "http://download.cirros-cloud.net/0.3.4/"
                               "cirros-0.3.4-x86_64-disk.img",
                "import_from_format": "qcow2",
                "image_properties": {
                    "disk_format": "qcow2",
                    "container_format": "bare",
                    "name": "test-task"
                }
            }
        }

        new_task = self.controller.create(request, task=task)
        executor_factory = self.gateway.get_task_executor_factory(
            request.context)
        task_executor = executor_factory.new_task_executor(request.context)
        task_executor.begin_processing(new_task.task_id)
        success_task = self.controller.get(request, new_task.task_id)

        # ignore second and microsecond to avoid flaky runs
        task_live_time = (success_task.expires_at.replace(second=0,
                                                          microsecond=0) -
                          success_task.updated_at.replace(second=0,
                                                          microsecond=0))
        task_live_time_hour = (task_live_time.days * 24 +
                               task_live_time.seconds / 3600)
        self.assertEqual(CONF.task.task_time_to_live, task_live_time_hour)

 def test_index_with_filter_and_limit(self):
     status = 'success'
     path = '/tasks?status=%s&limit=1' % status
     request = unit_test_utils.get_fake_request(path)
     output = self.deserializer.index(request)
     self.assertEqual(status, output['filters']['status'])
     self.assertEqual(1, output['limit'])

 def test_index_with_sort_dir(self):
     path = '/tasks'
     request = unit_test_utils.get_fake_request(path, is_admin=True)
     output = self.controller.index(request, sort_dir='asc', limit=3)
     actual = [task.task_id for task in output['tasks']]
     self.assertEqual(3, len(actual))
     self.assertEqual([UUID1, UUID2, UUID3], actual)

 def test_upload_invalid(self):
     request = unit_test_utils.get_fake_request()
     image = FakeImage('abcd')
     image.status = ValueError()
     self.image_repo.result = image
     self.assertRaises(webob.exc.HTTPBadRequest, self.controller.upload,
                       request, unit_test_utils.UUID1, 'YYYY', 4)

    def test_upload_data_to_store(self):
        # 'user_storage_quota' is not set
        def store_add(image_id, data, size, **kwargs):
            # Check if 'data' is instance of 'CooperativeReader' when
            # 'user_storage_quota' is disabled.
            self.assertIsInstance(data, utils.CooperativeReader)
            return location, 10, "checksum", {}

        req = unit_test_utils.get_fake_request()
        with self._get_store_and_notifier(
                ext_update_data={'size': 10},
                exc_class=store_add) as (location, checksum, image_meta,
                                         image_data, store, notifier,
                                         update_data):
            ret = image_meta.update(update_data)
            with patch.object(registry, 'update_image_metadata',
                              return_value=ret) as mock_update_image_metadata:
                actual_meta, location_data = upload_utils.upload_data_to_store(
                    req, image_meta, image_data, store, notifier)

                self.assertEqual(location, location_data['url'])
                self.assertEqual(image_meta.update(update_data), actual_meta)
                mock_update_image_metadata.assert_called_once_with(
                    req.context, image_meta['id'], update_data,
                    from_state='saving')

 def test_upload_with_trusts(self, mock_refresher):
     """Test that uploading with registry correctly uses trusts"""
     # initialize trust environment
     self.config(data_api='xmonitor.db.registry.api')
     refresher = mock.MagicMock()
     mock_refresher.return_value = refresher
     refresher.refresh_token.return_value = "fake_token"
     # request an image upload
     request = unit_test_utils.get_fake_request()
     request.environ['keystone.token_auth'] = mock.MagicMock()
     request.environ['keystone.token_info'] = {
         'token': {
             'roles': [{'name': 'FakeRole', 'id': 'FakeID'}]
         }
     }
     image = FakeImage('abcd')
     self.image_repo.result = image
     mock_fake_save = mock.Mock()
     mock_fake_save.side_effect = [None, exception.NotAuthenticated, None]
     temp_save = FakeImageRepo.save
     # mocking save to raise NotAuthenticated on the second call
     FakeImageRepo.save = mock_fake_save
     self.controller.upload(request, unit_test_utils.UUID2, 'YYYY', 4)
     # check image data
     self.assertEqual('YYYY', image.data)
     self.assertEqual(4, image.size)
     FakeImageRepo.save = temp_save
     # check that token has been correctly acquired and deleted
     mock_refresher.assert_called_once_with(
         request.environ['keystone.token_auth'],
         request.context.tenant, ['FakeRole'])
     refresher.refresh_token.assert_called_once_with()
     refresher.release_resources.assert_called_once_with()
     self.assertEqual("fake_token", request.context.auth_token)

 def test_member(self):
     req = unit_test_utils.get_fake_request()
     output = self.controller.member(req)
     self.assertEqual('member', output['name'])
     expected = set(['status', 'created_at', 'updated_at', 'image_id',
                     'member_id', 'schema'])
     self.assertEqual(expected, set(output['properties'].keys()))

 def test_upload_storage_forbidden(self):
     request = unit_test_utils.get_fake_request(user=unit_test_utils.USER2)
     image = FakeImage()
     image.set_data = Raise(exception.Forbidden)
     self.image_repo.result = image
     self.assertRaises(webob.exc.HTTPForbidden, self.controller.upload,
                       request, unit_test_utils.UUID2, 'YY', 2)

    def test_upload_data_to_store_not_found_after_upload(self):
        req = unit_test_utils.get_fake_request()

        with self._get_store_and_notifier(
            ext_update_data={'size': 10}) as (location, checksum, image_meta,
                                              image_data, store, notifier,
                                              update_data):
            exc = exception.ImageNotFound
            with patch.object(registry, 'update_image_metadata',
                              side_effect=exc) as mock_update_image_metadata:
                with patch.object(upload_utils,
                                  "initiate_deletion") as mock_initiate_del:
                    with patch.object(upload_utils,
                                      "safe_kill") as mock_safe_kill:
                        self.assertRaises(webob.exc.HTTPPreconditionFailed,
                                          upload_utils.upload_data_to_store,
                                          req, image_meta, image_data, store,
                                          notifier)
                        mock_update_image_metadata.assert_called_once_with(
                            req.context, image_meta['id'], update_data,
                            from_state='saving')
                        mock_initiate_del.assert_called_once_with(
                            req, {'url': location, 'status': 'active',
                                  'metadata': {}}, image_meta['id'])
                        mock_safe_kill.assert_called_once_with(
                            req, image_meta['id'], 'saving')

 def test_index_default_limit(self):
     self.config(limit_param_default=1, api_limit_max=3)
     path = '/tasks'
     request = unit_test_utils.get_fake_request(path)
     output = self.controller.index(request)
     actual = set([task.task_id for task in output['tasks']])
     self.assertEqual(1, len(actual))

 def test_index_with_id_filter(self):
     request = unit_test_utils.get_fake_request('/tasks?id=%s' % UUID1)
     output = self.controller.index(request, filters={'id': UUID1})
     self.assertEqual(1, len(output['tasks']))
     actual = set([task.task_id for task in output['tasks']])
     expected = set([UUID1])
     self.assertEqual(expected, actual)

 def test_download_no_location(self):
     # NOTE(mclaren): NoContent will be raised by the ResponseSerializer
     # That's tested below.
     request = unit_test_utils.get_fake_request()
     self.image_repo.result = FakeImage('abcd')
     image = self.controller.download(request, unit_test_utils.UUID2)
     self.assertEqual('abcd', image.image_id)

 def test_upload_storage_full(self):
     request = unit_test_utils.get_fake_request()
     image = FakeImage()
     image.set_data = Raise(glance_store.StorageFull)
     self.image_repo.result = image
     self.assertRaises(webob.exc.HTTPRequestEntityTooLarge,
                       self.controller.upload,
                       request, unit_test_utils.UUID2, 'YYYYYYY', 7)

 def test_index_with_filters_return_many(self):
     path = '/tasks?status=pending'
     request = unit_test_utils.get_fake_request(path, is_admin=True)
     output = self.controller.index(request, filters={'status': 'pending'})
     self.assertEqual(4, len(output['tasks']))
     actual = set([task.task_id for task in output['tasks']])
     expected = set([UUID1, UUID2, UUID3, UUID4])
     self.assertEqual(sorted(expected), sorted(actual))