Esempio n. 1
0
    def test_get_last_release_without_release(self):
        from papaye.models import Package

        package = Package(name='package1')

        result = package.get_last_release()
        self.assertIsNone(result)
Esempio n. 2
0
def not_found(request, stop=None):
    if not proxy_activated(request.registry.settings) or stop is not None:
        return HTTPNotFound()
    proxy = PyPiProxy()
    package_name = request.matchdict['traverse'][0]
    if package_name in request.root:
        local_package = request.root[package_name]
    else:
        local_package = Package(package_name)
        local_package.fake = True

    merged_repository = proxy.merged_repository(local_package)

    if merged_repository:
        package = merged_repository[package_name]
        traversed = len(request.matchdict['traverse'])
        if traversed == 1:
            view = ListReleaseFileView(package, request)
            view.stop = True
        elif traversed == 2:
            context = package[request.matchdict['traverse'][1]]
            view = ListReleaseFileByReleaseView(context, request)
        elif traversed == 3:
            release_file = package[request.matchdict['traverse'][1]][request.matchdict['traverse'][2]]
            filename = request.matchdict['traverse'][2]
            package_name, release_name, _ = request.matchdict['traverse']
            download_release_from_pypi.delay(request.registry._zodb_databases[''], package_name, release_name, filename)
            return HTTPTemporaryRedirect(location=release_file.pypi_url)
        return view()
    return HTTPNotFound()
Esempio n. 3
0
    def test_get_last_release_without_release(self):
        from papaye.models import Package

        package = Package(name='package1')

        result = package.get_last_release()
        self.assertIsNone(result)
Esempio n. 4
0
    def test_smart_merge_with_existing_release(self, mock):
        from papaye.proxy import PyPiProxy
        from papaye.factories import repository_root_factory
        from papaye.models import Package, Release, ReleaseFile
        mock.return_value = self.pypi_response
        root = repository_root_factory(self.request)

        # Existing releases
        package = Package(name='pyramid')
        package['1.5'] = Release(name='1.5', version='1.5', metadata={})
        package['1.5']['pyramid-1.5.tar.gz'] = ReleaseFile(
            filename='pyramid-1.5.tar.gz', content=b'', md5_digest='12345')

        package = Package(name='pyramid')
        package['1.5'] = Release(name='1.5', version='1.5', metadata={})
        package['1.5']['pyramid-1.5.tar.gz'] = ReleaseFile(
            filename='pyramid-1.5.tar.gz', content=b'', md5_digest='12345')

        proxy = PyPiProxy(self.request, 'pyramid')
        result = proxy.smart_merge(root, package)

        self.assertEqual([key for key in result.releases.keys()], [
            '1.5',
        ])
        self.assertEqual(result['1.5']['pyramid-1.5.tar.gz'].md5_digest,
                         '12345')
Esempio n. 5
0
    def build_remote_repository(self, package_name, release_name=None, metadata=False, content=False):
        package_name = self.get_remote_package_name(package_name)
        if package_name:
            info = self.get_remote_informations(self.pypi_url.format(package_name))
            package_root = Root()
            package = Package(info['info']['name'])
            package.__parent__ = package_root
            package_root[package.name] = package
            remote_releases = info['releases'].keys() if not release_name else [release_name, ]

            for remote_release in remote_releases:
                release = Release(
                    remote_release,
                    remote_release,
                    metadata=info['info'],
                    deserialize_metadata=metadata
                )
                package[remote_release] = release

                for remote_release_file in info['releases'][remote_release]:
                    filename = remote_release_file['filename']
                    md5_digest = remote_release_file['md5_digest']
                    if not content:
                        release_file = ReleaseFile(filename, b'', md5_digest)
                    else:
                        content_file = download_file(filename, remote_release_file['url'], md5_digest)
                        if content_file is not None:
                            release_file = ReleaseFile(filename, content_file, md5_digest)
                        else:
                            continue

                    setattr(release_file, 'pypi_url', remote_release_file['url'])
                    release[filename] = release_file
            return package_root
        return None
