Script 'mail_helper' called by obssrc Hello community, here is the log from the commit of package python-minidb for openSUSE:Factory checked in at 2021-03-17 20:16:13 ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ Comparing /work/SRC/openSUSE:Factory/python-minidb (Old) and /work/SRC/openSUSE:Factory/.python-minidb.new.2401 (New) ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
Package is "python-minidb" Wed Mar 17 20:16:13 2021 rev:5 rq:879471 version:2.0.4 Changes: -------- --- /work/SRC/openSUSE:Factory/python-minidb/python-minidb.changes 2020-03-27 22:01:55.326954157 +0100 +++ /work/SRC/openSUSE:Factory/.python-minidb.new.2401/python-minidb.changes 2021-03-17 20:19:53.627312506 +0100 @@ -1,0 +2,9 @@ +Tue Mar 16 15:59:42 UTC 2021 - Matej Cepl <[email protected]> + +- Update to 2.0.4: + - switch to pytest +- Rename 0001-switch-to-pytest.patch to no_ported_eq.patch as the + previous patch was upstreamed, and now is just a small cleanup + (gh#thp/minidb#15). + +------------------------------------------------------------------- Old: ---- 0001-switch-to-pytest.patch minidb-2.0.3.tar.gz New: ---- minidb-2.0.4.tar.gz no_ported_eq.patch ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ Other differences: ------------------ ++++++ python-minidb.spec ++++++ --- /var/tmp/diff_new_pack.jnkex2/_old 2021-03-17 20:19:54.167313244 +0100 +++ /var/tmp/diff_new_pack.jnkex2/_new 2021-03-17 20:19:54.171313249 +0100 @@ -1,7 +1,7 @@ # # spec file for package python-minidb # -# Copyright (c) 2020 SUSE LLC +# Copyright (c) 2021 SUSE LLC # # All modifications and additions to the file contributed by third parties # remain the property of their copyright owners, unless otherwise agreed @@ -20,32 +20,32 @@ %define skip_python2 1 %bcond_without test Name: python-minidb -Version: 2.0.3 +Version: 2.0.4 Release: 0 Summary: SQLite3-based store for Python objects License: ISC Group: Development/Languages/Python -URL: http://thp.io/2010/minidb/ +URL: https://thp.io/2010/minidb/ Source: https://files.pythonhosted.org/packages/source/m/minidb/minidb-%{version}.tar.gz -# https://github.com/thp/minidb/pull/14 -Patch0: 0001-switch-to-pytest.patch +# PATCH-FIX-UPSTREAM no_ported_eq.patch gh#thp/minidb#15 [email protected] +# Don't use ported_eq workaround. +Patch0: no_ported_eq.patch BuildRequires: %{python_module setuptools} +BuildRequires: %{pythons} +BuildRequires: fdupes BuildRequires: python-rpm-macros +BuildArch: noarch %if %{with test} BuildRequires: %{python_module pytest} BuildRequires: python3-testsuite %endif -BuildRequires: fdupes -BuildArch: noarch - %python_subpackages %description Minidb 2 allows you to store Python objects in a SQLite 3 database. %prep -%setup -q -n minidb-%{version} -%patch0 -p1 +%autosetup -p1 -n minidb-%{version} %build %python_build @@ -60,7 +60,6 @@ %endif %files %{python_files} -%defattr(-,root,root,-) %doc README %{python_sitelib}/minidb.py* %{python_sitelib}/minidb-%{version}-py*.egg-info ++++++ minidb-2.0.3.tar.gz -> minidb-2.0.4.tar.gz ++++++ diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/minidb-2.0.3/PKG-INFO new/minidb-2.0.4/PKG-INFO --- old/minidb-2.0.3/PKG-INFO 2020-03-23 20:50:00.000000000 +0100 +++ new/minidb-2.0.4/PKG-INFO 2020-05-03 10:38:40.000000000 +0200 @@ -1,11 +1,11 @@ Metadata-Version: 1.1 Name: minidb -Version: 2.0.3 +Version: 2.0.4 Summary: A simple SQLite3-based store for Python objects Home-page: http://thp.io/2010/minidb/ Author: Thomas Perl Author-email: [email protected] License: ISC -Download-URL: http://thp.io/2010/minidb/minidb-2.0.3.tar.gz +Download-URL: http://thp.io/2010/minidb/minidb-2.0.4.tar.gz Description: UNKNOWN Platform: UNKNOWN diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/minidb-2.0.3/minidb.py new/minidb-2.0.4/minidb.py --- old/minidb-2.0.3/minidb.py 2020-03-23 20:49:13.000000000 +0100 +++ new/minidb-2.0.4/minidb.py 2020-05-03 10:38:15.000000000 +0200 @@ -23,7 +23,7 @@ """A simple SQLite3-based store for Python objects""" __author__ = 'Thomas Perl <[email protected]>' -__version__ = '2.0.3' +__version__ = '2.0.4' __url__ = 'http://thp.io/2010/minidb/' __license__ = 'ISC' diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/minidb-2.0.3/test/test_minidb.py new/minidb-2.0.4/test/test_minidb.py --- old/minidb-2.0.3/test/test_minidb.py 2017-10-24 10:10:08.000000000 +0200 +++ new/minidb-2.0.4/test/test_minidb.py 2020-05-03 10:38:01.000000000 +0200 @@ -1,8 +1,11 @@ import minidb +import pytest +import datetime -from nose.tools import * -import datetime +def ported_eq(a, b, msg=None): + if not a == b: + raise AssertionError(msg or "%r != %r" % (a, b)) class FieldTest(minidb.Model): @@ -138,38 +141,38 @@ assert field_test._private1 == 997 -@raises(minidb.UnknownClass) def test_saving_without_registration_fails(): - with minidb.Store(debug=True) as db: - FieldTest(9).save(db) + with pytest.raises(minidb.UnknownClass): + with minidb.Store(debug=True) as db: + FieldTest(9).save(db) -@raises(TypeError) def test_registering_non_subclass_of_model_fails(): # This cannot be registered, as it's not a subclass of minidb.Model - class Something(object): - column = str - - with minidb.Store(debug=True) as db: - db.register(Something) - db.register(Something) + with pytest.raises(TypeError): + class Something(object): + column = str + + with minidb.Store(debug=True) as db: + db.register(Something) + db.register(Something) -@raises(KeyError) def test_invalid_keyword_arguments_fails(): - with minidb.Store(debug=True) as db: - db.register(FieldTest) - FieldTest(9, this_is_not_an_attribute=123).save(db) + with pytest.raises(KeyError): + with minidb.Store(debug=True) as db: + db.register(FieldTest) + FieldTest(9, this_is_not_an_attribute=123).save(db) -@raises(AttributeError) def test_invalid_column_raises_attribute_error(): - class HasOnlyColumnX(minidb.Model): - x = int - - with minidb.Store(debug=True) as db: - db.register(HasOnlyColumnX) - HasOnlyColumnX.c.y + with pytest.raises(AttributeError): + class HasOnlyColumnX(minidb.Model): + x = int + + with minidb.Store(debug=True) as db: + db.register(HasOnlyColumnX) + HasOnlyColumnX.c.y def test_json_serialization(): @@ -192,7 +195,7 @@ db.register(WithJsonField) d = {'a': [1, True, 3.9]} WithJsonField(bar=d).save(db) - eq_(next(WithJsonField.c.bar.query(db)).bar, d) + ported_eq(next(WithJsonField.c.bar.query(db)).bar, d) def test_json_field_renamed_query(): @@ -203,7 +206,7 @@ db.register(WithJsonField) d = {'a': [1, True, 3.9]} WithJsonField(bar=d).save(db) - eq_(next(WithJsonField.c.bar('renamed').query(db)).renamed, d) + ported_eq(next(WithJsonField.c.bar('renamed').query(db)).renamed, d) def test_field_conversion_get_object(): @@ -293,16 +296,16 @@ assert query_value == BLOB -@raises(ValueError) def test_get_with_multiple_value_raises_exception(): - class Mod(minidb.Model): - mod = str - - with minidb.Store(debug=True) as db: - db.register(Mod) - Mod(mod='foo').save(db) - Mod(mod='foo').save(db) - Mod.get(db, mod='foo') + with pytest.raises(ValueError): + class Mod(minidb.Model): + mod = str + + with minidb.Store(debug=True) as db: + db.register(Mod) + Mod(mod='foo').save(db) + Mod(mod='foo').save(db) + Mod.get(db, mod='foo') def test_get_with_no_value_returns_none(): @@ -329,72 +332,72 @@ assert {2, 3, 4, 5} == {v for (v,) in DeleteWhere.c.v.query(db)} -@raises(AttributeError) def test_invalid_rowproxy_access_by_attribute(): - class Foo(minidb.Model): - bar = str + with pytest.raises(AttributeError): + class Foo(minidb.Model): + bar = str - with minidb.Store(debug=True) as db: - db.register(Foo) - Foo(bar='baz').save(db) - next(Foo.query(db, Foo.c.bar)).baz + with minidb.Store(debug=True) as db: + db.register(Foo) + Foo(bar='baz').save(db) + next(Foo.query(db, Foo.c.bar)).baz -@raises(KeyError) def test_invalid_rowproxy_access_by_key(): - class Foo(minidb.Model): - bar = str + with pytest.raises(KeyError): + class Foo(minidb.Model): + bar = str - with minidb.Store(debug=True) as db: - db.register(Foo) - Foo(bar='baz').save(db) - next(Foo.query(db, Foo.c.bar))['baz'] + with minidb.Store(debug=True) as db: + db.register(Foo) + Foo(bar='baz').save(db) + next(Foo.query(db, Foo.c.bar))['baz'] -@raises(TypeError) def test_use_schema_without_registration_raises_typeerror(): - with minidb.Store(debug=True) as db: - class Foo(minidb.Model): - bar = str - Foo.query(db) + with pytest.raises(TypeError): + with minidb.Store(debug=True) as db: + class Foo(minidb.Model): + bar = str + Foo.query(db) -@raises(TypeError) def test_use_schema_with_nonidentity_class_raises_typeerror(): - with minidb.Store(debug=True) as db: - class Foo(minidb.Model): - bar = str - db.register(Foo) + with pytest.raises(TypeError): + with minidb.Store(debug=True) as db: + class Foo(minidb.Model): + bar = str + db.register(Foo) - class Foo(minidb.Model): - bar = str + class Foo(minidb.Model): + bar = str - Foo.query(db) + Foo.query(db) -@raises(TypeError) def test_upgrade_schema_without_upgrade_raises_typeerror(): - with minidb.Store(debug=True) as db: - class Foo(minidb.Model): - bar = str + with pytest.raises(TypeError): + with minidb.Store(debug=True) as db: + class Foo(minidb.Model): + bar = str + + db.register(Foo) + + class Foo(minidb.Model): + bar = str + baz = int - db.register(Foo) + db.register(Foo) - class Foo(minidb.Model): - bar = str - baz = int - db.register(Foo) - - -@raises(TypeError) def test_reregistering_class_raises_typeerror(): - class Foo(minidb.Model): - bar = int + with pytest.raises(TypeError): + class Foo(minidb.Model): + bar = int - with minidb.Store(debug=True) as db: - db.register(Foo) - db.register(Foo) + with minidb.Store(debug=True) as db: + db.register(Foo) + db.register(Foo) def test_upgrade_schema_with_upgrade_succeeds(): @@ -411,18 +414,18 @@ db.register(Foo, upgrade=True) -@raises(TypeError) def test_upgrade_schema_with_different_type_raises_typeerror(): - with minidb.Store(debug=True) as db: - class Foo(minidb.Model): - bar = str + with pytest.raises(TypeError): + with minidb.Store(debug=True) as db: + class Foo(minidb.Model): + bar = str - db.register(Foo) + db.register(Foo) - class Foo(minidb.Model): - bar = int + class Foo(minidb.Model): + bar = int - db.register(Foo, upgrade=True) + db.register(Foo, upgrade=True) def test_update_object(): @@ -474,11 +477,11 @@ # minidb.func.distinct(COLUMN)(NAME) result = {tuple(x) for x in Foo.query(db, lambda c: minidb.func.distinct(c.bar)('foo'))} - eq_(result, expected) + ported_eq(result, expected) # COLUMN.distinct(NAME) result = {tuple(x) for x in Foo.query(db, Foo.c.bar.distinct('foo'))} - eq_(result, expected) + ported_eq(result, expected) @@ -501,43 +504,43 @@ # minidb.func.sum(COLUMN)(NAME) result = {tuple(x) for x in Foo.query(db, lambda c: c.bar // minidb.func.sum(c.baz)('sum'), group_by=lambda c: c.bar)} - eq_(result, expected) + ported_eq(result, expected) # COLUMN.sum(NAME) result = {tuple(x) for x in Foo.query(db, lambda c: c.bar // c.baz.sum('sum'), group_by=lambda c: c.bar)} - eq_(result, expected) + ported_eq(result, expected) -@raises(ValueError) def test_save_without_db_raises_valueerror(): - class Foo(minidb.Model): - bar = int + with pytest.raises(ValueError): + class Foo(minidb.Model): + bar = int - Foo(bar=99).save() + Foo(bar=99).save() -@raises(ValueError) def test_delete_without_db_raises_valueerror(): - class Foo(minidb.Model): - bar = int + with pytest.raises(ValueError): + class Foo(minidb.Model): + bar = int - Foo(bar=99).delete() + Foo(bar=99).delete() -@raises(KeyError) def test_double_delete_without_id_raises_valueerror(): - class Foo(minidb.Model): - bar = str + with pytest.raises(KeyError): + class Foo(minidb.Model): + bar = str - with minidb.Store(debug=True) as db: - db.register(Foo) - a = Foo(bar='hello') - a.save(db) - assert a.id is not None - a.delete() - assert a.id is None - a.delete() + with minidb.Store(debug=True) as db: + db.register(Foo) + a = Foo(bar='hello') + a.save(db) + assert a.id is not None + a.delete() + assert a.id is None + a.delete() def test_default_values_are_set_if_none(): @@ -549,10 +552,10 @@ with minidb.Store(debug=True) as db: f = Foo() - eq_(f.name, 'Bob') + ported_eq(f.name, 'Bob') f = Foo(name='John') - eq_(f.name, 'John') + ported_eq(f.name, 'John') def test_default_values_with_callable(): @@ -569,16 +572,16 @@ with minidb.Store(debug=True) as db: f = Foo() - eq_(f.name, 'Bob') - eq_(f.email, '[email protected]') + ported_eq(f.name, 'Bob') + ported_eq(f.email, '[email protected]') f = Foo(name='John') - eq_(f.name, 'John') - eq_(f.email, '[email protected]') + ported_eq(f.name, 'John') + ported_eq(f.email, '[email protected]') f = Foo(name='Joe', email='[email protected]') - eq_(f.name, 'Joe') - eq_(f.email, '[email protected]') + ported_eq(f.name, 'Joe') + ported_eq(f.email, '[email protected]') def test_storing_and_retrieving_datetime(): ++++++ no_ported_eq.patch ++++++ >From ac709c48385583a0309ff850cd31896d5f19f647 Mon Sep 17 00:00:00 2001 From: Paolo Stivanin <[email protected]> Date: Fri, 27 Mar 2020 14:47:48 +0100 Subject: [PATCH] switch to pytest --- test/test_minidb.py | 33 ++++++++++++++------------------- 1 file changed, 14 insertions(+), 19 deletions(-) --- a/test/test_minidb.py +++ b/test/test_minidb.py @@ -3,11 +3,6 @@ import pytest import datetime -def ported_eq(a, b, msg=None): - if not a == b: - raise AssertionError(msg or "%r != %r" % (a, b)) - - class FieldTest(minidb.Model): CONSTANT = 123 @@ -195,7 +190,7 @@ def test_json_field_query(): db.register(WithJsonField) d = {'a': [1, True, 3.9]} WithJsonField(bar=d).save(db) - ported_eq(next(WithJsonField.c.bar.query(db)).bar, d) + assert next(WithJsonField.c.bar.query(db)).bar == d def test_json_field_renamed_query(): @@ -206,7 +201,7 @@ def test_json_field_renamed_query(): db.register(WithJsonField) d = {'a': [1, True, 3.9]} WithJsonField(bar=d).save(db) - ported_eq(next(WithJsonField.c.bar('renamed').query(db)).renamed, d) + assert next(WithJsonField.c.bar('renamed').query(db)).renamed == d def test_field_conversion_get_object(): @@ -477,11 +472,11 @@ def test_distinct(): # minidb.func.distinct(COLUMN)(NAME) result = {tuple(x) for x in Foo.query(db, lambda c: minidb.func.distinct(c.bar)('foo'))} - ported_eq(result, expected) + assert result == expected # COLUMN.distinct(NAME) result = {tuple(x) for x in Foo.query(db, Foo.c.bar.distinct('foo'))} - ported_eq(result, expected) + assert result == expected @@ -504,12 +499,12 @@ def test_group_by_with_sum(): # minidb.func.sum(COLUMN)(NAME) result = {tuple(x) for x in Foo.query(db, lambda c: c.bar // minidb.func.sum(c.baz)('sum'), group_by=lambda c: c.bar)} - ported_eq(result, expected) + assert result == expected # COLUMN.sum(NAME) result = {tuple(x) for x in Foo.query(db, lambda c: c.bar // c.baz.sum('sum'), group_by=lambda c: c.bar)} - ported_eq(result, expected) + assert result == expected def test_save_without_db_raises_valueerror(): @@ -552,10 +547,10 @@ def test_default_values_are_set_if_none( with minidb.Store(debug=True) as db: f = Foo() - ported_eq(f.name, 'Bob') + assert f.name == 'Bob' f = Foo(name='John') - ported_eq(f.name, 'John') + assert f.name == 'John' def test_default_values_with_callable(): @@ -572,16 +567,16 @@ def test_default_values_with_callable(): with minidb.Store(debug=True) as db: f = Foo() - ported_eq(f.name, 'Bob') - ported_eq(f.email, '[email protected]') + assert f.name == 'Bob' + assert f.email == '[email protected]' f = Foo(name='John') - ported_eq(f.name, 'John') - ported_eq(f.email, '[email protected]') + assert f.name == 'John' + assert f.email == '[email protected]' f = Foo(name='Joe', email='[email protected]') - ported_eq(f.name, 'Joe') - ported_eq(f.email, '[email protected]') + assert f.name == 'Joe' + assert f.email == '[email protected]' def test_storing_and_retrieving_datetime():
