diff --git a/tests/db/test_bigchain_api.py b/tests/db/test_bigchain_api.py
index ca082ba9..edea3a9e 100644
--- a/tests/db/test_bigchain_api.py
+++ b/tests/db/test_bigchain_api.py
@@ -214,7 +214,7 @@ class TestBigchainApi(object):
 
         assert new_block['block']['voters'] == [b.me]
         assert new_block['block']['node_pubkey'] == b.me
-        assert PublicKey(b.me).verify(b.serialize(new_block['block']), new_block['signature']) == True
+        assert PublicKey(b.me).verify(b.serialize(new_block['block']), new_block['signature']) is True
         assert new_block['id'] == block_hash
         assert new_block['votes'] == []
 
@@ -256,7 +256,7 @@ class TestTransactionValidation(object):
             b.validate_transaction(tx)
 
         assert excinfo.value.args[0] == 'A CREATE operation has no inputs'
-        assert b.is_valid_transaction(tx) == False
+        assert b.is_valid_transaction(tx) is False
 
     def test_create_operation_not_federation_node(self, b):
         tx = b.create_transaction('a', 'b', None, 'CREATE')
@@ -264,7 +264,7 @@ class TestTransactionValidation(object):
             b.validate_transaction(tx)
 
         assert excinfo.value.args[0] == 'Only federation nodes can use the operation `CREATE`'
-        assert b.is_valid_transaction(tx) == False
+        assert b.is_valid_transaction(tx) is False
 
     def test_non_create_operation_no_inputs(self, b):
         tx = b.create_transaction('a', 'b', None, 'd')
@@ -272,7 +272,7 @@ class TestTransactionValidation(object):
             b.validate_transaction(tx)
 
         assert excinfo.value.args[0] == 'Only `CREATE` transactions can have null inputs'
-        assert b.is_valid_transaction(tx) == False
+        assert b.is_valid_transaction(tx) is False
 
     def test_non_create_input_not_found(self, b):
         tx = b.create_transaction('a', 'b', 'c', 'd')
@@ -280,7 +280,7 @@ class TestTransactionValidation(object):
             b.validate_transaction(tx)
 
         assert excinfo.value.args[0] == 'input `c` does not exist in the bigchain'
-        assert b.is_valid_transaction(tx) == False
+        assert b.is_valid_transaction(tx) is False
 
     @pytest.mark.usefixtures('inputs')
     def test_non_create_valid_input_wrong_owner(self, b, user_public_key):
@@ -290,7 +290,7 @@ class TestTransactionValidation(object):
             b.validate_transaction(tx)
 
         assert excinfo.value.args[0] == 'current_owner `a` does not own the input `{}`'.format(valid_input)
-        assert b.is_valid_transaction(tx) == False
+        assert b.is_valid_transaction(tx) is False
 
     @pytest.mark.usefixtures('inputs')
     def test_non_create_double_spend(self, b, user_public_key, user_private_key):
@@ -309,7 +309,7 @@ class TestTransactionValidation(object):
             b.validate_transaction(tx_double_spend)
 
         assert excinfo.value.args[0] == 'input `{}` was already spent'.format(input_valid)
-        assert b.is_valid_transaction(tx_double_spend) == False
+        assert b.is_valid_transaction(tx_double_spend) is False
 
     @pytest.mark.usefixtures('inputs')
     def test_wrong_transaction_hash(self, b, user_public_key):
@@ -320,7 +320,7 @@ class TestTransactionValidation(object):
         tx_valid.update({'id': 'abcd'})
         with pytest.raises(exceptions.InvalidHash):
             b.validate_transaction(tx_valid)
-        assert b.is_valid_transaction(tx_valid) == False
+        assert b.is_valid_transaction(tx_valid) is False
 
     @pytest.mark.usefixtures('inputs')
     def test_wrong_signature(self, b, user_public_key):
@@ -332,7 +332,7 @@ class TestTransactionValidation(object):
         tx_invalid_signed = b.sign_transaction(tx_valid, wrong_private_key)
         with pytest.raises(exceptions.InvalidSignature):
             b.validate_transaction(tx_invalid_signed)