Esempio n. 6
0
    def test_get_last_release_with_alpha(self):
        from papaye.models import Package, Release

        package = Package(name='package1')
        package.releases.update([('1.0{}'.format(version), Release('', '1.0{}'.format(version), metadata={}))
                                 for version in ['', 'a1', 'a2', 'b1', 'b2', 'rc1']])
        result = package.get_last_release()
        self.assertEqual(result.version, '1.0')
Esempio n. 7
0
    def test_by_name(self):
        from papaye.models import Package
        from papaye.factories import repository_root_factory

        root = repository_root_factory(self.request)
        root['package1'] = Package(name='package1')

        result = Package.by_name('package1', self.request)
        self.assertEqual(result, root['package1'])
Esempio n. 8
0
    def test_get_last_release_with_minor(self):
        from papaye.models import Package, Release

        package = Package(name='package1')
        package.releases.update([(
            '1.{}'.format(index),
            Release('', '1.{}'.format(index), metadata={})) for index in range(1, 3)]
        )
        result = package.get_last_release()
        self.assertEqual(result.version, '1.2')
Esempio n. 9
0
    def test_get_last_release_with_minor(self):
        from papaye.models import Package, Release

        package = Package(name='package1')
        package.releases.update([('1.{}'.format(index),
                                  Release('',
                                          '1.{}'.format(index),
                                          metadata={}))
                                 for index in range(1, 3)])
        result = package.get_last_release()
        self.assertEqual(result.version, '1.2')
Esempio n. 10
0
    def test_get_last_release_with_alpha(self):
        from papaye.models import Package, Release

        package = Package(name='package1')
        package.releases.update([
            ('1.0{}'.format(version),
             Release('', '1.0{}'.format(version), metadata={}))
            for version in ['', 'a1', 'a2', 'b1', 'b2', 'rc1']
        ])
        result = package.get_last_release()
        self.assertEqual(result.version, '1.0')
Esempio n. 11
0
    def test_list_releases_files_with_another_package(self):
        from papaye.views.simple import ListReleaseFileView
        from papaye.models import Package, Release, Root, ReleaseFile

        # Test packages
        root = Root()
        root['package1'] = Package(name='package1')
        root['package2'] = Package(name='package2')
        root['package1']['release1'] = Release(name='release1',
                                               version='1.0',
                                               metadata={})
        root['package1']['release1'].__parent__ = root['package1']
        root['package2']['release2'] = Release(name='release2',
                                               version='2.0',
                                               metadata={})
        root['package2']['release2'].__parent__ = root['package2']
        root['package1']['release1']['releasefile1.tar.gz'] = ReleaseFile(
            filename='releasefile1.tar.gz', content=b'', md5_digest='12345')
        root['package1']['release1']['releasefile1.tar.gz'].__parent__ = root[
            'package1']['release1']
        root['package2']['release2']['releasefile2.tar.gz'] = ReleaseFile(
            filename='releasefile2.tar.gz', content=b'', md5_digest='12345')
        root['package2']['release2']['releasefile2.tar.gz'].__parent__ = root[
            'package2']['release2']

        view = ListReleaseFileView(root['package1'], self.request)
        response = view()

        self.assertIsInstance(response, dict)
        self.assertIn('objects', response)
        self.assertIsInstance(response['objects'], types.GeneratorType)
        self.assertEqual(
            [(url, release) for url, release in response['objects']],
            [
                ('http://example.com/simple/package1/release1/releasefile1.tar.gz#md5=12345',
                 root['package1']['release1']['releasefile1.tar.gz']),
            ],
        )

        view = ListReleaseFileView(root['package2'], self.request)
        response = view()

        self.assertIsInstance(response, dict)
        self.assertIn('objects', response)
        self.assertIsInstance(response['objects'], types.GeneratorType)
        self.assertEqual(
            [(url, release) for url, release in response['objects']],
            [
                ('http://example.com/simple/package2/release2/releasefile2.tar.gz#md5=12345',
                 root['package2']['release2']['releasefile2.tar.gz']),
            ],
        )
