From 2d103e4bfbbaebfdb0cbc0da17024c522d58e024b62545b0127f2e5a67b4bbaf Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Tom=C3=A1=C5=A1=20Chv=C3=A1tal?= Date: Mon, 4 May 2020 10:54:11 +0000 Subject: [PATCH] - Add patch to work with transaction 3.x: * transaction3.patch OBS-URL: https://build.opensuse.org/package/show/devel:languages:python/python-ZODB?expand=0&rev=15 --- python-ZODB.changes | 6 + python-ZODB.spec | 6 +- transaction3.patch | 285 ++++++++++++++++++++++++++++++++++++++++++++ 3 files changed, 294 insertions(+), 3 deletions(-) create mode 100644 transaction3.patch diff --git a/python-ZODB.changes b/python-ZODB.changes index c19a264..139faf9 100644 --- a/python-ZODB.changes +++ b/python-ZODB.changes @@ -1,3 +1,9 @@ +------------------------------------------------------------------- +Mon May 4 10:50:45 UTC 2020 - Tomáš Chvátal + +- Add patch to work with transaction 3.x: + * transaction3.patch + ------------------------------------------------------------------- Mon Mar 4 14:15:53 UTC 2019 - Tomáš Chvátal diff --git a/python-ZODB.spec b/python-ZODB.spec index 3bb7557..36d62be 100644 --- a/python-ZODB.spec +++ b/python-ZODB.spec @@ -1,7 +1,7 @@ # # spec file for package python-ZODB # -# Copyright (c) 2019 SUSE LINUX GmbH, Nuernberg, Germany. +# Copyright (c) 2020 SUSE LLC # Copyright (c) 2013 LISA GmbH, Bingen, Germany. # # All modifications and additions to the file contributed by third parties @@ -23,9 +23,9 @@ Version: 5.5.1 Release: 0 Summary: Zope Object Database: object database and persistence License: ZPL-2.1 -Group: Development/Libraries/Python URL: https://github.com/zopefoundation/ZODB Source: https://files.pythonhosted.org/packages/source/Z/ZODB/ZODB-%{version}.tar.gz +Patch0: transaction3.patch BuildRequires: %{python_module BTrees >= 4.2.0} BuildRequires: %{python_module ZConfig} BuildRequires: %{python_module manuel} @@ -63,7 +63,6 @@ support, and undo. %package -n %{name}-doc Summary: Zope Object Database: object database and persistence -Group: Development/Libraries/Python Provides: %{python_module ZODB-doc = %{version}} %description -n %{name}-doc @@ -71,6 +70,7 @@ This package contains documentation files for %{name}. %prep %setup -q -n ZODB-%{version} +%patch0 -p1 # delete backup files find . -name "*~" -print -delete # remove unwanted shebang diff --git a/transaction3.patch b/transaction3.patch new file mode 100644 index 0000000..268b627 --- /dev/null +++ b/transaction3.patch @@ -0,0 +1,285 @@ +From 0adcc6877f690186c97cc5da7e13788946d5e0df Mon Sep 17 00:00:00 2001 +From: Jason Madden +Date: Wed, 11 Dec 2019 10:24:00 -0600 +Subject: [PATCH] Fix tests with transaction 3.0. + +Only test changes were required, no production code changes. +--- + src/ZODB/tests/testZODB.py | 7 +- + src/ZODB/tests/test_datamanageradapter.py | 242 ---------------------- + 3 files changed, 6 insertions(+), 245 deletions(-) + delete mode 100644 src/ZODB/tests/test_datamanageradapter.py + +diff --git a/src/ZODB/tests/testZODB.py b/src/ZODB/tests/testZODB.py +index c5f7949e9..2ec6c5af7 100644 +--- a/src/ZODB/tests/testZODB.py ++++ b/src/ZODB/tests/testZODB.py +@@ -290,8 +290,9 @@ def checkFailingCommitSticks(self): + rt['a'] = 1 + + # Arrange for commit to fail during tpc_vote. +- poisoned = PoisonedObject(PoisonedJar(break_tpc_vote=True)) +- transaction.get().register(poisoned) ++ poisoned_jar = PoisonedJar(break_tpc_vote=True) ++ poisoned = PoisonedObject(poisoned_jar) ++ transaction.get().join(poisoned_jar) + + self.assertRaises(PoisonedError, transaction.get().commit) + # Trying to commit again fails too. +@@ -314,7 +315,7 @@ def checkFailingCommitSticks(self): + + # Cleaning up via begin() should also work. + rt['a'] = 2 +- transaction.get().register(poisoned) ++ transaction.get().join(poisoned_jar) + self.assertRaises(PoisonedError, transaction.commit) + self.assertRaises(TransactionFailedError, transaction.commit) + # The change to rt['a'] is lost. +diff --git a/src/ZODB/tests/test_datamanageradapter.py b/src/ZODB/tests/test_datamanageradapter.py +deleted file mode 100644 +index cfeb40bf3..000000000 +--- a/src/ZODB/tests/test_datamanageradapter.py ++++ /dev/null +@@ -1,242 +0,0 @@ +-############################################################################## +-# +-# Copyright (c) 2003 Zope Foundation and Contributors. +-# All Rights Reserved. +-# +-# This software is subject to the provisions of the Zope Public License, +-# Version 2.1 (ZPL). A copy of the ZPL should accompany this distribution. +-# THIS SOFTWARE IS PROVIDED "AS IS" AND ANY AND ALL EXPRESS OR IMPLIED +-# WARRANTIES ARE DISCLAIMED, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED +-# WARRANTIES OF TITLE, MERCHANTABILITY, AGAINST INFRINGEMENT, AND FITNESS +-# FOR A PARTICULAR PURPOSE. +-# +-############################################################################## +-import unittest +-from doctest import DocTestSuite +-from transaction._transaction import DataManagerAdapter +-from ZODB.tests.sampledm import DataManager +- +-def test_normal_commit(): +- """ +- So, we have a data manager: +- +- >>> dm = DataManager() +- +- and we do some work that modifies uncommited state: +- +- >>> dm.inc() +- >>> dm.state, dm.delta +- (0, 1) +- +- Now we'll commit the changes. When the data manager joins a transaction, +- the transaction will create an adapter. +- +- >>> dma = DataManagerAdapter(dm) +- +- and register it as a modified object. At commit time, the +- transaction will get the "jar" like this: +- +- >>> jar = getattr(dma, '_p_jar', dma) +- +- and, of course, the jar and the adapter will be the same: +- +- >>> jar is dma +- True +- +- The transaction will call tpc_begin: +- +- >>> t1 = '1' +- >>> jar.tpc_begin(t1) +- +- Then the transaction will call commit on the jar: +- +- >>> jar.commit(t1) +- +- This doesn't actually do anything. :) +- +- >>> dm.state, dm.delta +- (0, 1) +- +- The transaction will then call tpc_vote: +- +- >>> jar.tpc_vote(t1) +- +- This prepares the data manager: +- +- >>> dm.state, dm.delta +- (1, 1) +- >>> dm.prepared +- True +- +- Finally, tpc_finish is called: +- +- >>> jar.tpc_finish(t1) +- +- and the data manager finishes the two-phase commit: +- +- >>> dm.state, dm.delta +- (1, 0) +- >>> dm.prepared +- False +- """ +- +-def test_abort(): +- """ +- So, we have a data manager: +- +- >>> dm = DataManager() +- +- and we do some work that modifies uncommited state: +- +- >>> dm.inc() +- >>> dm.state, dm.delta +- (0, 1) +- +- When the data manager joins a transaction, +- the transaction will create an adapter. +- +- >>> dma = DataManagerAdapter(dm) +- +- and register it as a modified object. +- +- Now we'll abort the transaction. The transaction will get the +- "jar" like this: +- +- >>> jar = getattr(dma, '_p_jar', dma) +- +- and, of course, the jar and the adapter will be the same: +- +- >>> jar is dma +- True +- +- Then the transaction will call abort on the jar: +- +- >>> t1 = '1' +- >>> jar.abort(t1) +- +- Which aborts the changes in the data manager: +- +- >>> dm.state, dm.delta +- (0, 0) +- """ +- +-def test_tpc_abort_phase1(): +- """ +- So, we have a data manager: +- +- >>> dm = DataManager() +- +- and we do some work that modifies uncommited state: +- +- >>> dm.inc() +- >>> dm.state, dm.delta +- (0, 1) +- +- Now we'll commit the changes. When the data manager joins a transaction, +- the transaction will create an adapter. +- +- >>> dma = DataManagerAdapter(dm) +- +- and register it as a modified object. At commit time, the +- transaction will get the "jar" like this: +- +- >>> jar = getattr(dma, '_p_jar', dma) +- +- and, of course, the jar and the adapter will be the same: +- +- >>> jar is dma +- True +- +- The transaction will call tpc_begin: +- +- >>> t1 = '1' +- >>> jar.tpc_begin(t1) +- +- Then the transaction will call commit on the jar: +- +- >>> jar.commit(t1) +- +- This doesn't actually do anything. :) +- +- >>> dm.state, dm.delta +- (0, 1) +- +- At this point, the transaction decides to abort. It calls tpc_abort: +- +- >>> jar.tpc_abort(t1) +- +- Which causes the state of the data manager to be restored: +- +- >>> dm.state, dm.delta +- (0, 0) +- """ +- +-def test_tpc_abort_phase2(): +- """ +- So, we have a data manager: +- +- >>> dm = DataManager() +- +- and we do some work that modifies uncommited state: +- +- >>> dm.inc() +- >>> dm.state, dm.delta +- (0, 1) +- +- Now we'll commit the changes. When the data manager joins a transaction, +- the transaction will create an adapter. +- +- >>> dma = DataManagerAdapter(dm) +- +- and register it as a modified object. At commit time, the +- transaction will get the "jar" like this: +- +- >>> jar = getattr(dma, '_p_jar', dma) +- +- and, of course, the jar and the adapter will be the same: +- +- >>> jar is dma +- True +- +- The transaction will call tpc_begin: +- +- >>> t1 = '1' +- >>> jar.tpc_begin(t1) +- +- Then the transaction will call commit on the jar: +- +- >>> jar.commit(t1) +- +- This doesn't actually do anything. :) +- +- >>> dm.state, dm.delta +- (0, 1) +- +- The transaction calls vote: +- +- >>> jar.tpc_vote(t1) +- +- This prepares the data manager: +- +- >>> dm.state, dm.delta +- (1, 1) +- >>> dm.prepared +- True +- +- At this point, the transaction decides to abort. It calls tpc_abort: +- +- >>> jar.tpc_abort(t1) +- +- Which causes the state of the data manager to be restored: +- +- >>> dm.state, dm.delta +- (0, 0) +- >>> dm.prepared +- False +- """ +- +-def test_suite(): +- return DocTestSuite() +- +-if __name__ == '__main__': +- unittest.main()