diff --git a/python-happybase.changes b/python-happybase.changes index ff6bc25..d8f1f0d 100644 --- a/python-happybase.changes +++ b/python-happybase.changes @@ -1,3 +1,9 @@ +------------------------------------------------------------------- +Tue Mar 31 12:03:26 UTC 2020 - Paolo Stivanin + +- Switch from nose to pytest +- Add use_pytest.patch + ------------------------------------------------------------------- Thu Sep 12 09:02:50 UTC 2019 - Tomáš Chvátal diff --git a/python-happybase.spec b/python-happybase.spec index fd5e181..d78b3b8 100644 --- a/python-happybase.spec +++ b/python-happybase.spec @@ -1,7 +1,7 @@ # # spec file for package python-happybase # -# Copyright (c) 2019 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 @@ -25,7 +25,9 @@ License: MIT Group: Development/Languages/Python URL: https://github.com/wbolster/happybase Source: https://github.com/wbolster/happybase/archive/%{version}.tar.gz -BuildRequires: %{python_module nose} +# https://github.com/python-happybase/happybase/pull/238 +Patch0: use_pytest.patch +BuildRequires: %{python_module pytest} BuildRequires: %{python_module setuptools} BuildRequires: %{python_module thriftpy2} BuildRequires: fdupes @@ -51,6 +53,7 @@ This package contains the documentation. %prep %setup -q -n happybase-%{version} +%patch0 -p1 %build %python_build @@ -63,7 +66,7 @@ rm -r docs/build/html/.[a-z]* %check # the api tests need running thrift server -%python_expand nosetests-%{$python_bin_suffix} -v tests/test_util.py +%pytest tests/test_util.py %files %{python_files} %license LICENSE.rst diff --git a/use_pytest.patch b/use_pytest.patch new file mode 100644 index 0000000..4045e4c --- /dev/null +++ b/use_pytest.patch @@ -0,0 +1,482 @@ +Only in happybase: .idea +diff -ru happybase-orig/Makefile happybase/Makefile +--- happybase-orig/Makefile 2020-03-31 14:01:25.374555626 +0200 ++++ happybase/Makefile 2020-03-31 14:00:45.834479691 +0200 +@@ -10,7 +10,7 @@ + + test: + -find coverage/ -mindepth 1 -delete +- python $$(which nosetests) $${TESTS} ++ pytest $${TESTS} + + clean: + find . -name '*.py[co]' -delete +diff -ru happybase-orig/setup.cfg happybase/setup.cfg +--- happybase-orig/setup.cfg 2020-03-31 14:01:25.374555626 +0200 ++++ happybase/setup.cfg 2020-03-31 14:00:15.882422171 +0200 +@@ -1,16 +1,6 @@ +-[nosetests] +-stop = 1 +-verbosity = 2 +-with-coverage = 1 +-cover-erase = 1 +-cover-package=happybase.connection,happybase.table,happybase.batch,happybase.pool,happybase.util,tests +-cover-tests = 1 +-cover-html = 1 +-cover-html-dir = coverage/ +- + [build_sphinx] + source-dir = doc/ + build-dir = doc/build/ + + [wheel] +-universal = 1 +\ No newline at end of file ++universal = 1 +diff -ru happybase-orig/tests/test_api.py happybase/tests/test_api.py +--- happybase-orig/tests/test_api.py 2020-03-31 14:01:25.374555626 +0200 ++++ happybase/tests/test_api.py 2020-03-31 14:05:45.535055247 +0200 +@@ -10,19 +10,6 @@ + import six + from six.moves import range + +-from nose.tools import ( +- assert_dict_equal, +- assert_equal, +- assert_false, +- assert_in, +- assert_is_instance, +- assert_is_not_none, +- assert_list_equal, +- assert_not_in, +- assert_raises, +- assert_true, +-) +- + from happybase import Connection, ConnectionPool, NoConnectionsAvailable + + HAPPYBASE_HOST = os.environ.get('HAPPYBASE_HOST') +@@ -60,7 +47,7 @@ + global connection, table + connection = Connection(**connection_kwargs) + +- assert_is_not_none(connection) ++ assert connection is not None + + maybe_delete_table() + cfs = { +@@ -71,7 +58,7 @@ + connection.create_table(TEST_TABLE_NAME, families=cfs) + + table = connection.table(TEST_TABLE_NAME) +- assert_is_not_none(table) ++ assert table is not None + + + def teardown_module(): +@@ -92,11 +79,11 @@ + + + def test_enabling(): +- assert_true(connection.is_table_enabled(TEST_TABLE_NAME)) ++ assert connection.is_table_enabled(TEST_TABLE_NAME) + connection.disable_table(TEST_TABLE_NAME) +- assert_false(connection.is_table_enabled(TEST_TABLE_NAME)) ++ assert not connection.is_table_enabled(TEST_TABLE_NAME) + connection.enable_table(TEST_TABLE_NAME) +- assert_true(connection.is_table_enabled(TEST_TABLE_NAME)) ++ assert connection.is_table_enabled(TEST_TABLE_NAME) + + + def test_compaction(): +@@ -105,14 +92,14 @@ + + + def test_prefix(): +- assert_equal(TABLE_PREFIX + b'_', connection._table_name('')) +- assert_equal(TABLE_PREFIX + b'_foo', connection._table_name('foo')) ++ assert TABLE_PREFIX + b'_' == connection._table_name('') ++ assert TABLE_PREFIX + b'_foo' == connection._table_name('foo') + +- assert_equal(connection.table('foobar').name, TABLE_PREFIX + b'_foobar') +- assert_equal(connection.table('foobar', use_prefix=False).name, b'foobar') ++ assert connection.table('foobar').name == TABLE_PREFIX + b'_foobar' ++ assert connection.table('foobar', use_prefix=False).name == b'foobar' + + c = Connection(autoconnect=False) +- assert_equal(b'foo', c._table_name('foo')) ++ assert b'foo' == c._table_name('foo') + + with assert_raises(TypeError): + Connection(autoconnect=False, table_prefix=123) +@@ -130,13 +117,13 @@ + + def test_table_listing(): + names = connection.tables() +- assert_is_instance(names, list) +- assert_in(TEST_TABLE_NAME, names) ++ assert isinstance(names, list) ++ assert TEST_TABLE_NAME in names + + + def test_table_regions(): + regions = table.regions() +- assert_is_instance(regions, list) ++ assert isinstance(regions, list) + + + def test_invalid_table_create(): +@@ -151,11 +138,11 @@ + def test_families(): + families = table.families() + for name, fdesc in six.iteritems(families): +- assert_is_instance(name, bytes) +- assert_is_instance(fdesc, dict) +- assert_in('name', fdesc) +- assert_is_instance(fdesc['name'], six.binary_type) +- assert_in('max_versions', fdesc) ++ assert isinstance(name, bytes) ++ assert isinstance(fdesc, dict) ++ assert 'name' in fdesc ++ assert isinstance(fdesc['name'], six.binary_type) ++ assert 'max_versions' in fdesc + + + def test_put(): +@@ -168,23 +155,23 @@ + row = b'row-with-counter' + column = 'cf1:counter' + +- assert_equal(0, table.counter_get(row, column)) ++ assert 0 == table.counter_get(row, column) + +- assert_equal(10, table.counter_inc(row, column, 10)) +- assert_equal(10, table.counter_get(row, column)) ++ assert 10 == table.counter_inc(row, column, 10) ++ assert 10 == table.counter_get(row, column) + + table.counter_set(row, column, 0) +- assert_equal(1, table.counter_inc(row, column)) +- assert_equal(4, table.counter_inc(row, column, 3)) +- assert_equal(4, table.counter_get(row, column)) ++ assert 1 == table.counter_inc(row, column) ++ assert 4 == table.counter_inc(row, column, 3) ++ assert 4 == table.counter_get(row, column) + + table.counter_set(row, column, 3) +- assert_equal(3, table.counter_get(row, column)) +- assert_equal(8, table.counter_inc(row, column, 5)) +- assert_equal(6, table.counter_inc(row, column, -2)) +- assert_equal(5, table.counter_dec(row, column)) +- assert_equal(3, table.counter_dec(row, column, 2)) +- assert_equal(10, table.counter_dec(row, column, -7)) ++ assert 3 == table.counter_get(row, column) ++ assert 8 == table.counter_inc(row, column, 5) ++ assert 6 == table.counter_inc(row, column, -2) ++ assert 5 == table.counter_dec(row, column) ++ assert 3 == table.counter_dec(row, column, 2) ++ assert 10 == table.counter_dec(row, column, -7) + + + def test_batch(): +@@ -229,13 +216,13 @@ + with table.batch(transaction=True) as b: + b.put(b'fooz', {b'cf1:bar': b'baz'}) + raise ValueError +- assert_dict_equal({}, table.row(b'fooz', [b'cf1:bar'])) ++ assert {} == table.row(b'fooz', [b'cf1:bar']) + + with assert_raises(ValueError): + with table.batch(transaction=False) as b: + b.put(b'fooz', {b'cf1:bar': b'baz'}) + raise ValueError +- assert_dict_equal({b'cf1:bar': b'baz'}, table.row(b'fooz', [b'cf1:bar'])) ++ assert {b'cf1:bar': b'baz'} == table.row(b'fooz', [b'cf1:bar']) + + with table.batch(batch_size=5) as b: + for i in range(10): +@@ -246,12 +233,12 @@ + for i in range(95): + b.put(('row-batch2-%03d' % i).encode('ascii'), + {b'cf1:': str(i).encode('ascii')}) +- assert_equal(95, len(list(table.scan(row_prefix=b'row-batch2-')))) ++ assert 95 == len(list(table.scan(row_prefix=b'row-batch2-'))) + + with table.batch(batch_size=20) as b: + for i in range(95): + b.delete(('row-batch2-%03d' % i).encode('ascii')) +- assert_equal(0, len(list(table.scan(row_prefix=b'row-batch2-')))) ++ assert 0 == len(list(table.scan(row_prefix=b'row-batch2-'))) + + + def test_row(): +@@ -275,26 +262,26 @@ + b'cf1:col2': b'v2', + b'cf2:col1': b'v3', + b'cf2:col2': b'v4'} +- assert_dict_equal(exp, row(row_key)) ++ assert exp == row(row_key) + + exp = {b'cf1:col1': b'v1new', + b'cf1:col2': b'v2'} +- assert_dict_equal(exp, row(row_key, [b'cf1'])) ++ assert exp == row(row_key, [b'cf1']) + + exp = {b'cf1:col1': b'v1new', + b'cf2:col2': b'v4'} +- assert_dict_equal(exp, row(row_key, [b'cf1:col1', b'cf2:col2'])) ++ assert exp == row(row_key, [b'cf1:col1', b'cf2:col2']) + + exp = {b'cf1:col1': b'v1old', + b'cf2:col2': b'v4'} +- assert_dict_equal(exp, row(row_key, timestamp=2345)) ++ assert exp == row(row_key, timestamp=2345) + +- assert_dict_equal({}, row(row_key, timestamp=123)) ++ assert {} == row(row_key, timestamp=123) + + res = row(row_key, include_timestamp=True) +- assert_equal(len(res), 4) +- assert_equal(b'v1new', res[b'cf1:col1'][0]) +- assert_is_instance(res[b'cf1:col1'][1], int) ++ assert len(res) == 4 ++ assert b'v1new' == res[b'cf1:col1'][0] ++ assert isinstance(res[b'cf1:col1'][1], int) + + + def test_rows(): +@@ -314,17 +301,17 @@ + for row_key in row_keys: + table.put(row_key, data_new) + +- assert_dict_equal({}, table.rows([])) ++ assert {} == table.rows([]) + + rows = dict(table.rows(row_keys)) + for row_key in row_keys: +- assert_in(row_key, rows) +- assert_dict_equal(data_new, rows[row_key]) ++ assert row_key in rows ++ assert data_new == rows[row_key] + + rows = dict(table.rows(row_keys, timestamp=5000)) + for row_key in row_keys: +- assert_in(row_key, rows) +- assert_dict_equal(data_old, rows[row_key]) ++ assert row_key in rows ++ assert data_old == rows[row_key] + + + def test_cells(): +@@ -344,18 +331,18 @@ + table.cells(row_key, col, versions=0) + + results = table.cells(row_key, col, versions=1) +- assert_equal(len(results), 1) +- assert_equal(b'new', results[0]) ++ assert len(results) == 1 ++ assert b'new' == results[0] + + results = table.cells(row_key, col) +- assert_equal(len(results), 2) +- assert_equal(b'new', results[0]) +- assert_equal(b'old', results[1]) ++ assert len(results) == 2 ++ assert b'new' == results[0] ++ assert b'old' == results[1] + + results = table.cells(row_key, col, timestamp=2345, include_timestamp=True) +- assert_equal(len(results), 1) +- assert_equal(b'old', results[0][0]) +- assert_equal(1234, results[0][1]) ++ assert len(results) == 1 ++ assert b'old' == results[0][0] ++ assert 1234 == results[0][1] + + + def test_scan(): +@@ -389,36 +376,36 @@ + + scanner = table.scan(row_start=b'row-scan-a00012', + row_stop=b'row-scan-a00022') +- assert_equal(10, calc_len(scanner)) ++ assert 10 == calc_len(scanner) + + scanner = table.scan(row_start=b'xyz') +- assert_equal(0, calc_len(scanner)) ++ assert 0 == calc_len(scanner) + + scanner = table.scan(row_start=b'xyz', row_stop=b'zyx') +- assert_equal(0, calc_len(scanner)) ++ assert 0 == calc_len(scanner) + + scanner = table.scan(row_start=b'row-scan-', row_stop=b'row-scan-a999', + columns=[b'cf1:col1', b'cf2:col2']) + row_key, row = next(scanner) +- assert_equal(row_key, b'row-scan-a00000') +- assert_dict_equal(row, {b'cf1:col1': b'v1', +- b'cf2:col2': b'v2'}) +- assert_equal(2000 - 1, calc_len(scanner)) ++ assert row_key == b'row-scan-a00000' ++ assert row == {b'cf1:col1': b'v1', ++ b'cf2:col2': b'v2'} ++ assert 2000 - 1 == calc_len(scanner) + + scanner = table.scan(row_prefix=b'row-scan-a', batch_size=499, limit=1000) +- assert_equal(1000, calc_len(scanner)) ++ assert 1000 == calc_len(scanner) + + scanner = table.scan(row_prefix=b'row-scan-b', batch_size=1, limit=10) +- assert_equal(10, calc_len(scanner)) ++ assert 10 == calc_len(scanner) + + scanner = table.scan(row_prefix=b'row-scan-b', batch_size=5, limit=10) +- assert_equal(10, calc_len(scanner)) ++ assert 10 == calc_len(scanner) + + scanner = table.scan(timestamp=123) +- assert_equal(0, calc_len(scanner)) ++ assert 0 == calc_len(scanner) + + scanner = table.scan(row_prefix=b'row', timestamp=123) +- assert_equal(0, calc_len(scanner)) ++ assert 0 == calc_len(scanner) + + scanner = table.scan(batch_size=20) + next(scanner) +@@ -440,9 +427,9 @@ + + scan = table.scan(row_start=input_key, sorted_columns=True) + key, row = next(scan) +- assert_equal(key, input_key) +- assert_list_equal( +- sorted(input_row.items()), ++ assert key == input_key ++ assert ( ++ sorted(input_row.items()) == + list(row.items())) + + +@@ -460,18 +447,18 @@ + b'cf1:col2': b'v2'}) + + scan = table.scan(row_prefix=b'row-scan-reverse', reverse=True) +- assert_equal(2000, len(list(scan))) ++ assert 2000 == len(list(scan)) + + scan = table.scan(limit=10, reverse=True) +- assert_equal(10, len(list(scan))) ++ assert 10 == len(list(scan)) + + scan = table.scan(row_start=b'row-scan-reverse-1999', + row_stop=b'row-scan-reverse-0000', reverse=True) + key, data = next(scan) +- assert_equal(b'row-scan-reverse-1999', key) ++ assert b'row-scan-reverse-1999' == key + + key, data = list(scan)[-1] +- assert_equal(b'row-scan-reverse-0001', key) ++ assert b'row-scan-reverse-0001' == key + + + def test_scan_filter_and_batch_size(): +@@ -490,22 +477,22 @@ + table.put(row_key, data) + + table.delete(row_key, [b'cf1:col2'], timestamp=2345) +- assert_equal(1, len(table.cells(row_key, b'cf1:col2', versions=2))) +- assert_dict_equal(data, table.row(row_key)) ++ assert 1 == len(table.cells(row_key, b'cf1:col2', versions=2)) ++ assert data == table.row(row_key) + + table.delete(row_key, [b'cf1:col1']) + res = table.row(row_key) +- assert_not_in(b'cf1:col1', res) +- assert_in(b'cf1:col2', res) +- assert_in(b'cf1:col3', res) ++ assert b'cf1:col1' not in res ++ assert b'cf1:col2' in res ++ assert b'cf1:col3' in res + + table.delete(row_key, timestamp=12345) + res = table.row(row_key) +- assert_in(b'cf1:col2', res) +- assert_in(b'cf1:col3', res) ++ assert b'cf1:col2' in res ++ assert b'cf1:col3' in res + + table.delete(row_key) +- assert_dict_equal({}, table.row(row_key)) ++ assert {} == table.row(row_key) + + + def test_connection_pool_construction(): +diff -ru happybase-orig/tests/test_util.py happybase/tests/test_util.py +--- happybase-orig/tests/test_util.py 2020-03-31 14:01:25.374555626 +0200 ++++ happybase/tests/test_util.py 2020-03-31 14:16:46.128321257 +0200 +@@ -4,8 +4,6 @@ + + from codecs import decode, encode + +-from nose.tools import assert_equal, assert_less +- + import happybase.util as util + + +@@ -14,13 +12,13 @@ + + x1 = util.camel_case_to_pep8(lower_cc) + x2 = util.camel_case_to_pep8(upper_cc) +- assert_equal(correct, x1) +- assert_equal(correct, x2) ++ assert correct == x1 ++ assert correct == x2 + + y1 = util.pep8_to_camel_case(x1, True) + y2 = util.pep8_to_camel_case(x2, False) +- assert_equal(upper_cc, y1) +- assert_equal(lower_cc, y2) ++ assert upper_cc == y1 ++ assert lower_cc == y2 + + examples = [('foo', 'Foo', 'foo'), + ('fooBar', 'FooBar', 'foo_bar'), +@@ -28,7 +26,7 @@ + ('fOO', 'FOO', 'f_o_o')] + + for a, b, c in examples: +- yield check, a, b, c ++ check(a, b, c) + + + def test_bytes_increment(): +@@ -36,8 +34,8 @@ + s = decode(s_hex, 'hex') + v = util.bytes_increment(s) + v_hex = encode(v, 'hex') +- assert_equal(expected, v_hex) +- assert_less(s, v) ++ assert expected == v_hex ++ assert s < v + + test_values = [ + (b'00', b'01'), +@@ -53,4 +51,4 @@ + assert util.bytes_increment(b'\xff\xff\xff') is None + + for s, expected in test_values: +- yield check, s, expected ++ check(s, expected) +diff -ru happybase-orig/tox.ini happybase/tox.ini +--- happybase-orig/tox.ini 2020-03-31 14:01:25.374555626 +0200 ++++ happybase/tox.ini 2020-03-31 14:00:26.874443280 +0200 +@@ -3,6 +3,6 @@ + + [testenv] + deps= +- nose ++ pytest + coverage +-commands=nosetests ++commands=pytest +Only in happybase: venv