Esempio n. 12
0
    def test_get_last_remote_version_without_proxy(self, mock):
        from papaye.models import Package

        fake_response = Response(status=200,
                                 body='{"info": {"version": "1.0"}}')
        mock.return_value = fake_response

        # Test data
        package = Package('test')

        result = Package.get_last_remote_version(False, package.name)

        self.assertEqual(mock.call_count, 0)
        self.assertIsNone(result)
Esempio n. 13
0
    def test_get_last_remote_version_with_proxy_404(self, mock):
        from papaye.models import Package

        fake_response = FakeGRequestResponse(
            status_code=404, content=b'{"info": {"version": "1.0"}}')
        mock.return_value = fake_response

        # Test data
        package = Package('test')

        result = Package.get_last_remote_version(True, package.name)

        self.assertEqual(mock.call_count, 1)
        self.assertIsNone(result)
Esempio n. 14
0
    def test_upload_release_already_exists(self):
        from papaye.models import Root, Package, Release, ReleaseFile
        from papaye.views.simple import UploadView

        # Create a fake test file
        uploaded_file = io.BytesIO(b"content")
        storage = FieldStorage()
        storage.filename = 'foo.tar.gz'
        storage.file = uploaded_file

        self.request.POST = {
            "content": storage,
            "some_metadata": "Fake Metadata",
            "version": "1.0",
            "name": "my_package",
            ":action": "file_upload",
        }
        root = Root()

        # Create initial release
        package = Package('my_package')
        package['1.0'] = Release('1.0', '1.0', metadata={})
        package['1.0']['foo.tar.gz'] = ReleaseFile('foo.tar.gz', b'')
        root['my_package'] = package

        view = UploadView(root, self.request)
        result = view()

        self.assertIsInstance(result, Response)
        self.assertEqual(result.status_int, 409)
Esempio n. 15
0
    def test_list_release_with_two_release(self):
        from papaye.views.simple import ListReleaseFileByReleaseView
        from papaye.models import Package, Release, ReleaseFile
        from papaye.factories import repository_root_factory

        # Initial data
        root = repository_root_factory(self.request)
        package = Package('my_package')
        package['1.0'] = Release('1.0', '1.0', metadata={})
        package['1.0']['foo.tar.gz'] = ReleaseFile('foo.tar.gz', b'')
        package['2.0'] = Release('2.0', '2.0', metadata={})
        package['2.0']['foo2.tar.gz'] = ReleaseFile('foo2.tar.gz', b'')
        root['my_package'] = package
        view1 = ListReleaseFileByReleaseView(package['1.0'], self.request)
        view2 = ListReleaseFileByReleaseView(package['2.0'], self.request)

        result1 = view1()
        result2 = view2()

        self.assertIsInstance(result1, dict)
        self.assertIn('objects', result1)
        self.assertEqual(
            list(result1['objects']),
            [('http://example.com/simple/my_package/1.0/foo.tar.gz/',
              package['1.0']['foo.tar.gz'])])
        self.assertIsInstance(result2, dict)
        self.assertIn('objects', result2)
        self.assertEqual(
            list(result2['objects']),
            [('http://example.com/simple/my_package/2.0/foo2.tar.gz/',
              package['2.0']['foo2.tar.gz'])])
Esempio n. 16
0
    def __call__(self):
        post = dict(self.request.POST)
        metadata = dict([(key, value) for key, value in post.items()
                         if key != 'content'])
        if post.get(':action') == "file_upload":
            name = post.get('name')
            if ' ' in name:
                name = name.replace(' ', '-')
            version = post.get('version')
            content = post.get('content')
            md5_digest = post.get('md5_digest')

            package = self.context[name] if self.context.get(
                name) else Package(name)
            package.__parent__ = self.context
            self.context[name] = package

            release = package[version] if package.releases.get(
                version) else Release(
                    name=version, version=version, metadata=metadata)
            release.__parent__ = package
            self.context[name][version] = release

            if release.release_files.get(content.filename):
                return HTTPConflict()

            release_file = ReleaseFile(filename=content.filename,
                                       content=content.file.read(),
                                       md5_digest=md5_digest)
            release = self.context[name][version]
            self.context[name][version][content.filename] = release_file
            return Response()
        else:
            return HTTPBadRequest()