-        assert b.is_valid_transaction(tx_invalid_signed) == False
+        assert b.is_valid_transaction(tx_invalid_signed) is False
 
     def test_valid_create_transaction(self, b, user_public_key):
         tx = b.create_transaction(b.me, user_public_key, None, 'CREATE')
@@ -445,7 +445,7 @@ class TestBigchainCrypto(object):
         message = 'Hello World!'
         public_key = PublicKey(self.PUBLIC_VALUE_COMPRESSED_B58)
         private_key = PrivateKey(self.PRIVATE_VALUE_B58)
-        assert public_key.verify(message, private_key.sign(message)) == True
+        assert public_key.verify(message, private_key.sign(message)) is True
 
     def test_generate_key_pair(self):
         private_value_base58, public_value_compressed_base58 = generate_key_pair()
@@ -488,10 +488,10 @@ class TestBigchainVoter(object):
 
         assert vote['vote']['voting_for_block'] == block['id']
         assert vote['vote']['previous_block'] == genesis['id']
-        assert vote['vote']['is_block_valid'] == True
-        assert vote['vote']['invalid_reason'] == None
+        assert vote['vote']['is_block_valid'] is True
+        assert vote['vote']['invalid_reason'] is None
         assert vote['node_pubkey'] == b.me
-        assert PublicKey(b.me).verify(b.serialize(vote['vote']), vote['signature']) == True
+        assert PublicKey(b.me).verify(b.serialize(vote['vote']), vote['signature']) is True
 
     def test_invalid_block_voting(self, b, user_public_key):
         # create queue and voter
@@ -507,7 +507,7 @@ class TestBigchainVoter(object):
         block = b.create_block([transaction_signed])
         # change transaction id to make it invalid
         block['block']['transactions'][0]['id'] = 'abc'
-        assert b.is_valid_block(block) == False
+        assert b.is_valid_block(block) is False
         b.write_block(block, durability='hard')
 
         # insert into queue
@@ -530,10 +530,10 @@ class TestBigchainVoter(object):
 
         assert vote['vote']['voting_for_block'] == block['id']
         assert vote['vote']['previous_block'] == genesis['id']
-        assert vote['vote']['is_block_valid'] == False
-        assert vote['vote']['invalid_reason'] == None
+        assert vote['vote']['is_block_valid'] is False
+        assert vote['vote']['invalid_reason'] is None
         assert vote['node_pubkey'] == b.me
-        assert PublicKey(b.me).verify(b.serialize(vote['vote']), vote['signature']) == True
+        assert PublicKey(b.me).verify(b.serialize(vote['vote']), vote['signature']) is True
 
     def test_vote_creation_valid(self, b):
         # create valid block
@@ -544,10 +544,10 @@ class TestBigchainVoter(object):
         # assert vote is correct
         assert vote['vote']['voting_for_block'] == block['id']
         assert vote['vote']['previous_block'] == 'abc'
-        assert vote['vote']['is_block_valid'] == True
-        assert vote['vote']['invalid_reason'] == None
+        assert vote['vote']['is_block_valid'] is True
+        assert vote['vote']['invalid_reason'] is None
         assert vote['node_pubkey'] == b.me
-        assert PublicKey(b.me).verify(b.serialize(vote['vote']), vote['signature']) == True
+        assert PublicKey(b.me).verify(b.serialize(vote['vote']), vote['signature']) is True
 
     def test_vote_creation_invalid(self, b):
         # create valid block
@@ -558,10 +558,10 @@ class TestBigchainVoter(object):
         # assert vote is correct
         assert vote['vote']['voting_for_block'] == block['id']
         assert vote['vote']['previous_block'] == 'abc'
-        assert vote['vote']['is_block_valid'] == False
-        assert vote['vote']['invalid_reason'] == None
+        assert vote['vote']['is_block_valid'] is False
+        assert vote['vote']['invalid_reason'] is None
         assert vote['node_pubkey'] == b.me
