def test_get_changed_since(dbapp):
dbapp.engine.execute(packages.insert().values(name="foo1"))
dbapp.engine.execute(packages.insert().values(name="foo2"))
dbapp.engine.execute(packages.insert().values(name="foo3"))
now = datetime.datetime.utcnow()
dbapp.engine.execute(journals.insert().values(
name="foo2",
submitted_date=now - datetime.timedelta(seconds=10),
))
dbapp.engine.execute(journals.insert().values(
name="foo1",
submitted_date=now - datetime.timedelta(seconds=4),
))
dbapp.engine.execute(journals.insert().values(
name="foo3",
submitted_date=now - datetime.timedelta(seconds=3),
))
dbapp.engine.execute(journals.insert().values(
name="foo1",
submitted_date=now,
))
since = now - datetime.timedelta(seconds=5)
assert dbapp.models.packaging.get_changed_since(since) == ["foo1", "foo3"]
def test_get_roles_for_user(dbapp):
dbapp.engine.execute(users.insert().values(
id=1,
password="******",
username="******",
name="Test User",
last_login=datetime.datetime.utcnow(),
is_active=True,
is_superuser=False,
is_staff=False,
))
dbapp.engine.execute(users.insert().values(
id=2,
password="******",
username="******",
name="Test User",
last_login=datetime.datetime.utcnow(),
is_active=True,
is_superuser=False,
is_staff=False,
))
dbapp.engine.execute(packages.insert().values(name="test-project"))
dbapp.engine.execute(packages.insert().values(name="test-project2"))
dbapp.engine.execute(packages.insert().values(name="test-project3"))
dbapp.engine.execute(roles.insert().values(
package_name="test-project",
user_name="test-user",
role_name="Owner",
))
dbapp.engine.execute(roles.insert().values(
package_name="test-project",
user_name="test-user",
role_name="Maintainer",
))
dbapp.engine.execute(roles.insert().values(
package_name="test-project2",
user_name="a-test-user",
role_name="Maintainer",
))
dbapp.engine.execute(roles.insert().values(
package_name="test-project2",
user_name="test-user",
role_name="Maintainer",
))
assert dbapp.models.packaging.get_roles_for_user("test-user") == [
{
"package_name": "test-project",
"role_name": 'Maintainer'
},
{
"package_name": "test-project",
"role_name": "Owner"
},
{
"package_name": "test-project2",
"role_name": 'Maintainer'
},
]
def test_get_releases_since(dbapp):
dbapp.engine.execute(packages.insert().values(name="foo1"))
dbapp.engine.execute(packages.insert().values(name="foo2"))
dbapp.engine.execute(packages.insert().values(name="foo3"))
now = datetime.datetime.utcnow()
dbapp.engine.execute(releases.insert().values(
name="foo2",
version="1.0",
created=now - datetime.timedelta(seconds=10),
))
dbapp.engine.execute(releases.insert().values(
name="foo3",
version="2.0",
created=now - datetime.timedelta(seconds=9),
))
dbapp.engine.execute(releases.insert().values(
name="foo1",
version="1.0",
created=now - datetime.timedelta(seconds=4),
))
dbapp.engine.execute(releases.insert().values(
name="foo3",
version="1.0",
created=now - datetime.timedelta(seconds=3),
))
dbapp.engine.execute(releases.insert().values(
name="foo1",
version="2.0",
created=now,
))
since = now - datetime.timedelta(seconds=5)
assert dbapp.models.packaging.get_releases_since(since) == [
{
"name": "foo1",
"version": "2.0",
"summary": None,
"created": now,
},
{
"name": "foo3",
"version": "1.0",
"summary": None,
"created": now - datetime.timedelta(seconds=3),
},
{
"name": "foo1",
"version": "1.0",
"summary": None,
"created": now - datetime.timedelta(seconds=4),
},
]
def test_get_roles_for_user(dbapp):
dbapp.engine.execute(users.insert().values(
id=1,
password="******",
username="******",
name="Test User",
last_login=datetime.datetime.utcnow(),
is_active=True,
is_superuser=False,
is_staff=False,
))
dbapp.engine.execute(users.insert().values(
id=2,
password="******",
username="******",
name="Test User",
last_login=datetime.datetime.utcnow(),
is_active=True,
is_superuser=False,
is_staff=False,
))
dbapp.engine.execute(packages.insert().values(name="test-project"))
dbapp.engine.execute(packages.insert().values(name="test-project2"))
dbapp.engine.execute(packages.insert().values(name="test-project3"))
dbapp.engine.execute(roles.insert().values(
package_name="test-project",
user_name="test-user",
role_name="Owner",
))
dbapp.engine.execute(roles.insert().values(
package_name="test-project",
user_name="test-user",
role_name="Maintainer",
))
dbapp.engine.execute(roles.insert().values(
package_name="test-project2",
user_name="a-test-user",
role_name="Maintainer",
))
dbapp.engine.execute(roles.insert().values(
package_name="test-project2",
user_name="test-user",
role_name="Maintainer",
))
assert dbapp.db.packaging.get_roles_for_user("test-user") == [
{"package_name": "test-project", "role_name": 'Maintainer'},
{"package_name": "test-project", "role_name": "Owner"},
{"package_name": "test-project2", "role_name": 'Maintainer'},
]
def test_get_releases_since(dbapp):
dbapp.engine.execute(packages.insert().values(name="foo1"))
dbapp.engine.execute(packages.insert().values(name="foo2"))
dbapp.engine.execute(packages.insert().values(name="foo3"))
now = datetime.datetime.utcnow()
dbapp.engine.execute(releases.insert().values(
name="foo2", version="1.0",
created=now - datetime.timedelta(seconds=10),
))
dbapp.engine.execute(releases.insert().values(
name="foo3", version="2.0",
created=now - datetime.timedelta(seconds=9),
))
dbapp.engine.execute(releases.insert().values(
name="foo1", version="1.0",
created=now - datetime.timedelta(seconds=4),
))
dbapp.engine.execute(releases.insert().values(
name="foo3", version="1.0",
created=now - datetime.timedelta(seconds=3),
))
dbapp.engine.execute(releases.insert().values(
name="foo1", version="2.0", created=now,
))
since = now - datetime.timedelta(seconds=5)
assert dbapp.db.packaging.get_releases_since(since) == [
{
"name": "foo1",
"version": "2.0",
"summary": None,
"created": now,
},
{
"name": "foo3",
"version": "1.0",
"summary": None,
"created": now - datetime.timedelta(seconds=3),
},
{
"name": "foo1",
"version": "1.0",
"summary": None,
"created": now - datetime.timedelta(seconds=4),
},
]
def test_get_project_versions(dbapp):
dbapp.engine.execute(packages.insert().values(name="test-project"))
dbapp.engine.execute(releases.insert().values(
name="test-project",
version="2.0",
_pypi_ordering=2,
))
dbapp.engine.execute(releases.insert().values(
name="test-project",
version="1.0",
_pypi_ordering=1,
))
dbapp.engine.execute(releases.insert().values(
name="test-project",
version="3.0",
_pypi_ordering=3,
))
dbapp.engine.execute(releases.insert().values(
name="test-project",
version="4.0",
_pypi_ordering=4,
))
assert dbapp.db.packaging.get_project_versions("test-project") == \
["4.0", "3.0", "2.0", "1.0"]
def test_get_project(name, normalized, dbapp):
# prepare database
dbapp.engine.execute(
packages.insert().values(name=name, normalized_name=normalized)
)
assert dbapp.db.packaging.get_project(normalized) == name
def test_get_projects_for_user(dbapp):
dbapp.engine.execute(users.insert().values(
password="******",
username="******",
name="Test User",
last_login=datetime.datetime.utcnow(),
is_active=True,
is_superuser=False,
is_staff=False,
))
dbapp.engine.execute(packages.insert().values(name="test-project"))
dbapp.engine.execute(releases.insert().values(
name="test-project",
version="1.0",
summary="test summmary",
_pypi_ordering=1,
))
dbapp.engine.execute(releases.insert().values(
name="test-project",
version="2.0",
summary="test summmary 2.0",
_pypi_ordering=2,
))
dbapp.engine.execute(roles.insert().values(
package_name="test-project",
user_name="test-user",
role_name="Owner",
))
assert dbapp.db.packaging.get_projects_for_user("test-user") == [
{"name": "test-project", "summary": "test summmary 2.0"},
]
def test_get_projects_for_user(dbapp):
dbapp.engine.execute(users.insert().values(
password="******",
username="******",
name="Test User",
last_login=datetime.datetime.utcnow(),
is_active=True,
is_superuser=False,
is_staff=False,
))
dbapp.engine.execute(packages.insert().values(name="test-project"))
dbapp.engine.execute(releases.insert().values(
name="test-project",
version="1.0",
summary="test summmary",
_pypi_ordering=1,
))
dbapp.engine.execute(releases.insert().values(
name="test-project",
version="2.0",
summary="test summmary 2.0",
_pypi_ordering=2,
))
dbapp.engine.execute(roles.insert().values(
package_name="test-project",
user_name="test-user",
role_name="Owner",
))
assert dbapp.models.packaging.get_projects_for_user("test-user") == [
{
"name": "test-project",
"summary": "test summmary 2.0"
},
]
def test_all_projects(projects, dbapp):
# Insert some data into the database
for project in projects:
dbapp.engine.execute(packages.insert().values(name=project))
all_projects = [Project(p) for p in sorted(projects, key=lambda x: x.lower())]
assert dbapp.models.packaging.all_projects() == all_projects
def test_get_hosting_mode(name, mode, dbapp):
# prepare database
dbapp.engine.execute(
packages.insert().values(name=name, hosting_mode=mode)
)
assert dbapp.db.packaging.get_hosting_mode(name) == mode
def test_get_file_urls(name, values, urls, dbapp):
# prepare db
dbapp.engine.execute(packages.insert().values(name=name))
for value in values:
dbapp.engine.execute(release_files.insert().values(name=name, **value))
assert dbapp.models.packaging.get_file_urls(name) == [FileURL(f, u) for f, u in sorted(set(urls), reverse=True)]
def test_get_project_versions(dbapp):
dbapp.engine.execute(packages.insert().values(name="test-project"))
dbapp.engine.execute(releases.insert().values(
name="test-project",
version="2.0",
_pypi_ordering=2,
))
dbapp.engine.execute(releases.insert().values(
name="test-project",
version="1.0",
_pypi_ordering=1,
))
dbapp.engine.execute(releases.insert().values(
name="test-project",
version="3.0",
_pypi_ordering=3,
))
dbapp.engine.execute(releases.insert().values(
name="test-project",
version="4.0",
_pypi_ordering=4,
))
assert dbapp.models.packaging.get_project_versions("test-project") == \
["4.0", "3.0", "2.0", "1.0"]
def test_get_users_for_project(dbapp):
dbapp.engine.execute(users.insert().values(
id=1,
password="******",
username="******",
name="Test User",
last_login=datetime.datetime.utcnow(),
is_active=True,
is_superuser=False,
is_staff=False,
))
dbapp.engine.execute(users.insert().values(
id=2,
password="******",
username="******",
name="Test User",
last_login=datetime.datetime.utcnow(),
is_active=True,
is_superuser=False,
is_staff=False,
))
dbapp.engine.execute(users.insert().values(
id=3,
password="******",
username="******",
name="Test User2",
last_login=datetime.datetime.utcnow(),
is_active=True,
is_superuser=False,
is_staff=False,
))
dbapp.engine.execute(emails.insert().values(
user_id=3,
email="*****@*****.**",
primary=True,
verified=True,
))
dbapp.engine.execute(packages.insert().values(name="test-project"))
dbapp.engine.execute(roles.insert().values(
package_name="test-project",
user_name="test-user",
role_name="Owner",
))
dbapp.engine.execute(roles.insert().values(
package_name="test-project",
user_name="test-user2",
role_name="Maintainer",
))
dbapp.engine.execute(roles.insert().values(
package_name="test-project",
user_name="a-test-user",
role_name="Maintainer",
))
assert dbapp.models.packaging.get_users_for_project("test-project") == [
{"username": "******", "email": None},
{"username": "******", "email": None},
{"username": "******", "email": "*****@*****.**"},
]
def test_get_full_latest_releases(dbapp):
created = datetime.datetime.utcnow()
dbapp.engine.execute(packages.insert().values(name="test-project"))
dbapp.engine.execute(releases.insert().values(
created=created,
name="test-project",
version="1.0",
author="John Doe",
author_email="*****@*****.**",
maintainer="Jane Doe",
maintainer_email="*****@*****.**",
home_page="https://example.com/",
license="Apache License v2.0",
summary="A Test Project",
description="A Longer Test Project",
keywords="foo,bar,wat",
platform="All",
download_url="https://example.com/downloads/test-project-1.0.tar.gz",
_pypi_ordering=1,
))
dbapp.engine.execute(releases.insert().values(
created=created,
name="test-project",
version="2.0",
author="John Doe",
author_email="*****@*****.**",
maintainer="Jane Doe",
maintainer_email="*****@*****.**",
home_page="https://example.com/",
license="Apache License v2.0",
summary="A Test Project",
description="A Longer Test Project",
keywords="foo,bar,wat",
platform="All",
download_url="https://example.com/downloads/test-project-1.0.tar.gz",
_pypi_ordering=2,
))
assert dbapp.db.packaging.get_full_latest_releases() == [
{
"created": created,
"name": "test-project",
"version": "2.0",
"author": "John Doe",
"author_email": "*****@*****.**",
"maintainer": "Jane Doe",
"maintainer_email": "*****@*****.**",
"home_page": "https://example.com/",
"license": "Apache License v2.0",
"summary": "A Test Project",
"description": "A Longer Test Project",
"keywords": "foo,bar,wat",
"platform": "All",
"download_url": (
"https://example.com/downloads/test-project-1.0.tar.gz"
),
}
]
def test_all_projects(projects, dbapp):
# Insert some data into the database
for project in projects:
dbapp.engine.execute(packages.insert().values(name=project))
all_projects = sorted(projects, key=lambda x: x.lower())
assert dbapp.models.packaging.all_projects() == all_projects
def test_get_bugtrack_url(dbapp):
dbapp.engine.execute(packages.insert().values(
name="test-project",
bugtrack_url="https://example.com/issues/",
))
bugtracker = dbapp.db.packaging.get_bugtrack_url("test-project")
assert bugtracker == "https://example.com/issues/"
def add_project(name, classifiers):
dbapp.engine.execute(packages.insert().values(name=name))
dbapp.engine.execute(releases.insert().values(name=name, version="1"))
for trove_id in classifiers:
dbapp.engine.execute(release_classifiers.insert().values(
name=name,
version="1",
trove_id=trove_id,
))
def test_get_release_urls(name, attrs, dbapp):
# prepare database
dbapp.engine.execute(packages.insert().values(name=name))
for data in attrs:
dbapp.engine.execute(releases.insert().values(name=name, **data))
assert dbapp.models.packaging.get_release_urls(name) == {
a["version"]: (a.get("home_page"), a.get("download_url")) for a in attrs
}
def add_project(name, classifiers):
dbapp.engine.execute(packages.insert().values(name=name))
dbapp.engine.execute(releases.insert().values(name=name, version="1"))
for trove_id in classifiers:
dbapp.engine.execute(release_classifiers.insert().values(
name=name,
version="1",
trove_id=trove_id,
))
def create(name, delta):
dbapp.engine.execute(packages.insert().values(name=name))
dbapp.engine.execute(journals.insert().values(name=name,
version=None,
submitted_date=now -
delta,
action="create",
id=create.id))
create.id += 1
def test_get_bugtrack_url(dbapp):
dbapp.engine.execute(packages.insert().values(
name="test-project",
bugtrack_url="https://example.com/issues/",
))
bugtracker = dbapp.models.packaging.get_bugtrack_url("test-project")
assert bugtracker == "https://example.com/issues/"
def test_get_downloads(pgp, dbapp, monkeypatch):
dbapp.engine.execute(packages.insert().values(name="test-project"))
dbapp.engine.execute(releases.insert().values(
name="test-project",
version="1.0",
))
dbapp.engine.execute(release_files.insert().values(
name="test-project",
version="1.0",
filename="test-project-1.0.tar.gz",
python_version="source",
packagetype="sdist",
md5_digest="0cc175b9c0f1b6a831c399e269772661",
downloads=10,
upload_time=datetime.datetime(year=2013, month=1, day=30),
))
def os_exists():
yield # start
yield True # whether download file exists
yield pgp # whether .asc pgp file exists
f = os_exists().send
f(None) # start it off
os_exists = pretend.call_recorder(f)
monkeypatch.setattr(os.path, "exists", os_exists)
monkeypatch.setattr(os.path, "getsize", lambda x: 10)
dbapp.config.paths.packages = "fake"
downloads = dbapp.models.packaging.get_downloads("test-project", "1.0")
pgp_url = "/packages/source/t/test-project/test-project-1.0.tar.gz.asc"
assert downloads == [
{
"name": "test-project",
"version": "1.0",
"filename": "test-project-1.0.tar.gz",
"filepath": "fake/source/t/test-project/test-project-1.0.tar.gz",
"comment_text": None,
"downloads": 10,
"upload_time": datetime.datetime(year=2013, month=1, day=30),
"python_version": "source",
"md5_digest": "0cc175b9c0f1b6a831c399e269772661",
"url": "/packages/source/t/test-project/test-project-1.0.tar.gz",
"packagetype": "sdist",
"size": 10,
"pgp_url": pgp_url if pgp else None,
},
]
assert os_exists.calls == [
pretend.call(downloads[0]["filepath"]),
pretend.call(downloads[0]["filepath"] + ".asc")
]
def test_get_release_urls(name, attrs, dbapp):
# prepare database
dbapp.engine.execute(packages.insert().values(name=name))
for data in attrs:
dbapp.engine.execute(releases.insert().values(name=name, **data))
assert dbapp.models.packaging.get_release_urls(name) == {
a["version"]: (a.get("home_page"), a.get("download_url"))
for a in attrs
}
def create(name, delta):
dbapp.engine.execute(packages.insert().values(name=name))
dbapp.engine.execute(journals.insert().values(
name=name,
version=None,
submitted_date=now - delta,
action="create",
id=create.id,
))
create.id += 1
def test_get_file_urls(name, values, urls, dbapp):
# prepare db
dbapp.engine.execute(packages.insert().values(name=name))
for value in values:
dbapp.engine.execute(release_files.insert().values(name=name, **value))
assert dbapp.models.packaging.get_file_urls(name) == [{
"filename": f,
"url": u
} for f, u in sorted(set(urls), reverse=True)]
def test_get_downloads(pgp, dbapp, monkeypatch):
dbapp.engine.execute(packages.insert().values(name="test-project"))
dbapp.engine.execute(releases.insert().values(
name="test-project",
version="1.0",
))
dbapp.engine.execute(release_files.insert().values(
name="test-project",
version="1.0",
filename="test-project-1.0.tar.gz",
python_version="source",
packagetype="sdist",
md5_digest="0cc175b9c0f1b6a831c399e269772661",
downloads=10,
upload_time=datetime.datetime(year=2013, month=1, day=30),
))
def os_exists():
yield # start
yield True # whether download file exists
yield pgp # whether .asc pgp file exists
f = os_exists().send
f(None) # start it off
os_exists = pretend.call_recorder(f)
monkeypatch.setattr(os.path, "exists", os_exists)
monkeypatch.setattr(os.path, "getsize", lambda x: 10)
dbapp.config.paths.packages = "fake"
downloads = dbapp.db.packaging.get_downloads("test-project", "1.0")
pgp_url = "/packages/source/t/test-project/test-project-1.0.tar.gz.asc"
assert downloads == [
{
"name": "test-project",
"version": "1.0",
"filename": "test-project-1.0.tar.gz",
"filepath": "fake/source/t/test-project/test-project-1.0.tar.gz",
"comment_text": None,
"downloads": 10,
"upload_time": datetime.datetime(year=2013, month=1, day=30),
"python_version": "source",
"md5_digest": "0cc175b9c0f1b6a831c399e269772661",
"url": "/packages/source/t/test-project/test-project-1.0.tar.gz",
"packagetype": "sdist",
"size": 10,
"pgp_url": pgp_url if pgp else None,
},
]
assert os_exists.calls == [
pretend.call(downloads[0]["filepath"]),
pretend.call(downloads[0]["filepath"] + ".asc")
]
def test_get_changed_since(dbapp):
dbapp.engine.execute(packages.insert().values(name="foo1"))
dbapp.engine.execute(packages.insert().values(name="foo2"))
dbapp.engine.execute(packages.insert().values(name="foo3"))
now = datetime.datetime.utcnow()
dbapp.engine.execute(journals.insert().values(
name="foo2", submitted_date=now - datetime.timedelta(seconds=10),
))
dbapp.engine.execute(journals.insert().values(
name="foo1", submitted_date=now - datetime.timedelta(seconds=4),
))
dbapp.engine.execute(journals.insert().values(
name="foo3", submitted_date=now - datetime.timedelta(seconds=3),
))
dbapp.engine.execute(journals.insert().values(
name="foo1", submitted_date=now, ))
since = now - datetime.timedelta(seconds=5)
assert dbapp.db.packaging.get_changed_since(since) == ["foo1", "foo3"]
def test_get_download_count(dbapp):
dbapp.engine.execute(packages.insert().values(name="foo"))
dbapp.engine.execute(releases.insert().values(name="foo", version="1.0"))
dbapp.engine.execute(release_files.insert().values(
name="foo",
version="1.0",
filename="foo-1.0.tar.gz",
downloads=15,
))
dbapp.engine.execute(release_files.insert().values(
name="foo",
version="1.0",
filename="foo-1.0.tar.bz2",
downloads=12,
))
assert dbapp.models.packaging.get_download_count() == 27
def test_get_download_count(dbapp):
dbapp.engine.execute(packages.insert().values(name="foo"))
dbapp.engine.execute(releases.insert().values(name="foo", version="1.0"))
dbapp.engine.execute(release_files.insert().values(
name="foo",
version="1.0",
filename="foo-1.0.tar.gz",
downloads=15,
))
dbapp.engine.execute(release_files.insert().values(
name="foo",
version="1.0",
filename="foo-1.0.tar.bz2",
downloads=12,
))
assert dbapp.models.packaging.get_download_count() == 27
def test_get_downloads_missing(dbapp, monkeypatch):
dbapp.engine.execute(packages.insert().values(name="test-project"))
dbapp.engine.execute(releases.insert().values(
name="test-project",
version="1.0",
))
dbapp.engine.execute(release_files.insert().values(
name="test-project",
version="1.0",
filename="test-project-1.0.tar.gz",
python_version="source",
packagetype="sdist",
md5_digest="0cc175b9c0f1b6a831c399e269772661",
downloads=10,
upload_time=datetime.datetime(year=2013, month=1, day=30),
))
# file does not exist
os_exists = pretend.call_recorder(lambda p: False)
# we match the specific arguments below - no need forcing them here as well
log_error = pretend.call_recorder(lambda *a: None)
monkeypatch.setattr(os.path, "exists", os_exists)
# log from warehouse.packaging.db
monkeypatch.setattr(log, "error", log_error)
dbapp.config.paths.packages = "fake"
downloads = dbapp.db.packaging.get_downloads("test-project", "1.0")
assert downloads == []
filepath = "fake/source/t/test-project/test-project-1.0.tar.gz"
assert os_exists.calls == [pretend.call(filepath)]
# actual error message may vary, so just assert that the logging was called
assert log_error.calls == [
pretend.call(
"%s missing for package %s %s",
filepath,
"test-project",
"1.0",
),
]
def test_get_downloads_missing(dbapp, monkeypatch):
dbapp.engine.execute(packages.insert().values(name="test-project"))
dbapp.engine.execute(releases.insert().values(
name="test-project",
version="1.0",
))
dbapp.engine.execute(release_files.insert().values(
name="test-project",
version="1.0",
filename="test-project-1.0.tar.gz",
python_version="source",
packagetype="sdist",
md5_digest="0cc175b9c0f1b6a831c399e269772661",
downloads=10,
upload_time=datetime.datetime(year=2013, month=1, day=30),
))
# file does not exist
os_exists = pretend.call_recorder(lambda p: False)
# we match the specific arguments below - no need forcing them here as well
log_error = pretend.call_recorder(lambda *a: None)
monkeypatch.setattr(os.path, "exists", os_exists)
# log from warehouse.packaging.models
monkeypatch.setattr(log, "error", log_error)
dbapp.config.paths.packages = "fake"
downloads = dbapp.models.packaging.get_downloads("test-project", "1.0")
assert downloads == []
filepath = "fake/source/t/test-project/test-project-1.0.tar.gz"
assert os_exists.calls == [pretend.call(filepath)]
# actual error message may vary, so just assert that the logging was called
assert log_error.calls == [
pretend.call(
"%s missing for package %s %s",
filepath,
"test-project",
"1.0",
),
]
def upsert_project(self, name, username, user_ip, **additional_columns):
# NOTE: pypi behaviour is to assign the first submitter of a
# project the "owner" role. this code does not
# perform that behaviour (implement in the view instead)
db.validate_argument_column_mapping(additional_columns, packages)
existing_project = self.get_project(name)
if existing_project:
message = "updating project {0}".format(existing_project['name'])
query = (packages.update().where(
packages.c.name == existing_project['name']))
else:
message = "create"
query = packages.insert()
self.engine.execute(
query.values(name=name,
normalized_name=utils.normalize_project_name(name),
**additional_columns))
self._insert_journal_entry(name, None, message, username, user_ip)
def test_get_classifiers(dbapp):
dbapp.engine.execute(packages.insert().values(name="test-project"))
dbapp.engine.execute(releases.insert().values(
name="test-project",
version="1.0",
))
dbapp.engine.execute(classifiers.insert().values(
id=1,
classifier="Test :: Classifier",
))
dbapp.engine.execute(release_classifiers.insert().values(
name="test-project",
version="1.0",
trove_id=1,
))
test_classifiers = dbapp.models.packaging.get_classifiers(
"test-project",
"1.0",
)
assert test_classifiers == ["Test :: Classifier"]
def test_get_classifiers(dbapp):
dbapp.engine.execute(packages.insert().values(name="test-project"))
dbapp.engine.execute(releases.insert().values(
name="test-project",
version="1.0",
))
dbapp.engine.execute(classifiers.insert().values(
id=1,
classifier="Test :: Classifier",
))
dbapp.engine.execute(release_classifiers.insert().values(
name="test-project",
version="1.0",
trove_id=1,
))
test_classifiers = dbapp.db.packaging.get_classifiers(
"test-project",
"1.0",
)
assert test_classifiers == ["Test :: Classifier"]
def upsert_project(self, name, username, user_ip, **additional_columns):
# NOTE: pypi behaviour is to assign the first submitter of a
# project the "owner" role. this code does not
# perform that behaviour (implement in the view instead)
db.validate_argument_column_mapping(additional_columns, packages)
existing_project = self.get_project(name)
if existing_project:
message = "updating project {0}".format(existing_project['name'])
query = (packages.update()
.where(packages.c.name == existing_project['name']))
else:
message = "create"
query = packages.insert()
self.engine.execute(query.values(
name=name,
normalized_name=utils.normalize_project_name(name),
**additional_columns
))
self._insert_journal_entry(name, None, message, username, user_ip)
def test_get_recently_updated(dbapp):
dbapp.engine.execute(packages.insert().values(name="foo1"))
dbapp.engine.execute(packages.insert().values(name="foo2"))
dbapp.engine.execute(packages.insert().values(name="foo3"))
dbapp.engine.execute(packages.insert().values(name="foo4"))
dbapp.engine.execute(packages.insert().values(name="foo5"))
dbapp.engine.execute(packages.insert().values(name="foo6"))
dbapp.engine.execute(packages.insert().values(name="foo7"))
dbapp.engine.execute(packages.insert().values(name="foo8"))
dbapp.engine.execute(packages.insert().values(name="foo9"))
dbapp.engine.execute(packages.insert().values(name="foo10"))
dbapp.engine.execute(packages.insert().values(name="foo11"))
dbapp.engine.execute(packages.insert().values(name="foo12"))
now = datetime.datetime.utcnow()
dbapp.engine.execute(releases.insert().values(
name="foo1", version="2.0", created=now,
))
dbapp.engine.execute(releases.insert().values(
name="foo1", version="1.0",
created=now - datetime.timedelta(seconds=5),
))
dbapp.engine.execute(releases.insert().values(
name="foo2", version="1.0",
created=now - datetime.timedelta(seconds=10),
))
dbapp.engine.execute(releases.insert().values(
name="foo3", version="1.0",
created=now - datetime.timedelta(seconds=15),
))
dbapp.engine.execute(releases.insert().values(
name="foo4", version="1.0",
created=now - datetime.timedelta(seconds=20),
))
dbapp.engine.execute(releases.insert().values(
name="foo5", version="1.0",
created=now - datetime.timedelta(seconds=25),
))
dbapp.engine.execute(releases.insert().values(
name="foo6", version="1.0",
created=now - datetime.timedelta(seconds=30),
))
dbapp.engine.execute(releases.insert().values(
name="foo7", version="1.0",
created=now - datetime.timedelta(seconds=35),
))
dbapp.engine.execute(releases.insert().values(
name="foo8", version="1.0",
created=now - datetime.timedelta(seconds=40),
))
dbapp.engine.execute(releases.insert().values(
name="foo9", version="1.0",
created=now - datetime.timedelta(seconds=45),
))
dbapp.engine.execute(releases.insert().values(
name="foo10", version="1.0",
created=now - datetime.timedelta(seconds=50),
))
dbapp.engine.execute(releases.insert().values(
name="foo11", version="1.0",
created=now - datetime.timedelta(seconds=55),
))
dbapp.engine.execute(releases.insert().values(
name="foo12", version="1.0",
created=now - datetime.timedelta(seconds=60),
))
assert dbapp.db.packaging.get_recently_updated() == [
{
"name": "foo1",
"version": "2.0",
"summary": None,
"created": now,
},
{
"name": "foo2",
"version": "1.0",
"summary": None,
"created": now - datetime.timedelta(seconds=10),
},
{
"name": "foo3",
"version": "1.0",
"summary": None,
"created": now - datetime.timedelta(seconds=15),
},
{
"name": "foo4",
"version": "1.0",
"summary": None,
"created": now - datetime.timedelta(seconds=20),
},
{
"name": "foo5",
"version": "1.0",
"summary": None,
"created": now - datetime.timedelta(seconds=25),
},
{
"name": "foo6",
"version": "1.0",
"summary": None,
"created": now - datetime.timedelta(seconds=30),
},
{
"name": "foo7",
"version": "1.0",
"summary": None,
"created": now - datetime.timedelta(seconds=35),
},
{
"name": "foo8",
"version": "1.0",
"summary": None,
"created": now - datetime.timedelta(seconds=40),
},
{
"name": "foo9",
"version": "1.0",
"summary": None,
"created": now - datetime.timedelta(seconds=45),
},
{
"name": "foo10",
"version": "1.0",
"summary": None,
"created": now - datetime.timedelta(seconds=50),
},
]
def test_get_release(dbapp):
created = datetime.datetime.utcnow()
dbapp.engine.execute(packages.insert().values(name="test-project"))
dbapp.engine.execute(releases.insert().values(
created=created,
name="test-project",
version="1.0",
author="John Doe",
author_email="*****@*****.**",
maintainer="Jane Doe",
maintainer_email="*****@*****.**",
home_page="https://example.com/",
license="Apache License v2.0",
summary="A Test Project",
description="A Longer Test Project",
keywords="foo,bar,wat",
platform="All",
download_url="https://example.com/downloads/test-project-1.0.tar.gz",
_pypi_ordering=1,
))
dbapp.engine.execute(releases.insert().values(
created=created,
name="test-project",
version="2.0",
author="John Doe",
author_email="*****@*****.**",
maintainer="Jane Doe",
maintainer_email="*****@*****.**",
home_page="https://example.com/",
license="Apache License v2.0",
summary="A Test Project",
description="A Longer Test Project",
keywords="foo,bar,wat",
platform="All",
download_url="https://example.com/downloads/test-project-1.0.tar.gz",
_pypi_ordering=2,
))
dbapp.engine.execute(release_dependencies.insert().values(
name="test-project",
version="1.0",
kind=4,
specifier="requests (>=2.0)",
))
dbapp.engine.execute(release_dependencies.insert().values(
name="test-project",
version="2.0",
kind=4,
specifier="requests (>=2.0)",
))
dbapp.engine.execute(release_dependencies.insert().values(
name="test-project",
version="1.0",
kind=5,
specifier="test-project-old",
))
dbapp.engine.execute(release_dependencies.insert().values(
name="test-project",
version="2.0",
kind=5,
specifier="test-project-old",
))
dbapp.engine.execute(release_dependencies.insert().values(
name="test-project",
version="1.0",
kind=8,
specifier="Repository,git://git.example.com/",
))
dbapp.engine.execute(release_dependencies.insert().values(
name="test-project",
version="2.0",
kind=8,
specifier="Repository,git://git.example.com/",
))
test_release = dbapp.models.packaging.get_release("test-project", "1.0")
assert test_release == {
"name":
"test-project",
"version":
"1.0",
"author":
"John Doe",
"author_email":
"*****@*****.**",
"maintainer":
"Jane Doe",
"maintainer_email":
"*****@*****.**",
"home_page":
"https://example.com/",
"license":
"Apache License v2.0",
"summary":
"A Test Project",
"description":
"A Longer Test Project",
"keywords":
"foo,bar,wat",
"platform":
"All",
"download_url": ("https://example.com/downloads/"
"test-project-1.0.tar.gz"),
"requires_dist": ["requests (>=2.0)"],
"provides_dist": ["test-project-old"],
"project_url": {
"Repository": "git://git.example.com/"
},
"created":
created,
}
def create_package(name, version, ordering, created):
dbapp.engine.execute(packages.insert().values(
name=name, created=created))
dbapp.engine.execute(releases.insert().values(
name=name, version=version, _pypi_ordering=ordering,
created=created))
def test_get_full_latest_releases(dbapp):
created = datetime.datetime.utcnow()
dbapp.engine.execute(packages.insert().values(name="test-project"))
dbapp.engine.execute(releases.insert().values(
created=created,
name="test-project",
version="1.0",
author="John Doe",
author_email="*****@*****.**",
maintainer="Jane Doe",
maintainer_email="*****@*****.**",
home_page="https://example.com/",
license="Apache License v2.0",
summary="A Test Project",
description="A Longer Test Project",
keywords="foo,bar,wat",
platform="All",
download_url="https://example.com/downloads/test-project-1.0.tar.gz",
_pypi_ordering=1,
))
dbapp.engine.execute(releases.insert().values(
created=created,
name="test-project",
version="2.0",
author="John Doe",
author_email="*****@*****.**",
maintainer="Jane Doe",
maintainer_email="*****@*****.**",
home_page="https://example.com/",
license="Apache License v2.0",
summary="A Test Project",
description="A Longer Test Project",
keywords="foo,bar,wat",
platform="All",
download_url="https://example.com/downloads/test-project-1.0.tar.gz",
_pypi_ordering=2,
))
assert dbapp.models.packaging.get_full_latest_releases() == [{
"created":
created,
"name":
"test-project",
"version":
"2.0",
"author":
"John Doe",
"author_email":
"*****@*****.**",
"maintainer":
"Jane Doe",
"maintainer_email":
"*****@*****.**",
"home_page":
"https://example.com/",
"license":
"Apache License v2.0",
"summary":
"A Test Project",
"description":
"A Longer Test Project",
"keywords":
"foo,bar,wat",
"platform":
"All",
"download_url":
("https://example.com/downloads/test-project-1.0.tar.gz"),
}]
def test_get_hosting_mode(name, mode, dbapp):
# prepare database
dbapp.engine.execute(packages.insert().values(name=name,
hosting_mode=mode))
assert dbapp.models.packaging.get_hosting_mode(name) == mode
def test_get_project_count(dbapp):
dbapp.engine.execute(packages.insert().values(name="foo1"))
dbapp.engine.execute(packages.insert().values(name="foo2"))
dbapp.engine.execute(packages.insert().values(name="foo3"))
assert dbapp.models.packaging.get_project_count() == 3
def test_get_project_count(dbapp):
dbapp.engine.execute(packages.insert().values(name="foo1"))
dbapp.engine.execute(packages.insert().values(name="foo2"))
dbapp.engine.execute(packages.insert().values(name="foo3"))
assert dbapp.db.packaging.get_project_count() == 3
def test_get_recently_updated(dbapp):
dbapp.engine.execute(packages.insert().values(name="foo1"))
dbapp.engine.execute(packages.insert().values(name="foo2"))
dbapp.engine.execute(packages.insert().values(name="foo3"))
dbapp.engine.execute(packages.insert().values(name="foo4"))
dbapp.engine.execute(packages.insert().values(name="foo5"))
dbapp.engine.execute(packages.insert().values(name="foo6"))
dbapp.engine.execute(packages.insert().values(name="foo7"))
dbapp.engine.execute(packages.insert().values(name="foo8"))
dbapp.engine.execute(packages.insert().values(name="foo9"))
dbapp.engine.execute(packages.insert().values(name="foo10"))
dbapp.engine.execute(packages.insert().values(name="foo11"))
dbapp.engine.execute(packages.insert().values(name="foo12"))
now = datetime.datetime.utcnow()
dbapp.engine.execute(releases.insert().values(
name="foo1",
version="2.0",
created=now,
))
dbapp.engine.execute(releases.insert().values(
name="foo1",
version="1.0",
created=now - datetime.timedelta(seconds=5),
))
dbapp.engine.execute(releases.insert().values(
name="foo2",
version="1.0",
created=now - datetime.timedelta(seconds=10),
))
dbapp.engine.execute(releases.insert().values(
name="foo3",
version="1.0",
created=now - datetime.timedelta(seconds=15),
))
dbapp.engine.execute(releases.insert().values(
name="foo4",
version="1.0",
created=now - datetime.timedelta(seconds=20),
))
dbapp.engine.execute(releases.insert().values(
name="foo5",
version="1.0",
created=now - datetime.timedelta(seconds=25),
))
dbapp.engine.execute(releases.insert().values(
name="foo6",
version="1.0",
created=now - datetime.timedelta(seconds=30),
))
dbapp.engine.execute(releases.insert().values(
name="foo7",
version="1.0",
created=now - datetime.timedelta(seconds=35),
))
dbapp.engine.execute(releases.insert().values(
name="foo8",
version="1.0",
created=now - datetime.timedelta(seconds=40),
))
dbapp.engine.execute(releases.insert().values(
name="foo9",
version="1.0",
created=now - datetime.timedelta(seconds=45),
))
dbapp.engine.execute(releases.insert().values(
name="foo10",
version="1.0",
created=now - datetime.timedelta(seconds=50),
))
dbapp.engine.execute(releases.insert().values(
name="foo11",
version="1.0",
created=now - datetime.timedelta(seconds=55),
))
dbapp.engine.execute(releases.insert().values(
name="foo12",
version="1.0",
created=now - datetime.timedelta(seconds=60),
))
assert dbapp.models.packaging.get_recently_updated() == [
{
"name": "foo1",
"version": "2.0",
"summary": None,
"created": now,
},
{
"name": "foo2",
"version": "1.0",
"summary": None,
"created": now - datetime.timedelta(seconds=10),
},
{
"name": "foo3",
"version": "1.0",
"summary": None,
"created": now - datetime.timedelta(seconds=15),
},
{
"name": "foo4",
"version": "1.0",
"summary": None,
"created": now - datetime.timedelta(seconds=20),
},
{
"name": "foo5",
"version": "1.0",
"summary": None,
"created": now - datetime.timedelta(seconds=25),
},
{
"name": "foo6",
"version": "1.0",
"summary": None,
"created": now - datetime.timedelta(seconds=30),
},
{
"name": "foo7",
"version": "1.0",
"summary": None,
"created": now - datetime.timedelta(seconds=35),
},
{
"name": "foo8",
"version": "1.0",
"summary": None,
"created": now - datetime.timedelta(seconds=40),
},
{
"name": "foo9",
"version": "1.0",
"summary": None,
"created": now - datetime.timedelta(seconds=45),
},
{
"name": "foo10",
"version": "1.0",
"summary": None,
"created": now - datetime.timedelta(seconds=50),
},
]
def test_get_users_for_project(dbapp):
dbapp.engine.execute(users.insert().values(
id=1,
password="******",
username="******",
name="Test User",
last_login=datetime.datetime.utcnow(),
is_active=True,
is_superuser=False,
is_staff=False,
))
dbapp.engine.execute(users.insert().values(
id=2,
password="******",
username="******",
name="Test User",
last_login=datetime.datetime.utcnow(),
is_active=True,
is_superuser=False,
is_staff=False,
))
dbapp.engine.execute(users.insert().values(
id=3,
password="******",
username="******",
name="Test User2",
last_login=datetime.datetime.utcnow(),
is_active=True,
is_superuser=False,
is_staff=False,
))
dbapp.engine.execute(emails.insert().values(
user_id=3,
email="*****@*****.**",
primary=True,
verified=True,
))
dbapp.engine.execute(packages.insert().values(name="test-project"))
dbapp.engine.execute(roles.insert().values(
package_name="test-project",
user_name="test-user",
role_name="Owner",
))
dbapp.engine.execute(roles.insert().values(
package_name="test-project",
user_name="test-user2",
role_name="Maintainer",
))
dbapp.engine.execute(roles.insert().values(
package_name="test-project",
user_name="test-user",
role_name="Maintainer",
))
dbapp.engine.execute(roles.insert().values(
package_name="test-project",
user_name="a-test-user",
role_name="Maintainer",
))
assert dbapp.models.packaging.get_users_for_project("test-project") == [
{
"username": "******",
"email": None
},
{
"username": "******",
"email": None
},
{
"username": "******",
"email": "*****@*****.**"
},
]
def test_get_release(dbapp):
created = datetime.datetime.utcnow()
dbapp.engine.execute(packages.insert().values(name="test-project"))
dbapp.engine.execute(releases.insert().values(
created=created,
name="test-project",
version="1.0",
author="John Doe",
author_email="*****@*****.**",
maintainer="Jane Doe",
maintainer_email="*****@*****.**",
home_page="https://example.com/",
license="Apache License v2.0",
summary="A Test Project",
description="A Longer Test Project",
keywords="foo,bar,wat",
platform="All",
download_url="https://example.com/downloads/test-project-1.0.tar.gz",
_pypi_ordering=1,
))
dbapp.engine.execute(releases.insert().values(
created=created,
name="test-project",
version="2.0",
author="John Doe",
author_email="*****@*****.**",
maintainer="Jane Doe",
maintainer_email="*****@*****.**",
home_page="https://example.com/",
license="Apache License v2.0",
summary="A Test Project",
description="A Longer Test Project",
keywords="foo,bar,wat",
platform="All",
download_url="https://example.com/downloads/test-project-1.0.tar.gz",
_pypi_ordering=2,
))
dbapp.engine.execute(release_dependencies.insert().values(
name="test-project",
version="1.0",
kind=4,
specifier="requests (>=2.0)",
))
dbapp.engine.execute(release_dependencies.insert().values(
name="test-project",
version="2.0",
kind=4,
specifier="requests (>=2.0)",
))
dbapp.engine.execute(release_dependencies.insert().values(
name="test-project",
version="1.0",
kind=5,
specifier="test-project-old",
))
dbapp.engine.execute(release_dependencies.insert().values(
name="test-project",
version="2.0",
kind=5,
specifier="test-project-old",
))
dbapp.engine.execute(release_dependencies.insert().values(
name="test-project",
version="1.0",
kind=8,
specifier="Repository,git://git.example.com/",
))
dbapp.engine.execute(release_dependencies.insert().values(
name="test-project",
version="2.0",
kind=8,
specifier="Repository,git://git.example.com/",
))
test_release = dbapp.db.packaging.get_release("test-project", "1.0")
assert test_release == {
"name": "test-project",
"version": "1.0",
"author": "John Doe",
"author_email": "*****@*****.**",
"maintainer": "Jane Doe",
"maintainer_email": "*****@*****.**",
"home_page": "https://example.com/",
"license": "Apache License v2.0",
"summary": "A Test Project",
"description": "A Longer Test Project",
"keywords": "foo,bar,wat",
"platform": "All",
"download_url": ("https://example.com/downloads/"
"test-project-1.0.tar.gz"),
"requires_dist": ["requests (>=2.0)"],
"provides_dist": ["test-project-old"],
"project_url": {"Repository": "git://git.example.com/"},
"created": created,
}
def test_get_project(name, normalized, dbapp):
# prepare database
dbapp.engine.execute(packages.insert().values(name=name,
normalized_name=normalized))
assert dbapp.models.packaging.get_project(normalized) == name