Esempio n. 17
0
def remove_package(request):
    package_name = request.matchdict.get("package_name")
    package = Package.by_name(package_name, request)
    if package is None:
        return HTTPNotFound()
    del request.root[package_name]
    return {"success": True}
Esempio n. 18
0
    def test_download_release_from_pypi_with_existing_package(self, get_connection_mock, request_mock):
        from papaye.factories import repository_root_factory
        from papaye.models import Package, Release, ReleaseFile
        from papaye.tasks.download import download_release_from_pypi
        request = get_current_request()
        get_connection_mock.return_value = self.conn
        json_response = open(get_resource('pyramid.json'), 'rb')
        release_file_content = open(get_resource('pyramid-1.5.tar.gz'), 'rb')
        request_mock.side_effect = [
            FakeGRequestResponse(200, b'', 'http://pypi.python.org/simple/pyramid/'),
            FakeGRequestResponse(200, json_response.read()),
            FakeGRequestResponse(200, release_file_content.read()),
        ]
        root = repository_root_factory(self.conn)
        package = Package('pyramid')
        release = Release('1.0', '1.0', metadata={})
        release_file = ReleaseFile('pyramid-1.0.tar.gz', b'')
        root['pyramid'] = package
        root['pyramid']['1.0'] = release
        root['pyramid']['1.0']['pyramid-1.0.tar.gz']= release_file

        download_release_from_pypi(request.registry.settings, 'pyramid', '1.5')

        self.assertEqual(request_mock.call_count, 3)
        assert request_mock.call_count == 3
        assert len(list(root['pyramid'])) == 2
Esempio n. 19
0
def test_get_package_by_version_with_unknown_release(setup):
    from papaye.views.api import get_package_by_version
    from papaye.models import Package, Root, Release
    request = testing.DummyRequest()
    root = Root()
    root['package1'] = Package(name='package1')
    root['package2'] = Package(name='package2')
    root['package1']['1.0'] = Release('1.0', '1.0',
                                      {'summary': 'The package 1'})
    root['package2']['1.0'] = Release('1.0', '1.0',
                                      {'summary': 'The package 2'})
    request.context = root
    request.matchdict = {'package_name': 'package2', 'version': '2.0'}

    result = get_package_by_version(request)

    assert isinstance(result, HTTPNotFound) is True
Esempio n. 20
0
    def test_list_packages(self):
        from papaye.views.simple import ListPackagesView
        from papaye.models import Package, Root

        # Test packages
        root = Root()
        root['package1'] = Package(name='package1')
        root['package2'] = Package(name='package2')

        view = ListPackagesView(root, self.request)
        response = view()

        self.assertIsInstance(response, dict)
        self.assertIn('objects', response)
        self.assertIsInstance(response['objects'], types.GeneratorType)
        self.assertEqual(
            [package.name for url, package in response['objects']],
            ['package1', 'package2'])
Esempio n. 21
0
    def test_get_index(self):
        from papaye.models import Root, Package
        root = Root()
        package = Package(name='package1')
        root['package'] = package

        result = root[0]

        assert result == package
Esempio n. 22
0
    def test_get_index(self):
        from papaye.models import Package, Release
        package = Package(name='package1')
        release = Release('1.0', '1.0', metadata={})
        package['release'] = release

        result = package[0]

        assert result == release
Esempio n. 23
0
    def test_by_name(self):
        from papaye.models import Package
        from papaye.factories import repository_root_factory

        root = repository_root_factory(self.request)
        root['package1'] = Package(name='package1')

        result = Package.by_name('package1', self.request)
        self.assertEqual(result, root['package1'])
