Python api.package_upload函数代码示例

 def test_class_name_is_unique(self):
     value = self._stub_package(class_definitions=('foo', 'bar'))
     api.package_upload(value, self.tenant_id)
     value = self._stub_package(class_definitions=('bar', 'baz'),
                                fully_qualified_name='com.example.package2')
     self.assertRaises(exc.HTTPConflict, api.package_upload, value,
                       self.tenant_id)

    def test_package_fqn_is_unique(self):
        self._create_categories()
        values = self._stub_package()

        api.package_upload(values, self.tenant_id)
        self.assertRaises(db_exception.DBDuplicateEntry,
                          api.package_upload, values, self.tenant_id)

 def test_class_name_public_public_violation(self):
     value = self._stub_package(class_definitions=("foo", "bar"), is_public=True)
     api.package_upload(value, self.tenant_id)
     value = self._stub_package(
         class_definitions=("foo", "bar"), is_public=True, fully_qualified_name="com.example.package2"
     )
     self.assertRaises(exc.HTTPConflict, api.package_upload, value, self.tenant_id_2)

    def test_packages_filter_by_id(self):
        """GET /catalog/packages with parameter "id" returns packages
        filtered by id.
        """
        self._set_policy_rules(
            {'get_package': '',
             'manage_public_package': ''}
        )
        _, package1_data = self._test_package()
        _, package2_data = self._test_package()

        package1_data['fully_qualified_name'] += '_1'
        package1_data['name'] += '_1'
        package1_data['class_definitions'] = (u'test.mpl.v1.app.Thing1',)
        package2_data['fully_qualified_name'] += '_2'
        package2_data['name'] += '_2'
        package2_data['class_definitions'] = (u'test.mpl.v1.app.Thing2',)

        expected_package = db_catalog_api.package_upload(package1_data, '')
        db_catalog_api.package_upload(package2_data, '')

        req = self._get('/catalog/packages',
                        params={'id': expected_package.id})
        self.expect_policy_check('get_package')
        self.expect_policy_check('manage_public_package')

        res = req.get_response(self.api)
        self.assertEqual(200, res.status_code)

        self.assertEqual(1, len(res.json['packages']))

        found_package = res.json['packages'][0]

        self.assertEqual(expected_package.id, found_package['id'])

    def test_package_search_search(self):
        pkg1 = api.package_upload(
            self._stub_package(
                fully_qualified_name=str(uuid.uuid4())), self.tenant_id)
        pkg2 = api.package_upload(
            self._stub_package(
                tags=[],
                fully_qualified_name=str(uuid.uuid4())), self.tenant_id)

        res = api.package_search(
            {'search': 'tag1'}, self.context)
        self.assertEqual(1, len(res))
        res = api.package_search(
            {'search': pkg1.fully_qualified_name}, self.context)
        self.assertEqual(1, len(res))
        res = api.package_search(
            {'search': pkg2.fully_qualified_name}, self.context)
        self.assertEqual(1, len(res))
        res = api.package_search(
            {'search': 'not_a_valid_uuid'}, self.context)
        self.assertEqual(0, len(res))

        res = api.package_search(
            {'search': 'some text'}, self.context)
        self.assertEqual(2, len(res))

    def test_pagination_loops_through_names(self):
        """Tests that packages with same display name are not skipped

        Creates 10 packages with the same display name and iterates
        through them, checking that package are not skipped.
        """

        for dummy in range(10):
            api.package_upload(
                self._stub_package(name='test',
                                   fully_qualified_name=str(uuid.uuid4())),
                self.tenant_id)
        res = api.package_search({}, self.context, limit=4)
        self.assertEqual(4, len(res))
        marker = res[-1].id

        res = api.package_search({'marker': marker}, self.context, limit=4)
        self.assertEqual(4, len(res))
        marker = res[-1].id

        res = api.package_search({'marker': marker}, self.context, limit=4)
        self.assertEqual(2, len(res))
        marker = res[-1].id

        res = api.package_search({'marker': marker}, self.context, limit=4)
        self.assertEqual(0, len(res))

 def test_package_update_public_public_fqn_violation(self):
     id1 = api.package_upload(self._stub_package(), self.tenant_id).id
     id2 = api.package_upload(self._stub_package(), self.tenant_id_2).id
     patch = self.get_change('replace', ['is_public'], True)
     api.package_update(id1, [patch], self.context)
     self.assertRaises(exc.HTTPConflict, api.package_update,
                       id2, [patch], self.context_2)

 def test_class_name_private_public_no_violation(self):
     value = self._stub_package(class_definitions=("foo", "bar"), is_public=False)
     api.package_upload(value, self.tenant_id)
     value = self._stub_package(
         class_definitions=("foo", "bar"), is_public=True, fully_qualified_name="com.example.package2"
     )
     api.package_upload(value, self.tenant_id_2)

    def test_package_search_owned(self):
        api.package_upload(self._stub_package(is_public=True, fully_qualified_name=str(uuid.uuid4())), self.tenant_id)
        api.package_upload(self._stub_package(is_public=True, fully_qualified_name=str(uuid.uuid4())), self.tenant_id_2)

        res = api.package_search({"owned": "true"}, self.context_admin)
        self.assertEqual(1, len(res))
        res = api.package_search({"owned": "false"}, self.context_admin)
        self.assertEqual(2, len(res))

 def test_package_update_public_public_class_name_violation(self):
     id1 = api.package_upload(self._stub_package(class_definitions=("foo", "bar")), self.tenant_id).id
     id2 = api.package_upload(
         self._stub_package(class_definitions=("foo", "bar"), fully_qualified_name="com.example.package2"),
         self.tenant_id_2,
     ).id
     patch = self.get_change("replace", ["is_public"], True)
     api.package_update(id1, [patch], self.context)
     self.assertRaises(exc.HTTPConflict, api.package_update, id2, [patch], self.context_2)

 def test_package_update_public_public_class_name_violation(self):
     id1 = api.package_upload(self._stub_package(
         class_definitions=('foo', 'bar')), self.tenant_id).id
     id2 = api.package_upload(self._stub_package(
         class_definitions=('foo', 'bar'),
         fully_qualified_name='com.example.package2'), self.tenant_id_2).id
     patch = self.get_change('replace', ['is_public'], True)
     api.package_update(id1, [patch], self.context)
     self.assertRaises(exc.HTTPConflict, api.package_update,
                       id2, [patch], self.context_2)

    def test_package_search_type(self):
        api.package_upload(
            self._stub_package(type="Application", fully_qualified_name=str(uuid.uuid4())), self.tenant_id
        )
        api.package_upload(self._stub_package(type="Library", fully_qualified_name=str(uuid.uuid4())), self.tenant_id)

        res = api.package_search({"type": "Library"}, self.context)
        self.assertEqual(1, len(res))
        res = api.package_search({"type": "Application"}, self.context)
        self.assertEqual(1, len(res))

    def test_package_search_tags(self):
        api.package_upload(self._stub_package(fully_qualified_name=str(uuid.uuid4())), self.tenant_id)
        api.package_upload(self._stub_package(tags=[], fully_qualified_name=str(uuid.uuid4())), self.tenant_id)

        res = api.package_search({"tag": ["tag1"]}, self.context)
        self.assertEqual(1, len(res))
        res = api.package_search({"tag": ["tag2"]}, self.context)
        self.assertEqual(1, len(res))
        res = api.package_search({"tag": ["tag3"]}, self.context)
        self.assertEqual(0, len(res))

    def test_package_search_disabled(self):
        api.package_upload(
            self._stub_package(is_public=True, enabled=True, fully_qualified_name=str(uuid.uuid4())), self.tenant_id
        )
        api.package_upload(
            self._stub_package(is_public=True, enabled=False, fully_qualified_name=str(uuid.uuid4())), self.tenant_id
        )

        res = api.package_search({"include_disabled": "false"}, self.context)
        self.assertEqual(1, len(res))
        res = api.package_search({"include_disabled": "true"}, self.context)
        self.assertEqual(2, len(res))

    def test_packages_filter_by_in_category(self):
        """Test that packages are filtered by in:cat1,cat2,cat3

        GET /catalog/packages with parameter "category=in:cat1,cat2,cat3"
        returns packages filtered by category.
        """
        names = ['cat1', 'cat2', 'cat3', 'cat4']
        for name in names:
            db_catalog_api.category_add(name)
        self._set_policy_rules(
            {'get_package': '',
             'manage_public_package': ''}
        )
        _, package1_data = self._test_package()
        _, package2_data = self._test_package()
        _, package3_data = self._test_package()

        package1_data['fully_qualified_name'] += '_1'
        package1_data['name'] += '_1'
        package1_data['class_definitions'] = (u'test.mpl.v1.app.Thing1',)
        package1_data['categories'] = ('cat1', 'cat2')

        package2_data['fully_qualified_name'] += '_2'
        package2_data['name'] += '_2'
        package2_data['class_definitions'] = (u'test.mpl.v1.app.Thing2',)
        package2_data['categories'] = ('cat2', 'cat3')

        package3_data['fully_qualified_name'] += '_3'
        package3_data['name'] += '_3'
        package3_data['class_definitions'] = (u'test.mpl.v1.app.Thing3',)
        package3_data['categories'] = ('cat2', 'cat4')

        expected_packages = [db_catalog_api.package_upload(package1_data, ''),
                             db_catalog_api.package_upload(package2_data, '')]
        db_catalog_api.package_upload(package3_data, '')

        categories_in = "in:cat1,cat3"

        req = self._get('/catalog/packages',
                        params={'category': categories_in})
        self.expect_policy_check('get_package')
        self.expect_policy_check('manage_public_package')

        res = req.get_response(self.api)
        self.assertEqual(200, res.status_code)
        self.assertEqual(2, len(res.json['packages']))

        found_packages = res.json['packages']

        self.assertEqual([pack.id for pack in expected_packages],
                         [pack['id'] for pack in found_packages])