datanommer.models 1.0.2__py3-none-any.whl → 1.2.0__py3-none-any.whl

datanommer/models/__init__.py

@@ -14,6 +14,7 @@
 # You should have received a copy of the GNU General Public License along
 # with this program.  If not, see <http://www.gnu.org/licenses/>.
 import datetime
+import importlib.metadata
 import json
 import logging
 import math
@@ -21,7 +22,6 @@ import traceback
 import uuid
 from warnings import warn
 
-import pkg_resources
 from sqlalchemy import (
     and_,
     between,
@@ -31,11 +31,14 @@ from sqlalchemy import (
     DDL,
     event,
     ForeignKey,
+    func,
     Integer,
     not_,
     or_,
+    select,
     String,
     Table,
+    text,
     TypeDecorator,
     Unicode,
     UnicodeText,
@@ -61,6 +64,9 @@ except ImportError:  # pragma: no cover
     UniqueViolation = lookup_error("23505")
 
 
+__version__ = importlib.metadata.version("datanommer.models")
+
+
 log = logging.getLogger("datanommer")
 
 maker = sessionmaker()
@@ -80,7 +86,7 @@ def init(uri=None, alembic_ini=None, engine=None, create=False):
         raise ValueError("One of uri or engine must be specified")
 
     if uri and not engine:
-        engine = create_engine(uri)
+        engine = create_engine(uri, future=True)
 
     # We need to hang our own attribute on the sqlalchemy session to stop
     # ourselves from initializing twice.  That is only a problem if the code
@@ -90,11 +96,12 @@ def init(uri=None, alembic_ini=None, engine=None, create=False):
         return
     session._datanommer_initialized = True
 
-    session.configure(bind=engine)
+    maker.configure(bind=engine)
     DeclarativeBase.query = session.query_property()
 
     if create:
-        session.execute("CREATE EXTENSION IF NOT EXISTS timescaledb")
+        with engine.begin() as connection:
+            connection.execute(text("CREATE EXTENSION IF NOT EXISTS timescaledb"))
         DeclarativeBase.metadata.create_all(engine)
         # Loads the alembic configuration and generates the version table, with
         # the most recent revision stamped as head
@@ -122,7 +129,7 @@ def add(message):
             log.exception("Failed to parse sent-at timestamp value")
             return
     else:
-        sent_at = datetime.datetime.utcnow()
+        sent_at = datetime.datetime.now(tz=datetime.timezone.utc)
 
     # Workaround schemas misbehaving
     try:
@@ -158,11 +165,6 @@ def add(message):
     session.commit()
 
 
-def source_version_default(context):
-    dist = pkg_resources.get_distribution("datanommer.models")
-    return dist.version
-
-
 # https://docs.sqlalchemy.org/en/14/core/custom_types.html#marshal-json-strings
 
 
@@ -224,7 +226,7 @@ class Message(DeclarativeBase):
     username = Column(Unicode)
     crypto = Column(UnicodeText)
     source_name = Column(Unicode, default="datanommer")
-    source_version = Column(Unicode, default=source_version_default)
+    source_version = Column(Unicode, default=lambda context: __version__)
     msg = Column(JSONEncodedDict, nullable=False)
     headers = Column(postgresql.JSONB(none_as_null=True))
     users = relationship(
@@ -314,7 +316,7 @@ class Message(DeclarativeBase):
 
     @classmethod
     def from_msg_id(cls, msg_id):
-        return cls.query.filter(cls.msg_id == msg_id).first()
+        return session.execute(select(cls).where(cls.msg_id == msg_id)).scalar_one_or_none()
 
     def as_dict(self, request=None):
         return dict(
@@ -337,13 +339,12 @@ class Message(DeclarativeBase):
     def as_fedora_message_dict(self):
         headers = self.headers or {}
         if "sent-at" not in headers:
-            headers["sent-at"] = self.timestamp.astimezone(
-                datetime.timezone.utc
-            ).isoformat()
+            headers["sent-at"] = self.timestamp.astimezone(datetime.timezone.utc).isoformat()
         return dict(
             body=self.msg,
             headers=headers,
             id=self.msg_id,
+            priority=headers.get("priority", 0),
             queue=None,
             topic=self.topic,
         )
@@ -353,6 +354,7 @@ class Message(DeclarativeBase):
             "The __json__() method has been renamed to as_dict(), and will be removed "
             "in the next major version",
             DeprecationWarning,
+            stacklevel=2,
         )
         return self.as_dict(request)
 
@@ -419,69 +421,55 @@ class Message(DeclarativeBase):
         not_topics = not_topics or []
         contains = contains or []
 
-        query = Message.query
+        Message = cls
+        query = select(Message)
 
         # A little argument validation.  We could provide some defaults in
         # these mixed cases.. but instead we'll just leave it up to our caller.
         if (start is not None and end is None) or (end is not None and start is None):
             raise ValueError(
-                "Either both start and end must be specified "
-                "or neither must be specified"
+                "Either both start and end must be specified or neither must be specified"
             )
 
         if start and end:
-            query = query.filter(between(Message.timestamp, start, end))
+            query = query.where(between(Message.timestamp, start, end))
 
         if msg_id:
-            query = query.filter(Message.msg_id == msg_id)
+            query = query.where(Message.msg_id == msg_id)
 
         # Add the four positive filters as necessary
         if users:
-            query = query.filter(
-                or_(*(Message.users.any(User.name == u) for u in users))
-            )
+            query = query.where(or_(*(Message.users.any(User.name == u) for u in users)))
 
         if packages:
-            query = query.filter(
-                or_(*(Message.packages.any(Package.name == p) for p in packages))
-            )
+            query = query.where(or_(*(Message.packages.any(Package.name == p) for p in packages)))
 
         if categories:
-            query = query.filter(
-                or_(*(Message.category == category for category in categories))
-            )
+            query = query.where(or_(*(Message.category == category for category in categories)))
 
         if topics:
-            query = query.filter(or_(*(Message.topic == topic for topic in topics)))
+            query = query.where(or_(*(Message.topic == topic for topic in topics)))
 
         if contains:
-            query = query.filter(
-                or_(*(Message.msg.like(f"%{contain}%") for contain in contains))
-            )
+            query = query.where(or_(*(Message.msg.like(f"%{contain}%") for contain in contains)))
 
         # And then the four negative filters as necessary
         if not_users:
-            query = query.filter(
-                not_(or_(*(Message.users.any(User.name == u) for u in not_users)))
-            )
+            query = query.where(not_(or_(*(Message.users.any(User.name == u) for u in not_users))))
 
         if not_packs:
-            query = query.filter(
+            query = query.where(
                 not_(or_(*(Message.packages.any(Package.name == p) for p in not_packs)))
             )
 
         if not_cats:
-            query = query.filter(
-                not_(or_(*(Message.category == category for category in not_cats)))
-            )
+            query = query.where(not_(or_(*(Message.category == category for category in not_cats))))
 
         if not_topics:
-            query = query.filter(
-                not_(or_(*(Message.topic == topic for topic in not_topics)))
-            )
+            query = query.where(not_(or_(*(Message.topic == topic for topic in not_topics))))
 
         # Finally, tag on our pagination arguments
-        total = query.count()
+        total = session.scalar(query.with_only_columns(func.count(Message.id)))
         query = query.order_by(getattr(Message.timestamp, order)())
 
         if not rows_per_page:
@@ -494,12 +482,11 @@ class Message(DeclarativeBase):
             return total, page, query
         else:
             # Execute!
-            messages = query.all()
+            messages = session.scalars(query).all()
             return total, pages, messages
 
 
 class NamedSingleton:
-
     id = Column(Integer, primary_key=True, autoincrement=True)
     name = Column(UnicodeText, index=True, unique=True)
 
@@ -513,8 +500,8 @@ class NamedSingleton:
         if name in cls._cache:
             # If we cache the instance, SQLAlchemy will run this query anyway because the instance
             # will be from a different transaction. So just cache the id.
-            return cls.query.get(cls._cache[name])
-        obj = cls.query.filter_by(name=name).one_or_none()
+            return session.get(cls, cls._cache[name])
+        obj = session.execute(select(cls).where(cls.name == name)).scalar_one_or_none()
         if obj is None:
             obj = cls(name=name)
             session.add(obj)
@@ -546,16 +533,3 @@ def _setup_hypertable(table_class):
 
 
 _setup_hypertable(Message)
-
-
-# Set the version
-try:  # pragma: no cover
-    import importlib.metadata
-
-    __version__ = importlib.metadata.version("datanommer.models")
-except ImportError:  # pragma: no cover
-    try:
-        __version__ = pkg_resources.get_distribution("datanommer.models").version
-    except pkg_resources.DistributionNotFound:
-        # The app is not installed, but the flask dev server can run it nonetheless.
-        __version__ = None

datanommer/models/alembic/env.py

@@ -0,0 +1,93 @@
+# This file is a part of datanommer, a message sink for fedmsg.
+# Copyright (C) 2014, Red Hat, Inc.
+#
+# This program is free software: you can redistribute it and/or modify it under
+# the terms of the GNU General Public License as published by the Free Software
+# Foundation, either version 3 of the License, or (at your option) any later
+# version.
+#
+# This program is distributed in the hope that it will be useful, but WITHOUT
+# ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
+# FOR A PARTICULAR PURPOSE.  See the GNU General Public License for more
+# details.
+#
+# You should have received a copy of the GNU General Public License along
+# with this program.  If not, see <http://www.gnu.org/licenses/>.
+
+from logging.config import fileConfig
+
+from alembic import context
+from sqlalchemy import engine_from_config, pool
+
+# add your model's MetaData object here
+# for 'autogenerate' support
+# from myapp import mymodel
+# target_metadata = mymodel.Base.metadata
+from datanommer.models import DeclarativeBase
+
+
+target_metadata = DeclarativeBase.metadata
+
+
+# this is the Alembic Config object, which provides
+# access to the values within the .ini file in use.
+config = context.config
+
+# Interpret the config file for Python logging.
+# This line sets up loggers basically.
+fileConfig(config.config_file_name)
+
+# other values from the config, defined by the needs of env.py,
+# can be acquired:
+# my_important_option = config.get_main_option("my_important_option")
+# ... etc.
+
+
+def run_migrations_offline():
+    """Run migrations in 'offline' mode.
+
+    This configures the context with just a URL
+    and not an Engine, though an Engine is acceptable
+    here as well.  By skipping the Engine creation
+    we don't even need a DBAPI to be available.
+
+    Calls to context.execute() here emit the given string to the
+    script output.
+
+    """
+    # TODO: Pull this from datanommer's fedmsg.d config isntead of using
+    # the alembic.ini
+    url = config.get_main_option("sqlalchemy.url")
+    context.configure(url=url)
+
+    with context.begin_transaction():
+        context.run_migrations()
+
+
+def run_migrations_online():
+    """Run migrations in 'online' mode.
+
+    In this scenario we need to create an Engine
+    and associate a connection with the context.
+
+    """
+    engine = engine_from_config(
+        config.get_section(config.config_ini_section),
+        prefix="sqlalchemy.",
+        poolclass=pool.NullPool,
+    )
+
+    connection = engine.connect()
+    context.configure(connection=connection, target_metadata=target_metadata)
+
+    try:
+        with context.begin_transaction():
+            context.run_migrations()
+    finally:
+        connection.close()
+
+
+if context.is_offline_mode():
+    run_migrations_offline()
+else:
+    run_migrations_online()

datanommer/models/alembic/script.py.mako

@@ -0,0 +1,22 @@
+"""${message}
+
+Revision ID: ${up_revision}
+Revises: ${down_revision}
+Create Date: ${create_date}
+
+"""
+
+# revision identifiers, used by Alembic.
+revision = ${repr(up_revision)}
+down_revision = ${repr(down_revision)}
+
+from alembic import op
+import sqlalchemy as sa
+${imports if imports else ""}
+
+def upgrade():
+    ${upgrades if upgrades else "pass"}
+
+
+def downgrade():
+    ${downgrades if downgrades else "pass"}

datanommer/models/alembic/versions/5db25abc63be_init.py

@@ -0,0 +1,19 @@
+"""Initial revision
+
+Revision ID: 5db25abc63be
+Revises: None
+Create Date: 2021-09-15 16:15:37.188484
+
+"""
+
+# revision identifiers, used by Alembic.
+revision = "5db25abc63be"
+down_revision = None
+
+
+def upgrade():
+    pass
+
+
+def downgrade():
+    pass

datanommer/models/alembic/versions/951c40020acc_unique.py

@@ -0,0 +1,27 @@
+"""Add a unique index on packages and users
+
+Revision ID: 951c40020acc
+Revises: 5db25abc63be
+Create Date: 2021-09-22 15:38:57.339646
+"""
+
+from alembic import op
+
+
+# revision identifiers, used by Alembic.
+revision = "951c40020acc"
+down_revision = "5db25abc63be"
+
+
+def upgrade():
+    op.drop_index("ix_packages_name", table_name="packages")
+    op.create_index(op.f("ix_packages_name"), "packages", ["name"], unique=True)
+    op.drop_index("ix_users_name", table_name="users")
+    op.create_index(op.f("ix_users_name"), "users", ["name"], unique=True)
+
+
+def downgrade():
+    op.drop_index(op.f("ix_users_name"), table_name="users")
+    op.create_index("ix_users_name", "users", ["name"], unique=False)
+    op.drop_index(op.f("ix_packages_name"), table_name="packages")
+    op.create_index("ix_packages_name", "packages", ["name"], unique=False)

datanommer/models/testing/__init__.py

@@ -1,46 +1,48 @@
-import os
-
 import pytest
+import sqlalchemy as sa
 from pytest_postgresql import factories
+from pytest_postgresql.janitor import DatabaseJanitor
 from sqlalchemy.orm import scoped_session
 
 import datanommer.models as dm
 
 
-@pytest.fixture(scope="session")
-def postgresql_proc_with_timescaledb(postgresql_proc):
-    with open(os.path.join(postgresql_proc.datadir, "postgresql.conf"), "a") as pgconf:
-        pgconf.write("\nshared_preload_libraries = 'timescaledb'\n")
-        pgconf.write("timescaledb.telemetry_level=off\n")
-    postgresql_proc.stop()
-    postgresql_proc.start()
-    yield postgresql_proc
-
-
-_inital_sql = os.path.abspath(os.path.join(os.path.dirname(__file__), "startup.sql"))
-pgsql = factories.postgresql(
-    "postgresql_proc_with_timescaledb",
-    load=[_inital_sql],
+postgresql_proc = factories.postgresql_proc(
+    postgres_options="-c shared_preload_libraries=timescaledb -c timescaledb.telemetry_level=off",
 )
 
 
-@pytest.fixture()
-def datanommer_db_url(pgsql):
+@pytest.fixture(scope="session")
+def datanommer_db_url(postgresql_proc):
     return (
-        f"postgresql+psycopg2://{pgsql.info.user}:@"
-        f"{pgsql.info.host}:{pgsql.info.port}"
-        f"/{pgsql.info.dbname}"
+        f"postgresql+psycopg2://{postgresql_proc.user}:@"
+        f"{postgresql_proc.host}:{postgresql_proc.port}"
+        f"/{postgresql_proc.dbname}"
     )
 
 
 @pytest.fixture()
-def datanommer_models(datanommer_db_url):
-    dm.session = scoped_session(dm.maker)
-    dm.init(datanommer_db_url, create=True)
+def datanommer_db(postgresql_proc, datanommer_db_url):
+    with DatabaseJanitor(
+        user=postgresql_proc.user,
+        host=postgresql_proc.host,
+        port=postgresql_proc.port,
+        dbname=postgresql_proc.dbname,
+        # Don't use a template database
+        # template_dbname=postgresql_proc.template_dbname,
+        version=postgresql_proc.version,
+    ):
+        engine = sa.create_engine(datanommer_db_url, future=True, poolclass=sa.pool.NullPool)
+        # Renew the global object, dm.init checks a custom attribute
+        dm.session = scoped_session(dm.maker)
+        dm.init(engine=engine, create=True)
+        yield engine
+        dm.session.close()
+
+
+@pytest.fixture()
+def datanommer_models(datanommer_db):
     dm.User.clear_cache()
     dm.Package.clear_cache()
     yield dm.session
     dm.session.rollback()
-    # engine = dm.session.get_bind()
-    dm.session.close()
-    # dm.DeclarativeBase.metadata.drop_all(engine)

datanommer_models-1.2.0.dist-info/METADATA

@@ -0,0 +1,54 @@
+Metadata-Version: 2.1
+Name: datanommer.models
+Version: 1.2.0
+Summary: SQLAlchemy models for datanommer
+Home-page: https://github.com/fedora-infra/datanommer
+License: GPL-3.0-or-later
+Author: Fedora Infrastructure
+Author-email: admin@fedoraproject.org
+Requires-Python: >=3.10,<4.0
+Classifier: License :: OSI Approved :: GNU General Public License v3 or later (GPLv3+)
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Provides-Extra: schemas
+Requires-Dist: SQLAlchemy (>=1.3.24,<3.0.0)
+Requires-Dist: alembic (>=1.6.5,<2.0.0)
+Requires-Dist: anitya-schema ; extra == "schemas"
+Requires-Dist: bodhi-messages ; extra == "schemas"
+Requires-Dist: bugzilla2fedmsg-schema ; extra == "schemas"
+Requires-Dist: ci-messages ; extra == "schemas"
+Requires-Dist: copr-messaging ; extra == "schemas"
+Requires-Dist: discourse2fedmsg-messages ; extra == "schemas"
+Requires-Dist: fedocal-messages ; extra == "schemas"
+Requires-Dist: fedora-elections-messages ; extra == "schemas"
+Requires-Dist: fedora-messaging (>=2.1.0)
+Requires-Dist: fedora-messaging-git-hook-messages ; extra == "schemas"
+Requires-Dist: fedora-messaging-the-new-hotness-schema ; extra == "schemas"
+Requires-Dist: fedora-planet-messages ; extra == "schemas"
+Requires-Dist: fedorainfra-ansible-messages ; extra == "schemas"
+Requires-Dist: fmn-messages ; extra == "schemas"
+Requires-Dist: kerneltest-messages (>=1.0.0,<2.0.0) ; extra == "schemas"
+Requires-Dist: koji-fedoramessaging-messages (>=1.2.2,<2.0.0) ; extra == "schemas"
+Requires-Dist: koschei-messages ; extra == "schemas"
+Requires-Dist: mdapi-messages ; extra == "schemas"
+Requires-Dist: mediawiki-messages ; extra == "schemas"
+Requires-Dist: meetbot-messages ; extra == "schemas"
+Requires-Dist: noggin-messages ; extra == "schemas"
+Requires-Dist: nuancier-messages ; extra == "schemas"
+Requires-Dist: pagure-messages ; extra == "schemas"
+Requires-Dist: psycopg2 (>=2.9.1,<3.0.0)
+Requires-Dist: tahrir-messages ; extra == "schemas"
+Project-URL: Repository, https://github.com/fedora-infra/datanommer
+Description-Content-Type: text/x-rst
+
+datanommer.models
+=================
+
+This package contains the SQLAlchemy data model for datanommer.
+
+Datanommer is a storage consumer for the Fedora Infrastructure Message Bus
+(fedmsg).  It is comprised of a `fedmsg <http://fedmsg.com>`_ consumer that
+stuffs every message into a sqlalchemy database.
+

datanommer_models-1.2.0.dist-info/RECORD

@@ -0,0 +1,10 @@
+datanommer/models/__init__.py,sha256=ImCJYqPGAPBjx5OoVu6Lbo0mC6Zu9buGfrdgbectsTc,16874
+datanommer/models/alembic/env.py,sha256=WNTimgnH70CakhvuV5QCilCnOcjTy7kcx0nD7hryYx0,2793
+datanommer/models/alembic/script.py.mako,sha256=D8kFI44_9vBJZrAYSkZxDTX2-S5Y-oEetEd9BKlo9S8,412
+datanommer/models/alembic/versions/5db25abc63be_init.py,sha256=xMD7WGCOqeVNFroCZds_aS_jta2yTrAHc_XhtmZLZRs,249
+datanommer/models/alembic/versions/951c40020acc_unique.py,sha256=GwKDhppKW7y5BUV8BqILZCAiR7GsNyIvoTXUu2A1ZMI,843
+datanommer/models/testing/__init__.py,sha256=T_uy2jBp5TG507WAVTx4A96_SsFgy4UrY6WKOuG_l1Q,1453
+datanommer_models-1.2.0.dist-info/LICENSE,sha256=jOtLnuWt7d5Hsx6XXB2QxzrSe2sWWh3NgMfFRetluQM,35147
+datanommer_models-1.2.0.dist-info/METADATA,sha256=KxGFi0ZMyjdK7oslLs8ImIlD9oHogCWF4MXOj2Yyg0k,2502
+datanommer_models-1.2.0.dist-info/WHEEL,sha256=sP946D7jFCHeNz5Iq4fL4Lu-PrWrFsgfLXbbkciIZwg,88
+datanommer_models-1.2.0.dist-info/RECORD,,

{datanommer.models-1.0.2.dist-info → datanommer_models-1.2.0.dist-info}/WHEEL

@@ -1,4 +1,4 @@
 Wheel-Version: 1.0
-Generator: poetry 1.0.3
+Generator: poetry-core 1.9.0
 Root-Is-Purelib: true
 Tag: py3-none-any

datanommer/models/testing/startup.sql

@@ -1 +0,0 @@
-CREATE EXTENSION IF NOT EXISTS timescaledb;

datanommer.models-1.0.2.dist-info/METADATA

@@ -1,41 +0,0 @@
-Metadata-Version: 2.1
-Name: datanommer.models
-Version: 1.0.2
-Summary: SQLAlchemy models for datanommer
-Home-page: https://github.com/fedora-infra/datanommer
-License: GPL-3.0-or-later
-Author: Fedora Infrastructure
-Author-email: admin@fedoraproject.org
-Requires-Python: >=3.7,<4.0
-Classifier: License :: OSI Approved :: GNU General Public License v3 or later (GPLv3+)
-Classifier: Programming Language :: Python :: 3
-Classifier: Programming Language :: Python :: 3.7
-Classifier: Programming Language :: Python :: 3.8
-Classifier: Programming Language :: Python :: 3.9
-Provides-Extra: schemas
-Requires-Dist: SQLAlchemy (>=1.0.9,<1.4.23)
-Requires-Dist: alembic (>=1.6.5,<2.0.0)
-Requires-Dist: anitya-schema; extra == "schemas"
-Requires-Dist: bodhi-messages; extra == "schemas"
-Requires-Dist: copr-messaging; extra == "schemas"
-Requires-Dist: discourse2fedmsg-messages; extra == "schemas"
-Requires-Dist: fedocal-messages; extra == "schemas"
-Requires-Dist: fedora-messaging (>=2.1.0,<3.0.0)
-Requires-Dist: fedora-messaging-the-new-hotness-schema; extra == "schemas"
-Requires-Dist: fedora-planet-messages; extra == "schemas"
-Requires-Dist: fedorainfra-ansible-messages; extra == "schemas"
-Requires-Dist: noggin-messages; extra == "schemas"
-Requires-Dist: nuancier-messages; extra == "schemas"
-Requires-Dist: psycopg2 (>=2.9.1,<3.0.0)
-Project-URL: Repository, https://github.com/fedora-infra/datanommer
-Description-Content-Type: text/x-rst
-
-datanommer.models
-=================
-
-This package contains the SQLAlchemy data model for datanommer.
-
-Datanommer is a storage consumer for the Fedora Infrastructure Message Bus
-(fedmsg).  It is comprised of a `fedmsg <http://fedmsg.com>`_ consumer that
-stuffs every message into a sqlalchemy database.
-

datanommer.models-1.0.2.dist-info/RECORD

@@ -1,11 +0,0 @@
-datanommer/models/__init__.py,sha256=4smdWjO0DSxKQeOn0UAfH93eUKQPtTKklqnBdWbGP0Q,17280
-datanommer/models/testing/__init__.py,sha256=4aNMycVGrYA6Ljo74ePweDrzSr9oaA7K_W2gtn0YZ74,1271
-datanommer/models/testing/startup.sql,sha256=tdjQMZcM7bVDoLnfSg1-fpKKiAPihiVPy-syF0H8mvo,44
-tests/conftest.py,sha256=W9WzREc28ksZGv2m1IFgHcrffKG_V1PFPqnRgxsxTSs,45
-tests/test_jsonencodeddict.py,sha256=C3cEFTx-hQHoHZUczAQ2LDFVC6bvPV92DR17Ig2VnX4,1928
-tests/test_model.py,sha256=NWV5Z7guirls57A73HUsRxiyOnpWAOYIDUh0Afk4nX8,18950
-tox.ini,sha256=5ichc5c0HCb16Du3ZB9Kv4tDmI9VGjAfRLJB7Vo_XVs,260
-datanommer.models-1.0.2.dist-info/LICENSE,sha256=jOtLnuWt7d5Hsx6XXB2QxzrSe2sWWh3NgMfFRetluQM,35147
-datanommer.models-1.0.2.dist-info/WHEEL,sha256=V7iVckP-GYreevsTDnv1eAinQt_aArwnAxmnP0gygBY,83
-datanommer.models-1.0.2.dist-info/METADATA,sha256=zGoHqTFLbwPrHB0gCuHOGKj6sk75UYv2SHJkckmMYDw,1734
-datanommer.models-1.0.2.dist-info/RECORD,,

tests/conftest.py

@@ -1 +0,0 @@
-pytest_plugins = "datanommer.models.testing"

tests/test_jsonencodeddict.py

@@ -1,61 +0,0 @@
-import pytest
-from sqlalchemy import Column, create_engine, Integer, MetaData, Table
-from sqlalchemy.sql import select
-
-from datanommer.models import JSONEncodedDict
-
-
-@pytest.fixture
-def connection():
-    engine = create_engine("sqlite:///:memory:")
-    with engine.connect() as connection:
-        yield connection
-
-
-@pytest.fixture
-def table(connection):
-    metadata = MetaData()
-    table = Table(
-        "test_table",
-        metadata,
-        Column("id", Integer, primary_key=True),
-        Column("data", JSONEncodedDict),
-    )
-    metadata.create_all(connection)
-    yield table
-    metadata.drop_all(connection)
-
-
-def test_jsonencodeddict(connection, table):
-    connection.execute(table.insert().values(data={"foo": "bar"}))
-    # Check that it's stored as a string
-    for row in connection.execute("SELECT data FROM test_table"):
-        assert row["data"] == '{"foo": "bar"}'
-    # Check that SQLAlchemy retrieves it as a dict
-    for row in connection.execute(select(table.c.data)):
-        assert row["data"] == {"foo": "bar"}
-
-
-def test_jsonencodeddict_null(connection, table):
-    # Make sure NULL values are supported
-    connection.execute(table.insert().values(data=None))
-    for row in connection.execute(select(table.c.data)):
-        assert row["data"] is None
-
-
-def test_jsonencodeddict_compare(connection, table):
-    # Make sure NULL values are supported
-    connection.execute(table.insert().values(data={"foo": "bar"}))
-    for row in connection.execute(
-        select(table.c.data).filter(table.c.data == {"foo": "bar"})
-    ):
-        assert row["data"] == {"foo": "bar"}
-
-
-def test_jsonencodeddict_compare_like(connection, table):
-    # Make sure NULL values are supported
-    connection.execute(table.insert().values(data={"foo": "bar"}))
-    for row in connection.execute(
-        select(table.c.data).filter(table.c.data.like("%foo%"))
-    ):
-        assert row["data"] == {"foo": "bar"}

tests/test_model.py

@@ -1,628 +0,0 @@
-# This file is a part of datanommer, a message sink for fedmsg.
-# Copyright (C) 2014, Red Hat, Inc.
-#
-# This program is free software: you can redistribute it and/or modify it under
-# the terms of the GNU General Public License as published by the Free Software
-# Foundation, either version 3 of the License, or (at your option) any later
-# version.
-#
-# This program is distributed in the hope that it will be useful, but WITHOUT
-# ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
-# FOR A PARTICULAR PURPOSE.  See the GNU General Public License for more
-# details.
-#
-# You should have received a copy of the GNU General Public License along
-# with this program.  If not, see <http://www.gnu.org/licenses/>.
-import datetime
-import json
-import logging
-
-import pytest
-from bodhi.messages.schemas.update import UpdateCommentV1
-from fedora_messaging import message as fedora_message
-from sqlalchemy import create_engine
-from sqlalchemy.exc import IntegrityError
-from sqlalchemy.orm.query import Query
-
-from datanommer.models import add, init, Message, Package, session, User
-
-
-def generate_message(
-    topic="org.fedoraproject.test.a.nice.message",
-    body={"encouragement": "You're doing great!"},
-    headers=None,
-):
-    return fedora_message.Message(topic=topic, body=body, headers=headers)
-
-
-def generate_bodhi_update_complete_message(text="testing testing"):
-    msg = UpdateCommentV1(
-        body={
-            "comment": {
-                "karma": -1,
-                "text": text,
-                "timestamp": "2019-03-18 16:54:48",
-                "update": {
-                    "alias": "FEDORA-EPEL-2021-f2d195dada",
-                    "builds": [
-                        {"nvr": "abrt-addon-python3-2.1.11-50.el7"},
-                        {"nvr": "kernel-10.4.0-2.el7"},
-                    ],
-                    "status": "pending",
-                    "release": {"name": "F35"},
-                    "request": "testing",
-                    "user": {"name": "ryanlerch"},
-                },
-                "user": {"name": "dudemcpants"},
-            }
-        }
-    )
-    msg.topic = f"org.fedoraproject.stg.{msg.topic}"
-    return msg
-
-
-def test_init_uri_and_engine():
-    uri = "sqlite:///db.db"
-    engine = create_engine(uri)
-
-    with pytest.raises(ValueError, match="uri and engine cannot both be specified"):
-        init(uri, engine=engine)
-
-
-def test_init_no_uri_and_no_engine():
-    with pytest.raises(ValueError, match="One of uri or engine must be specified"):
-        init()
-
-
-def test_init_with_engine(caplog):
-    uri = "sqlite:///db.db"
-    engine = create_engine(uri)
-
-    init(engine=engine)
-
-    assert not caplog.records
-
-    # if the init with just the engine worked, trying it again will fail
-    init(engine=engine)
-    assert caplog.records[0].message == "Session already initialized.  Bailing"
-
-
-def test_init_no_init_twice(datanommer_models, mocker, caplog):
-    init("sqlite:///db.db")
-    assert caplog.records[0].message == "Session already initialized.  Bailing"
-
-
-def test_unclassified_category(datanommer_models):
-    example_message = generate_message(topic="too.short")
-    add(example_message)
-    dbmsg = Message.query.first()
-
-    assert dbmsg.category == "Unclassified"
-
-
-def test_from_msg_id(datanommer_models):
-    example_message = generate_message()
-    example_message.id = "ACUSTOMMESSAGEID"
-    add(example_message)
-    dbmsg = Message.from_msg_id("ACUSTOMMESSAGEID")
-
-    assert dbmsg.msg_id == "ACUSTOMMESSAGEID"
-
-
-def test_add_missing_msg_id(datanommer_models, caplog):
-    caplog.set_level(logging.INFO)
-    example_message = generate_message()
-    example_message._properties.message_id = None
-    add(example_message)
-    dbmsg = Message.query.first()
-    assert (
-        "Message on org.fedoraproject.test.a.nice.message was received without a msg_id"
-        in caplog.records[-1].message
-    )
-    assert dbmsg.msg_id is not None
-
-
-def test_add_missing_timestamp(datanommer_models):
-    example_message = generate_message()
-    example_message._properties.headers["sent-at"] = None
-
-    add(example_message)
-
-    dbmsg = Message.query.first()
-    timediff = datetime.datetime.utcnow() - dbmsg.timestamp
-    # 10 seconds between adding the message and checking
-    # the timestamp should be more than enough.
-    assert timediff < datetime.timedelta(seconds=10)
-
-
-def test_add_timestamp_with_Z(datanommer_models):
-    example_message = generate_message()
-    example_message._properties.headers["sent-at"] = "2021-07-27T04:22:42Z"
-
-    add(example_message)
-
-    dbmsg = Message.query.first()
-    assert dbmsg.timestamp.astimezone(datetime.timezone.utc) == datetime.datetime(
-        2021, 7, 27, 4, 22, 42, tzinfo=datetime.timezone.utc
-    )
-
-
-def test_add_timestamp_with_junk(datanommer_models, caplog):
-    example_message = generate_message()
-    example_message._properties.headers["sent-at"] = "2021-07-27T04:22:42JUNK"
-
-    add(example_message)
-
-    assert "Failed to parse sent-at timestamp value" in caplog.records[0].message
-
-    assert Message.query.count() == 0
-
-
-def test_add_and_check_for_others(datanommer_models):
-
-    # There are no users or packages at the start
-    assert User.query.count() == 0
-    assert Package.query.count() == 0
-
-    # Then add a message
-    add(generate_bodhi_update_complete_message())
-
-    # There should now be two of each
-    assert User.query.count() == 2
-    assert Package.query.count() == 2
-
-    # If we add it again, there should be no duplicates
-    add(generate_bodhi_update_complete_message())
-    assert User.query.count() == 2
-    assert Package.query.count() == 2
-
-    # Add a new username
-    add(generate_bodhi_update_complete_message(text="this is @abompard in a comment"))
-    assert User.query.count() == 3
-    assert Package.query.count() == 2
-
-
-def test_add_nothing(datanommer_models):
-    assert Message.query.count() == 0
-
-
-def test_add_and_check(datanommer_models):
-    add(generate_message())
-    session.flush()
-    assert Message.query.count() == 1
-
-
-def test_categories(datanommer_models):
-    add(generate_bodhi_update_complete_message())
-    session.flush()
-    obj = Message.query.first()
-    assert obj.category == "bodhi"
-
-
-def test_categories_with_umb(datanommer_models):
-    add(generate_message(topic="/topic/VirtualTopic.eng.brew.task.closed"))
-    session.flush()
-    obj = Message.query.first()
-    assert obj.category == "brew"
-
-
-def test_grep_all(datanommer_models):
-    example_message = generate_message()
-    add(example_message)
-    session.flush()
-    t, p, r = Message.grep()
-    assert t == 1
-    assert p == 1
-    assert len(r) == 1
-    assert r[0].msg == example_message.body
-
-
-def test_grep_category(datanommer_models):
-    example_message = generate_message(topic="org.fedoraproject.prod.bodhi.newupdate")
-    add(example_message)
-    session.flush()
-    t, p, r = Message.grep(categories=["bodhi"])
-    assert t == 1
-    assert p == 1
-    assert len(r) == 1
-    assert r[0].msg == example_message.body
-
-
-def test_grep_not_category(datanommer_models):
-    example_message = generate_message(topic="org.fedoraproject.prod.bodhi.newupdate")
-    add(example_message)
-    session.flush()
-    t, p, r = Message.grep(not_categories=["bodhi"])
-    assert t == 0
-    assert p == 0
-    assert len(r) == 0
-
-
-def test_add_headers(datanommer_models):
-    example_headers = {"foo": "bar", "baz": 1, "wibble": ["zork", "zap"]}
-    example_message = generate_message(
-        topic="org.fedoraproject.prod.bodhi.newupdate", headers=example_headers
-    )
-    add(example_message)
-    dbmsg = Message.query.first()
-    assert dbmsg.headers["foo"] == "bar"
-    assert dbmsg.headers["baz"] == 1
-    assert dbmsg.headers["wibble"] == ["zork", "zap"]
-
-
-def test_grep_topics(datanommer_models):
-    example_message = generate_message(topic="org.fedoraproject.prod.bodhi.newupdate")
-    add(example_message)
-    session.flush()
-    t, p, r = Message.grep(topics=["org.fedoraproject.prod.bodhi.newupdate"])
-    assert t == 1
-    assert p == 1
-    assert len(r) == 1
-    assert r[0].msg == example_message.body
-
-
-def test_grep_not_topics(datanommer_models):
-    example_message = generate_message(topic="org.fedoraproject.prod.bodhi.newupdate")
-    add(example_message)
-    session.flush()
-    t, p, r = Message.grep(not_topics=["org.fedoraproject.prod.bodhi.newupdate"])
-    assert t == 0
-    assert p == 0
-    assert len(r) == 0
-
-
-def test_grep_start_end_validation(datanommer_models):
-    with pytest.raises(
-        ValueError,
-        match="Either both start and end must be specified or neither must be specified",
-    ):
-        Message.grep(start="2020-03-26")
-    with pytest.raises(
-        ValueError,
-        match="Either both start and end must be specified or neither must be specified",
-    ):
-        Message.grep(end="2020-03-26")
-
-
-def test_grep_start_end(datanommer_models):
-    example_message = generate_message()
-    example_message._properties.headers["sent-at"] = "2021-04-01T00:00:01"
-    add(example_message)
-
-    bodhi_example_message = generate_bodhi_update_complete_message()
-    bodhi_example_message._properties.headers["sent-at"] = "2021-06-01T00:00:01"
-    add(bodhi_example_message)
-
-    session.flush()
-    total, pages, messages = Message.grep(start="2021-04-01", end="2021-05-01")
-    assert total == 1
-    assert pages == 1
-    assert len(messages) == 1
-    assert messages[0].msg == example_message.body
-
-    total, pages, messages = Message.grep(start="2021-06-01", end="2021-07-01")
-    assert total == 1
-    assert pages == 1
-    assert len(messages) == 1
-    assert messages[0].msg == bodhi_example_message.body
-
-
-def test_grep_msg_id(datanommer_models):
-    example_message = generate_message()
-    add(example_message)
-
-    bodhi_example_message = generate_bodhi_update_complete_message()
-    add(bodhi_example_message)
-
-    session.flush()
-    total, pages, messages = Message.grep(msg_id=example_message.id)
-    assert total == 1
-    assert pages == 1
-    assert len(messages) == 1
-    assert messages[0].msg == example_message.body
-
-    total, pages, messages = Message.grep(msg_id=bodhi_example_message.id)
-    assert total == 1
-    assert pages == 1
-    assert len(messages) == 1
-    assert messages[0].msg == bodhi_example_message.body
-
-    total, pages, messages = Message.grep(msg_id="NOTAMESSAGEID")
-    assert total == 0
-    assert pages == 0
-    assert len(messages) == 0
-
-
-def test_grep_users(datanommer_models):
-    example_message = generate_message()
-    add(example_message)
-
-    bodhi_example_message = generate_bodhi_update_complete_message()
-    add(bodhi_example_message)
-
-    session.flush()
-
-    total, pages, messages = Message.grep(users=["dudemcpants"])
-
-    assert total == 1
-    assert pages == 1
-    assert len(messages) == 1
-
-    assert messages[0].msg == bodhi_example_message.body
-
-
-def test_grep_not_users(datanommer_models):
-    example_message = generate_message()
-    add(example_message)
-
-    bodhi_example_message = generate_bodhi_update_complete_message()
-    add(bodhi_example_message)
-
-    session.flush()
-
-    total, pages, messages = Message.grep(not_users=["dudemcpants"])
-
-    assert total == 1
-    assert pages == 1
-    assert len(messages) == 1
-
-    assert messages[0].msg == example_message.body
-
-
-def test_grep_packages(datanommer_models):
-    example_message = generate_message()
-    add(example_message)
-
-    bodhi_example_message = generate_bodhi_update_complete_message()
-    add(bodhi_example_message)
-
-    session.flush()
-
-    total, pages, messages = Message.grep(packages=["kernel"])
-
-    assert total == 1
-    assert pages == 1
-    assert len(messages) == 1
-
-    assert messages[0].msg == bodhi_example_message.body
-
-
-def test_grep_not_packages(datanommer_models):
-    example_message = generate_message()
-    add(example_message)
-
-    bodhi_example_message = generate_bodhi_update_complete_message()
-    add(bodhi_example_message)
-
-    session.flush()
-
-    total, pages, messages = Message.grep(not_packages=["kernel"])
-
-    assert total == 1
-    assert pages == 1
-    assert len(messages) == 1
-
-    assert messages[0].msg == example_message.body
-
-
-def test_grep_contains(datanommer_models):
-    example_message = generate_message(topic="org.fedoraproject.prod.bodhi.newupdate")
-    add(example_message)
-    session.flush()
-    t, p, r = Message.grep(contains=["doing"])
-    assert t == 1
-    assert p == 1
-    assert len(r) == 1
-    assert r[0].msg == example_message.body
-
-
-def test_grep_rows_per_page_none(datanommer_models):
-    for x in range(0, 200):
-        example_message = generate_message()
-        example_message.id = f"{x}"
-        add(example_message)
-
-    session.flush()
-
-    total, pages, messages = Message.grep()
-    assert total == 200
-    assert pages == 2
-    assert len(messages) == 100
-
-    total, pages, messages = Message.grep(rows_per_page=None)
-    assert total == 200
-    assert pages == 1
-    assert len(messages) == 200
-
-
-def test_grep_rows_per_page_zero(datanommer_models):
-    for x in range(0, 200):
-        example_message = generate_message()
-        example_message.id = f"{x}"
-        add(example_message)
-    session.flush()
-
-    try:
-        total, pages, messages = Message.grep(rows_per_page=0)
-    except ZeroDivisionError as e:
-        assert False, e
-    assert total == 200
-    assert pages == 1
-    assert len(messages) == 200
-
-
-def test_grep_defer(datanommer_models):
-    example_message = generate_message()
-    add(example_message)
-
-    session.flush()
-
-    total, pages, query = Message.grep(defer=True)
-    assert isinstance(query, Query)
-
-    assert query.all() == Message.grep()[2]
-
-
-def test_add_duplicate(datanommer_models, caplog):
-    example_message = generate_message()
-    add(example_message)
-    add(example_message)
-    # if no exception was thrown, then we successfully ignored the
-    # duplicate message
-    assert Message.query.count() == 1
-    assert (
-        "Skipping message from org.fedoraproject.test.a.nice.message"
-        in caplog.records[0].message
-    )
-
-
-def test_add_integrity_error(datanommer_models, mocker, caplog):
-    mock_session_add = mocker.patch("datanommer.models.session.add")
-    mock_session_add.side_effect = IntegrityError("asdf", "asd", "asdas")
-    example_message = generate_message()
-    add(example_message)
-    assert "Unknown Integrity Error: message" in caplog.records[0].message
-    assert Message.query.count() == 0
-
-
-def test_add_duplicate_package(datanommer_models):
-    # Define a special message schema and register it
-    class MessageWithPackages(fedora_message.Message):
-        @property
-        def packages(self):
-            return ["pkg", "pkg"]
-
-    fedora_message._schema_name_to_class["MessageWithPackages"] = MessageWithPackages
-    fedora_message._class_to_schema_name[MessageWithPackages] = "MessageWithPackages"
-    example_message = MessageWithPackages(
-        topic="org.fedoraproject.test.a.nice.message",
-        body={"encouragement": "You're doing great!"},
-        headers=None,
-    )
-    try:
-        add(example_message)
-    except IntegrityError as e:
-        assert False, e
-    assert Message.query.count() == 1
-    dbmsg = Message.query.first()
-    assert len(dbmsg.packages) == 1
-    assert dbmsg.packages[0].name == "pkg"
-
-
-def test_add_message_with_error_on_packages(datanommer_models, caplog):
-    # Define a special message schema and register it
-    class CustomMessage(fedora_message.Message):
-        @property
-        def packages(self):
-            raise KeyError
-
-        def _filter_headers(self):
-            return {}
-
-    fedora_message._schema_name_to_class["CustomMessage"] = CustomMessage
-    fedora_message._class_to_schema_name[CustomMessage] = "CustomMessage"
-    example_message = CustomMessage(
-        topic="org.fedoraproject.test.a.nice.message",
-        body={"encouragement": "You're doing great!"},
-        headers=None,
-    )
-    try:
-        add(example_message)
-    except KeyError as e:
-        assert False, e
-    assert Message.query.count() == 1
-    assert caplog.records[0].message == (
-        f"Could not get the list of packages from a message on "
-        f"org.fedoraproject.test.a.nice.message with id {example_message.id}"
-    )
-
-
-def test_as_fedora_message_dict(datanommer_models):
-    example_message = generate_message()
-    add(example_message)
-
-    dbmsg = Message.query.first()
-
-    message_json = json.dumps(dbmsg.as_fedora_message_dict())
-
-    # this should be the same as if we use the fedora_messaging dump function
-    assert json.loads(fedora_message.dumps(example_message)) == json.loads(message_json)
-
-
-def test_as_fedora_message_dict_old_headers(datanommer_models):
-    # Messages received with fedmsg don't have the sent-at header
-    example_message = generate_message()
-    add(example_message)
-
-    dbmsg = Message.query.first()
-    del dbmsg.headers["sent-at"]
-
-    message_dict = dbmsg.as_fedora_message_dict()
-    print(message_dict)
-    print(json.loads(fedora_message.dumps(example_message)))
-
-    # this should be the same as if we use the fedora_messaging dump function
-    assert json.loads(fedora_message.dumps(example_message)) == message_dict
-
-
-def test_as_fedora_message_dict_no_headers(datanommer_models):
-    # Messages can have no headers
-    example_message = generate_message()
-    add(example_message)
-
-    dbmsg = Message.query.first()
-    assert len(dbmsg.headers.keys()) == 3
-
-    # Clear the headers
-    dbmsg.headers = None
-
-    try:
-        message_dict = dbmsg.as_fedora_message_dict()
-    except TypeError as e:
-        assert False, e
-
-    assert list(message_dict["headers"].keys()) == ["sent-at"]
-
-
-def test_as_dict(datanommer_models):
-    add(generate_message())
-    dbmsg = Message.query.first()
-    message_dict = dbmsg.as_dict()
-
-    # we should have 14 keys in this dict
-    assert len(message_dict) == 14
-    assert message_dict["msg"] == {"encouragement": "You're doing great!"}
-    assert message_dict["topic"] == "org.fedoraproject.test.a.nice.message"
-
-
-def test_as_dict_with_users_and_packages(datanommer_models):
-    add(generate_bodhi_update_complete_message())
-    dbmsg = Message.query.first()
-    message_dict = dbmsg.as_dict()
-
-    assert message_dict["users"] == ["dudemcpants", "ryanlerch"]
-    assert message_dict["packages"] == ["abrt-addon-python3", "kernel"]
-
-
-def test___json__deprecated(datanommer_models, caplog, mocker):
-    mock_as_dict = mocker.patch("datanommer.models.Message.as_dict")
-
-    add(generate_message())
-
-    with pytest.warns(DeprecationWarning):
-        Message.query.first().__json__()
-
-    mock_as_dict.assert_called_once()
-
-
-def test_singleton_create(datanommer_models):
-    Package.get_or_create("foobar")
-    assert [p.name for p in Package.query.all()] == ["foobar"]
-
-
-def test_singleton_get_existing(datanommer_models):
-    p1 = Package.get_or_create("foobar")
-    # Clear the in-memory cache
-    Package._cache.clear()
-    p2 = Package.get_or_create("foobar")
-    assert p1.id == p2.id

tox.ini

@@ -1,15 +0,0 @@
-[tox]
-envlist = py{37,38,39},licenses
-skipsdist = True
-isolated_build = true
-requires =
-    poetry
-    tox-poetry
-
-[testenv]
-commands = pytest -c ../pyproject.toml {posargs}
-
-[testenv:licenses]
-deps = poetry
-commands =
-    {toxinidir}/../tools/run-liccheck.sh