Esempio n. 24
0
    def test_iter(self):
        from papaye.models import Root, Package
        root = Root()
        package = Package(name='package1')
        root['package'] = package

        result = iter(root)

        assert isinstance(result, types.GeneratorType)
        assert list(result) == [
            package,
        ]
Esempio n. 25
0
    def test_by_packagename(self):
        from papaye.models import Release, Package
        from papaye.factories import repository_root_factory

        root = repository_root_factory(self.request)
        root['package1'] = Package(name='package1')
        root['package1']['1.0'] = Release('1.0', '1.0', metadata={})

        result = Release.by_packagename('package1', self.request)
        self.assertEqual(result, [
            root['package1']['1.0'],
        ])
Esempio n. 26
0
    def test_iter(self):
        from papaye.models import Package, Release
        package = Package(name='package1')
        release = Release('1.0', '1.0', metadata={})
        package['release'] = release

        result = iter(package)

        assert isinstance(result, types.GeneratorType)
        assert list(result) == [
            release,
        ]
Esempio n. 27
0
    def test_get_last_remote_version_with_proxy_404(self, mock):
        from papaye.models import Package

        fake_response = FakeGRequestResponse(status_code=404, content=b'{"info": {"version": "1.0"}}')
        mock.return_value = fake_response

        # Test data
        package = Package('test')

        result = Package.get_last_remote_version(True, package.name)

        self.assertEqual(mock.call_count, 1)
        self.assertIsNone(result)
Esempio n. 28
0
    def test_get_last_remote_version_without_proxy(self, mock):
        from papaye.models import Package

        fake_response = Response(status=200, body='{"info": {"version": "1.0"}}')
        mock.return_value = fake_response

        # Test data
        package = Package('test')

        result = Package.get_last_remote_version(False, package.name)

        self.assertEqual(mock.call_count, 0)
        self.assertIsNone(result)
Esempio n. 29
0
 def __call__(self):
     check_update = True if self.request.GET.get('check_update', 'true') == 'true' else False
     package = self.context.__parent__.__parent__
     last_remote_version = Package.get_last_remote_version(self.proxy, package.name)
     if check_update:
         if not package.repository_is_up_to_date(last_remote_version):
             return not_found(self.request)
     response = Response()
     response.content_disposition = 'attachment; filename="{}"'.format(self.context.filename)
     response.charset = 'utf-8'
     response.content_type = self.context.content_type
     response.body_file = self.context.content.open()
     return response
Esempio n. 30
0
    def test_repository_is_up_to_date(self):
        from papaye.models import Package, Release

        # Test package
        package = Package(name='package1')
        release = Release(name='1.0', version='1.0', metadata={})
        package['release'] = release

        self.assertTrue(package.repository_is_up_to_date('1.0'))
        self.assertTrue(package.repository_is_up_to_date('0.9'))
        self.assertTrue(package.repository_is_up_to_date('1.0a'))
        self.assertFalse(package.repository_is_up_to_date('1.1'))
        self.assertFalse(package.repository_is_up_to_date('1.1a'))
        self.assertTrue(package.repository_is_up_to_date(''))
        self.assertTrue(package.repository_is_up_to_date(None))
Esempio n. 31
0
def test_get_package(setup):
    from papaye.views.api import get_package
    from papaye.models import Package, Root, Release
    request = testing.DummyRequest()
    root = Root()
    root['package1'] = Package(name='package1')
    root['package2'] = Package(name='package2')
    root['package1']['1.0'] = Release('1.0', '1.0', {
        'summary': 'The package 1',
        'description': 'A description',
    })
    root['package2']['1.0'] = Release('1.0', '1.0', {
        'summary': 'The package 2',
        'description': 'A description',
    })
    request.context = root
    request.matchdict = {'package_name': 'package1'}

    result = get_package(request)

    assert isinstance(result, dict) is True
    assert result['name'] == 'package1'
    assert 'metadata' in result
