commit 5a3ab96773069aa217099346d72396da26e7bd0c Author: Adrian Schröter Date: Wed Jun 7 08:27:48 2023 +0200 Sync from SUSE:ALP:Source:Standard:1.0 python-chai revision 0bef49cfe2f9477d431164333157e38e diff --git a/.gitattributes b/.gitattributes new file mode 100644 index 0000000..fecc750 --- /dev/null +++ b/.gitattributes @@ -0,0 +1,23 @@ +## Default LFS +*.7z filter=lfs diff=lfs merge=lfs -text +*.bsp filter=lfs diff=lfs merge=lfs -text +*.bz2 filter=lfs diff=lfs merge=lfs -text +*.gem filter=lfs diff=lfs merge=lfs -text +*.gz filter=lfs diff=lfs merge=lfs -text +*.jar filter=lfs diff=lfs merge=lfs -text +*.lz filter=lfs diff=lfs merge=lfs -text +*.lzma filter=lfs diff=lfs merge=lfs -text +*.obscpio filter=lfs diff=lfs merge=lfs -text +*.oxt filter=lfs diff=lfs merge=lfs -text +*.pdf filter=lfs diff=lfs merge=lfs -text +*.png filter=lfs diff=lfs merge=lfs -text +*.rpm filter=lfs diff=lfs merge=lfs -text +*.tbz filter=lfs diff=lfs merge=lfs -text +*.tbz2 filter=lfs diff=lfs merge=lfs -text +*.tgz filter=lfs diff=lfs merge=lfs -text +*.ttf filter=lfs diff=lfs merge=lfs -text +*.txz filter=lfs diff=lfs merge=lfs -text +*.whl filter=lfs diff=lfs merge=lfs -text +*.xz filter=lfs diff=lfs merge=lfs -text +*.zip filter=lfs diff=lfs merge=lfs -text +*.zst filter=lfs diff=lfs merge=lfs -text diff --git a/0001-Fix-tests.patch b/0001-Fix-tests.patch new file mode 100644 index 0000000..87f2d87 --- /dev/null +++ b/0001-Fix-tests.patch @@ -0,0 +1,1119 @@ +From 066fba05fcab35bf08fc87b388482ebc0ab0ccb9 Mon Sep 17 00:00:00 2001 +From: Paolo Stivanin +Date: Thu, 26 Mar 2020 10:16:04 +0100 +Subject: [PATCH] Fix tests + +--- + tests/{chai_test.py => test_chai.py} | 40 ++-- + ...{comparator_test.py => test_comparator.py} | 50 ++-- + ...xpectation_test.py => test_expectation.py} | 50 ++-- + ...{functional_test.py => test_functional.py} | 2 +- + tests/{mock_test.py => test_mock.py} | 22 +- + tests/{sample_test.py => test_sample.py} | 0 + tests/{stub_test.py => test_stub.py} | 222 +++++++++--------- + 7 files changed, 193 insertions(+), 193 deletions(-) + rename tests/{chai_test.py => test_chai.py} (78%) + rename tests/{comparator_test.py => test_comparator.py} (80%) + rename tests/{expectation_test.py => test_expectation.py} (84%) + rename tests/{functional_test.py => test_functional.py} (98%) + rename tests/{mock_test.py => test_mock.py} (88%) + rename tests/{sample_test.py => test_sample.py} (100%) + rename tests/{stub_test.py => test_stub.py} (71%) + +diff --git a/tests/chai_test.py b/tests/test_chai.py +similarity index 78% +rename from tests/chai_test.py +rename to tests/test_chai.py +index 71a93da..eb72600 100644 +--- a/tests/chai_test.py ++++ b/tests/test_chai.py +@@ -59,8 +59,8 @@ class ChaiTest(unittest.TestCase): + def test_setup(self): + case = CupOf() + case.setup() +- self.assertEquals( deque(), case._stubs ) +- self.assertEquals( deque(), case._mocks ) ++ self.assertEqual( deque(), case._stubs ) ++ self.assertEqual( deque(), case._mocks ) + + def test_teardown_closes_out_stubs_and_mocks(self): + class Stub(object): +@@ -76,8 +76,8 @@ class ChaiTest(unittest.TestCase): + case._stubs = deque([stub]) + case._mocks = deque([(obj,'mock1','fee'), (obj,'mock2')]) + case.teardown() +- self.assertEquals( 1, stub.calls ) +- self.assertEquals( 'fee', obj.mock1 ) ++ self.assertEqual( 1, stub.calls ) ++ self.assertEqual( 'fee', obj.mock1 ) + self.assertFalse( hasattr(obj, 'mock2') ) + + def test_stub(self): +@@ -87,14 +87,14 @@ class ChaiTest(unittest.TestCase): + case = CupOf() + milk = Milk() + case.setup() +- self.assertEquals( deque(), case._stubs ) ++ self.assertEqual( deque(), case._stubs ) + case.stub( milk.pour ) + self.assertTrue( isinstance(milk.pour, Stub) ) +- self.assertEquals( deque([milk.pour]), case._stubs ) ++ self.assertEqual( deque([milk.pour]), case._stubs ) + + # Test it's only added once + case.stub( milk, 'pour' ) +- self.assertEquals( deque([milk.pour]), case._stubs ) ++ self.assertEqual( deque([milk.pour]), case._stubs ) + + def test_expect(self): + class Milk(object): +@@ -103,27 +103,27 @@ class ChaiTest(unittest.TestCase): + case = CupOf() + milk = Milk() + case.setup() +- self.assertEquals( deque(), case._stubs ) ++ self.assertEqual( deque(), case._stubs ) + case.expect( milk.pour ) +- self.assertEquals( deque([milk.pour]), case._stubs ) ++ self.assertEqual( deque([milk.pour]), case._stubs ) + + # Test it's only added once + case.expect( milk, 'pour' ) +- self.assertEquals( deque([milk.pour]), case._stubs ) ++ self.assertEqual( deque([milk.pour]), case._stubs ) + +- self.assertEquals( 2, len(milk.pour._expectations) ) ++ self.assertEqual( 2, len(milk.pour._expectations) ) + + def test_mock_no_binding(self): + case = CupOf() + case.setup() + +- self.assertEquals( deque(), case._mocks ) ++ self.assertEqual( deque(), case._mocks ) + mock1 = case.mock() + self.assertTrue( isinstance(mock1, Mock) ) +- self.assertEquals( deque(), case._mocks ) ++ self.assertEqual( deque(), case._mocks ) + mock2 = case.mock() + self.assertTrue( isinstance(mock2, Mock) ) +- self.assertEquals( deque(), case._mocks ) ++ self.assertEqual( deque(), case._mocks ) + self.assertNotEqual( mock1, mock2 ) + + def test_mock_with_attr_binding(self): +@@ -136,18 +136,18 @@ class ChaiTest(unittest.TestCase): + milk = Milk() + orig_pour = milk.pour + +- self.assertEquals( deque(), case._mocks ) ++ self.assertEqual( deque(), case._mocks ) + mock1 = case.mock( milk, 'pour' ) + self.assertTrue( isinstance(mock1, Mock) ) +- self.assertEquals( deque([(milk,'pour',orig_pour)]), case._mocks ) ++ self.assertEqual( deque([(milk,'pour',orig_pour)]), case._mocks ) + mock2 = case.mock( milk, 'pour' ) + self.assertTrue( isinstance(mock2, Mock) ) +- self.assertEquals( deque([(milk,'pour',orig_pour),(milk,'pour',mock1)]), case._mocks ) ++ self.assertEqual( deque([(milk,'pour',orig_pour),(milk,'pour',mock1)]), case._mocks ) + self.assertNotEqual( mock1, mock2 ) + + mock3 = case.mock( milk, 'foo' ) + self.assertTrue( isinstance(mock3, Mock) ) +- self.assertEquals( deque([(milk,'pour',orig_pour),(milk,'pour',mock1),(milk,'foo')]), case._mocks ) ++ self.assertEqual( deque([(milk,'pour',orig_pour),(milk,'pour',mock1),(milk,'foo')]), case._mocks ) + + def test_chai_class_use_metaclass(self): + obj = CupOf() +@@ -169,8 +169,8 @@ class ChaiTest(unittest.TestCase): + case._stubs = deque([stub]) + + case.test_local_definitions_work_and_are_global() +- self.assertEquals(1, stub.unmet_calls) +- self.assertEquals(1, stub.teardown_calls) ++ self.assertEqual(1, stub.unmet_calls) ++ self.assertEqual(1, stub.teardown_calls) + + def test_raises_if_unmet_expectations(self): + class Milk(object): +diff --git a/tests/comparator_test.py b/tests/test_comparator.py +similarity index 80% +rename from tests/comparator_test.py +rename to tests/test_comparator.py +index 594b3b6..8899b0e 100644 +--- a/tests/comparator_test.py ++++ b/tests/test_comparator.py +@@ -43,11 +43,11 @@ class ComparatorsTest(unittest.TestCase): + + def test_equals_repr(self): + comp = Equals(3) +- self.assertEquals(str(comp), "3") ++ self.assertEqual(str(comp), "3") + + def test_eq(self): + comp = Equals(3) +- self.assertEquals( comp, 3 ) ++ self.assertEqual( comp, 3 ) + + def test_is_a(self): + comp = IsA(str) +@@ -64,13 +64,13 @@ class ComparatorsTest(unittest.TestCase): + + def test_is_a_repr(self): + comp = IsA(str) +- self.assertEquals(repr(comp), "IsA(str)") ++ self.assertEqual(repr(comp), "IsA(str)") + + def test_is_a_format_name(self): + comp = IsA(str) +- self.assertEquals(comp._format_name(), "str") ++ self.assertEqual(comp._format_name(), "str") + comp = IsA((str, list)) +- self.assertEquals(comp._format_name(), "['str', 'list']") ++ self.assertEqual(comp._format_name(), "['str', 'list']") + + def test_is(self): + class Test(object): +@@ -79,7 +79,7 @@ class ComparatorsTest(unittest.TestCase): + obj1 = Test() + obj2 = Test() + comp = Is(obj1) +- self.assertEquals( obj1, obj2 ) ++ self.assertEqual( obj1, obj2 ) + self.assertTrue( comp.test(obj1) ) + self.assertFalse( comp.test(obj2) ) + +@@ -90,7 +90,7 @@ class ComparatorsTest(unittest.TestCase): + return "An Object" + + obj = TestObj() +- self.assertEquals(repr(Is(obj)), "Is(An Object)" ) ++ self.assertEqual(repr(Is(obj)), "Is(An Object)" ) + + def test_almost_equal(self): + comp = AlmostEqual(3.14159265, 3) +@@ -99,7 +99,7 @@ class ComparatorsTest(unittest.TestCase): + + def test_almost_equal_repr(self): + comp = AlmostEqual(3.14159265, 3) +- self.assertEquals(repr(comp), "AlmostEqual(value: 3.14159265, places: 3)") ++ self.assertEqual(repr(comp), "AlmostEqual(value: 3.14159265, places: 3)") + + def test_regex(self): + comp = Regex('[wf][io]{2}') +@@ -109,7 +109,7 @@ class ComparatorsTest(unittest.TestCase): + + def test_regex_repr(self): + comp = Regex('[wf][io]{2}') +- self.assertEquals(repr(comp), "Regex(pattern: [wf][io]{2}, flags: 0)") ++ self.assertEqual(repr(comp), "Regex(pattern: [wf][io]{2}, flags: 0)") + + def test_any(self): + comp = Any(1,2.3,str) +@@ -120,9 +120,9 @@ class ComparatorsTest(unittest.TestCase): + def test_any_repr(self): + comp = Any(1,2,3,str) + if sys.version_info.major==2: +- self.assertEquals(repr(comp), "Any([1, 2, 3, Any([IsA(str), Is()])])") ++ self.assertEqual(repr(comp), "Any([1, 2, 3, Any([IsA(str), Is()])])") + else: +- self.assertEquals(repr(comp), "Any([1, 2, 3, Any([IsA(str), Is()])])") ++ self.assertEqual(repr(comp), "Any([1, 2, 3, Any([IsA(str), Is()])])") + + def test_in(self): + comp = In(['foo', 'bar']) +@@ -149,7 +149,7 @@ class ComparatorsTest(unittest.TestCase): + comp = All(IsA(bytearray), Equals('foo'.encode('ascii'))) + self.assertTrue( comp.test(bytearray('foo'.encode('ascii'))) ) + self.assertFalse( comp.test('foo') ) +- self.assertEquals( 'foo'.encode('ascii'), bytearray('foo'.encode('ascii')) ) ++ self.assertEqual( 'foo'.encode('ascii'), bytearray('foo'.encode('ascii')) ) + + def test_all_repr(self): + comp = All(IsA(bytearray), Equals('foobar')) +@@ -186,38 +186,38 @@ class ComparatorsTest(unittest.TestCase): + + def test_variable(self): + comp = Variable('foo') +- self.assertEquals( 0, len(Variable._cache) ) ++ self.assertEqual( 0, len(Variable._cache) ) + self.assertTrue( comp.test('bar') ) +- self.assertEquals( 1, len(Variable._cache) ) ++ self.assertEqual( 1, len(Variable._cache) ) + self.assertTrue( comp.test('bar') ) + self.assertFalse( comp.test('bar2') ) + + self.assertTrue( Variable('foo').test('bar') ) + self.assertFalse( Variable('foo').test('bar2') ) +- self.assertEquals( 1, len(Variable._cache) ) ++ self.assertEqual( 1, len(Variable._cache) ) + +- self.assertEquals( 'bar', comp.value ) +- self.assertEquals( 'bar', Variable('foo').value ) ++ self.assertEqual( 'bar', comp.value ) ++ self.assertEqual( 'bar', Variable('foo').value ) + + v = Variable('foo2') +- self.assertEquals( 1, len(Variable._cache) ) ++ self.assertEqual( 1, len(Variable._cache) ) + v.test('dog') +- self.assertEquals( 'dog', v.value ) +- self.assertEquals( 2, len(Variable._cache) ) ++ self.assertEqual( 'dog', v.value ) ++ self.assertEqual( 2, len(Variable._cache) ) + + Variable.clear() +- self.assertEquals( 0, len(Variable._cache) ) ++ self.assertEqual( 0, len(Variable._cache) ) + + def test_variable_repr(self): + v = Variable('foo') +- self.assertEquals( repr(v), "Variable('foo')" ) ++ self.assertEqual( repr(v), "Variable('foo')" ) + + def test_like_init(self): + c = Like({'foo':'bar'}) +- self.assertEquals( {'foo':'bar'}, c._src ) ++ self.assertEqual( {'foo':'bar'}, c._src ) + + c = Like(['foo', 'bar']) +- self.assertEquals( ['foo','bar'], c._src ) ++ self.assertEqual( ['foo','bar'], c._src ) + + def test_like_test(self): + c = Like({'foo':'bar'}) +@@ -232,4 +232,4 @@ class ComparatorsTest(unittest.TestCase): + + def test_like_repr(self): + c = Like({'foo':'bar'}) +- self.assertEquals( repr(c), "Like({'foo': 'bar'})" ) ++ self.assertEqual( repr(c), "Like({'foo': 'bar'})" ) +diff --git a/tests/expectation_test.py b/tests/test_expectation.py +similarity index 84% +rename from tests/expectation_test.py +rename to tests/test_expectation.py +index 0abee54..b6c2ea6 100644 +--- a/tests/expectation_test.py ++++ b/tests/test_expectation.py +@@ -87,45 +87,45 @@ class ExpectationRule(unittest.TestCase): + + def test_times(self): + exp = Expectation(self.stub) +- self.assertEquals( exp, exp.times(3) ) +- self.assertEquals( 3, exp._min_count ) +- self.assertEquals( 3, exp._max_count ) ++ self.assertEqual( exp, exp.times(3) ) ++ self.assertEqual( 3, exp._min_count ) ++ self.assertEqual( 3, exp._max_count ) + + def test_at_least_once(self): + exp = Expectation(self.stub) +- self.assertEquals( exp, exp.at_least_once() ) ++ self.assertEqual( exp, exp.at_least_once() ) + exp.test() + self.assertTrue(exp.closed(with_counts=True)) + + def test_at_least(self): + exp = Expectation(self.stub) +- self.assertEquals( exp, exp.at_least(10) ) ++ self.assertEqual( exp, exp.at_least(10) ) + for x in range(10): + exp.test() + self.assertTrue(exp.closed(with_counts=True)) + + def test_at_most_once(self): + exp = Expectation(self.stub) +- self.assertEquals( exp, exp.args(1).at_most_once() ) ++ self.assertEqual( exp, exp.args(1).at_most_once() ) + exp.test(1) + self.assertTrue(exp.closed(with_counts=True)) + + def test_at_most(self): + exp = Expectation(self.stub) +- self.assertEquals( exp, exp.args(1).at_most(10) ) ++ self.assertEqual( exp, exp.args(1).at_most(10) ) + for x in range(10): + exp.test(1) + self.assertTrue(exp.closed(with_counts=True)) + + def test_once(self): + exp = Expectation(self.stub) +- self.assertEquals( exp, exp.args(1).once() ) ++ self.assertEqual( exp, exp.args(1).once() ) + exp.test(1) + self.assertTrue(exp.closed()) + + def test_any_order(self): + exp = Expectation(self.stub) +- self.assertEquals( exp, exp.any_order().times(1) ) ++ self.assertEqual( exp, exp.any_order().times(1) ) + self.assertFalse( exp.closed() ) + exp.close() + self.assertFalse( exp.closed() ) +@@ -136,7 +136,7 @@ class ExpectationRule(unittest.TestCase): + + def test_any_order_with_no_max(self): + exp = Expectation(self.stub) +- self.assertEquals( exp, exp.any_order().at_least_once() ) ++ self.assertEqual( exp, exp.any_order().at_least_once() ) + self.assertFalse( exp.closed() ) + exp.close() + self.assertFalse( exp.closed() ) +@@ -151,9 +151,9 @@ class ExpectationRule(unittest.TestCase): + foo.append('foo') + + exp = Expectation(self.stub) +- self.assertEquals( exp, exp.side_effect(effect) ) ++ self.assertEqual( exp, exp.side_effect(effect) ) + exp.test() +- self.assertEquals( ['foo'], called ) ++ self.assertEqual( ['foo'], called ) + + def test_side_effect_with_args(self): + called = [] +@@ -162,9 +162,9 @@ class ExpectationRule(unittest.TestCase): + called.append('foo') + + exp = Expectation(self.stub) +- self.assertEquals( exp, exp.side_effect(effect, 'a', b='c') ) ++ self.assertEqual( exp, exp.side_effect(effect, 'a', b='c') ) + exp.test() +- self.assertEquals( ['foo'], called ) ++ self.assertEqual( ['foo'], called ) + + def test_side_effect_with_passed_args(self): + called = [] +@@ -174,9 +174,9 @@ class ExpectationRule(unittest.TestCase): + + exp = Expectation(self.stub) + exp.args('a', b='c') +- self.assertEquals( exp, exp.side_effect(effect) ) ++ self.assertEqual( exp, exp.side_effect(effect) ) + exp.test('a', b='c') +- self.assertEquals( ['foo'], called ) ++ self.assertEqual( ['foo'], called ) + + def test_side_effect_with_an_exception(self): + called = [] +@@ -185,9 +185,9 @@ class ExpectationRule(unittest.TestCase): + class Zono(Exception): pass + + exp = Expectation(self.stub) +- self.assertEquals( exp, exp.side_effect(effect).raises(Zono) ) ++ self.assertEqual( exp, exp.side_effect(effect).raises(Zono) ) + self.assertRaises( Zono, exp.test ) +- self.assertEquals( ['foo'], called ) ++ self.assertEqual( ['foo'], called ) + + def test_teardown(self): + called = [] +@@ -199,7 +199,7 @@ class ExpectationRule(unittest.TestCase): + exp = Expectation( notastub() ) + exp.teardown() + exp.test() +- self.assertEquals( ['foo'], called ) ++ self.assertEqual( ['foo'], called ) + + def test_closed(self): + exp = Expectation(self.stub) +@@ -223,7 +223,7 @@ class ExpectationRule(unittest.TestCase): + exp = Expectation(self.stub) + exp.returns(123) + +- self.assertEquals(exp.test(), 123) ++ self.assertEqual(exp.test(), 123) + + def test_return_value_with_variable(self): + exp = Expectation(self.stub) +@@ -231,7 +231,7 @@ class ExpectationRule(unittest.TestCase): + Variable._cache['test'] = 123 + exp.returns( var ) + +- self.assertEquals(exp.test(), 123) ++ self.assertEqual(exp.test(), 123) + Variable.clear() + + def test_return_value_with_variable_in_tuple(self): +@@ -240,13 +240,13 @@ class ExpectationRule(unittest.TestCase): + Variable._cache['test'] = 123 + exp.returns( (var,'foo') ) + +- self.assertEquals(exp.test(), (123,'foo')) ++ self.assertEqual(exp.test(), (123,'foo')) + Variable.clear() + + def test_with_returns_return_value(self): + exp = Expectation(self.stub) + with exp.returns(123) as num: +- self.assertEquals(num, 123) ++ self.assertEqual(num, 123) + + def test_with_raises_exceptions(self): + exp = Expectation(self.stub) +@@ -261,7 +261,7 @@ class ExpectationRule(unittest.TestCase): + class CustomException(Exception): pass + + exp = Expectation(self.stub) +- self.assertEquals( exp, exp.raises(CustomException) ) ++ self.assertEqual( exp, exp.raises(CustomException) ) + + self.assertRaises(CustomException, exp.test) + +@@ -269,7 +269,7 @@ class ExpectationRule(unittest.TestCase): + class CustomException(Exception): pass + + exp = Expectation(self.stub) +- self.assertEquals( exp, exp.raises(CustomException()) ) ++ self.assertEqual( exp, exp.raises(CustomException()) ) + + self.assertRaises(CustomException, exp.test) + +diff --git a/tests/functional_test.py b/tests/test_functional.py +similarity index 98% +rename from tests/functional_test.py +rename to tests/test_functional.py +index 4d9aae6..2bdc9a7 100644 +--- a/tests/functional_test.py ++++ b/tests/test_functional.py +@@ -65,7 +65,7 @@ class FunctionalTest(Chai): + return x + f = Foo() + +- assert_equals( 3, f.bar(3) ) ++ assert_equals(3, f.bar(3)) + + expect( f.bar ) + assert_equals( None, f.bar() ) +diff --git a/tests/mock_test.py b/tests/test_mock.py +similarity index 88% +rename from tests/mock_test.py +rename to tests/test_mock.py +index 0fefcec..5e0d24b 100644 +--- a/tests/mock_test.py ++++ b/tests/test_mock.py +@@ -17,10 +17,10 @@ class MockTest(unittest.TestCase): + # self.assertTrue( isinstance(m.foo, types.MethodType) ) + def test_get_attribute_creates_a_mock_method(self): + m = Mock() +- self.assertEquals( 'mock', m._name ) ++ self.assertEqual( 'mock', m._name ) + self.assertTrue( isinstance(m.foo, Mock) ) + self.assertFalse( m.foo is m ) +- self.assertEquals( 'mock.foo', m.foo._name ) ++ self.assertEqual( 'mock.foo', m.foo._name ) + + def test_get_attribute_caches_auto_methods(self): + m = Mock() +@@ -42,17 +42,17 @@ class MockTest(unittest.TestCase): + def test_get_attribute_auto_method_not_raises_unexpectedcall_when_stubbed(self): + m = Mock() + stub(m.foo).expect().returns('success') +- self.assertEquals( 'success', m.foo() ) ++ self.assertEqual( 'success', m.foo() ) + + def test_get_attribute_auto_method_not_raises_unexpectedcall_multiple_depths(self): + m = Mock() + stub(m.foo.bar).expect().returns('success') +- self.assertEquals( 'success', m.foo.bar() ) ++ self.assertEqual( 'success', m.foo.bar() ) + + def test_get_attribute_does_not_overwrite_existing_attr(self): + m = Mock() + m.foo = 42 +- self.assertEquals( 42, m.foo ) ++ self.assertEqual( 42, m.foo ) + + def test_call_raises_unexpectedcall_when_unstubbed(self): + m = Mock() +@@ -61,7 +61,7 @@ class MockTest(unittest.TestCase): + def test_call_not_raises_unexpectedcall_when_stubbed(self): + m = Mock() + stub(m).expect().returns('success') +- self.assertEquals( 'success', m() ) ++ self.assertEqual( 'success', m() ) + + def test_nonzero_returns_true_when_unstubbed(self): + m = Mock() +@@ -97,13 +97,13 @@ class MockTest(unittest.TestCase): + stub( m.__reversed__ ).expect().returns( 'backwards' ) + stub( m.__contains__ ).expect().args('foo').returns( True ) + +- self.assertEquals( 42, len(m) ) +- self.assertEquals( 'getitem', m['foo'] ) ++ self.assertEqual( 42, len(m) ) ++ self.assertEqual( 'getitem', m['foo'] ) + m['foo']='bar' + del m['foo'] +- self.assertEquals( i, iter(m) ) +- self.assertEquals( 'backwards', reversed(m) ) +- self.assertEquals( True, 'foo' in m ) ++ self.assertEqual( i, iter(m) ) ++ self.assertEqual( 'backwards', reversed(m) ) ++ self.assertEqual( True, 'foo' in m ) + + def test_context_manager_interface_when_unstubbed(self): + m = Mock() +diff --git a/tests/sample_test.py b/tests/test_sample.py +similarity index 100% +rename from tests/sample_test.py +rename to tests/test_sample.py +diff --git a/tests/stub_test.py b/tests/test_stub.py +similarity index 71% +rename from tests/stub_test.py +rename to tests/test_stub.py +index c5a655e..ceab5bc 100644 +--- a/tests/stub_test.py ++++ b/tests/test_stub.py +@@ -80,8 +80,8 @@ class StubTest(unittest.TestCase): + f.bar = Mock() + res = stub(f, 'bar') + self.assertTrue(isinstance(res, StubMethod)) +- self.assertEquals(res, f.bar.__call__) +- self.assertEquals(res, stub(f, 'bar')) ++ self.assertEqual(res, f.bar.__call__) ++ self.assertEqual(res, stub(f, 'bar')) + + def test_stub_mock_with_obj_ref(self): + class Foo(object): +@@ -91,8 +91,8 @@ class StubTest(unittest.TestCase): + f.bar = Mock() + res = stub(f.bar) + self.assertTrue(isinstance(res, StubMethod)) +- self.assertEquals(res, f.bar.__call__) +- self.assertEquals(res, stub(f.bar)) ++ self.assertEqual(res, f.bar.__call__) ++ self.assertEqual(res, stub(f.bar)) + + def test_stub_type_with_obj_ref(self): + class Foo(object): +@@ -100,14 +100,14 @@ class StubTest(unittest.TestCase): + + res = stub(Foo) + self.assertTrue(isinstance(res, StubNew)) +- self.assertEquals(res, Foo.__new__) +- self.assertEquals(res, stub(Foo)) ++ self.assertEqual(res, Foo.__new__) ++ self.assertEqual(res, stub(Foo)) + + # test that __init__ called only once + res.expect() +- self.assertEquals(1, len(res._expectations)) ++ self.assertEqual(1, len(res._expectations)) + res = stub(Foo) +- self.assertEquals(1, len(res._expectations)) ++ self.assertEqual(1, len(res._expectations)) + + def test_stub_unbound_method_with_attr_name(self): + class Foo(object): +@@ -115,8 +115,8 @@ class StubTest(unittest.TestCase): + + res = stub(Foo, 'bar') + self.assertTrue(isinstance(res,StubUnboundMethod)) +- self.assertEquals(res, stub(Foo,'bar')) +- self.assertEquals(res, getattr(Foo,'bar')) ++ self.assertEqual(res, stub(Foo,'bar')) ++ self.assertEqual(res, getattr(Foo,'bar')) + + @unittest.skipIf(sys.version_info.major==3, "can't stub unbound methods by reference in python 3") + def test_stub_unbound_method_with_obj_ref(self): +@@ -125,8 +125,8 @@ class StubTest(unittest.TestCase): + + res = stub(Foo.bar) + self.assertTrue(isinstance(res,StubUnboundMethod)) +- self.assertEquals(res, stub(Foo.bar)) +- self.assertEquals(res, getattr(Foo,'bar')) ++ self.assertEqual(res, stub(Foo.bar)) ++ self.assertEqual(res, getattr(Foo,'bar')) + + def test_stub_bound_method_for_instance_with_attr_name(self): + class Foo(object): +@@ -136,11 +136,11 @@ class StubTest(unittest.TestCase): + orig = foo.bar + res = stub(foo, 'bar') + self.assertTrue(isinstance(res,StubMethod)) +- self.assertEquals(res._instance, foo) +- self.assertEquals(res._obj, orig) +- self.assertEquals(res._attr, 'bar') +- self.assertEquals(res, stub(foo,'bar')) +- self.assertEquals(res, getattr(foo,'bar')) ++ self.assertEqual(res._instance, foo) ++ self.assertEqual(res._obj, orig) ++ self.assertEqual(res._attr, 'bar') ++ self.assertEqual(res, stub(foo,'bar')) ++ self.assertEqual(res, getattr(foo,'bar')) + + def test_stub_bound_method_for_instance_with_obj_ref(self): + class Foo(object): +@@ -150,11 +150,11 @@ class StubTest(unittest.TestCase): + orig = foo.bar + res = stub(foo.bar) + self.assertTrue(isinstance(res,StubMethod)) +- self.assertEquals(res._instance, foo) +- self.assertEquals(res._obj, orig) +- self.assertEquals(res._attr, 'bar') +- self.assertEquals(res, stub(foo.bar)) +- self.assertEquals(res, getattr(foo,'bar')) ++ self.assertEqual(res._instance, foo) ++ self.assertEqual(res._obj, orig) ++ self.assertEqual(res._attr, 'bar') ++ self.assertEqual(res, stub(foo.bar)) ++ self.assertEqual(res, getattr(foo,'bar')) + + def test_stub_bound_method_for_classmethod_with_attr_name(self): + class Foo(object): +@@ -163,8 +163,8 @@ class StubTest(unittest.TestCase): + + res = stub(Foo, 'bar') + self.assertTrue(isinstance(res,StubMethod)) +- self.assertEquals(res, stub(Foo,'bar')) +- self.assertEquals(res, getattr(Foo,'bar')) ++ self.assertEqual(res, stub(Foo,'bar')) ++ self.assertEqual(res, getattr(Foo,'bar')) + + def test_stub_bound_method_for_classmethod_with_obj_ref(self): + class Foo(object): +@@ -173,8 +173,8 @@ class StubTest(unittest.TestCase): + + res = stub(Foo.bar) + self.assertTrue(isinstance(res,StubMethod)) +- self.assertEquals(res, stub(Foo.bar)) +- self.assertEquals(res, getattr(Foo,'bar')) ++ self.assertEqual(res, stub(Foo.bar)) ++ self.assertEqual(res, getattr(Foo,'bar')) + + @unittest.skipIf(IS_PYPY, "no method-wrapper in PyPy") + def test_stub_method_wrapper_with_attr_name(self): +@@ -183,8 +183,8 @@ class StubTest(unittest.TestCase): + foo = Foo() + res = stub(foo, '__hash__') + self.assertTrue(isinstance(res,StubMethodWrapper)) +- self.assertEquals(res, stub(foo, '__hash__')) +- self.assertEquals(res, getattr(foo, '__hash__')) ++ self.assertEqual(res, stub(foo, '__hash__')) ++ self.assertEqual(res, getattr(foo, '__hash__')) + + @unittest.skipIf(IS_PYPY, "no method-wrapper in PyPy") + def test_stub_method_wrapper_with_obj_ref(self): +@@ -193,22 +193,22 @@ class StubTest(unittest.TestCase): + foo = Foo() + res = stub(foo.__hash__) + self.assertTrue(isinstance(res,StubMethodWrapper)) +- self.assertEquals(res, stub(foo.__hash__)) +- self.assertEquals(res, getattr(foo, '__hash__')) ++ self.assertEqual(res, stub(foo.__hash__)) ++ self.assertEqual(res, getattr(foo, '__hash__')) + + def test_stub_module_function_with_attr_name(self): + res = stub(samples, 'mod_func_1') + self.assertTrue(isinstance(res,StubFunction)) +- self.assertEquals(res, getattr(samples,'mod_func_1')) +- self.assertEquals(res, stub(samples,'mod_func_1')) ++ self.assertEqual(res, getattr(samples,'mod_func_1')) ++ self.assertEqual(res, stub(samples,'mod_func_1')) + res.teardown() + + def test_stub_module_function_with_obj_ref(self): + res = stub(samples.mod_func_1) + self.assertTrue(isinstance(res,StubFunction)) +- self.assertEquals(res, getattr(samples,'mod_func_1')) +- self.assertEquals(res, samples.mod_func_1) +- self.assertEquals(res, stub(samples.mod_func_1)) ++ self.assertEqual(res, getattr(samples,'mod_func_1')) ++ self.assertEqual(res, samples.mod_func_1) ++ self.assertEqual(res, stub(samples.mod_func_1)) + res.teardown() + + class StubClassTest(unittest.TestCase): +@@ -217,9 +217,9 @@ class StubClassTest(unittest.TestCase): + ### + def test_init(self): + s = Stub('obj','attr') +- self.assertEquals('obj', s._obj) +- self.assertEquals('attr', s._attr) +- self.assertEquals([], s._expectations) ++ self.assertEqual('obj', s._obj) ++ self.assertEqual('attr', s._attr) ++ self.assertEqual([], s._expectations) + + def test_unment_expectations(self): + s = Stub('obj', 'attr') +@@ -231,15 +231,15 @@ class StubClassTest(unittest.TestCase): + s = Stub('obj') + s._expections = ['1','2'] + s.teardown() +- self.assertEquals([], s._expectations) ++ self.assertEqual([], s._expectations) + + def test_expect(self): + s = Stub('obj') + +- self.assertEquals([], s._expectations) ++ self.assertEqual([], s._expectations) + e = s.expect() +- self.assertEquals([e], s._expectations) +- self.assertEquals(s, e._stub) ++ self.assertEqual([e], s._expectations) ++ self.assertEqual(s, e._stub) + + def test_call_orig_raises_notimplemented(self): + s = Stub('obj') +@@ -259,7 +259,7 @@ class StubClassTest(unittest.TestCase): + + s = Stub('obj') + s._expectations = [ Expect() ] +- self.assertEquals('success', s('foo')) ++ self.assertEqual('success', s('foo')) + + def test_call_raises_unexpected_call_when_all_expectations_closed(self): + class Expect(object): +@@ -291,10 +291,10 @@ class StubClassTest(unittest.TestCase): + s = Stub('obj') + s._expectations = [ Expect(True), Expect(False) ] + self.assertRaises(UnexpectedCall, s, 'foo') +- self.assertEquals(0, s._expectations[0]._match_count) +- self.assertEquals(1, s._expectations[1]._match_count) +- self.assertEquals(0, s._expectations[0]._close_count) +- self.assertEquals(0, s._expectations[1]._close_count) ++ self.assertEqual(0, s._expectations[0]._match_count) ++ self.assertEqual(1, s._expectations[1]._match_count) ++ self.assertEqual(0, s._expectations[0]._close_count) ++ self.assertEqual(0, s._expectations[1]._close_count) + + class StubPropertyTest(unittest.TestCase): + # FIXME: Need to test teardown and init, these test might be in the base stub tests. +@@ -305,7 +305,7 @@ class StubPropertyTest(unittest.TestCase): + def prop(self): return 3 + + s = StubProperty(Foo, 'prop') +- self.assertEquals(s.name, 'Foo.prop') ++ self.assertEqual(s.name, 'Foo.prop') + + class StubMethodTest(unittest.TestCase): + +@@ -316,29 +316,29 @@ class StubMethodTest(unittest.TestCase): + f = Foo() + orig = f.bar + s = StubMethod(f.bar) +- self.assertEquals(s._obj, orig) +- self.assertEquals(s._instance, f) +- self.assertEquals(s._attr, 'bar') +- self.assertEquals(s, getattr(f,'bar')) ++ self.assertEqual(s._obj, orig) ++ self.assertEqual(s._instance, f) ++ self.assertEqual(s._attr, 'bar') ++ self.assertEqual(s, getattr(f,'bar')) + + f = Foo() + orig = f.bar + s = StubMethod(f, 'bar') +- self.assertEquals(s._obj, orig) +- self.assertEquals(s._instance, f) +- self.assertEquals(s._attr, 'bar') +- self.assertEquals(s, getattr(f,'bar')) ++ self.assertEqual(s._obj, orig) ++ self.assertEqual(s._instance, f) ++ self.assertEqual(s._attr, 'bar') ++ self.assertEqual(s, getattr(f,'bar')) + + def test_name(self): + class Expect(object): + def closed(self): return False + obj = Expect() + s = StubMethod(obj.closed) +- self.assertEquals("Expect.closed", s.name) ++ self.assertEqual("Expect.closed", s.name) + s.teardown() + + s = StubMethod(obj, 'closed') +- self.assertEquals("Expect.closed", s.name) ++ self.assertEqual("Expect.closed", s.name) + s.teardown() + + def test_call_orig(self): +@@ -350,9 +350,9 @@ class StubMethodTest(unittest.TestCase): + f = Foo(3) + sa = StubMethod(f.a) + sb = StubMethod(f.b) +- self.assertEquals(3, sa.call_orig()) ++ self.assertEqual(3, sa.call_orig()) + sb.call_orig(5) +- self.assertEquals(5, sa.call_orig()) ++ self.assertEqual(5, sa.call_orig()) + + def test_teardown(self): + class Foo(object): +@@ -362,7 +362,7 @@ class StubMethodTest(unittest.TestCase): + orig = f.bar + s = StubMethod(f.bar) + s.teardown() +- self.assertEquals(orig, f.bar) ++ self.assertEqual(orig, f.bar) + + def test_teardown_of_classmethods(self): + class Foo(object): +@@ -378,46 +378,46 @@ class StubMethodTest(unittest.TestCase): + orig = samples.mod_instance_foo + s = StubMethod(samples, 'mod_instance_foo') + s.teardown() +- self.assertEquals(orig, samples.mod_instance_foo) ++ self.assertEqual(orig, samples.mod_instance_foo) + + class StubFunctionTest(unittest.TestCase): + + def test_init(self): + s = StubFunction(samples.mod_func_1) +- self.assertEquals(s._instance, samples) +- self.assertEquals(s._attr, 'mod_func_1') +- self.assertEquals(s, samples.mod_func_1) +- self.assertEquals(False, s._was_object_method) ++ self.assertEqual(s._instance, samples) ++ self.assertEqual(s._attr, 'mod_func_1') ++ self.assertEqual(s, samples.mod_func_1) ++ self.assertEqual(False, s._was_object_method) + s.teardown() + + def test_init_with_object_method(self): + x = samples.SampleBase() + s = StubFunction(x, '__new__') +- self.assertEquals(True, s._was_object_method) ++ self.assertEqual(True, s._was_object_method) + + def test_name(self): + s = StubFunction(samples.mod_func_1) +- self.assertEquals('tests.samples.mod_func_1', s.name) ++ self.assertEqual('tests.samples.mod_func_1', s.name) + s.teardown() + + def test_call_orig(self): + s = StubFunction(samples.mod_func_3) +- self.assertEquals(12, s.call_orig(4)) ++ self.assertEqual(12, s.call_orig(4)) + s.teardown() + + def test_teardown(self): + orig = samples.mod_func_1 + s = StubFunction(samples.mod_func_1) + s.teardown() +- self.assertEquals(orig, samples.mod_func_1) ++ self.assertEqual(orig, samples.mod_func_1) + + def test_teardown_on_object_method(self): + x = samples.SampleBase() +- self.assertEquals(object.__new__, getattr(x, '__new__')) ++ self.assertEqual(object.__new__, getattr(x, '__new__')) + s = StubFunction(x, '__new__') +- self.assertNotEquals(object.__new__, getattr(x, '__new__')) ++ self.assertNotEqual(object.__new__, getattr(x, '__new__')) + s.teardown() +- self.assertEquals(object.__new__, getattr(x, '__new__')) ++ self.assertEqual(object.__new__, getattr(x, '__new__')) + + class StubNewTest(unittest.TestCase): + +@@ -425,19 +425,19 @@ class StubNewTest(unittest.TestCase): + def test_new(self): + class Foo(object): pass + +- self.assertEquals(0, len(StubNew._cache)) ++ self.assertEqual(0, len(StubNew._cache)) + x = StubNew(Foo) + self.assertTrue(x is StubNew(Foo)) +- self.assertEquals(1, len(StubNew._cache)) ++ self.assertEqual(1, len(StubNew._cache)) + StubNew._cache.clear() + + def test_init(self): + class Foo(object): pass + + s = StubNew(Foo) +- self.assertEquals(s._instance, Foo) +- self.assertEquals(s._attr, '__new__') +- self.assertEquals(s, Foo.__new__) ++ self.assertEqual(s._instance, Foo) ++ self.assertEqual(s._attr, '__new__') ++ self.assertEqual(s, Foo.__new__) + s.teardown() + + def test_call(self): +@@ -449,7 +449,7 @@ class StubNewTest(unittest.TestCase): + + s = StubNew(Foo) + s._expectations = [ Expect() ] +- self.assertEquals('success', Foo('state', a='b')) ++ self.assertEqual('success', Foo('state', a='b')) + s.teardown() + + @unittest.skipIf(sys.version_info.major==3, "can't stub unbound methods in python 3") +@@ -462,7 +462,7 @@ class StubNewTest(unittest.TestCase): + s = StubNew(Foo) + f = s.call_orig(3) + self.assertTrue(isinstance(f,Foo)) +- self.assertEquals(3, f._val) ++ self.assertEqual(3, f._val) + s.teardown() + StubNew._cache.clear() + +@@ -471,12 +471,12 @@ class StubNewTest(unittest.TestCase): + class Foo(object): pass + + orig = Foo.__new__ +- self.assertEquals(0, len(StubNew._cache)) ++ self.assertEqual(0, len(StubNew._cache)) + x = StubNew(Foo) +- self.assertEquals(1, len(StubNew._cache)) ++ self.assertEqual(1, len(StubNew._cache)) + x.teardown() +- self.assertEquals(0, len(StubNew._cache)) +- self.assertEquals(orig, Foo.__new__) ++ self.assertEqual(0, len(StubNew._cache)) ++ self.assertEqual(orig, Foo.__new__) + + @unittest.skipIf(sys.version_info.major==3, "can't stub unbound methods in python 3") + def test_teardown_on_custom_new(self): +@@ -487,16 +487,16 @@ class StubNewTest(unittest.TestCase): + return rval + + f1 = Foo('f1') +- self.assertEquals(('f1',), f1.args) ++ self.assertEqual(('f1',), f1.args) + orig = Foo.__new__ +- self.assertEquals(0, len(StubNew._cache)) ++ self.assertEqual(0, len(StubNew._cache)) + x = StubNew(Foo) +- self.assertEquals(1, len(StubNew._cache)) ++ self.assertEqual(1, len(StubNew._cache)) + x.teardown() +- self.assertEquals(0, len(StubNew._cache)) +- self.assertEquals(orig, Foo.__new__) ++ self.assertEqual(0, len(StubNew._cache)) ++ self.assertEqual(orig, Foo.__new__) + f2 = Foo('f2') +- self.assertEquals(('f2',), f2.args) ++ self.assertEqual(('f2',), f2.args) + + + class StubUnboundMethodTest(unittest.TestCase): +@@ -506,16 +506,16 @@ class StubUnboundMethodTest(unittest.TestCase): + def bar(self): pass + + s = StubUnboundMethod(Foo, 'bar') +- self.assertEquals(s._instance, Foo) +- self.assertEquals(s._attr, 'bar') +- self.assertEquals(s, getattr(Foo,'bar')) ++ self.assertEqual(s._instance, Foo) ++ self.assertEqual(s._attr, 'bar') ++ self.assertEqual(s, getattr(Foo,'bar')) + + def test_name(self): + class Expect(object): + def closed(self): return False + + s = StubUnboundMethod(Expect, 'closed') +- self.assertEquals("Expect.closed", s.name) ++ self.assertEqual("Expect.closed", s.name) + s.teardown() + + def test_teardown(self): +@@ -525,7 +525,7 @@ class StubUnboundMethodTest(unittest.TestCase): + orig = Foo.bar + s = StubUnboundMethod(Foo, 'bar') + s.teardown() +- self.assertEquals(orig, Foo.bar) ++ self.assertEqual(orig, Foo.bar) + + def test_call_acts_as_any_instance(self): + class Foo(object): +@@ -544,7 +544,7 @@ class StubUnboundMethodTest(unittest.TestCase): + f2 = Foo() + f2.bar() + +- self.assertEquals(2, s.calls) ++ self.assertEqual(2, s.calls) + + class StubMethodWrapperTest(unittest.TestCase): + +@@ -553,16 +553,16 @@ class StubMethodWrapperTest(unittest.TestCase): + foo = Foo() + + s = StubMethodWrapper(foo.__hash__) +- self.assertEquals(s._instance, foo) +- self.assertEquals(s._attr, '__hash__') +- self.assertEquals(s, getattr(foo,'__hash__')) ++ self.assertEqual(s._instance, foo) ++ self.assertEqual(s._attr, '__hash__') ++ self.assertEqual(s, getattr(foo,'__hash__')) + + def test_name(self): + class Foo(object):pass + foo = Foo() + + s = StubMethodWrapper(foo.__hash__) +- self.assertEquals("Foo.__hash__", s.name) ++ self.assertEqual("Foo.__hash__", s.name) + s.teardown() + + def test_call_orig(self): +@@ -575,9 +575,9 @@ class StubMethodWrapperTest(unittest.TestCase): + sg = StubMethodWrapper(f.get) + ss = StubMethodWrapper(f.set) + +- self.assertEquals(3, sg.call_orig()) ++ self.assertEqual(3, sg.call_orig()) + ss.call_orig(5) +- self.assertEquals(5, sg.call_orig()) ++ self.assertEqual(5, sg.call_orig()) + + def test_teardown(self): + class Foo(object):pass +@@ -585,7 +585,7 @@ class StubMethodWrapperTest(unittest.TestCase): + orig = obj.__hash__ + s = StubMethodWrapper(obj.__hash__) + s.teardown() +- self.assertEquals(orig, obj.__hash__) ++ self.assertEqual(orig, obj.__hash__) + + @unittest.skipIf(IS_PYPY, "no method-wrapper in PyPy") + class StubWrapperDescriptionTest(unittest.TestCase): +@@ -593,26 +593,26 @@ class StubWrapperDescriptionTest(unittest.TestCase): + def test_init(self): + class Foo(object):pass + s = StubWrapperDescriptor(Foo, '__hash__') +- self.assertEquals(s._obj, Foo) +- self.assertEquals(s._attr, '__hash__') +- self.assertEquals(s, getattr(Foo,'__hash__')) ++ self.assertEqual(s._obj, Foo) ++ self.assertEqual(s._attr, '__hash__') ++ self.assertEqual(s, getattr(Foo,'__hash__')) + + def test_name(self): + class Foo(object):pass + + s = StubWrapperDescriptor(Foo, '__hash__') +- self.assertEquals("Foo.__hash__", s.name) ++ self.assertEqual("Foo.__hash__", s.name) + s.teardown() + + def test_call_orig(self): + class Foo(object): pass + if sys.version_info < (3, 3): +- foo_str = "" ++ foo_str = "" + else: +- foo_str = ".Foo'>" ++ foo_str = ".Foo'>" + + s = StubWrapperDescriptor(Foo, '__str__') +- self.assertEquals(foo_str, s.call_orig()) ++ self.assertEqual(foo_str, s.call_orig()) + s.teardown() + + def test_teardown(self): +@@ -620,4 +620,4 @@ class StubWrapperDescriptionTest(unittest.TestCase): + orig = Foo.__hash__ + s = StubWrapperDescriptor(Foo, '__hash__') + s.teardown() +- self.assertEquals(orig, Foo.__hash__) ++ self.assertEqual(orig, Foo.__hash__) +-- +2.25.1 + diff --git a/chai-1.1.2.tar.gz b/chai-1.1.2.tar.gz new file mode 100644 index 0000000..5055a2b --- /dev/null +++ b/chai-1.1.2.tar.gz @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:ff8d2b6855f660cd23cd5ec79bd10264d39f24f6235773331b48e7fcd637d6cc +size 107807 diff --git a/python-chai.changes b/python-chai.changes new file mode 100644 index 0000000..a68ac94 --- /dev/null +++ b/python-chai.changes @@ -0,0 +1,39 @@ +------------------------------------------------------------------- +Fri Apr 21 12:23:13 UTC 2023 - Dirk Müller + +- add sle15_python_module_pythons (jsc#PED-68) + +------------------------------------------------------------------- +Thu Mar 26 09:20:19 UTC 2020 - Paolo Stivanin + +- Add 0001-Fix-tests.patch + * remove deprecation warnings + * fix files name under tests folder, so that they can be executed + with unittest + +------------------------------------------------------------------- +Mon Oct 14 11:44:47 UTC 2019 - Matej Cepl + +- Replace %fdupes -s with plain %fdupes; hardlinks are better. + +------------------------------------------------------------------- +Tue Dec 4 12:49:08 UTC 2018 - Matej Cepl + +- Remove superfluous devel dependency for noarch package + +------------------------------------------------------------------- +Mon Sep 11 18:39:32 UTC 2017 - jengelh@inai.de + +- Ensure neutrality of description. + +------------------------------------------------------------------- +Sat Jul 15 18:37:48 UTC 2017 - aloisio@gmx.com + +- Update to version 1.1.2 +- Converted to singlespec + +------------------------------------------------------------------- +Wed Aug 6 08:12:32 UTC 2014 - toddrme2178@gmail.com + +- Initial version + diff --git a/python-chai.spec b/python-chai.spec new file mode 100644 index 0000000..f17e88c --- /dev/null +++ b/python-chai.spec @@ -0,0 +1,60 @@ +# +# spec file for package python-chai +# +# Copyright (c) 2023 SUSE LLC +# +# All modifications and additions to the file contributed by third parties +# remain the property of their copyright owners, unless otherwise agreed +# upon. The license for this file, and modifications and additions to the +# file, is the same license as for the pristine package itself (unless the +# license for the pristine package is not an Open Source License, in which +# case the license is the MIT License). An "Open Source License" is a +# license that conforms to the Open Source Definition (Version 1.9) +# published by the Open Source Initiative. + +# Please submit bugfixes or comments via https://bugs.opensuse.org/ +# + + +%{?!python_module:%define python_module() python-%{**} python3-%{**}} +%{?sle15_python_module_pythons} +Name: python-chai +Version: 1.1.2 +Release: 0 +Summary: Mocking/stub framework for Python +License: BSD-3-Clause +URL: https://github.com/agoragames/chai +Source: https://files.pythonhosted.org/packages/source/c/chai/chai-%{version}.tar.gz +# https://github.com/agoragames/chai/pull/37 +Patch0: 0001-Fix-tests.patch +BuildRequires: %{python_module setuptools} +BuildRequires: fdupes +BuildRequires: python-rpm-macros +BuildArch: noarch +%python_subpackages + +%description +Chai provides an API for mocking/stubbing Python +objects, patterned after the Mocha library for Ruby. + +%prep +%setup -q -n chai-%{version} +rm -rf chai.egg-info +%patch0 -p1 + +%build +%python_build + +%install +%python_install +%python_expand %fdupes %{buildroot}%{$python_sitelib} + +%check +%python_exec -m unittest discover -s tests/ -v + +%files %{python_files} +%license LICENSE.txt +%doc README.rst +%{python_sitelib}/* + +%changelog