-        assert PublicKey(b.me).verify(b.serialize(vote['vote']), vote['signature']) == True
+        assert PublicKey(b.me).verify(b.serialize(vote['vote']), vote['signature']) is True
 
 
 class TestBigchainBlock(object):
diff --git a/tests/db/test_utils.py b/tests/db/test_utils.py
index 20f2942c..c8caff60 100644
--- a/tests/db/test_utils.py
+++ b/tests/db/test_utils.py
@@ -24,24 +24,25 @@ def test_init_creates_db_tables_and_indexes():
 
     utils.init()
 
-    assert r.db_list().contains(dbname).run(conn) == True
+    assert r.db_list().contains(dbname).run(conn) is True
 
-    assert r.db(dbname).table_list().contains('backlog', 'bigchain').run(conn) == True
+    assert r.db(dbname).table_list().contains('backlog', 'bigchain').run(conn) is True
 
     assert r.db(dbname).table('bigchain').index_list().contains(
         'block_timestamp',
-        'block_number').run(conn) == True
+        'block_number').run(conn) is True
 
     assert r.db(dbname).table('backlog').index_list().contains(
         'transaction_timestamp',
-        'assignee__transaction_timestamp').run(conn) == True
+        'assignee__transaction_timestamp').run(conn) is True
 
 
 def test_init_fails_if_db_exists():
+    conn = utils.get_conn()
     dbname = bigchaindb.config['database']['name']
 
     # The db is set up by fixtures
-    assert r.db_list().contains(dbname) == True
+    assert r.db_list().contains(dbname).run(conn) is True
 
     with pytest.raises(bigchaindb.exceptions.DatabaseAlreadyExists):
         utils.init()
@@ -52,12 +53,12 @@ def test_drop_interactively_drops_the_database_when_user_says_yes(monkeypatch):
     dbname = bigchaindb.config['database']['name']
 
     # The db is set up by fixtures
-    assert r.db_list().contains(dbname).run(conn) == True
+    assert r.db_list().contains(dbname).run(conn) is True
 
     monkeypatch.setattr(builtins, 'input', lambda x: 'y')
     utils.drop()
 
-    assert r.db_list().contains(dbname).run(conn) == False
+    assert r.db_list().contains(dbname).run(conn) is False
 
 
 def test_drop_programmatically_drops_the_database_when_assume_yes_is_true(monkeypatch):