Esempio n. 32
0
    def test_serialize(self):
        from papaye.serializers import ReleaseAPISerializer
        from papaye.models import Package, Release, ReleaseFile
        serializer = ReleaseAPISerializer(request=self.request)
        package = Package(name='package')
        package['1.0'] = Release('1.0', '1.0', {
            'summary': 'The package',
            'description': 'A description',
        })
        package['2.0'] = Release('2.0', '2.0', {
            'summary': 'The package',
            'description': 'A description',
        })
        package['1.0']['package-1.0.tar.gz'] = ReleaseFile('package-1.0.tar.gz', b'')
        expected = {
            'name': 'package',
            'version': '1.0',
            'gravatar_hash': None,
            'metadata': {
                'summary': 'The package',
                'description': {'html': True, 'content': '<p>A description</p>\n'},
                'version': None,
                'author': None,
                'author_email': None,
                'home_page': None,
                'keywords': [],
                'license': None,
                'maintainer': None,
                'maintainer_email': None,
                'platform': None,
                'classifiers': [],
                'name': None,
            },
            'download_url': 'http://example.com/simple/package/1.0/package-1.0.tar.gz/',
            'release_files': [{
                'size': '0',
                'filename': 'package-1.0.tar.gz',
                'url': 'http://example.com/simple/package/1.0/package-1.0.tar.gz/',
                'version': '1.0',
                'upload_date': str(package['1.0']['package-1.0.tar.gz'].upload_date),
            }],
            'other_releases': [{
                'url': 'http://example.com/#/package/package/2.0',
                'version': '2.0',
            }]
        }

        result = serializer.serialize(package['1.0'])

        self.assertEqual(result, expected)
Esempio n. 33
0
def test_get_packages(setup):
    from papaye.views.api import list_packages
    from papaye.models import Package, Root, Release
    request = testing.DummyRequest()
    root = Root()
    root['package1'] = Package(name='package1')
    root['package2'] = Package(name='package2')
    root['package1']['1.0'] = Release('1.0', '1.0', {
        'summary': 'The package 1',
        'description': 'A description',
    })
    root['package2']['1.0'] = Release('1.0', '1.0', {
        'summary': 'The package 2',
        'description': 'A description',
    })
    expected = [
        {
            'name': 'package1',
            'summary': 'The package 1',
        },
        {
            'name': 'package2',
            'summary': 'The package 2',
        },
    ]
    request.context = root

    result = list_packages(request)

    assert isinstance(result, dict) is True
    assert 'result' in result
    assert isinstance(result['result'], list) is True
    assert 'count' in result
    assert result['count'] == 2
    assert len(result['result']) == 2
    assert isinstance(result['result'][0], dict) is True
    assert [dict(element) for element in result['result']] == expected
Esempio n. 34
0
    def build_repository(self,
                         release_name=None,
                         with_metadata=False,
                         root=None):
        package_name = self.get_remote_package_name(self.package_name)
        if not package_name:
            return None
        info = self.get_remote_informations(self.pypi_url.format(package_name))
        if info:
            package_root = Root() if root is None else root
            package = Package(info['info']['name'])
            package.__parent__ = package_root
            package_root[package.name] = package

            remote_releases = [
                release_name,
            ] if release_name else info['releases'].keys()

            for remote_release in remote_releases:
                release = Release(remote_release,
                                  remote_release,
                                  metadata=info['info'],
                                  deserialize_metadata=with_metadata)
                package[remote_release] = release

                for remote_release_file in info['releases'][remote_release]:
                    filename = remote_release_file['filename']
                    md5_digest = remote_release_file['md5_digest']
                    release_file = ReleaseFile(filename, b'', md5_digest)
                    setattr(release_file, 'pypi_url',
                            remote_release_file['url'])
                    release[filename] = release_file
            if root:
                return self.smart_merge(root, package)
            return package
        return None
