Hello community, here is the log from the commit of package python-minidb for openSUSE:Leap:15.2 checked in at 2020-03-29 14:56:25 ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ Comparing /work/SRC/openSUSE:Leap:15.2/python-minidb (Old) and /work/SRC/openSUSE:Leap:15.2/.python-minidb.new.3160 (New) ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
Package is "python-minidb" Sun Mar 29 14:56:25 2020 rev:12 rq:789304 version:2.0.3 Changes: -------- --- /work/SRC/openSUSE:Leap:15.2/python-minidb/python-minidb.changes 2020-03-09 18:08:52.192981948 +0100 +++ /work/SRC/openSUSE:Leap:15.2/.python-minidb.new.3160/python-minidb.changes 2020-03-29 14:56:27.859193977 +0200 @@ -1,0 +2,6 @@ +Fri Mar 27 14:01:08 UTC 2020 - Paolo Stivanin <[email protected]> + +- Update to 2.0.3 +- Add 0001-switch-to-pytest.patch + +------------------------------------------------------------------- Old: ---- minidb-2.0.2.tar.gz New: ---- 0001-switch-to-pytest.patch minidb-2.0.3.tar.gz ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ Other differences: ------------------ ++++++ python-minidb.spec ++++++ --- /var/tmp/diff_new_pack.Ya0ArM/_old 2020-03-29 14:56:28.171194220 +0200 +++ /var/tmp/diff_new_pack.Ya0ArM/_new 2020-03-29 14:56:28.175194223 +0200 @@ -1,7 +1,7 @@ # # spec file for package python-minidb # -# Copyright (c) 2018 SUSE LINUX GmbH, Nuernberg, Germany. +# Copyright (c) 2020 SUSE LLC # # All modifications and additions to the file contributed by third parties # remain the property of their copyright owners, unless otherwise agreed @@ -20,17 +20,19 @@ %define skip_python2 1 %bcond_without test Name: python-minidb -Version: 2.0.2 +Version: 2.0.3 Release: 0 Summary: SQLite3-based store for Python objects License: ISC Group: Development/Languages/Python -Url: http://thp.io/2010/minidb/ +URL: http://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 BuildRequires: %{python_module setuptools} BuildRequires: python-rpm-macros %if %{with test} -BuildRequires: %{python_module nose} +BuildRequires: %{python_module pytest} BuildRequires: python3-testsuite %endif BuildRequires: fdupes @@ -43,6 +45,7 @@ %prep %setup -q -n minidb-%{version} +%patch0 -p1 %build %python_build @@ -53,7 +56,7 @@ %if %{with test} %check -%python_expand nosetests-%{$python_bin_suffix} +%pytest test/test_minidb.py %endif %files %{python_files} ++++++ 0001-switch-to-pytest.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 | 227 ++++++++++++++++++++++---------------------- 1 file changed, 115 insertions(+), 112 deletions(-) diff --git a/test/test_minidb.py b/test/test_minidb.py index 8f6d44a..632aeec 100644 --- a/test/test_minidb.py +++ b/test/test_minidb.py @@ -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 @@ def test_loading_objects(): 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 pytest.raises(TypeError): + class Something(object): + column = str - with minidb.Store(debug=True) as db: - db.register(Something) - db.register(Something) + 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 pytest.raises(AttributeError): + class HasOnlyColumnX(minidb.Model): + x = int - with minidb.Store(debug=True) as db: - db.register(HasOnlyColumnX) - HasOnlyColumnX.c.y + with minidb.Store(debug=True) as db: + db.register(HasOnlyColumnX) + HasOnlyColumnX.c.y def test_json_serialization(): @@ -192,7 +195,7 @@ def test_json_field_query(): 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 @@ def test_json_field_renamed_query(): 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 @@ def test_storing_and_retrieving_bytes(): assert query_value == BLOB -@raises(ValueError) def test_get_with_multiple_value_raises_exception(): - class Mod(minidb.Model): - mod = str + 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') + 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 @@ def test_delete_where(): 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) + db.register(Foo) - class Foo(minidb.Model): - bar = str - baz = int + class Foo(minidb.Model): + bar = str + baz = int - db.register(Foo) + 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 @@ def test_upgrade_schema_with_upgrade_succeeds(): 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 @@ 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'))} - 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 @@ 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)} - 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 @@ def test_default_values_are_set_if_none(): 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 @@ def test_default_values_with_callable(): 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(): -- 2.25.1 ++++++ minidb-2.0.2.tar.gz -> minidb-2.0.3.tar.gz ++++++ diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/minidb-2.0.2/PKG-INFO new/minidb-2.0.3/PKG-INFO --- old/minidb-2.0.2/PKG-INFO 2017-01-15 22:05:47.000000000 +0100 +++ new/minidb-2.0.3/PKG-INFO 2020-03-23 20:50:00.000000000 +0100 @@ -1,11 +1,11 @@ Metadata-Version: 1.1 Name: minidb -Version: 2.0.2 +Version: 2.0.3 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.2.tar.gz +Download-URL: http://thp.io/2010/minidb/minidb-2.0.3.tar.gz Description: UNKNOWN Platform: UNKNOWN diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/minidb-2.0.2/README new/minidb-2.0.3/README --- old/minidb-2.0.2/README 2016-01-16 18:33:46.000000000 +0100 +++ new/minidb-2.0.3/README 2018-05-17 22:39:52.000000000 +0200 @@ -27,6 +27,10 @@ >>> db = minidb.Store('filename.db', debug=True) +Note that for persisting data into the file, you actually need to call +db.close() to flush the changes to disk, and optionally db.commit() if you +want to save the changes to disk without closing the database. + To actually store objects, we need to subclass from minidb.Model (which takes care of all the behind-the-scenes magic for making your class persistable, and adds methods for working with the database): @@ -37,8 +41,8 @@ ... age = int Every subclass of minidb.Model will also have a "id" attribute that is None if -an instance is not stored in the database, or an automatically assigne value if -it is in the database. This uniquely identifies an object in the database. +an instance is not stored in the database, or an automatically assigned value +if it is in the database. This uniquely identifies an object in the database. Now it's time to register our minidb.Model subclass with the store: diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/minidb-2.0.2/minidb.py new/minidb-2.0.3/minidb.py --- old/minidb-2.0.2/minidb.py 2017-01-15 22:05:30.000000000 +0100 +++ new/minidb-2.0.3/minidb.py 2020-03-23 20:49:13.000000000 +0100 @@ -5,7 +5,7 @@ # |_|_|_|_|_||_|_\__,_|_.__/ # simple python object store # -# Copyright 2009-2010, 2014-2017 Thomas Perl <thp.io>. All rights reserved. +# Copyright 2009-2010, 2014-2020 Thomas Perl <thp.io>. All rights reserved. # # Permission to use, copy, modify, and/or distribute this software for any # purpose with or without fee is hereby granted, provided that the above @@ -23,7 +23,7 @@ """A simple SQLite3-based store for Python objects""" __author__ = 'Thomas Perl <[email protected]>' -__version__ = '2.0.2' +__version__ = '2.0.3' __url__ = 'http://thp.io/2010/minidb/' __license__ = 'ISC' @@ -141,7 +141,7 @@ return self def __exit__(self, exc_type, exc_value, traceback): - if (exc_type, exc_value, traceback) is (None, None, None): + if exc_type is exc_value is traceback is None: self.commit() self.close() @@ -260,7 +260,7 @@ pk = getattr(o, pk_name) assert pk is not None - res = self._execute('DELETE FROM %s WHERE %s = ?' % (table, pk_name), [pk]) + self._execute('DELETE FROM %s WHERE %s = ?' % (table, pk_name), [pk]) setattr(o, pk_name, None) def _update(self, o):
