Attachment 905347 Details for Bug 1106804 – build.log

build.log

<fdopen> (text/plain), 104.19 KB, created by Dennis Gilmore on 2014-06-09 17:31:57 UTC

(hide)

Description:

Filename:

MIME Type:

Creator: Dennis Gilmore

Created: 2014-06-09 17:31:57 UTC

Size: 104.19 KB

patch

obsolete

>Mock Version: 1.1.39
>Mock Version: 1.1.39
>ENTER do(['bash', '--login', '-c', 'rpmbuild -bs --target noarch --nodeps builddir/build/SPECS/python-redis.spec'], False, '/var/lib/mock/f21-build-2141954-392939/root/', None, 86400, True, False, 1000, 425, None, False, {'LANG': 'en_US.UTF-8', 'TERM': 'vt100', 'SHELL': '/bin/bash', 'HOSTNAME': 'mock', 'PROMPT_COMMAND': 'echo -n "<mock-chroot>"', 'HOME': '/builddir', 'PATH': '/usr/bin:/bin:/usr/sbin:/sbin'}, logger=<mockbuild.trace_decorator.getLog object at 0x1c1ec10>)
>Executing command: ['bash', '--login', '-c', 'rpmbuild -bs --target noarch --nodeps builddir/build/SPECS/python-redis.spec'] with env {'LANG': 'en_US.UTF-8', 'TERM': 'vt100', 'SHELL': '/bin/bash', 'HOSTNAME': 'mock', 'PROMPT_COMMAND': 'echo -n "<mock-chroot>"', 'HOME': '/builddir', 'PATH': '/usr/bin:/bin:/usr/sbin:/sbin'}
>warning: Could not canonicalize hostname: arm02-builder19.arm.fedoraproject.org
>Building target platforms: noarch
>Building for target noarch
>Wrote: /builddir/build/SRPMS/python-redis-2.9.1-3.fc21.src.rpm
>Child return code was: 0
>LEAVE do --> 
>
>ENTER do(['bash', '--login', '-c', 'rpmbuild -bb --target noarch --nodeps  builddir/build/SPECS/python-redis.spec'], False, '/var/lib/mock/f21-build-2141954-392939/root/', None, 86400, True, False, 1000, 425, None, False, {'LANG': 'en_US.UTF-8', 'TERM': 'vt100', 'SHELL': '/bin/bash', 'HOSTNAME': 'mock', 'PROMPT_COMMAND': 'echo -n "<mock-chroot>"', 'HOME': '/builddir', 'PATH': '/usr/bin:/bin:/usr/sbin:/sbin'}, logger=<mockbuild.trace_decorator.getLog object at 0x1c1ec10>)
>Executing command: ['bash', '--login', '-c', 'rpmbuild -bb --target noarch --nodeps  builddir/build/SPECS/python-redis.spec'] with env {'LANG': 'en_US.UTF-8', 'TERM': 'vt100', 'SHELL': '/bin/bash', 'HOSTNAME': 'mock', 'PROMPT_COMMAND': 'echo -n "<mock-chroot>"', 'HOME': '/builddir', 'PATH': '/usr/bin:/bin:/usr/sbin:/sbin'}
>Building target platforms: noarch
>Building for target noarch
>Executing(%prep): /bin/sh -e /var/tmp/rpm-tmp.rUOvxO
>+ umask 022
>+ cd /builddir/build/BUILD
>+ cd /builddir/build/BUILD
>+ rm -rf redis-2.9.1
>+ /usr/bin/gzip -dc /builddir/build/SOURCES/redis-2.9.1.tar.gz
>+ /usr/bin/tar -xf -
>+ STATUS=0
>+ '[' 0 -ne 0 ']'
>+ cd redis-2.9.1
>+ /usr/bin/chmod -Rf a+rX,u+w,g-w,o-w .
>+ rm -rf redis.egg-info
>+ rm -rf /builddir/build/BUILD/python3-python-redis-2.9.1-3.fc21
>+ cp -a . /builddir/build/BUILD/python3-python-redis-2.9.1-3.fc21
>+ exit 0
>Executing(%build): /bin/sh -e /var/tmp/rpm-tmp.OrH8Hy
>+ umask 022
>~/build/BUILD/python3-python-redis-2.9.1-3.fc21 ~/build/BUILD/redis-2.9.1
>+ cd /builddir/build/BUILD
>+ cd redis-2.9.1
>+ pushd /builddir/build/BUILD/python3-python-redis-2.9.1-3.fc21
>+ /usr/bin/python3 setup.py build
>running build
>running build_py
>creating build
>creating build/lib
>creating build/lib/redis
>copying redis/utils.py -> build/lib/redis
>copying redis/client.py -> build/lib/redis
>copying redis/exceptions.py -> build/lib/redis
>copying redis/_compat.py -> build/lib/redis
>copying redis/connection.py -> build/lib/redis
>copying redis/__init__.py -> build/lib/redis
>copying redis/sentinel.py -> build/lib/redis
>+ popd
>~/build/BUILD/redis-2.9.1
>+ /usr/bin/python2 setup.py build
>running build
>running build_py
>creating build
>creating build/lib
>creating build/lib/redis
>copying redis/utils.py -> build/lib/redis
>copying redis/client.py -> build/lib/redis
>copying redis/exceptions.py -> build/lib/redis
>copying redis/_compat.py -> build/lib/redis
>copying redis/connection.py -> build/lib/redis
>copying redis/__init__.py -> build/lib/redis
>copying redis/sentinel.py -> build/lib/redis
>+ exit 0
>Executing(%install): /bin/sh -e /var/tmp/rpm-tmp.n2M8IJ
>+ umask 022
>+ cd /builddir/build/BUILD
>+ '[' /builddir/build/BUILDROOT/python-redis-2.9.1-3.fc21.noarch '!=' / ']'
>+ rm -rf /builddir/build/BUILDROOT/python-redis-2.9.1-3.fc21.noarch
>++ dirname /builddir/build/BUILDROOT/python-redis-2.9.1-3.fc21.noarch
>+ mkdir -p /builddir/build/BUILDROOT
>+ mkdir /builddir/build/BUILDROOT/python-redis-2.9.1-3.fc21.noarch
>+ cd redis-2.9.1
>~/build/BUILD/python3-python-redis-2.9.1-3.fc21 ~/build/BUILD/redis-2.9.1
>+ pushd /builddir/build/BUILD/python3-python-redis-2.9.1-3.fc21
>+ /usr/bin/python3 setup.py install -O1 --skip-build --root=/builddir/build/BUILDROOT/python-redis-2.9.1-3.fc21.noarch
>running install
>running install_lib
>creating /builddir/build/BUILDROOT/python-redis-2.9.1-3.fc21.noarch/usr
>creating /builddir/build/BUILDROOT/python-redis-2.9.1-3.fc21.noarch/usr/lib
>creating /builddir/build/BUILDROOT/python-redis-2.9.1-3.fc21.noarch/usr/lib/python3.4
>creating /builddir/build/BUILDROOT/python-redis-2.9.1-3.fc21.noarch/usr/lib/python3.4/site-packages
>creating /builddir/build/BUILDROOT/python-redis-2.9.1-3.fc21.noarch/usr/lib/python3.4/site-packages/redis
>copying build/lib/redis/utils.py -> /builddir/build/BUILDROOT/python-redis-2.9.1-3.fc21.noarch/usr/lib/python3.4/site-packages/redis
>copying build/lib/redis/client.py -> /builddir/build/BUILDROOT/python-redis-2.9.1-3.fc21.noarch/usr/lib/python3.4/site-packages/redis
>copying build/lib/redis/exceptions.py -> /builddir/build/BUILDROOT/python-redis-2.9.1-3.fc21.noarch/usr/lib/python3.4/site-packages/redis
>copying build/lib/redis/_compat.py -> /builddir/build/BUILDROOT/python-redis-2.9.1-3.fc21.noarch/usr/lib/python3.4/site-packages/redis
>copying build/lib/redis/connection.py -> /builddir/build/BUILDROOT/python-redis-2.9.1-3.fc21.noarch/usr/lib/python3.4/site-packages/redis
>copying build/lib/redis/__init__.py -> /builddir/build/BUILDROOT/python-redis-2.9.1-3.fc21.noarch/usr/lib/python3.4/site-packages/redis
>copying build/lib/redis/sentinel.py -> /builddir/build/BUILDROOT/python-redis-2.9.1-3.fc21.noarch/usr/lib/python3.4/site-packages/redis
>byte-compiling /builddir/build/BUILDROOT/python-redis-2.9.1-3.fc21.noarch/usr/lib/python3.4/site-packages/redis/utils.py to utils.cpython-34.pyc
>byte-compiling /builddir/build/BUILDROOT/python-redis-2.9.1-3.fc21.noarch/usr/lib/python3.4/site-packages/redis/client.py to client.cpython-34.pyc
>byte-compiling /builddir/build/BUILDROOT/python-redis-2.9.1-3.fc21.noarch/usr/lib/python3.4/site-packages/redis/exceptions.py to exceptions.cpython-34.pyc
>byte-compiling /builddir/build/BUILDROOT/python-redis-2.9.1-3.fc21.noarch/usr/lib/python3.4/site-packages/redis/_compat.py to _compat.cpython-34.pyc
>byte-compiling /builddir/build/BUILDROOT/python-redis-2.9.1-3.fc21.noarch/usr/lib/python3.4/site-packages/redis/connection.py to connection.cpython-34.pyc
>byte-compiling /builddir/build/BUILDROOT/python-redis-2.9.1-3.fc21.noarch/usr/lib/python3.4/site-packages/redis/__init__.py to __init__.cpython-34.pyc
>byte-compiling /builddir/build/BUILDROOT/python-redis-2.9.1-3.fc21.noarch/usr/lib/python3.4/site-packages/redis/sentinel.py to sentinel.cpython-34.pyc
>writing byte-compilation script '/tmp/tmpwwj6zd52.py'
>/usr/bin/python3 -O /tmp/tmpwwj6zd52.py
>removing /tmp/tmpwwj6zd52.py
>running install_egg_info
>running egg_info
>creating redis.egg-info
>writing top-level names to redis.egg-info/top_level.txt
>writing dependency_links to redis.egg-info/dependency_links.txt
>writing redis.egg-info/PKG-INFO
>writing manifest file 'redis.egg-info/SOURCES.txt'
>reading manifest file 'redis.egg-info/SOURCES.txt'
>reading manifest template 'MANIFEST.in'
>warning: no previously-included files found matching '__pycache__'
>warning: no previously-included files matching '*.pyc' found under directory 'tests'
>writing manifest file 'redis.egg-info/SOURCES.txt'
>Copying redis.egg-info to /builddir/build/BUILDROOT/python-redis-2.9.1-3.fc21.noarch/usr/lib/python3.4/site-packages/redis-2.9.1-py3.4.egg-info
>running install_scripts
>+ popd
>~/build/BUILD/redis-2.9.1
>+ /usr/bin/python2 setup.py install -O1 --skip-build --root /builddir/build/BUILDROOT/python-redis-2.9.1-3.fc21.noarch
>running install
>running install_lib
>creating /builddir/build/BUILDROOT/python-redis-2.9.1-3.fc21.noarch/usr/lib/python2.7
>creating /builddir/build/BUILDROOT/python-redis-2.9.1-3.fc21.noarch/usr/lib/python2.7/site-packages
>creating /builddir/build/BUILDROOT/python-redis-2.9.1-3.fc21.noarch/usr/lib/python2.7/site-packages/redis
>copying build/lib/redis/utils.py -> /builddir/build/BUILDROOT/python-redis-2.9.1-3.fc21.noarch/usr/lib/python2.7/site-packages/redis
>copying build/lib/redis/client.py -> /builddir/build/BUILDROOT/python-redis-2.9.1-3.fc21.noarch/usr/lib/python2.7/site-packages/redis
>copying build/lib/redis/exceptions.py -> /builddir/build/BUILDROOT/python-redis-2.9.1-3.fc21.noarch/usr/lib/python2.7/site-packages/redis
>copying build/lib/redis/_compat.py -> /builddir/build/BUILDROOT/python-redis-2.9.1-3.fc21.noarch/usr/lib/python2.7/site-packages/redis
>copying build/lib/redis/connection.py -> /builddir/build/BUILDROOT/python-redis-2.9.1-3.fc21.noarch/usr/lib/python2.7/site-packages/redis
>copying build/lib/redis/__init__.py -> /builddir/build/BUILDROOT/python-redis-2.9.1-3.fc21.noarch/usr/lib/python2.7/site-packages/redis
>copying build/lib/redis/sentinel.py -> /builddir/build/BUILDROOT/python-redis-2.9.1-3.fc21.noarch/usr/lib/python2.7/site-packages/redis
>byte-compiling /builddir/build/BUILDROOT/python-redis-2.9.1-3.fc21.noarch/usr/lib/python2.7/site-packages/redis/utils.py to utils.pyc
>byte-compiling /builddir/build/BUILDROOT/python-redis-2.9.1-3.fc21.noarch/usr/lib/python2.7/site-packages/redis/client.py to client.pyc
>byte-compiling /builddir/build/BUILDROOT/python-redis-2.9.1-3.fc21.noarch/usr/lib/python2.7/site-packages/redis/exceptions.py to exceptions.pyc
>byte-compiling /builddir/build/BUILDROOT/python-redis-2.9.1-3.fc21.noarch/usr/lib/python2.7/site-packages/redis/_compat.py to _compat.pyc
>byte-compiling /builddir/build/BUILDROOT/python-redis-2.9.1-3.fc21.noarch/usr/lib/python2.7/site-packages/redis/connection.py to connection.pyc
>byte-compiling /builddir/build/BUILDROOT/python-redis-2.9.1-3.fc21.noarch/usr/lib/python2.7/site-packages/redis/__init__.py to __init__.pyc
>byte-compiling /builddir/build/BUILDROOT/python-redis-2.9.1-3.fc21.noarch/usr/lib/python2.7/site-packages/redis/sentinel.py to sentinel.pyc
>writing byte-compilation script '/tmp/tmpWxN7fd.py'
>/usr/bin/python2 -O /tmp/tmpWxN7fd.py
>removing /tmp/tmpWxN7fd.py
>running install_egg_info
>running egg_info
>creating redis.egg-info
>writing redis.egg-info/PKG-INFO
>writing top-level names to redis.egg-info/top_level.txt
>writing dependency_links to redis.egg-info/dependency_links.txt
>writing manifest file 'redis.egg-info/SOURCES.txt'
>reading manifest file 'redis.egg-info/SOURCES.txt'
>reading manifest template 'MANIFEST.in'
>warning: no previously-included files found matching '__pycache__'
>warning: no previously-included files matching '*.pyc' found under directory 'tests'
>writing manifest file 'redis.egg-info/SOURCES.txt'
>Copying redis.egg-info to /builddir/build/BUILDROOT/python-redis-2.9.1-3.fc21.noarch/usr/lib/python2.7/site-packages/redis-2.9.1-py2.7.egg-info
>running install_scripts
>+ /usr/lib/rpm/find-debuginfo.sh --strict-build-id -m --run-dwz --dwz-low-mem-die-limit 10000000 --dwz-max-die-limit 50000000 /builddir/build/BUILD/redis-2.9.1
>/usr/lib/rpm/sepdebugcrcfix: Updated 0 CRC32s, 0 CRC32s did match.
>find: 'debug': No such file or directory
>+ /usr/lib/rpm/check-buildroot
>+ /usr/lib/rpm/brp-compress
>+ /usr/lib/rpm/brp-strip-static-archive /usr/bin/strip
>+ /usr/lib/rpm/brp-python-bytecompile /usr/bin/python 1
>Bytecompiling .py files below /builddir/build/BUILDROOT/python-redis-2.9.1-3.fc21.noarch/usr/lib/python3.4 using /usr/bin/python3.4
>Bytecompiling .py files below /builddir/build/BUILDROOT/python-redis-2.9.1-3.fc21.noarch/usr/lib/python2.7 using /usr/bin/python2.7
>+ /usr/lib/rpm/brp-python-hardlink
>+ /usr/lib/rpm/redhat/brp-java-repack-jars
>Executing(%check): /bin/sh -e /var/tmp/rpm-tmp.y85Wn9
>+ umask 022
>+ cd /builddir/build/BUILD
>+ cd redis-2.9.1
>~/build/BUILD/python3-python-redis-2.9.1-3.fc21 ~/build/BUILD/redis-2.9.1
>+ pushd /builddir/build/BUILD/python3-python-redis-2.9.1-3.fc21
>+ redis-server
>+ /usr/bin/python3 setup.py test
>running test
>running egg_info
>writing redis.egg-info/PKG-INFO
>writing top-level names to redis.egg-info/top_level.txt
>writing dependency_links to redis.egg-info/dependency_links.txt
>reading manifest file 'redis.egg-info/SOURCES.txt'
>reading manifest template 'MANIFEST.in'
>warning: no previously-included files found matching '__pycache__'
>warning: no previously-included files matching '*.pyc' found under directory 'tests'
>writing manifest file 'redis.egg-info/SOURCES.txt'
>running build_ext
>============================= test session starts ==============================
>platform linux -- Python 3.4.1 -- py-1.4.20 -- pytest-2.5.2
>collected 51 items / 1 errors
>tests/test_connection_pool.py ..............
>tests/test_encoding.py EE
>tests/test_lock.py EEEEEEE
>tests/test_pipeline.py EEEEEEEEEEEEEE
>tests/test_pubsub.py EEE
>tests/test_sentinel.py .......FF..
>==================================== ERRORS ====================================
>___________________ ERROR collecting tests/test_commands.py ____________________
>tests/test_commands.py:30: in <module>
>>   class TestRedisCommands(object):
>tests/test_commands.py:43: in TestRedisCommands
>>       @skip_if_server_version_lt('2.6.9')
>tests/conftest.py:16: in skip_if_server_version_lt
>>       version = _get_client(redis.Redis).info()['redis_version']
>tests/conftest.py:9: in _get_client
>>       client.flushdb()
>redis/client.py:534: in flushdb
>>       return self.execute_command('FLUSHDB')
>redis/client.py:464: in execute_command
>>           connection.send_command(*args)
>redis/connection.py:334: in send_command
>>       self.send_packed_command(self.pack_command(*args))
>redis/connection.py:316: in send_packed_command
>>           self.connect()
>redis/connection.py:253: in connect
>>           raise ConnectionError(self._error_message(e))
>E           redis.exceptions.ConnectionError: Error 111 connecting localhost:6379. Connection refused.
>_______ ERROR at setup of TestPythonParserEncoding.test_simple_encoding ________
>request = <SubRequest 'r' for <Function 'test_simple_encoding'>>
>    @pytest.fixture()
>    def r(request):
>>       return _redis_client(request=request, decode_responses=True)
>tests/test_encoding.py:11: 
>_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 
>request = <SubRequest 'r' for <Function 'test_simple_encoding'>>
>kwargs = {'decode_responses': True}
>    @pytest.fixture()
>    def r(request, **kwargs):
>>       return _get_client(redis.Redis, request, **kwargs)
>tests/conftest.py:23: 
>_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 
>cls = <class 'redis.client.Redis'>
>request = <SubRequest 'r' for <Function 'test_simple_encoding'>>
>kwargs = {'decode_responses': True}
>params = {'db': 9, 'decode_responses': True, 'host': 'localhost', 'port': 6379}
>client = Redis<ConnectionPool<Connection<host=localhost,port=6379,db=9>>>
>    def _get_client(cls, request=None, **kwargs):
>        params = {'host': 'localhost', 'port': 6379, 'db': 9}
>        params.update(kwargs)
>        client = cls(**params)
>>       client.flushdb()
>tests/conftest.py:9: 
>_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 
>self = Redis<ConnectionPool<Connection<host=localhost,port=6379,db=9>>>
>    def flushdb(self):
>        "Delete all keys in the current database"
>>       return self.execute_command('FLUSHDB')
>redis/client.py:534: 
>_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 
>self = Redis<ConnectionPool<Connection<host=localhost,port=6379,db=9>>>
>args = ('FLUSHDB',), options = {}
>pool = ConnectionPool<Connection<host=localhost,port=6379,db=9>>
>command_name = 'FLUSHDB', connection = Connection<host=localhost,port=6379,db=9>
>    def execute_command(self, *args, **options):
>        "Execute a command and return a parsed response"
>        pool = self.connection_pool
>        command_name = args[0]
>        connection = pool.get_connection(command_name, **options)
>        try:
>            connection.send_command(*args)
>            return self.parse_response(connection, command_name, **options)
>        except ConnectionError:
>            connection.disconnect()
>>           connection.send_command(*args)
>redis/client.py:464: 
>_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 
>self = Connection<host=localhost,port=6379,db=9>, args = ('FLUSHDB',)
>    def send_command(self, *args):
>        "Pack and send a command to the Redis server"
>>       self.send_packed_command(self.pack_command(*args))
>redis/connection.py:334: 
>_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 
>self = Connection<host=localhost,port=6379,db=9>
>command = b'*1\r\n$7\r\nFLUSHDB\r\n'
>    def send_packed_command(self, command):
>        "Send an already packed command to the Redis server"
>        if not self._sock:
>>           self.connect()
>redis/connection.py:316: 
>_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 
>self = Connection<host=localhost,port=6379,db=9>
>    def connect(self):
>        "Connects to the Redis server if not already connected"
>        if self._sock:
>            return
>        try:
>            sock = self._connect()
>        except socket.error:
>            e = sys.exc_info()[1]
>>           raise ConnectionError(self._error_message(e))
>E           redis.exceptions.ConnectionError: Error 111 connecting localhost:6379. Connection refused.
>redis/connection.py:253: ConnectionError
>________ ERROR at setup of TestPythonParserEncoding.test_list_encoding _________
>request = <SubRequest 'r' for <Function 'test_list_encoding'>>
>    @pytest.fixture()
>    def r(request):
>>       return _redis_client(request=request, decode_responses=True)
>tests/test_encoding.py:11: 
>_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 
>request = <SubRequest 'r' for <Function 'test_list_encoding'>>
>kwargs = {'decode_responses': True}
>    @pytest.fixture()
>    def r(request, **kwargs):
>>       return _get_client(redis.Redis, request, **kwargs)
>tests/conftest.py:23: 
>_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 
>cls = <class 'redis.client.Redis'>
>request = <SubRequest 'r' for <Function 'test_list_encoding'>>
>kwargs = {'decode_responses': True}
>params = {'db': 9, 'decode_responses': True, 'host': 'localhost', 'port': 6379}
>client = Redis<ConnectionPool<Connection<host=localhost,port=6379,db=9>>>
>    def _get_client(cls, request=None, **kwargs):
>        params = {'host': 'localhost', 'port': 6379, 'db': 9}
>        params.update(kwargs)
>        client = cls(**params)
>>       client.flushdb()
>tests/conftest.py:9: 
>_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 
>self = Redis<ConnectionPool<Connection<host=localhost,port=6379,db=9>>>
>    def flushdb(self):
>        "Delete all keys in the current database"
>>       return self.execute_command('FLUSHDB')
>redis/client.py:534: 
>_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 
>self = Redis<ConnectionPool<Connection<host=localhost,port=6379,db=9>>>
>args = ('FLUSHDB',), options = {}
>pool = ConnectionPool<Connection<host=localhost,port=6379,db=9>>
>command_name = 'FLUSHDB', connection = Connection<host=localhost,port=6379,db=9>
>    def execute_command(self, *args, **options):
>        "Execute a command and return a parsed response"
>        pool = self.connection_pool
>        command_name = args[0]
>        connection = pool.get_connection(command_name, **options)
>        try:
>            connection.send_command(*args)
>            return self.parse_response(connection, command_name, **options)
>        except ConnectionError:
>            connection.disconnect()
>>           connection.send_command(*args)
>redis/client.py:464: 
>_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 
>self = Connection<host=localhost,port=6379,db=9>, args = ('FLUSHDB',)
>    def send_command(self, *args):
>        "Pack and send a command to the Redis server"
>>       self.send_packed_command(self.pack_command(*args))
>redis/connection.py:334: 
>_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 
>self = Connection<host=localhost,port=6379,db=9>
>command = b'*1\r\n$7\r\nFLUSHDB\r\n'
>    def send_packed_command(self, command):
>        "Send an already packed command to the Redis server"
>        if not self._sock:
>>           self.connect()
>redis/connection.py:316: 
>_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 
>self = Connection<host=localhost,port=6379,db=9>
>    def connect(self):
>        "Connects to the Redis server if not already connected"
>        if self._sock:
>            return
>        try:
>            sock = self._connect()
>        except socket.error:
>            e = sys.exc_info()[1]
>>           raise ConnectionError(self._error_message(e))
>E           redis.exceptions.ConnectionError: Error 111 connecting localhost:6379. Connection refused.
>redis/connection.py:253: ConnectionError
>_____________________ ERROR at setup of TestLock.test_lock _____________________
>request = <SubRequest 'r' for <Function 'test_lock'>>, kwargs = {}
>    @pytest.fixture()
>    def r(request, **kwargs):
>>       return _get_client(redis.Redis, request, **kwargs)
>tests/conftest.py:23: 
>_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 
>cls = <class 'redis.client.Redis'>
>request = <SubRequest 'r' for <Function 'test_lock'>>, kwargs = {}
>params = {'db': 9, 'host': 'localhost', 'port': 6379}
>client = Redis<ConnectionPool<Connection<host=localhost,port=6379,db=9>>>
>    def _get_client(cls, request=None, **kwargs):
>        params = {'host': 'localhost', 'port': 6379, 'db': 9}
>        params.update(kwargs)
>        client = cls(**params)
>>       client.flushdb()
>tests/conftest.py:9: 
>_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 
>self = Redis<ConnectionPool<Connection<host=localhost,port=6379,db=9>>>
>    def flushdb(self):
>        "Delete all keys in the current database"
>>       return self.execute_command('FLUSHDB')
>redis/client.py:534: 
>_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 
>self = Redis<ConnectionPool<Connection<host=localhost,port=6379,db=9>>>
>args = ('FLUSHDB',), options = {}
>pool = ConnectionPool<Connection<host=localhost,port=6379,db=9>>
>command_name = 'FLUSHDB', connection = Connection<host=localhost,port=6379,db=9>
>    def execute_command(self, *args, **options):
>        "Execute a command and return a parsed response"
>        pool = self.connection_pool
>        command_name = args[0]
>        connection = pool.get_connection(command_name, **options)
>        try:
>            connection.send_command(*args)
>            return self.parse_response(connection, command_name, **options)
>        except ConnectionError:
>            connection.disconnect()
>>           connection.send_command(*args)
>redis/client.py:464: 
>_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 
>self = Connection<host=localhost,port=6379,db=9>, args = ('FLUSHDB',)
>    def send_command(self, *args):
>        "Pack and send a command to the Redis server"
>>       self.send_packed_command(self.pack_command(*args))
>redis/connection.py:334: 
>_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 
>self = Connection<host=localhost,port=6379,db=9>
>command = b'*1\r\n$7\r\nFLUSHDB\r\n'
>    def send_packed_command(self, command):
>        "Send an already packed command to the Redis server"
>        if not self._sock:
>>           self.connect()
>redis/connection.py:316: 
>_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 
>self = Connection<host=localhost,port=6379,db=9>
>    def connect(self):
>        "Connects to the Redis server if not already connected"
>        if self._sock:
>            return
>        try:
>            sock = self._connect()
>        except socket.error:
>            e = sys.exc_info()[1]
>>           raise ConnectionError(self._error_message(e))
>E           redis.exceptions.ConnectionError: Error 111 connecting localhost:6379. Connection refused.
>redis/connection.py:253: ConnectionError
>_______________ ERROR at setup of TestLock.test_competing_locks ________________
>request = <SubRequest 'r' for <Function 'test_competing_locks'>>, kwargs = {}
>    @pytest.fixture()
>    def r(request, **kwargs):
>>       return _get_client(redis.Redis, request, **kwargs)
>tests/conftest.py:23: 
>_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 
>cls = <class 'redis.client.Redis'>
>request = <SubRequest 'r' for <Function 'test_competing_locks'>>, kwargs = {}
>params = {'db': 9, 'host': 'localhost', 'port': 6379}
>client = Redis<ConnectionPool<Connection<host=localhost,port=6379,db=9>>>
>    def _get_client(cls, request=None, **kwargs):
>        params = {'host': 'localhost', 'port': 6379, 'db': 9}
>        params.update(kwargs)
>        client = cls(**params)
>>       client.flushdb()
>tests/conftest.py:9: 
>_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 
>self = Redis<ConnectionPool<Connection<host=localhost,port=6379,db=9>>>
>    def flushdb(self):
>        "Delete all keys in the current database"
>>       return self.execute_command('FLUSHDB')
>redis/client.py:534: 
>_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 
>self = Redis<ConnectionPool<Connection<host=localhost,port=6379,db=9>>>
>args = ('FLUSHDB',), options = {}
>pool = ConnectionPool<Connection<host=localhost,port=6379,db=9>>
>command_name = 'FLUSHDB', connection = Connection<host=localhost,port=6379,db=9>
>    def execute_command(self, *args, **options):
>        "Execute a command and return a parsed response"
>        pool = self.connection_pool
>        command_name = args[0]
>        connection = pool.get_connection(command_name, **options)
>        try:
>            connection.send_command(*args)
>            return self.parse_response(connection, command_name, **options)
>        except ConnectionError:
>            connection.disconnect()
>>           connection.send_command(*args)
>redis/client.py:464: 
>_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 
>self = Connection<host=localhost,port=6379,db=9>, args = ('FLUSHDB',)
>    def send_command(self, *args):
>        "Pack and send a command to the Redis server"
>>       self.send_packed_command(self.pack_command(*args))
>redis/connection.py:334: 
>_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 
>self = Connection<host=localhost,port=6379,db=9>
>command = b'*1\r\n$7\r\nFLUSHDB\r\n'
>    def send_packed_command(self, command):
>        "Send an already packed command to the Redis server"
>        if not self._sock:
>>           self.connect()
>redis/connection.py:316: 
>_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 
>self = Connection<host=localhost,port=6379,db=9>
>    def connect(self):
>        "Connects to the Redis server if not already connected"
>        if self._sock:
>            return
>        try:
>            sock = self._connect()
>        except socket.error:
>            e = sys.exc_info()[1]
>>           raise ConnectionError(self._error_message(e))
>E           redis.exceptions.ConnectionError: Error 111 connecting localhost:6379. Connection refused.
>redis/connection.py:253: ConnectionError
>___________________ ERROR at setup of TestLock.test_timeouts ___________________
>request = <SubRequest 'r' for <Function 'test_timeouts'>>, kwargs = {}
>    @pytest.fixture()
>    def r(request, **kwargs):
>>       return _get_client(redis.Redis, request, **kwargs)
>tests/conftest.py:23: 
>_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 
>cls = <class 'redis.client.Redis'>
>request = <SubRequest 'r' for <Function 'test_timeouts'>>, kwargs = {}
>params = {'db': 9, 'host': 'localhost', 'port': 6379}
>client = Redis<ConnectionPool<Connection<host=localhost,port=6379,db=9>>>
>    def _get_client(cls, request=None, **kwargs):
>        params = {'host': 'localhost', 'port': 6379, 'db': 9}
>        params.update(kwargs)
>        client = cls(**params)
>>       client.flushdb()
>tests/conftest.py:9: 
>_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 
>self = Redis<ConnectionPool<Connection<host=localhost,port=6379,db=9>>>
>    def flushdb(self):
>        "Delete all keys in the current database"
>>       return self.execute_command('FLUSHDB')
>redis/client.py:534: 
>_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 
>self = Redis<ConnectionPool<Connection<host=localhost,port=6379,db=9>>>
>args = ('FLUSHDB',), options = {}
>pool = ConnectionPool<Connection<host=localhost,port=6379,db=9>>
>command_name = 'FLUSHDB', connection = Connection<host=localhost,port=6379,db=9>
>    def execute_command(self, *args, **options):
>        "Execute a command and return a parsed response"
>        pool = self.connection_pool
>        command_name = args[0]
>        connection = pool.get_connection(command_name, **options)
>        try:
>            connection.send_command(*args)
>            return self.parse_response(connection, command_name, **options)
>        except ConnectionError:
>            connection.disconnect()
>>           connection.send_command(*args)
>redis/client.py:464: 
>_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 
>self = Connection<host=localhost,port=6379,db=9>, args = ('FLUSHDB',)
>    def send_command(self, *args):
>        "Pack and send a command to the Redis server"
>>       self.send_packed_command(self.pack_command(*args))
>redis/connection.py:334: 
>_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 
>self = Connection<host=localhost,port=6379,db=9>
>command = b'*1\r\n$7\r\nFLUSHDB\r\n'
>    def send_packed_command(self, command):
>        "Send an already packed command to the Redis server"
>        if not self._sock:
>>           self.connect()
>redis/connection.py:316: 
>_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 
>self = Connection<host=localhost,port=6379,db=9>
>    def connect(self):
>        "Connects to the Redis server if not already connected"
>        if self._sock:
>            return
>        try:
>            sock = self._connect()
>        except socket.error:
>            e = sys.exc_info()[1]
>>           raise ConnectionError(self._error_message(e))
>E           redis.exceptions.ConnectionError: Error 111 connecting localhost:6379. Connection refused.
>redis/connection.py:253: ConnectionError
>_________________ ERROR at setup of TestLock.test_non_blocking _________________
>request = <SubRequest 'r' for <Function 'test_non_blocking'>>, kwargs = {}
>    @pytest.fixture()
>    def r(request, **kwargs):
>>       return _get_client(redis.Redis, request, **kwargs)
>tests/conftest.py:23: 
>_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 
>cls = <class 'redis.client.Redis'>
>request = <SubRequest 'r' for <Function 'test_non_blocking'>>, kwargs = {}
>params = {'db': 9, 'host': 'localhost', 'port': 6379}
>client = Redis<ConnectionPool<Connection<host=localhost,port=6379,db=9>>>
>    def _get_client(cls, request=None, **kwargs):
>        params = {'host': 'localhost', 'port': 6379, 'db': 9}
>        params.update(kwargs)
>        client = cls(**params)
>>       client.flushdb()
>tests/conftest.py:9: 
>_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 
>self = Redis<ConnectionPool<Connection<host=localhost,port=6379,db=9>>>
>    def flushdb(self):
>        "Delete all keys in the current database"
>>       return self.execute_command('FLUSHDB')
>redis/client.py:534: 
>_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 
>self = Redis<ConnectionPool<Connection<host=localhost,port=6379,db=9>>>
>args = ('FLUSHDB',), options = {}
>pool = ConnectionPool<Connection<host=localhost,port=6379,db=9>>
>command_name = 'FLUSHDB', connection = Connection<host=localhost,port=6379,db=9>
>    def execute_command(self, *args, **options):
>        "Execute a command and return a parsed response"
>        pool = self.connection_pool
>        command_name = args[0]
>        connection = pool.get_connection(command_name, **options)
>        try:
>            connection.send_command(*args)
>            return self.parse_response(connection, command_name, **options)
>        except ConnectionError:
>            connection.disconnect()
>>           connection.send_command(*args)
>redis/client.py:464: 
>_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 
>self = Connection<host=localhost,port=6379,db=9>, args = ('FLUSHDB',)
>    def send_command(self, *args):
>        "Pack and send a command to the Redis server"
>>       self.send_packed_command(self.pack_command(*args))
>redis/connection.py:334: 
>_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 
>self = Connection<host=localhost,port=6379,db=9>
>command = b'*1\r\n$7\r\nFLUSHDB\r\n'
>    def send_packed_command(self, command):
>        "Send an already packed command to the Redis server"
>        if not self._sock:
>>           self.connect()
>redis/connection.py:316: 
>_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 
>self = Connection<host=localhost,port=6379,db=9>
>    def connect(self):
>        "Connects to the Redis server if not already connected"
>        if self._sock:
>            return
>        try:
>            sock = self._connect()
>        except socket.error:
>            e = sys.exc_info()[1]
>>           raise ConnectionError(self._error_message(e))
>E           redis.exceptions.ConnectionError: Error 111 connecting localhost:6379. Connection refused.
>redis/connection.py:253: ConnectionError
>_______________ ERROR at setup of TestLock.test_context_manager ________________
>request = <SubRequest 'r' for <Function 'test_context_manager'>>, kwargs = {}
>    @pytest.fixture()
>    def r(request, **kwargs):
>>       return _get_client(redis.Redis, request, **kwargs)
>tests/conftest.py:23: 
>_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 
>cls = <class 'redis.client.Redis'>
>request = <SubRequest 'r' for <Function 'test_context_manager'>>, kwargs = {}
>params = {'db': 9, 'host': 'localhost', 'port': 6379}
>client = Redis<ConnectionPool<Connection<host=localhost,port=6379,db=9>>>
>    def _get_client(cls, request=None, **kwargs):
>        params = {'host': 'localhost', 'port': 6379, 'db': 9}
>        params.update(kwargs)
>        client = cls(**params)
>>       client.flushdb()
>tests/conftest.py:9: 
>_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 
>self = Redis<ConnectionPool<Connection<host=localhost,port=6379,db=9>>>
>    def flushdb(self):
>        "Delete all keys in the current database"
>>       return self.execute_command('FLUSHDB')
>redis/client.py:534: 
>_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 
>self = Redis<ConnectionPool<Connection<host=localhost,port=6379,db=9>>>
>args = ('FLUSHDB',), options = {}
>pool = ConnectionPool<Connection<host=localhost,port=6379,db=9>>
>command_name = 'FLUSHDB', connection = Connection<host=localhost,port=6379,db=9>
>    def execute_command(self, *args, **options):
>        "Execute a command and return a parsed response"
>        pool = self.connection_pool
>        command_name = args[0]
>        connection = pool.get_connection(command_name, **options)
>        try:
>            connection.send_command(*args)
>            return self.parse_response(connection, command_name, **options)
>        except ConnectionError:
>            connection.disconnect()
>>           connection.send_command(*args)
>redis/client.py:464: 
>_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 
>self = Connection<host=localhost,port=6379,db=9>, args = ('FLUSHDB',)
>    def send_command(self, *args):
>        "Pack and send a command to the Redis server"
>>       self.send_packed_command(self.pack_command(*args))
>redis/connection.py:334: 
>_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 
>self = Connection<host=localhost,port=6379,db=9>
>command = b'*1\r\n$7\r\nFLUSHDB\r\n'
>    def send_packed_command(self, command):
>        "Send an already packed command to the Redis server"
>        if not self._sock:
>>           self.connect()
>redis/connection.py:316: 
>_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 
>self = Connection<host=localhost,port=6379,db=9>
>    def connect(self):
>        "Connects to the Redis server if not already connected"
>        if self._sock:
>            return
>        try:
>            sock = self._connect()
>        except socket.error:
>            e = sys.exc_info()[1]
>>           raise ConnectionError(self._error_message(e))
>E           redis.exceptions.ConnectionError: Error 111 connecting localhost:6379. Connection refused.
>redis/connection.py:253: ConnectionError
>________________ ERROR at setup of TestLock.test_float_timeout _________________
>request = <SubRequest 'r' for <Function 'test_float_timeout'>>, kwargs = {}
>    @pytest.fixture()
>    def r(request, **kwargs):
>>       return _get_client(redis.Redis, request, **kwargs)
>tests/conftest.py:23: 
>_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 
>cls = <class 'redis.client.Redis'>
>request = <SubRequest 'r' for <Function 'test_float_timeout'>>, kwargs = {}
>params = {'db': 9, 'host': 'localhost', 'port': 6379}
>client = Redis<ConnectionPool<Connection<host=localhost,port=6379,db=9>>>
>    def _get_client(cls, request=None, **kwargs):
>        params = {'host': 'localhost', 'port': 6379, 'db': 9}
>        params.update(kwargs)
>        client = cls(**params)
>>       client.flushdb()
>tests/conftest.py:9: 
>_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 
>self = Redis<ConnectionPool<Connection<host=localhost,port=6379,db=9>>>
>    def flushdb(self):
>        "Delete all keys in the current database"
>>       return self.execute_command('FLUSHDB')
>redis/client.py:534: 
>_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 
>self = Redis<ConnectionPool<Connection<host=localhost,port=6379,db=9>>>
>args = ('FLUSHDB',), options = {}
>pool = ConnectionPool<Connection<host=localhost,port=6379,db=9>>
>command_name = 'FLUSHDB', connection = Connection<host=localhost,port=6379,db=9>
>    def execute_command(self, *args, **options):
>        "Execute a command and return a parsed response"
>        pool = self.connection_pool
>        command_name = args[0]
>        connection = pool.get_connection(command_name, **options)
>        try:
>            connection.send_command(*args)
>            return self.parse_response(connection, command_name, **options)
>        except ConnectionError:
>            connection.disconnect()
>>           connection.send_command(*args)
>redis/client.py:464: 
>_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 
>self = Connection<host=localhost,port=6379,db=9>, args = ('FLUSHDB',)
>    def send_command(self, *args):
>        "Pack and send a command to the Redis server"
>>       self.send_packed_command(self.pack_command(*args))
>redis/connection.py:334: 
>_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 
>self = Connection<host=localhost,port=6379,db=9>
>command = b'*1\r\n$7\r\nFLUSHDB\r\n'
>    def send_packed_command(self, command):
>        "Send an already packed command to the Redis server"
>        if not self._sock:
>>           self.connect()
>redis/connection.py:316: 
>_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 
>self = Connection<host=localhost,port=6379,db=9>
>    def connect(self):
>        "Connects to the Redis server if not already connected"
>        if self._sock:
>            return
>        try:
>            sock = self._connect()
>        except socket.error:
>            e = sys.exc_info()[1]
>>           raise ConnectionError(self._error_message(e))
>E           redis.exceptions.ConnectionError: Error 111 connecting localhost:6379. Connection refused.
>redis/connection.py:253: ConnectionError
>___________ ERROR at setup of TestLock.test_high_sleep_raises_error ____________
>request = <SubRequest 'r' for <Function 'test_high_sleep_raises_error'>>
>kwargs = {}
>    @pytest.fixture()
>    def r(request, **kwargs):
>>       return _get_client(redis.Redis, request, **kwargs)
>tests/conftest.py:23: 
>_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 
>cls = <class 'redis.client.Redis'>
>request = <SubRequest 'r' for <Function 'test_high_sleep_raises_error'>>
>kwargs = {}, params = {'db': 9, 'host': 'localhost', 'port': 6379}
>client = Redis<ConnectionPool<Connection<host=localhost,port=6379,db=9>>>
>    def _get_client(cls, request=None, **kwargs):
>        params = {'host': 'localhost', 'port': 6379, 'db': 9}
>        params.update(kwargs)
>        client = cls(**params)
>>       client.flushdb()
>tests/conftest.py:9: 
>_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 
>self = Redis<ConnectionPool<Connection<host=localhost,port=6379,db=9>>>
>    def flushdb(self):
>        "Delete all keys in the current database"
>>       return self.execute_command('FLUSHDB')
>redis/client.py:534: 
>_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 
>self = Redis<ConnectionPool<Connection<host=localhost,port=6379,db=9>>>
>args = ('FLUSHDB',), options = {}
>pool = ConnectionPool<Connection<host=localhost,port=6379,db=9>>
>command_name = 'FLUSHDB', connection = Connection<host=localhost,port=6379,db=9>
>    def execute_command(self, *args, **options):
>        "Execute a command and return a parsed response"
>        pool = self.connection_pool
>        command_name = args[0]
>        connection = pool.get_connection(command_name, **options)
>        try:
>            connection.send_command(*args)
>            return self.parse_response(connection, command_name, **options)
>        except ConnectionError:
>            connection.disconnect()
>>           connection.send_command(*args)
>redis/client.py:464: 
>_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 
>self = Connection<host=localhost,port=6379,db=9>, args = ('FLUSHDB',)
>    def send_command(self, *args):
>        "Pack and send a command to the Redis server"
>>       self.send_packed_command(self.pack_command(*args))
>redis/connection.py:334: 
>_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 
>self = Connection<host=localhost,port=6379,db=9>
>command = b'*1\r\n$7\r\nFLUSHDB\r\n'
>    def send_packed_command(self, command):
>        "Send an already packed command to the Redis server"
>        if not self._sock:
>>           self.connect()
>redis/connection.py:316: 
>_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 
>self = Connection<host=localhost,port=6379,db=9>
>    def connect(self):
>        "Connects to the Redis server if not already connected"
>        if self._sock:
>            return
>        try:
>            sock = self._connect()
>        except socket.error:
>            e = sys.exc_info()[1]
>>           raise ConnectionError(self._error_message(e))
>E           redis.exceptions.ConnectionError: Error 111 connecting localhost:6379. Connection refused.
>redis/connection.py:253: ConnectionError
>_________________ ERROR at setup of TestPipeline.test_pipeline _________________
>request = <SubRequest 'r' for <Function 'test_pipeline'>>, kwargs = {}
>    @pytest.fixture()
>    def r(request, **kwargs):
>>       return _get_client(redis.Redis, request, **kwargs)
>tests/conftest.py:23: 
>_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 
>cls = <class 'redis.client.Redis'>
>request = <SubRequest 'r' for <Function 'test_pipeline'>>, kwargs = {}
>params = {'db': 9, 'host': 'localhost', 'port': 6379}
>client = Redis<ConnectionPool<Connection<host=localhost,port=6379,db=9>>>
>    def _get_client(cls, request=None, **kwargs):
>        params = {'host': 'localhost', 'port': 6379, 'db': 9}
>        params.update(kwargs)
>        client = cls(**params)
>>       client.flushdb()
>tests/conftest.py:9: 
>_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 
>self = Redis<ConnectionPool<Connection<host=localhost,port=6379,db=9>>>
>    def flushdb(self):
>        "Delete all keys in the current database"
>>       return self.execute_command('FLUSHDB')
>redis/client.py:534: 
>_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 
>self = Redis<ConnectionPool<Connection<host=localhost,port=6379,db=9>>>
>args = ('FLUSHDB',), options = {}
>pool = ConnectionPool<Connection<host=localhost,port=6379,db=9>>
>command_name = 'FLUSHDB', connection = Connection<host=localhost,port=6379,db=9>
>    def execute_command(self, *args, **options):
>        "Execute a command and return a parsed response"
>        pool = self.connection_pool
>        command_name = args[0]
>        connection = pool.get_connection(command_name, **options)
>        try:
>            connection.send_command(*args)
>            return self.parse_response(connection, command_name, **options)
>        except ConnectionError:
>            connection.disconnect()
>>           connection.send_command(*args)
>redis/client.py:464: 
>_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 
>self = Connection<host=localhost,port=6379,db=9>, args = ('FLUSHDB',)
>    def send_command(self, *args):
>        "Pack and send a command to the Redis server"
>>       self.send_packed_command(self.pack_command(*args))
>redis/connection.py:334: 
>_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 
>self = Connection<host=localhost,port=6379,db=9>
>command = b'*1\r\n$7\r\nFLUSHDB\r\n'
>    def send_packed_command(self, command):
>        "Send an already packed command to the Redis server"
>        if not self._sock:
>>           self.connect()
>redis/connection.py:316: 
>_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 
>self = Connection<host=localhost,port=6379,db=9>
>    def connect(self):
>        "Connects to the Redis server if not already connected"
>        if self._sock:
>            return
>        try:
>            sock = self._connect()
>        except socket.error:
>            e = sys.exc_info()[1]
>>           raise ConnectionError(self._error_message(e))
>E           redis.exceptions.ConnectionError: Error 111 connecting localhost:6379. Connection refused.
>redis/connection.py:253: ConnectionError
>_____________ ERROR at setup of TestPipeline.test_pipeline_length ______________
>request = <SubRequest 'r' for <Function 'test_pipeline_length'>>, kwargs = {}
>    @pytest.fixture()
>    def r(request, **kwargs):
>>       return _get_client(redis.Redis, request, **kwargs)
>tests/conftest.py:23: 
>_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 
>cls = <class 'redis.client.Redis'>
>request = <SubRequest 'r' for <Function 'test_pipeline_length'>>, kwargs = {}
>params = {'db': 9, 'host': 'localhost', 'port': 6379}
>client = Redis<ConnectionPool<Connection<host=localhost,port=6379,db=9>>>
>    def _get_client(cls, request=None, **kwargs):
>        params = {'host': 'localhost', 'port': 6379, 'db': 9}
>        params.update(kwargs)
>        client = cls(**params)
>>       client.flushdb()
>tests/conftest.py:9: 
>_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 
>self = Redis<ConnectionPool<Connection<host=localhost,port=6379,db=9>>>
>    def flushdb(self):
>        "Delete all keys in the current database"
>>       return self.execute_command('FLUSHDB')
>redis/client.py:534: 
>_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 
>self = Redis<ConnectionPool<Connection<host=localhost,port=6379,db=9>>>
>args = ('FLUSHDB',), options = {}
>pool = ConnectionPool<Connection<host=localhost,port=6379,db=9>>
>command_name = 'FLUSHDB', connection = Connection<host=localhost,port=6379,db=9>
>    def execute_command(self, *args, **options):
>        "Execute a command and return a parsed response"
>        pool = self.connection_pool
>        command_name = args[0]
>        connection = pool.get_connection(command_name, **options)
>        try:
>            connection.send_command(*args)
>            return self.parse_response(connection, command_name, **options)
>        except ConnectionError:
>            connection.disconnect()
>>           connection.send_command(*args)
>redis/client.py:464: 
>_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 
>self = Connection<host=localhost,port=6379,db=9>, args = ('FLUSHDB',)
>    def send_command(self, *args):
>        "Pack and send a command to the Redis server"
>>       self.send_packed_command(self.pack_command(*args))
>redis/connection.py:334: 
>_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 
>self = Connection<host=localhost,port=6379,db=9>
>command = b'*1\r\n$7\r\nFLUSHDB\r\n'
>    def send_packed_command(self, command):
>        "Send an already packed command to the Redis server"
>        if not self._sock:
>>           self.connect()
>redis/connection.py:316: 
>_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 
>self = Connection<host=localhost,port=6379,db=9>
>    def connect(self):
>        "Connects to the Redis server if not already connected"
>        if self._sock:
>            return
>        try:
>            sock = self._connect()
>        except socket.error:
>            e = sys.exc_info()[1]
>>           raise ConnectionError(self._error_message(e))
>E           redis.exceptions.ConnectionError: Error 111 connecting localhost:6379. Connection refused.
>redis/connection.py:253: ConnectionError
>_________ ERROR at setup of TestPipeline.test_pipeline_no_transaction __________
>request = <SubRequest 'r' for <Function 'test_pipeline_no_transaction'>>
>kwargs = {}
>    @pytest.fixture()
>    def r(request, **kwargs):
>>       return _get_client(redis.Redis, request, **kwargs)
>tests/conftest.py:23: 
>_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 
>cls = <class 'redis.client.Redis'>
>request = <SubRequest 'r' for <Function 'test_pipeline_no_transaction'>>
>kwargs = {}, params = {'db': 9, 'host': 'localhost', 'port': 6379}
>client = Redis<ConnectionPool<Connection<host=localhost,port=6379,db=9>>>
>    def _get_client(cls, request=None, **kwargs):
>        params = {'host': 'localhost', 'port': 6379, 'db': 9}
>        params.update(kwargs)
>        client = cls(**params)
>>       client.flushdb()
>tests/conftest.py:9: 
>_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 
>self = Redis<ConnectionPool<Connection<host=localhost,port=6379,db=9>>>
>    def flushdb(self):
>        "Delete all keys in the current database"
>>       return self.execute_command('FLUSHDB')
>redis/client.py:534: 
>_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 
>self = Redis<ConnectionPool<Connection<host=localhost,port=6379,db=9>>>
>args = ('FLUSHDB',), options = {}
>pool = ConnectionPool<Connection<host=localhost,port=6379,db=9>>
>command_name = 'FLUSHDB', connection = Connection<host=localhost,port=6379,db=9>
>    def execute_command(self, *args, **options):
>        "Execute a command and return a parsed response"
>        pool = self.connection_pool
>        command_name = args[0]
>        connection = pool.get_connection(command_name, **options)
>        try:
>            connection.send_command(*args)
>            return self.parse_response(connection, command_name, **options)
>        except ConnectionError:
>            connection.disconnect()
>>           connection.send_command(*args)
>redis/client.py:464: 
>_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 
>self = Connection<host=localhost,port=6379,db=9>, args = ('FLUSHDB',)
>    def send_command(self, *args):
>        "Pack and send a command to the Redis server"
>>       self.send_packed_command(self.pack_command(*args))
>redis/connection.py:334: 
>_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 
>self = Connection<host=localhost,port=6379,db=9>
>command = b'*1\r\n$7\r\nFLUSHDB\r\n'
>    def send_packed_command(self, command):
>        "Send an already packed command to the Redis server"
>        if not self._sock:
>>           self.connect()
>redis/connection.py:316: 
>_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 
>self = Connection<host=localhost,port=6379,db=9>
>    def connect(self):
>        "Connects to the Redis server if not already connected"
>        if self._sock:
>            return
>        try:
>            sock = self._connect()
>        except socket.error:
>            e = sys.exc_info()[1]
>>           raise ConnectionError(self._error_message(e))
>E           redis.exceptions.ConnectionError: Error 111 connecting localhost:6379. Connection refused.
>redis/connection.py:253: ConnectionError
>______ ERROR at setup of TestPipeline.test_pipeline_no_transaction_watch _______
>request = <SubRequest 'r' for <Function 'test_pipeline_no_transaction_watch'>>
>kwargs = {}
>    @pytest.fixture()
>    def r(request, **kwargs):
>>       return _get_client(redis.Redis, request, **kwargs)
>tests/conftest.py:23: 
>_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 
>cls = <class 'redis.client.Redis'>
>request = <SubRequest 'r' for <Function 'test_pipeline_no_transaction_watch'>>
>kwargs = {}, params = {'db': 9, 'host': 'localhost', 'port': 6379}
>client = Redis<ConnectionPool<Connection<host=localhost,port=6379,db=9>>>
>    def _get_client(cls, request=None, **kwargs):
>        params = {'host': 'localhost', 'port': 6379, 'db': 9}
>        params.update(kwargs)
>        client = cls(**params)
>>       client.flushdb()
>tests/conftest.py:9: 
>_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 
>self = Redis<ConnectionPool<Connection<host=localhost,port=6379,db=9>>>
>    def flushdb(self):
>        "Delete all keys in the current database"
>>       return self.execute_command('FLUSHDB')
>redis/client.py:534: 
>_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 
>self = Redis<ConnectionPool<Connection<host=localhost,port=6379,db=9>>>
>args = ('FLUSHDB',), options = {}
>pool = ConnectionPool<Connection<host=localhost,port=6379,db=9>>
>command_name = 'FLUSHDB', connection = Connection<host=localhost,port=6379,db=9>
>    def execute_command(self, *args, **options):
>        "Execute a command and return a parsed response"
>        pool = self.connection_pool
>        command_name = args[0]
>        connection = pool.get_connection(command_name, **options)
>        try:
>            connection.send_command(*args)
>            return self.parse_response(connection, command_name, **options)
>        except ConnectionError:
>            connection.disconnect()
>>           connection.send_command(*args)
>redis/client.py:464: 
>_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 
>self = Connection<host=localhost,port=6379,db=9>, args = ('FLUSHDB',)
>    def send_command(self, *args):
>        "Pack and send a command to the Redis server"
>>       self.send_packed_command(self.pack_command(*args))
>redis/connection.py:334: 
>_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 
>self = Connection<host=localhost,port=6379,db=9>
>command = b'*1\r\n$7\r\nFLUSHDB\r\n'
>    def send_packed_command(self, command):
>        "Send an already packed command to the Redis server"
>        if not self._sock:
>>           self.connect()
>redis/connection.py:316: 
>_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 
>self = Connection<host=localhost,port=6379,db=9>
>    def connect(self):
>        "Connects to the Redis server if not already connected"
>        if self._sock:
>            return
>        try:
>            sock = self._connect()
>        except socket.error:
>            e = sys.exc_info()[1]
>>           raise ConnectionError(self._error_message(e))
>E           redis.exceptions.ConnectionError: Error 111 connecting localhost:6379. Connection refused.
>redis/connection.py:253: ConnectionError
>__ ERROR at setup of TestPipeline.test_pipeline_no_transaction_watch_failure ___
>request = <SubRequest 'r' for <Function 'test_pipeline_no_transaction_watch_failure'>>
>kwargs = {}
>    @pytest.fixture()
>    def r(request, **kwargs):
>>       return _get_client(redis.Redis, request, **kwargs)
>tests/conftest.py:23: 
>_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 
>cls = <class 'redis.client.Redis'>
>request = <SubRequest 'r' for <Function 'test_pipeline_no_transaction_watch_failure'>>
>kwargs = {}, params = {'db': 9, 'host': 'localhost', 'port': 6379}
>client = Redis<ConnectionPool<Connection<host=localhost,port=6379,db=9>>>
>    def _get_client(cls, request=None, **kwargs):
>        params = {'host': 'localhost', 'port': 6379, 'db': 9}
>        params.update(kwargs)
>        client = cls(**params)
>>       client.flushdb()
>tests/conftest.py:9: 
>_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 
>self = Redis<ConnectionPool<Connection<host=localhost,port=6379,db=9>>>
>    def flushdb(self):
>        "Delete all keys in the current database"
>>       return self.execute_command('FLUSHDB')
>redis/client.py:534: 
>_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 
>self = Redis<ConnectionPool<Connection<host=localhost,port=6379,db=9>>>
>args = ('FLUSHDB',), options = {}
>pool = ConnectionPool<Connection<host=localhost,port=6379,db=9>>
>command_name = 'FLUSHDB', connection = Connection<host=localhost,port=6379,db=9>
>    def execute_command(self, *args, **options):
>        "Execute a command and return a parsed response"
>        pool = self.connection_pool
>        command_name = args[0]
>        connection = pool.get_connection(command_name, **options)
>        try:
>            connection.send_command(*args)
>            return self.parse_response(connection, command_name, **options)
>        except ConnectionError:
>            connection.disconnect()
>>           connection.send_command(*args)
>redis/client.py:464: 
>_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 
>self = Connection<host=localhost,port=6379,db=9>, args = ('FLUSHDB',)
>    def send_command(self, *args):
>        "Pack and send a command to the Redis server"
>>       self.send_packed_command(self.pack_command(*args))
>redis/connection.py:334: 
>_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 
>self = Connection<host=localhost,port=6379,db=9>
>command = b'*1\r\n$7\r\nFLUSHDB\r\n'
>    def send_packed_command(self, command):
>        "Send an already packed command to the Redis server"
>        if not self._sock:
>>           self.connect()
>redis/connection.py:316: 
>_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 
>self = Connection<host=localhost,port=6379,db=9>
>    def connect(self):
>        "Connects to the Redis server if not already connected"
>        if self._sock:
>            return
>        try:
>            sock = self._connect()
>        except socket.error:
>            e = sys.exc_info()[1]
>>           raise ConnectionError(self._error_message(e))
>E           redis.exceptions.ConnectionError: Error 111 connecting localhost:6379. Connection refused.
>redis/connection.py:253: ConnectionError
>__________ ERROR at setup of TestPipeline.test_exec_error_in_response __________
>request = <SubRequest 'r' for <Function 'test_exec_error_in_response'>>
>kwargs = {}
>    @pytest.fixture()
>    def r(request, **kwargs):
>>       return _get_client(redis.Redis, request, **kwargs)
>tests/conftest.py:23: 
>_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 
>cls = <class 'redis.client.Redis'>
>request = <SubRequest 'r' for <Function 'test_exec_error_in_response'>>
>kwargs = {}, params = {'db': 9, 'host': 'localhost', 'port': 6379}
>client = Redis<ConnectionPool<Connection<host=localhost,port=6379,db=9>>>
>    def _get_client(cls, request=None, **kwargs):
>        params = {'host': 'localhost', 'port': 6379, 'db': 9}
>        params.update(kwargs)
>        client = cls(**params)
>>       client.flushdb()
>tests/conftest.py:9: 
>_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 
>self = Redis<ConnectionPool<Connection<host=localhost,port=6379,db=9>>>
>    def flushdb(self):
>        "Delete all keys in the current database"
>>       return self.execute_command('FLUSHDB')
>redis/client.py:534: 
>_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 
>self = Redis<ConnectionPool<Connection<host=localhost,port=6379,db=9>>>
>args = ('FLUSHDB',), options = {}
>pool = ConnectionPool<Connection<host=localhost,port=6379,db=9>>
>command_name = 'FLUSHDB', connection = Connection<host=localhost,port=6379,db=9>
>    def execute_command(self, *args, **options):
>        "Execute a command and return a parsed response"
>        pool = self.connection_pool
>        command_name = args[0]
>        connection = pool.get_connection(command_name, **options)
>        try:
>            connection.send_command(*args)
>            return self.parse_response(connection, command_name, **options)
>        except ConnectionError:
>            connection.disconnect()
>>           connection.send_command(*args)
>redis/client.py:464: 
>_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 
>self = Connection<host=localhost,port=6379,db=9>, args = ('FLUSHDB',)
>    def send_command(self, *args):
>        "Pack and send a command to the Redis server"
>>       self.send_packed_command(self.pack_command(*args))
>redis/connection.py:334: 
>_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 
>self = Connection<host=localhost,port=6379,db=9>
>command = b'*1\r\n$7\r\nFLUSHDB\r\n'
>    def send_packed_command(self, command):
>        "Send an already packed command to the Redis server"
>        if not self._sock:
>>           self.connect()
>redis/connection.py:316: 
>_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 
>self = Connection<host=localhost,port=6379,db=9>
>    def connect(self):
>        "Connects to the Redis server if not already connected"
>        if self._sock:
>            return
>        try:
>            sock = self._connect()
>        except socket.error:
>            e = sys.exc_info()[1]
>>           raise ConnectionError(self._error_message(e))
>E           redis.exceptions.ConnectionError: Error 111 connecting localhost:6379. Connection refused.
>redis/connection.py:253: ConnectionError
>____________ ERROR at setup of TestPipeline.test_exec_error_raised _____________
>request = <SubRequest 'r' for <Function 'test_exec_error_raised'>>, kwargs = {}
>    @pytest.fixture()
>    def r(request, **kwargs):
>>       return _get_client(redis.Redis, request, **kwargs)
>tests/conftest.py:23: 
>_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 
>cls = <class 'redis.client.Redis'>
>request = <SubRequest 'r' for <Function 'test_exec_error_raised'>>, kwargs = {}
>params = {'db': 9, 'host': 'localhost', 'port': 6379}
>client = Redis<ConnectionPool<Connection<host=localhost,port=6379,db=9>>>
>    def _get_client(cls, request=None, **kwargs):
>        params = {'host': 'localhost', 'port': 6379, 'db': 9}
>        params.update(kwargs)
>        client = cls(**params)
>>       client.flushdb()
>tests/conftest.py:9: 
>_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 
>self = Redis<ConnectionPool<Connection<host=localhost,port=6379,db=9>>>
>    def flushdb(self):
>        "Delete all keys in the current database"
>>       return self.execute_command('FLUSHDB')
>redis/client.py:534: 
>_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 
>self = Redis<ConnectionPool<Connection<host=localhost,port=6379,db=9>>>
>args = ('FLUSHDB',), options = {}
>pool = ConnectionPool<Connection<host=localhost,port=6379,db=9>>
>command_name = 'FLUSHDB', connection = Connection<host=localhost,port=6379,db=9>
>    def execute_command(self, *args, **options):
>        "Execute a command and return a parsed response"
>        pool = self.connection_pool
>        command_name = args[0]
>        connection = pool.get_connection(command_name, **options)
>        try:
>            connection.send_command(*args)
>            return self.parse_response(connection, command_name, **options)
>        except ConnectionError:
>            connection.disconnect()
>>           connection.send_command(*args)
>redis/client.py:464: 
>_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 
>self = Connection<host=localhost,port=6379,db=9>, args = ('FLUSHDB',)
>    def send_command(self, *args):
>        "Pack and send a command to the Redis server"
>>       self.send_packed_command(self.pack_command(*args))
>redis/connection.py:334: 
>_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 
>self = Connection<host=localhost,port=6379,db=9>
>command = b'*1\r\n$7\r\nFLUSHDB\r\n'
>    def send_packed_command(self, command):
>        "Send an already packed command to the Redis server"
>        if not self._sock:
>>           self.connect()
>redis/connection.py:316: 
>_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 
>self = Connection<host=localhost,port=6379,db=9>
>    def connect(self):
>        "Connects to the Redis server if not already connected"
>        if self._sock:
>            return
>        try:
>            sock = self._connect()
>        except socket.error:
>            e = sys.exc_info()[1]
>>           raise ConnectionError(self._error_message(e))
>E           redis.exceptions.ConnectionError: Error 111 connecting localhost:6379. Connection refused.
>redis/connection.py:253: ConnectionError
>____________ ERROR at setup of TestPipeline.test_parse_error_raised ____________
>request = <SubRequest 'r' for <Function 'test_parse_error_raised'>>, kwargs = {}
>    @pytest.fixture()
>    def r(request, **kwargs):
>>       return _get_client(redis.Redis, request, **kwargs)
>tests/conftest.py:23: 
>_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 
>cls = <class 'redis.client.Redis'>
>request = <SubRequest 'r' for <Function 'test_parse_error_raised'>>, kwargs = {}
>params = {'db': 9, 'host': 'localhost', 'port': 6379}
>client = Redis<ConnectionPool<Connection<host=localhost,port=6379,db=9>>>
>    def _get_client(cls, request=None, **kwargs):
>        params = {'host': 'localhost', 'port': 6379, 'db': 9}
>        params.update(kwargs)
>        client = cls(**params)
>>       client.flushdb()
>tests/conftest.py:9: 
>_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 
>self = Redis<ConnectionPool<Connection<host=localhost,port=6379,db=9>>>
>    def flushdb(self):
>        "Delete all keys in the current database"
>>       return self.execute_command('FLUSHDB')
>redis/client.py:534: 
>_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 
>self = Redis<ConnectionPool<Connection<host=localhost,port=6379,db=9>>>
>args = ('FLUSHDB',), options = {}
>pool = ConnectionPool<Connection<host=localhost,port=6379,db=9>>
>command_name = 'FLUSHDB', connection = Connection<host=localhost,port=6379,db=9>
>    def execute_command(self, *args, **options):
>        "Execute a command and return a parsed response"
>        pool = self.connection_pool
>        command_name = args[0]
>        connection = pool.get_connection(command_name, **options)
>        try:
>            connection.send_command(*args)
>            return self.parse_response(connection, command_name, **options)
>        except ConnectionError:
>            connection.disconnect()
>>           connection.send_command(*args)
>redis/client.py:464: 
>_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 
>self = Connection<host=localhost,port=6379,db=9>, args = ('FLUSHDB',)
>    def send_command(self, *args):
>        "Pack and send a command to the Redis server"
>>       self.send_packed_command(self.pack_command(*args))
>redis/connection.py:334: 
>_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 
>self = Connection<host=localhost,port=6379,db=9>
>command = b'*1\r\n$7\r\nFLUSHDB\r\n'
>    def send_packed_command(self, command):
>        "Send an already packed command to the Redis server"
>        if not self._sock:
>>           self.connect()
>redis/connection.py:316: 
>_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 
>self = Connection<host=localhost,port=6379,db=9>
>    def connect(self):
>        "Connects to the Redis server if not already connected"
>        if self._sock:
>            return
>        try:
>            sock = self._connect()
>        except socket.error:
>            e = sys.exc_info()[1]
>>           raise ConnectionError(self._error_message(e))
>E           redis.exceptions.ConnectionError: Error 111 connecting localhost:6379. Connection refused.
>redis/connection.py:253: ConnectionError
>______________ ERROR at setup of TestPipeline.test_watch_succeed _______________
>request = <SubRequest 'r' for <Function 'test_watch_succeed'>>, kwargs = {}
>    @pytest.fixture()
>    def r(request, **kwargs):
>>       return _get_client(redis.Redis, request, **kwargs)
>tests/conftest.py:23: 
>_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 
>cls = <class 'redis.client.Redis'>
>request = <SubRequest 'r' for <Function 'test_watch_succeed'>>, kwargs = {}
>params = {'db': 9, 'host': 'localhost', 'port': 6379}
>client = Redis<ConnectionPool<Connection<host=localhost,port=6379,db=9>>>
>    def _get_client(cls, request=None, **kwargs):
>        params = {'host': 'localhost', 'port': 6379, 'db': 9}
>        params.update(kwargs)
>        client = cls(**params)
>>       client.flushdb()
>tests/conftest.py:9: 
>_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 
>self = Redis<ConnectionPool<Connection<host=localhost,port=6379,db=9>>>
>    def flushdb(self):
>        "Delete all keys in the current database"
>>       return self.execute_command('FLUSHDB')
>redis/client.py:534: 
>_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 
>self = Redis<ConnectionPool<Connection<host=localhost,port=6379,db=9>>>
>args = ('FLUSHDB',), options = {}
>pool = ConnectionPool<Connection<host=localhost,port=6379,db=9>>
>command_name = 'FLUSHDB', connection = Connection<host=localhost,port=6379,db=9>
>    def execute_command(self, *args, **options):
>        "Execute a command and return a parsed response"
>        pool = self.connection_pool
>        command_name = args[0]
>        connection = pool.get_connection(command_name, **options)
>        try:
>            connection.send_command(*args)
>            return self.parse_response(connection, command_name, **options)
>        except ConnectionError:
>            connection.disconnect()
>>           connection.send_command(*args)
>redis/client.py:464: 
>_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 
>self = Connection<host=localhost,port=6379,db=9>, args = ('FLUSHDB',)
>    def send_command(self, *args):
>        "Pack and send a command to the Redis server"
>>       self.send_packed_command(self.pack_command(*args))
>redis/connection.py:334: 
>_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 
>self = Connection<host=localhost,port=6379,db=9>
>command = b'*1\r\n$7\r\nFLUSHDB\r\n'
>    def send_packed_command(self, command):
>        "Send an already packed command to the Redis server"
>        if not self._sock:
>>           self.connect()
>redis/connection.py:316: 
>_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 
>self = Connection<host=localhost,port=6379,db=9>
>    def connect(self):
>        "Connects to the Redis server if not already connected"
>        if self._sock:
>            return
>        try:
>            sock = self._connect()
>        except socket.error:
>            e = sys.exc_info()[1]
>>           raise ConnectionError(self._error_message(e))
>E           redis.exceptions.ConnectionError: Error 111 connecting localhost:6379. Connection refused.
>redis/connection.py:253: ConnectionError
>______________ ERROR at setup of TestPipeline.test_watch_failure _______________
>request = <SubRequest 'r' for <Function 'test_watch_failure'>>, kwargs = {}
>    @pytest.fixture()
>    def r(request, **kwargs):
>>       return _get_client(redis.Redis, request, **kwargs)
>tests/conftest.py:23: 
>_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 
>cls = <class 'redis.client.Redis'>
>request = <SubRequest 'r' for <Function 'test_watch_failure'>>, kwargs = {}
>params = {'db': 9, 'host': 'localhost', 'port': 6379}
>client = Redis<ConnectionPool<Connection<host=localhost,port=6379,db=9>>>
>    def _get_client(cls, request=None, **kwargs):
>        params = {'host': 'localhost', 'port': 6379, 'db': 9}
>        params.update(kwargs)
>        client = cls(**params)
>>       client.flushdb()
>tests/conftest.py:9: 
>_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 
>self = Redis<ConnectionPool<Connection<host=localhost,port=6379,db=9>>>
>    def flushdb(self):
>        "Delete all keys in the current database"
>>       return self.execute_command('FLUSHDB')
>redis/client.py:534: 
>_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 
>self = Redis<ConnectionPool<Connection<host=localhost,port=6379,db=9>>>
>args = ('FLUSHDB',), options = {}
>pool = ConnectionPool<Connection<host=localhost,port=6379,db=9>>
>command_name = 'FLUSHDB', connection = Connection<host=localhost,port=6379,db=9>
>    def execute_command(self, *args, **options):
>        "Execute a command and return a parsed response"
>        pool = self.connection_pool
>        command_name = args[0]
>        connection = pool.get_connection(command_name, **options)
>        try:
>            connection.send_command(*args)
>            return self.parse_response(connection, command_name, **options)
>        except ConnectionError:
>            connection.disconnect()
>>           connection.send_command(*args)
>redis/client.py:464: 
>_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 
>self = Connection<host=localhost,port=6379,db=9>, args = ('FLUSHDB',)
>    def send_command(self, *args):
>        "Pack and send a command to the Redis server"
>>       self.send_packed_command(self.pack_command(*args))
>redis/connection.py:334: 
>_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 
>self = Connection<host=localhost,port=6379,db=9>
>command = b'*1\r\n$7\r\nFLUSHDB\r\n'
>    def send_packed_command(self, command):
>        "Send an already packed command to the Redis server"
>        if not self._sock:
>>           self.connect()
>redis/connection.py:316: 
>_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 
>self = Connection<host=localhost,port=6379,db=9>
>    def connect(self):
>        "Connects to the Redis server if not already connected"
>        if self._sock:
>            return
>        try:
>            sock = self._connect()
>        except socket.error:
>            e = sys.exc_info()[1]
>>           raise ConnectionError(self._error_message(e))
>E           redis.exceptions.ConnectionError: Error 111 connecting localhost:6379. Connection refused.
>redis/connection.py:253: ConnectionError
>_________________ ERROR at setup of TestPipeline.test_unwatch __________________
>request = <SubRequest 'r' for <Function 'test_unwatch'>>, kwargs = {}
>    @pytest.fixture()
>    def r(request, **kwargs):
>>       return _get_client(redis.Redis, request, **kwargs)
>tests/conftest.py:23: 
>_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 
>cls = <class 'redis.client.Redis'>
>request = <SubRequest 'r' for <Function 'test_unwatch'>>, kwargs = {}
>params = {'db': 9, 'host': 'localhost', 'port': 6379}
>client = Redis<ConnectionPool<Connection<host=localhost,port=6379,db=9>>>
>    def _get_client(cls, request=None, **kwargs):
>        params = {'host': 'localhost', 'port': 6379, 'db': 9}
>        params.update(kwargs)
>        client = cls(**params)
>>       client.flushdb()
>tests/conftest.py:9: 
>_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 
>self = Redis<ConnectionPool<Connection<host=localhost,port=6379,db=9>>>
>    def flushdb(self):
>        "Delete all keys in the current database"
>>       return self.execute_command('FLUSHDB')
>redis/client.py:534: 
>_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 
>self = Redis<ConnectionPool<Connection<host=localhost,port=6379,db=9>>>
>args = ('FLUSHDB',), options = {}
>pool = ConnectionPool<Connection<host=localhost,port=6379,db=9>>
>command_name = 'FLUSHDB', connection = Connection<host=localhost,port=6379,db=9>
>    def execute_command(self, *args, **options):
>        "Execute a command and return a parsed response"
>        pool = self.connection_pool
>        command_name = args[0]
>        connection = pool.get_connection(command_name, **options)
>        try:
>            connection.send_command(*args)
>            return self.parse_response(connection, command_name, **options)
>        except ConnectionError:
>            connection.disconnect()
>>           connection.send_command(*args)
>redis/client.py:464: 
>_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 
>self = Connection<host=localhost,port=6379,db=9>, args = ('FLUSHDB',)
>    def send_command(self, *args):
>        "Pack and send a command to the Redis server"
>>       self.send_packed_command(self.pack_command(*args))
>redis/connection.py:334: 
>_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 
>self = Connection<host=localhost,port=6379,db=9>
>command = b'*1\r\n$7\r\nFLUSHDB\r\n'
>    def send_packed_command(self, command):
>        "Send an already packed command to the Redis server"
>        if not self._sock:
>>           self.connect()
>redis/connection.py:316: 
>_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 
>self = Connection<host=localhost,port=6379,db=9>
>    def connect(self):
>        "Connects to the Redis server if not already connected"
>        if self._sock:
>            return
>        try:
>            sock = self._connect()
>        except socket.error:
>            e = sys.exc_info()[1]
>>           raise ConnectionError(self._error_message(e))
>E           redis.exceptions.ConnectionError: Error 111 connecting localhost:6379. Connection refused.
>redis/connection.py:253: ConnectionError
>___________ ERROR at setup of TestPipeline.test_transaction_callable ___________
>request = <SubRequest 'r' for <Function 'test_transaction_callable'>>
>kwargs = {}
>    @pytest.fixture()
>    def r(request, **kwargs):
>>       return _get_client(redis.Redis, request, **kwargs)
>tests/conftest.py:23: 
>_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 
>cls = <class 'redis.client.Redis'>
>request = <SubRequest 'r' for <Function 'test_transaction_callable'>>
>kwargs = {}, params = {'db': 9, 'host': 'localhost', 'port': 6379}
>client = Redis<ConnectionPool<Connection<host=localhost,port=6379,db=9>>>
>    def _get_client(cls, request=None, **kwargs):
>        params = {'host': 'localhost', 'port': 6379, 'db': 9}
>        params.update(kwargs)
>        client = cls(**params)
>>       client.flushdb()
>tests/conftest.py:9: 
>_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 
>self = Redis<ConnectionPool<Connection<host=localhost,port=6379,db=9>>>
>    def flushdb(self):
>        "Delete all keys in the current database"
>>       return self.execute_command('FLUSHDB')
>redis/client.py:534: 
>_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 
>self = Redis<ConnectionPool<Connection<host=localhost,port=6379,db=9>>>
>args = ('FLUSHDB',), options = {}
>pool = ConnectionPool<Connection<host=localhost,port=6379,db=9>>
>command_name = 'FLUSHDB', connection = Connection<host=localhost,port=6379,db=9>
>    def execute_command(self, *args, **options):
>        "Execute a command and return a parsed response"
>        pool = self.connection_pool
>        command_name = args[0]
>        connection = pool.get_connection(command_name, **options)
>        try:
>            connection.send_command(*args)
>            return self.parse_response(connection, command_name, **options)
>        except ConnectionError:
>            connection.disconnect()
>>           connection.send_command(*args)
>redis/client.py:464: 
>_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 
>self = Connection<host=localhost,port=6379,db=9>, args = ('FLUSHDB',)
>    def send_command(self, *args):
>        "Pack and send a command to the Redis server"
>>       self.send_packed_command(self.pack_command(*args))
>redis/connection.py:334: 
>_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 
>self = Connection<host=localhost,port=6379,db=9>
>command = b'*1\r\n$7\r\nFLUSHDB\r\n'
>    def send_packed_command(self, command):
>        "Send an already packed command to the Redis server"
>        if not self._sock:
>>           self.connect()
>redis/connection.py:316: 
>_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 
>self = Connection<host=localhost,port=6379,db=9>
>    def connect(self):
>        "Connects to the Redis server if not already connected"
>        if self._sock:
>            return
>        try:
>            sock = self._connect()
>        except socket.error:
>            e = sys.exc_info()[1]
>>           raise ConnectionError(self._error_message(e))
>E           redis.exceptions.ConnectionError: Error 111 connecting localhost:6379. Connection refused.
>redis/connection.py:253: ConnectionError
>__ ERROR at setup of TestPipeline.test_exec_error_in_no_transaction_pipeline ___
>request = <SubRequest 'r' for <Function 'test_exec_error_in_no_transaction_pipeline'>>
>kwargs = {}
>    @pytest.fixture()
>    def r(request, **kwargs):
>>       return _get_client(redis.Redis, request, **kwargs)
>tests/conftest.py:23: 
>_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 
>cls = <class 'redis.client.Redis'>
>request = <SubRequest 'r' for <Function 'test_exec_error_in_no_transaction_pipeline'>>
>kwargs = {}, params = {'db': 9, 'host': 'localhost', 'port': 6379}
>client = Redis<ConnectionPool<Connection<host=localhost,port=6379,db=9>>>
>    def _get_client(cls, request=None, **kwargs):
>        params = {'host': 'localhost', 'port': 6379, 'db': 9}
>        params.update(kwargs)
>        client = cls(**params)
>>       client.flushdb()
>tests/conftest.py:9: 
>_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 
>self = Redis<ConnectionPool<Connection<host=localhost,port=6379,db=9>>>
>    def flushdb(self):
>        "Delete all keys in the current database"
>>       return self.execute_command('FLUSHDB')
>redis/client.py:534: 
>_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 
>self = Redis<ConnectionPool<Connection<host=localhost,port=6379,db=9>>>
>args = ('FLUSHDB',), options = {}
>pool = ConnectionPool<Connection<host=localhost,port=6379,db=9>>
>command_name = 'FLUSHDB', connection = Connection<host=localhost,port=6379,db=9>
>    def execute_command(self, *args, **options):
>        "Execute a command and return a parsed response"
>        pool = self.connection_pool
>        command_name = args[0]
>        connection = pool.get_connection(command_name, **options)
>        try:
>            connection.send_command(*args)
>            return self.parse_response(connection, command_name, **options)
>        except ConnectionError:
>            connection.disconnect()
>>           connection.send_command(*args)
>redis/client.py:464: 
>_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 
>self = Connection<host=localhost,port=6379,db=9>, args = ('FLUSHDB',)
>    def send_command(self, *args):
>        "Pack and send a command to the Redis server"
>>       self.send_packed_command(self.pack_command(*args))
>redis/connection.py:334: 
>_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 
>self = Connection<host=localhost,port=6379,db=9>
>command = b'*1\r\n$7\r\nFLUSHDB\r\n'
>    def send_packed_command(self, command):
>        "Send an already packed command to the Redis server"
>        if not self._sock:
>>           self.connect()
>redis/connection.py:316: 
>_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 
>self = Connection<host=localhost,port=6379,db=9>
>    def connect(self):
>        "Connects to the Redis server if not already connected"
>        if self._sock:
>            return
>        try:
>            sock = self._connect()
>        except socket.error:
>            e = sys.exc_info()[1]
>>           raise ConnectionError(self._error_message(e))
>E           redis.exceptions.ConnectionError: Error 111 connecting localhost:6379. Connection refused.
>redis/connection.py:253: ConnectionError
> ERROR at setup of TestPipeline.test_exec_error_in_no_transaction_pipeline_unicode_command 
>request = <SubRequest 'r' for <Function 'test_exec_error_in_no_transaction_pipeline_unicode_command'>>
>kwargs = {}
>    @pytest.fixture()
>    def r(request, **kwargs):
>>       return _get_client(redis.Redis, request, **kwargs)
>tests/conftest.py:23: 
>_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 
>cls = <class 'redis.client.Redis'>
>request = <SubRequest 'r' for <Function 'test_exec_error_in_no_transaction_pipeline_unicode_command'>>
>kwargs = {}, params = {'db': 9, 'host': 'localhost', 'port': 6379}
>client = Redis<ConnectionPool<Connection<host=localhost,port=6379,db=9>>>
>    def _get_client(cls, request=None, **kwargs):
>        params = {'host': 'localhost', 'port': 6379, 'db': 9}
>        params.update(kwargs)
>        client = cls(**params)
>>       client.flushdb()
>tests/conftest.py:9: 
>_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 
>self = Redis<ConnectionPool<Connection<host=localhost,port=6379,db=9>>>
>    def flushdb(self):
>        "Delete all keys in the current database"
>>       return self.execute_command('FLUSHDB')
>redis/client.py:534: 
>_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 
>self = Redis<ConnectionPool<Connection<host=localhost,port=6379,db=9>>>
>args = ('FLUSHDB',), options = {}
>pool = ConnectionPool<Connection<host=localhost,port=6379,db=9>>
>command_name = 'FLUSHDB', connection = Connection<host=localhost,port=6379,db=9>
>    def execute_command(self, *args, **options):
>        "Execute a command and return a parsed response"
>        pool = self.connection_pool
>        command_name = args[0]
>        connection = pool.get_connection(command_name, **options)
>        try:
>            connection.send_command(*args)
>            return self.parse_response(connection, command_name, **options)
>        except ConnectionError:
>            connection.disconnect()
>>           connection.send_command(*args)
>redis/client.py:464: 
>_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 
>self = Connection<host=localhost,port=6379,db=9>, args = ('FLUSHDB',)
>    def send_command(self, *args):
>        "Pack and send a command to the Redis server"
>>       self.send_packed_command(self.pack_command(*args))
>redis/connection.py:334: 
>_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 
>self = Connection<host=localhost,port=6379,db=9>
>command = b'*1\r\n$7\r\nFLUSHDB\r\n'
>    def send_packed_command(self, command):
>        "Send an already packed command to the Redis server"
>        if not self._sock:
>>           self.connect()
>redis/connection.py:316: 
>_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 
>self = Connection<host=localhost,port=6379,db=9>
>    def connect(self):
>        "Connects to the Redis server if not already connected"
>        if self._sock:
>            return
>        try:
>            sock = self._connect()
>        except socket.error:
>            e = sys.exc_info()[1]
>>           raise ConnectionError(self._error_message(e))
>E           redis.exceptions.ConnectionError: Error 111 connecting localhost:6379. Connection refused.
>redis/connection.py:253: ConnectionError
>_____________ ERROR at setup of TestPubSub.test_channel_subscribe ______________
>request = <SubRequest 'r' for <Function 'test_channel_subscribe'>>, kwargs = {}
>    @pytest.fixture()
>    def r(request, **kwargs):
>>       return _get_client(redis.Redis, request, **kwargs)
>tests/conftest.py:23: 
>_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 
>cls = <class 'redis.client.Redis'>
>request = <SubRequest 'r' for <Function 'test_channel_subscribe'>>, kwargs = {}
>params = {'db': 9, 'host': 'localhost', 'port': 6379}
>client = Redis<ConnectionPool<Connection<host=localhost,port=6379,db=9>>>
>    def _get_client(cls, request=None, **kwargs):
>        params = {'host': 'localhost', 'port': 6379, 'db': 9}
>        params.update(kwargs)
>        client = cls(**params)
>>       client.flushdb()
>tests/conftest.py:9: 
>_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 
>self = Redis<ConnectionPool<Connection<host=localhost,port=6379,db=9>>>
>    def flushdb(self):
>        "Delete all keys in the current database"
>>       return self.execute_command('FLUSHDB')
>redis/client.py:534: 
>_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 
>self = Redis<ConnectionPool<Connection<host=localhost,port=6379,db=9>>>
>args = ('FLUSHDB',), options = {}
>pool = ConnectionPool<Connection<host=localhost,port=6379,db=9>>
>command_name = 'FLUSHDB', connection = Connection<host=localhost,port=6379,db=9>
>    def execute_command(self, *args, **options):
>        "Execute a command and return a parsed response"
>        pool = self.connection_pool
>        command_name = args[0]
>        connection = pool.get_connection(command_name, **options)
>        try:
>            connection.send_command(*args)
>            return self.parse_response(connection, command_name, **options)
>        except ConnectionError:
>            connection.disconnect()
>>           connection.send_command(*args)
>redis/client.py:464: 
>_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 
>self = Connection<host=localhost,port=6379,db=9>, args = ('FLUSHDB',)
>    def send_command(self, *args):
>        "Pack and send a command to the Redis server"
>>       self.send_packed_command(self.pack_command(*args))
>redis/connection.py:334: 
>_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 
>self = Connection<host=localhost,port=6379,db=9>
>command = b'*1\r\n$7\r\nFLUSHDB\r\n'
>    def send_packed_command(self, command):
>        "Send an already packed command to the Redis server"
>        if not self._sock:
>>           self.connect()
>redis/connection.py:316: 
>_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 
>self = Connection<host=localhost,port=6379,db=9>
>    def connect(self):
>        "Connects to the Redis server if not already connected"
>        if self._sock:
>            return
>        try:
>            sock = self._connect()
>        except socket.error:
>            e = sys.exc_info()[1]
>>           raise ConnectionError(self._error_message(e))
>E           redis.exceptions.ConnectionError: Error 111 connecting localhost:6379. Connection refused.
>redis/connection.py:253: ConnectionError
>_____________ ERROR at setup of TestPubSub.test_pattern_subscribe ______________
>request = <SubRequest 'r' for <Function 'test_pattern_subscribe'>>, kwargs = {}
>    @pytest.fixture()
>    def r(request, **kwargs):
>>       return _get_client(redis.Redis, request, **kwargs)
>tests/conftest.py:23: 
>_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 
>cls = <class 'redis.client.Redis'>
>request = <SubRequest 'r' for <Function 'test_pattern_subscribe'>>, kwargs = {}
>params = {'db': 9, 'host': 'localhost', 'port': 6379}
>client = Redis<ConnectionPool<Connection<host=localhost,port=6379,db=9>>>
>    def _get_client(cls, request=None, **kwargs):
>        params = {'host': 'localhost', 'port': 6379, 'db': 9}
>        params.update(kwargs)
>        client = cls(**params)
>>       client.flushdb()
>tests/conftest.py:9: 
>_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 
>self = Redis<ConnectionPool<Connection<host=localhost,port=6379,db=9>>>
>    def flushdb(self):
>        "Delete all keys in the current database"
>>       return self.execute_command('FLUSHDB')
>redis/client.py:534: 
>_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 
>self = Redis<ConnectionPool<Connection<host=localhost,port=6379,db=9>>>
>args = ('FLUSHDB',), options = {}
>pool = ConnectionPool<Connection<host=localhost,port=6379,db=9>>
>command_name = 'FLUSHDB', connection = Connection<host=localhost,port=6379,db=9>
>    def execute_command(self, *args, **options):
>        "Execute a command and return a parsed response"
>        pool = self.connection_pool
>        command_name = args[0]
>        connection = pool.get_connection(command_name, **options)
>        try:
>            connection.send_command(*args)
>            return self.parse_response(connection, command_name, **options)
>        except ConnectionError:
>            connection.disconnect()
>>           connection.send_command(*args)
>redis/client.py:464: 
>_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 
>self = Connection<host=localhost,port=6379,db=9>, args = ('FLUSHDB',)
>    def send_command(self, *args):
>        "Pack and send a command to the Redis server"
>>       self.send_packed_command(self.pack_command(*args))
>redis/connection.py:334: 
>_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 
>self = Connection<host=localhost,port=6379,db=9>
>command = b'*1\r\n$7\r\nFLUSHDB\r\n'
>    def send_packed_command(self, command):
>        "Send an already packed command to the Redis server"
>        if not self._sock:
>>           self.connect()
>redis/connection.py:316: 
>_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 
>self = Connection<host=localhost,port=6379,db=9>
>    def connect(self):
>        "Connects to the Redis server if not already connected"
>        if self._sock:
>            return
>        try:
>            sock = self._connect()
>        except socket.error:
>            e = sys.exc_info()[1]
>>           raise ConnectionError(self._error_message(e))
>E           redis.exceptions.ConnectionError: Error 111 connecting localhost:6379. Connection refused.
>redis/connection.py:253: ConnectionError
>_________ ERROR at setup of TestPubSubRedisDown.test_channel_subscribe _________
>request = <SubRequest 'r' for <Function 'test_channel_subscribe'>>, kwargs = {}
>    @pytest.fixture()
>    def r(request, **kwargs):
>>       return _get_client(redis.Redis, request, **kwargs)
>tests/conftest.py:23: 
>_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 
>cls = <class 'redis.client.Redis'>
>request = <SubRequest 'r' for <Function 'test_channel_subscribe'>>, kwargs = {}
>params = {'db': 9, 'host': 'localhost', 'port': 6379}
>client = Redis<ConnectionPool<Connection<host=localhost,port=6379,db=9>>>
>    def _get_client(cls, request=None, **kwargs):
>        params = {'host': 'localhost', 'port': 6379, 'db': 9}
>        params.update(kwargs)
>        client = cls(**params)
>>       client.flushdb()
>tests/conftest.py:9: 
>_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 
>self = Redis<ConnectionPool<Connection<host=localhost,port=6379,db=9>>>
>    def flushdb(self):
>        "Delete all keys in the current database"
>>       return self.execute_command('FLUSHDB')
>redis/client.py:534: 
>_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 
>self = Redis<ConnectionPool<Connection<host=localhost,port=6379,db=9>>>
>args = ('FLUSHDB',), options = {}
>pool = ConnectionPool<Connection<host=localhost,port=6379,db=9>>
>command_name = 'FLUSHDB', connection = Connection<host=localhost,port=6379,db=9>
>    def execute_command(self, *args, **options):
>        "Execute a command and return a parsed response"
>        pool = self.connection_pool
>        command_name = args[0]
>        connection = pool.get_connection(command_name, **options)
>        try:
>            connection.send_command(*args)
>            return self.parse_response(connection, command_name, **options)
>        except ConnectionError:
>            connection.disconnect()
>>           connection.send_command(*args)
>redis/client.py:464: 
>_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 
>self = Connection<host=localhost,port=6379,db=9>, args = ('FLUSHDB',)
>    def send_command(self, *args):
>        "Pack and send a command to the Redis server"
>>       self.send_packed_command(self.pack_command(*args))
>redis/connection.py:334: 
>_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 
>self = Connection<host=localhost,port=6379,db=9>
>command = b'*1\r\n$7\r\nFLUSHDB\r\n'
>    def send_packed_command(self, command):
>        "Send an already packed command to the Redis server"
>        if not self._sock:
>>           self.connect()
>redis/connection.py:316: 
>_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 
>self = Connection<host=localhost,port=6379,db=9>
>    def connect(self):
>        "Connects to the Redis server if not already connected"
>        if self._sock:
>            return
>        try:
>            sock = self._connect()
>        except socket.error:
>            e = sys.exc_info()[1]
>>           raise ConnectionError(self._error_message(e))
>E           redis.exceptions.ConnectionError: Error 111 connecting localhost:6379. Connection refused.
>redis/connection.py:253: ConnectionError
>=================================== FAILURES ===================================
>_______________________________ test_master_for ________________________________
>cluster = <tests.test_sentinel.SentinelTestCluster object at 0xb5cc74b0>
>sentinel = <redis.sentinel.Sentinel object at 0xb5cc74d0>
>    def test_master_for(cluster, sentinel):
>        master = sentinel.master_for('mymaster', db=9)
>>       assert master.ping()
>tests/test_sentinel.py:137: 
>_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 
>self = <[KeyError("'host'") raised in repr()] StrictRedis object at 0xb5cc7190>
>    def ping(self):
>        "Ping the Redis server"
>>       return self.execute_command('PING')
>redis/client.py:564: 
>_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 
>self = <[KeyError("'host'") raised in repr()] StrictRedis object at 0xb5cc7190>
>args = ('PING',), options = {}
>pool = <[KeyError("'host'") raised in repr()] SentinelConnectionPool object at 0xb5cc79b0>
>command_name = 'PING', connection = Connection<host=localhost,port=6379,db=9>
>    def execute_command(self, *args, **options):
>        "Execute a command and return a parsed response"
>        pool = self.connection_pool
>        command_name = args[0]
>        connection = pool.get_connection(command_name, **options)
>        try:
>            connection.send_command(*args)
>            return self.parse_response(connection, command_name, **options)
>        except ConnectionError:
>            connection.disconnect()
>>           connection.send_command(*args)
>redis/client.py:464: 
>_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 
>self = Connection<host=localhost,port=6379,db=9>, args = ('PING',)
>    def send_command(self, *args):
>        "Pack and send a command to the Redis server"
>>       self.send_packed_command(self.pack_command(*args))
>redis/connection.py:334: 
>_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 
>self = Connection<host=localhost,port=6379,db=9>
>command = b'*1\r\n$4\r\nPING\r\n'
>    def send_packed_command(self, command):
>        "Send an already packed command to the Redis server"
>        if not self._sock:
>>           self.connect()
>redis/connection.py:316: 
>_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 
>self = Connection<host=localhost,port=6379,db=9>
>    def connect(self):
>        if self._sock:
>            return  # already connected
>        if self.connection_pool.is_master:
>>           self.connect_to(self.connection_pool.get_master_address())
>redis/sentinel.py:36: 
>_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 
>self = Connection<host=localhost,port=6379,db=9>, address = ('127.0.0.1', 6379)
>    def connect_to(self, address):
>        self.host, self.port = address
>>       super(SentinelManagedConnection, self).connect()
>redis/sentinel.py:26: 
>_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 
>self = Connection<host=localhost,port=6379,db=9>
>    def connect(self):
>        "Connects to the Redis server if not already connected"
>        if self._sock:
>            return
>        try:
>            sock = self._connect()
>        except socket.error:
>            e = sys.exc_info()[1]
>>           raise ConnectionError(self._error_message(e))
>E           redis.exceptions.ConnectionError: Error 111 connecting 127.0.0.1:6379. Connection refused.
>redis/connection.py:253: ConnectionError
>________________________________ test_slave_for ________________________________
>cluster = <tests.test_sentinel.SentinelTestCluster object at 0xb5b8b330>
>sentinel = <redis.sentinel.Sentinel object at 0xb5b8b430>
>    def test_slave_for(cluster, sentinel):
>        cluster.slaves = [
>            {'ip': '127.0.0.1', 'port': 6379,
>             'is_odown': False, 'is_sdown': False},
>        ]
>        slave = sentinel.slave_for('mymaster', db=9)
>>       assert slave.ping()
>tests/test_sentinel.py:151: 
>_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 
>self = <[KeyError("'host'") raised in repr()] StrictRedis object at 0xb5b8b3f0>
>    def ping(self):
>        "Ping the Redis server"
>>       return self.execute_command('PING')
>redis/client.py:564: 
>_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 
>self = <[KeyError("'host'") raised in repr()] StrictRedis object at 0xb5b8b3f0>
>args = ('PING',), options = {}
>pool = <[KeyError("'host'") raised in repr()] SentinelConnectionPool object at 0xb5b8b3d0>
>command_name = 'PING', connection = Connection<host=localhost,port=6379,db=9>
>    def execute_command(self, *args, **options):
>        "Execute a command and return a parsed response"
>        pool = self.connection_pool
>        command_name = args[0]
>        connection = pool.get_connection(command_name, **options)
>        try:
>            connection.send_command(*args)
>            return self.parse_response(connection, command_name, **options)
>        except ConnectionError:
>            connection.disconnect()
>>           connection.send_command(*args)
>redis/client.py:464: 
>_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 
>self = Connection<host=localhost,port=6379,db=9>, args = ('PING',)
>    def send_command(self, *args):
>        "Pack and send a command to the Redis server"
>>       self.send_packed_command(self.pack_command(*args))
>redis/connection.py:334: 
>_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 
>self = Connection<host=localhost,port=6379,db=9>
>command = b'*1\r\n$4\r\nPING\r\n'
>    def send_packed_command(self, command):
>        "Send an already packed command to the Redis server"
>        if not self._sock:
>>           self.connect()
>redis/connection.py:316: 
>_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 
>self = Connection<host=localhost,port=6379,db=9>
>    def connect(self):
>        if self._sock:
>            return  # already connected
>        if self.connection_pool.is_master:
>            self.connect_to(self.connection_pool.get_master_address())
>        else:
>>           for slave in self.connection_pool.rotate_slaves():
>                try:
>                    return self.connect_to(slave)
>redis/sentinel.py:38: 
>_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 
>self = <[KeyError("'host'") raised in repr()] SentinelConnectionPool object at 0xb5b8b3d0>
>    def rotate_slaves(self):
>        "Round-robin slave balancer"
>        slaves = self.sentinel_manager.discover_slaves(self.service_name)
>        if slaves:
>            if self.slave_rr_counter is None:
>                self.slave_rr_counter = random.randint(0, len(slaves) - 1)
>            for _ in xrange(len(slaves)):
>                self.slave_rr_counter = (
>                    self.slave_rr_counter + 1) % len(slaves)
>                slave = slaves[self.slave_rr_counter]
>                yield slave
>        # Fallback to the master connection
>        try:
>            yield self.get_master_address()
>        except MasterNotFoundError:
>            pass
>>       raise SlaveNotFoundError('No slave found for %r' % (self.service_name))
>E       redis.sentinel.SlaveNotFoundError: No slave found for 'mymaster'
>redis/sentinel.py:93: SlaveNotFoundError
>================ 2 failed, 23 passed, 27 error in 10.80 seconds ================
>RPM build errors:
>error: Bad exit status from /var/tmp/rpm-tmp.y85Wn9 (%check)
>    Bad exit status from /var/tmp/rpm-tmp.y85Wn9 (%check)
>Child pid '32460' is dead
>Child dead, killing orphans
>Child return code was: 1
>EXCEPTION: Command failed. See logs for output.
> # ['bash', '--login', '-c', 'rpmbuild -bb --target noarch --nodeps  builddir/build/SPECS/python-redis.spec']
>Traceback (most recent call last):
>  File "/usr/lib/python2.7/site-packages/mockbuild/trace_decorator.py", line 70, in trace
>    result = func(*args, **kw)
>  File "/usr/lib/python2.7/site-packages/mockbuild/util.py", line 376, in do
>    raise mockbuild.exception.Error, ("Command failed. See logs for output.\n # %s" % (command,), child.returncode)
>Error: Command failed. See logs for output.
> # ['bash', '--login', '-c', 'rpmbuild -bb --target noarch --nodeps  builddir/build/SPECS/python-redis.spec']
>LEAVE do --> EXCEPTION RAISED
>

Actions: View

Attachments on bug 1106804: 905347 | 905348 | 905349