Esempio n. 35
0
 def __call__(self):
     package = self.context
     release_files = []
     for release in package.releases.values():
         for release_file in release.release_files.values():
             release_files.append(release_file)
     context = {
         'objects': ((self.request.resource_url(
             release_file,
             route_name='simple'
         )[:-1] + "#md5={}".format(release_file.md5_digest), release_file) for release_file in release_files),
     }
     if package.repository_is_up_to_date(Package.get_last_remote_version(self.proxy, package.name)):
         return context
     else:
         return not_found(self.request)
Esempio n. 36
0
 def __call__(self):
     check_update = True if self.request.GET.get(
         'check_update', 'true') == 'true' else False
     package = self.context.__parent__.__parent__
     last_remote_version = Package.get_last_remote_version(
         self.proxy, package.name)
     if check_update:
         if not package.repository_is_up_to_date(last_remote_version):
             return not_found(self.request)
     response = Response()
     response.content_disposition = 'attachment; filename="{}"'.format(
         self.context.filename)
     response.charset = 'utf-8'
     response.content_type = self.context.content_type
     response.body_file = self.context.content.open()
     response.content_length = self.context.size
     return response
Esempio n. 37
0
    def test_repository_is_up_to_date(self):
        from papaye.models import Package, Release

        # Test package
        package = Package(name='package1')
        release = Release(name='1.0', version='1.0', metadata={})
        package['release'] = release

        self.assertTrue(package.repository_is_up_to_date('1.0'))
        self.assertTrue(package.repository_is_up_to_date('0.9'))
        self.assertTrue(package.repository_is_up_to_date('1.0a'))
        self.assertFalse(package.repository_is_up_to_date('1.1'))
        self.assertFalse(package.repository_is_up_to_date('1.1a'))
        self.assertTrue(package.repository_is_up_to_date(''))
        self.assertTrue(package.repository_is_up_to_date(None))
Esempio n. 38
0
 def __call__(self):
     package = self.context
     release_files = []
     for release in package.releases.values():
         for release_file in release.release_files.values():
             release_file.__name__ = release_file.__name__.replace(' ', '-')
             release_files.append(release_file)
     context = {
         'objects':
         ((self.request.resource_url(release_file, route_name='simple')[:-1]
           + "#md5={}".format(release_file.md5_digest), release_file)
          for release_file in release_files),
     }
     if package.repository_is_up_to_date(
             Package.get_last_remote_version(self.proxy, package.name)):
         return context
     else:
         return not_found(self.request)
Esempio n. 39
0
    def test_list_releases_files_with_new_remotes_release(
            self, mock, requests_mock):
        from papaye.views.simple import ListReleaseFileView
        from papaye.models import Package, Release, Root, ReleaseFile

        mock.return_value = "3.0"

        # Test packages
        root = Root()
        root['package1'] = Package(name='package1')
        root['package1']['release1'] = Release(name='release1',
                                               version='1.0',
                                               metadata={})
        root['package1']['release1'].__parent__ = root['package1']
        root['package1']['release1']['releasefile1.tar.gz'] = ReleaseFile(
            filename='releasefile1.tar.gz', content=b'', md5_digest='12345')
        root['package1']['release1']['releasefile1.tar.gz'].__parent__ = root[
            'package1']['release1']

        self.request.matchdict['traverse'] = (
            root['package1'].__name__, root['package1']['release1'].__name__)
        self.request.registry.settings['papaye.proxy'] = 'true'
        view = ListReleaseFileView(root['package1'], self.request)
        pypi_result = {
            'info': {
                'name': 'package1',
            },
            'releases': {
                'release1': [{
                    'filename': 'releasefile1.tar.gz',
                    'url': 'http://example.com/',
                    'md5_digest': 'fake md5',
                }]
            }
        }
        requests_mock.return_value = FakeGRequestResponse(
            200, bytes(json.dumps(pypi_result), 'utf-8'))
        response = view()

        self.assertIsInstance(response, dict)