@@ -65,11 +66,11 @@ def test_drop_programmatically_drops_the_database_when_assume_yes_is_true(monkey
     dbname = bigchaindb.config['database']['name']
 
     # The db is set up by fixtures
-    assert r.db_list().contains(dbname).run(conn) == True
+    assert r.db_list().contains(dbname).run(conn) is True
 
     utils.drop(assume_yes=True)
 
-    assert r.db_list().contains(dbname).run(conn) == False
+    assert r.db_list().contains(dbname).run(conn) is False
 
 
 def test_drop_interactively_does_not_drop_the_database_when_user_says_no(monkeypatch):
@@ -78,19 +79,19 @@ def test_drop_interactively_does_not_drop_the_database_when_user_says_no(monkeyp
 
     # The db is set up by fixtures
     print(r.db_list().contains(dbname).run(conn))
-    assert r.db_list().contains(dbname).run(conn) == True
+    assert r.db_list().contains(dbname).run(conn) is True
 
     monkeypatch.setattr(builtins, 'input', lambda x: 'n')
     utils.drop()
 
-    assert r.db_list().contains(dbname).run(conn) == True
+    assert r.db_list().contains(dbname).run(conn) is True
 
 def test_drop_non_existent_db_raises_an_error():
     conn = utils.get_conn()
     dbname = bigchaindb.config['database']['name']
 
     # The db is set up by fixtures
-    assert r.db_list().contains(dbname).run(conn) == True
+    assert r.db_list().contains(dbname).run(conn) is True
     utils.drop(assume_yes=True)
 
     with pytest.raises(bigchaindb.exceptions.DatabaseDoesNotExist):
diff --git a/tests/db/test_voter.py b/tests/db/test_voter.py
index 26c2bac0..550c5da9 100644
--- a/tests/db/test_voter.py
+++ b/tests/db/test_voter.py
@@ -42,10 +42,10 @@ class TestBigchainVoter(object):
 
         assert vote['vote']['voting_for_block'] == block['id']
         assert vote['vote']['previous_block'] == genesis['id']
-        assert vote['vote']['is_block_valid'] == True
-        assert vote['vote']['invalid_reason'] == None
+        assert vote['vote']['is_block_valid'] is True
+        assert vote['vote']['invalid_reason'] is None
         assert vote['node_pubkey'] == b.me
-        assert PublicKey(b.me).verify(b.serialize(vote['vote']), vote['signature']) == True
+        assert PublicKey(b.me).verify(b.serialize(vote['vote']), vote['signature']) is True
 
 
     def test_invalid_block_voting(self, b, user_public_key):
@@ -83,10 +83,10 @@ class TestBigchainVoter(object):
 
         assert vote['vote']['voting_for_block'] == block['id']
         assert vote['vote']['previous_block'] == genesis['id']
-        assert vote['vote']['is_block_valid'] == False
-        assert vote['vote']['invalid_reason'] == None
+        assert vote['vote']['is_block_valid'] is False
+        assert vote['vote']['invalid_reason'] is None
         assert vote['node_pubkey'] == b.me
-        assert PublicKey(b.me).verify(b.serialize(vote['vote']), vote['signature']) == True
+        assert PublicKey(b.me).verify(b.serialize(vote['vote']), vote['signature']) is True
 
     def test_vote_creation_valid(self, b):
         # create valid block
@@ -97,10 +97,10 @@ class TestBigchainVoter(object):
         # assert vote is correct
         assert vote['vote']['voting_for_block'] == block['id']
         assert vote['vote']['previous_block'] == 'abc'
-        assert vote['vote']['is_block_valid'] == True
-        assert vote['vote']['invalid_reason'] == None
+        assert vote['vote']['is_block_valid'] is True
+        assert vote['vote']['invalid_reason'] is None
         assert vote['node_pubkey'] == b.me
-        assert PublicKey(b.me).verify(b.serialize(vote['vote']), vote['signature']) == True
+        assert PublicKey(b.me).verify(b.serialize(vote['vote']), vote['signature']) is True
 
     def test_vote_creation_invalid(self, b):
         # create valid block
@@ -111,10 +111,10 @@ class TestBigchainVoter(object):
         # assert vote is correct
         assert vote['vote']['voting_for_block'] == block['id']
         assert vote['vote']['previous_block'] == 'abc'
-        assert vote['vote']['is_block_valid'] == False
-        assert vote['vote']['invalid_reason'] == None
+        assert vote['vote']['is_block_valid'] is False
+        assert vote['vote']['invalid_reason'] is None
         assert vote['node_pubkey'] == b.me
-        assert PublicKey(b.me).verify(b.serialize(vote['vote']), vote['signature']) == True
+        assert PublicKey(b.me).verify(b.serialize(vote['vote']), vote['signature']) is True
 
     def test_voter_considers_unvoted_blocks_when_single_node(self, b):
         # simulate a voter going donw in a single node environment
diff --git a/tests/utils/test_config_utils.py b/tests/utils/test_config_utils.py
index 54c425b4..b95db9aa 100644
--- a/tests/utils/test_config_utils.py
+++ b/tests/utils/test_config_utils.py
@@ -19,7 +19,7 @@ def test_bigchain_instance_is_initialized_when_conf_provided():
 
     config_utils.dict_config({'keypair': {'public': 'a', 'private': 'b'}})
 
-    assert bigchaindb.config['CONFIGURED'] == True
+    assert bigchaindb.config['CONFIGURED'] is True
     b = bigchaindb.Bigchain()
 
     assert b.me