Esempio n. 40
0
    def test_download_release_with_old_release(self, mock_requests):
        from papaye.views.simple import DownloadReleaseView
        from papaye.models import ReleaseFile, Release, Package

        pypi_response = {
            'info': {
                'name': 'package',
                'version': '2.0',
            },
            'releases': {
                '2.0': [{
                    'filename': 'releasefile1.tar.gz',
                    'url': 'http://example.com/',
                    'md5_digest': 'fake md5',
                }]
            }
        }
        # mock_last_version.return_value = '2.0'
        mock_requests.return_value = FakeGRequestResponse(
            200, bytes(json.dumps(pypi_response), 'utf-8'))

        package = Package(name='package')
        release = Release(name='1.0', version='1.0', metadata={})
        release_file = ReleaseFile(filename='releasefile-1.0.tar.gz',
                                   content=b'Hello')
        package['1.0'] = release
        package['1.0']['releasefile-1.0.tar.gz'] = release_file

        self.request.matchdict['traverse'] = (package.__name__,
                                              release.__name__,
                                              release_file.__name__)
        self.request.traversed = (package.__name__, release.__name__)

        view = DownloadReleaseView(release_file, self.request)
        view.proxy = True
        result = view()

        self.assertIsInstance(result, HTTPNotFound)
Esempio n. 41
0
    def test_serialize_with_metadata_is_none(self):
        from papaye.serializers import ReleaseAPISerializer
        from papaye.models import Package, Release, ReleaseFile
        serializer = ReleaseAPISerializer(request=self.request)
        package = Package(name='package')
        package['1.0'] = Release('1.0', '1.0', {
            'summary': 'The package',
            'description': 'A description',
        })
        package['1.0'].metadata = None
        package['2.0'] = Release('2.0', '2.0', {
            'summary': 'The package',
            'description': 'A description',
        })
        package['1.0']['package-1.0.tar.gz'] = ReleaseFile('package-1.0.tar.gz', b'')
        expected = {
            'name': 'package',
            'version': '1.0',
            'gravatar_hash': None,
            'metadata': None,
            'download_url': 'http://example.com/simple/package/1.0/package-1.0.tar.gz/',
            'release_files': [{
                'size': '0',
                'filename': 'package-1.0.tar.gz',
                'url': 'http://example.com/simple/package/1.0/package-1.0.tar.gz/',
                'version': '1.0',
                'upload_date': str(package['1.0']['package-1.0.tar.gz'].upload_date),
            }],
            'other_releases': [{
                'url': 'http://example.com/#/package/package/2.0',
                'version': '2.0',
            }]
        }

        result = serializer.serialize(package['1.0'])

        self.assertEqual(result, expected)
Esempio n. 42
0
    def test_download_release(self, mock):
        from papaye.views.simple import DownloadReleaseView
        from papaye.models import ReleaseFile, Release, Package

        package = Package(name='package')
        release = Release(name='1.0', version='1.0', metadata={})
        release_file = ReleaseFile(filename='releasefile-1.0.tar.gz',
                                   content=b'Hello')
        release_file.content_type = 'text/plain'
        package['1.0'] = release
        package['1.0']['releasefile-1.0.tar.gz'] = release_file

        pypi_response = {
            'info': {
                'name': 'package',
                'version': '1.0'
            },
            'releases': {
                '1.0': [{
                    'filename': 'releasefile1.tar.gz',
                    'url': 'http://example.com/',
                    'md5_digest': 'fake md5',
                }]
            }
        }
        mock.return_value = FakeGRequestResponse(
            200, bytes(json.dumps(pypi_response), 'utf-8'))

        self.request.registry.settings['papaye.proxy'] = 'true'
        view = DownloadReleaseView(release_file, self.request)
        result = view()

        self.assertEqual(result.status_code, 200)
        self.assertEqual(result.body, b'Hello')
        self.assertEqual(result.content_type, 'text/plain')
        self.assertEqual(result.content_disposition,
                         'attachment; filename="releasefile-1.0.tar.gz"')
Esempio n. 43
0
    def test_by_name_not_found(self):
        from papaye.models import Package

        result = Package.by_name('package1', self.request)
        self.assertEqual(result, None)