diff --git a/tests/module/blueprints/search/test_controllers.py b/tests/module/blueprints/search/test_controllers.py
@@ -1,4 +1,4 @@
-import time
+import os
 import unittest
 from importlib import import_module
 from elasticsearch import Elasticsearch, NotFoundError
@@ -9,6 +9,9 @@

 module = import_module('conductor.blueprints.search.controllers')

+PACKAGES_INDEX_NAME = os.environ.get('OS_ES_PACKAGES_INDEX_NAME',
+                                     'test_packages')
+

 class SearchTest(unittest.TestCase):

@@ -19,13 +22,14 @@ def setUp(self):
        # Clean index
        self.es = Elasticsearch(hosts=[LOCAL_ELASTICSEARCH])
        try:
-            self.es.indices.delete(index='packages')
+            self.es.indices.delete(index=PACKAGES_INDEX_NAME)
        except NotFoundError:
            pass
-        self.pr = PackageRegistry(es_instance=self.es)
+        self.pr = PackageRegistry(es_instance=self.es,
+                                  index_name=PACKAGES_INDEX_NAME)

    def indexSomeRecords(self, amount):
-        self.es.indices.delete(index='packages')
+        self.es.indices.delete(index=PACKAGES_INDEX_NAME)
        for i in range(amount):
            body = {
                'id': True,
@@ -35,8 +39,8 @@ def indexSomeRecords(self, amount):
                    'name': 'innername'
                }
            }
-            self.es.index('packages', 'package', body)
-        self.es.indices.flush('packages')
+            self.es.index(PACKAGES_INDEX_NAME, 'package', body)
+        self.es.indices.flush(PACKAGES_INDEX_NAME)

    def indexSomeRecordsToTestMapping(self):
        for i in range(3):
@@ -49,29 +53,39 @@ def indexSomeRecordsToTestMapping(self):

    def indexSomeRealLookingRecords(self, amount):
        for i in range(amount):
-            self.pr.save_model('package-id-%d' % i,
-                               '', {
-                                   'author': 'The one and only author number%d' % (i+1),
-                                   'title': 'This dataset is number%d' % i
-                               }, {}, {},
-                               'The one and only author number%d' % (i+1), '', True)
+            self.pr.save_model(
+                'package-id-%d' % i,
+                '',
+                {
+                    'author': 'The one and only author number%d' % (i+1),
+                    'title': 'This dataset is number%d' % i
+                },
+                {},
+                {},
+                'The one and only author number%d' % (i+1), '', True)

    def indexSomePrivateRecords(self):
        i = 0
        for owner in ['owner1', 'owner2']:
            for private in [True, False]:
                for loaded in [True, False]:
                    for content in ['cat', 'dog']:
-                        self.pr.save_model('%s-%s-%s-%s' % (owner, private, loaded, content),
-                                           '', {
-                                               'author': 'The one and only author number%d' % (i+1),
-                                               'title': 'This dataset is number%d, content is %s' % (i, content),
-                                               'owner': owner,
-                                               'private': private
-                                           }, {}, {},
-                                           'The one and only author number%d' % (i+1), '', loaded)
+                        self.pr.save_model(
+                            '%s-%s-%s-%s' % (owner, private, loaded, content),
+                            '',
+                            {
+                                'author': 'The one and only author number%d' %
+                                (i+1),
+                                'title':
+                                    'This dataset is number%d, content is %s' %
+                                (i, content),
+                                'owner': owner,
+                                'private': private
+                            }, {}, {},
+                            'The one and only author number%d' % (i+1), '',
+                            loaded)
                        i += 1
-        self.es.indices.flush('packages')
+        self.es.indices.flush(PACKAGES_INDEX_NAME)

    # Tests
    def test___search___all_values_and_empty(self):
@@ -87,47 +101,66 @@ def test___search___all_values_and_two_results(self):

    def test___search___filter_simple_property(self):
        self.indexSomeRecords(10)
-        self.assertEquals(len(module.search('package', None, {'model': ['"str7"']})), 1)
+        self.assertEquals(
+            len(module.search('package', None, {'model': ['"str7"']})), 1)

    def test___search___filter_numeric_property(self):
        self.indexSomeRecords(10)
-        self.assertEquals(len(module.search('package', None, {'package': ["7"]})), 1)
+        self.assertEquals(
+            len(module.search('package', None, {'package': ["7"]})), 1)

    def test___search___filter_boolean_property(self):
        self.indexSomeRecords(10)
-        self.assertEquals(len(module.search('package', None, {'id': ["true"]})), 10)
+        self.assertEquals(
+            len(module.search('package', None, {'id': ["true"]})), 10)

    def test___search___filter_multiple_properties(self):
        self.indexSomeRecords(10)
-        self.assertEquals(len(module.search('package', None, {'model': ['"str6"'], 'package': ["6"]})), 1)
+        self.assertEquals(
+            len(module.search(
+                'package', None, {'model': ['"str6"'], 'package': ["6"]})), 1)

    def test___search___filter_multiple_values_for_property(self):
        self.indexSomeRecords(10)
-        self.assertEquals(len(module.search('package', None, {'model': ['"str6"','"str7"']})), 2)
+        self.assertEquals(
+            len(module.search(
+                'package', None, {'model': ['"str6"', '"str7"']})), 2)

    def test___search___filter_inner_property(self):
        self.indexSomeRecords(7)
-        self.assertEquals(len(module.search('package', None, {"origin_url.name": ['"innername"']})), 7)
+        self.assertEquals(
+            len(module.search(
+                'package', None, {"origin_url.name": ['"innername"']})), 7)

    def test___search___filter_no_results(self):
-        self.assertEquals(len(module.search('package', None, {'model': ['"str6"'], 'package': ["7"]})), 0)
+        self.assertEquals(
+            len(module.search(
+                'package', None, {'model': ['"str6"'], 'package': ["7"]})), 0)

    def test___search___filter_bad_value(self):
-        self.assertEquals(module.search('package', None, {'model': ['str6'], 'package': ["6"]}), None)
+        self.assertEquals(
+            module.search(
+                'package', None, {'model': ['str6'], 'package': ["6"]}), None)

    def test___search___filter_nonexistent_kind(self):
-        self.assertEquals(module.search('box', None, {'model': ['str6'], 'package': ["6"]}), None)
+        self.assertEquals(
+            module.search(
+                'box', None, {'model': ['str6'], 'package': ["6"]}), None)

    def test___search___filter_nonexistent_property(self):
-        self.assertEquals(module.search('box', None, {'model': ['str6'], 'boxing': ["6"]}), None)
+        self.assertEquals(
+            module.search(
+                'box', None, {'model': ['str6'], 'boxing': ["6"]}), None)

    def test___search___q_param_no_recs_no_results(self):
        self.indexSomeRealLookingRecords(0)
-        self.assertEquals(len(module.search('package', None, {'q': ['"author"']})), 0)
+        self.assertEquals(
+            len(module.search('package', None, {'q': ['"author"']})), 0)

    def test___search___q_param_some_recs_no_results(self):
        self.indexSomeRealLookingRecords(2)
-        self.assertEquals(len(module.search('package', None, {'q': ['"writer"']})), 0)
+        self.assertEquals(
+            len(module.search('package', None, {'q': ['"writer"']})), 0)

    def test___search___q_param_some_recs_some_results(self):
        self.indexSomeRealLookingRecords(2)
@@ -178,7 +211,8 @@ def test___search___q_param_anonymous_search(self):

    def test___search___q_param_anonymous_search_with_param(self):
        self.indexSomePrivateRecords()
-        recs = module.search('package', None, {'q': ['"cat"'], 'package.owner': ['"owner1"']})
+        recs = module.search(
+            'package', None, {'q': ['"cat"'], 'package.owner': ['"owner1"']})
        self.assertEquals(len(recs), 1)
        ids = set([r['id'] for r in recs])
        self.assertSetEqual(ids, {'owner1-False-True-cat'})
@@ -202,12 +236,15 @@ def test___search___q_param_with_similar_param(self):
        self.assertSetEqual(ids, {'package-id-2'})
        self.assertEquals(len(recs), 1)

-        recs = module.search('package', None, {'q': ['"dataset"'], 'package.author': ['"BlaBla2@test2.com"']})
+        recs = module.search(
+            'package', None,
+            {'q': ['"dataset"'], 'package.author': ['"BlaBla2@test2.com"']})
        ids = set([r['id'] for r in recs])
        self.assertSetEqual(ids, {'package-id-2'})
        self.assertEquals(len(recs), 1)

-        recs = module.search('package', None, {'package.author': ['"BlaBla2@test2.com"']})
+        recs = module.search(
+            'package', None, {'package.author': ['"BlaBla2@test2.com"']})
        ids = set([r['id'] for r in recs])
        self.assertSetEqual(ids, {'package-id-2'})
        self.assertEquals(len(recs), 1)
diff --git a/tests/module/blueprints/user/test_permission_controllers.py b/tests/module/blueprints/user/test_permission_controllers.py
@@ -20,15 +20,15 @@ def setUp(self):
        # Cleanup
        self.addCleanup(patch.stopall)

-        goog_provider = namedtuple("resp",['headers'])({'Location':'google'})
+        goog_provider = namedtuple("resp", ['headers'])({'Location': 'google'})
        oauth_response = {
            'access_token': 'access_token'
        }
        module.google_remote_app = Mock(
            return_value=namedtuple('google_remote_app',
                                    ['authorize', 'authorized_response'])
-            (authorize=lambda **kwargs:goog_provider,
-             authorized_response=lambda **kwargs:oauth_response)
+            (authorize=lambda **kwargs: goog_provider,
+             authorized_response=lambda **kwargs: oauth_response)
        )

    # Tests
@@ -52,4 +52,4 @@ def test___check___good_token(self):
        client_token = jwt.encode(token, module.PRIVATE_KEY)
        ret = module.authorize(client_token, 'os.datastore')
        self.assertEquals(ret.get('service'), 'os.datastore')
-        self.assertGreater(len(ret.get('permissions',{})), 0)
+        self.assertGreater(len(ret.get('permissions', {})), 0)
diff --git a/tests/module/blueprints/user/test_user_controllers.py b/tests/module/blueprints/user/test_user_controllers.py
@@ -1,5 +1,5 @@
+import os
 import unittest
-
 import time
 import jwt
 import datetime
@@ -18,6 +18,9 @@

 models = import_module('conductor.blueprints.user.models')

+USERS_INDEX_NAME = os.environ.get('OS_ES_USERS_INDEX_NAME', 'test_users')
+
+
 class UserAdminTest(unittest.TestCase):

    USERID = 'uusseerriidd'
@@ -36,29 +39,33 @@ def setUp(self):
        # Clean index
        self.es = Elasticsearch(hosts=[LOCAL_ELASTICSEARCH])
        try:
-            self.es.indices.delete(index='users')
+            self.es.indices.delete(index=USERS_INDEX_NAME)
        except NotFoundError:
            pass
-        self.es.indices.create('users')
+        self.es.indices.create(USERS_INDEX_NAME)
        time.sleep(1)

    def test___create_user___success(self):
-        user = models.create_or_get_user(self.USERID, self.NAME, self.EMAIL, self.AVATAR_URL)
+        user = models.create_or_get_user(self.USERID, self.NAME, self.EMAIL,
+                                         self.AVATAR_URL)
        self.assertEquals(user['id'], self.USERID)
        self.assertEquals(user['name'], self.NAME)
        self.assertEquals(user['email'], self.EMAIL)
        self.assertEquals(user['avatar_url'], self.AVATAR_URL)

    def test___create__existing_user___success(self):
-        models.create_or_get_user(self.USERID, self.NAME, self.EMAIL, self.AVATAR_URL)
-        user = models.create_or_get_user(self.USERID, self.NAME, self.EMAIL, self.AVATAR_URL)
+        models.create_or_get_user(self.USERID, self.NAME, self.EMAIL,
+                                  self.AVATAR_URL)
+        user = models.create_or_get_user(self.USERID, self.NAME, self.EMAIL,
+                                         self.AVATAR_URL)
        self.assertEquals(user['id'], self.USERID)
        self.assertEquals(user['name'], self.NAME)
        self.assertEquals(user['email'], self.EMAIL)
        self.assertEquals(user['avatar_url'], self.AVATAR_URL)

    def test___get__existing_user___success(self):
-        models.create_or_get_user(self.USERID, self.NAME, self.EMAIL, self.AVATAR_URL)
+        models.create_or_get_user(self.USERID, self.NAME, self.EMAIL,
+                                  self.AVATAR_URL)
        hash = models.hash_email(self.EMAIL)
        user = models.get_user(hash)
        self.assertEquals(user['id'], self.USERID)
@@ -72,7 +79,8 @@ def test___get__nonexisting_user___success(self):
        self.assertIs(user, None)

    def test___save__existing_user___success(self):
-        user2 = models.create_or_get_user(self.USERID, self.NAME, self.EMAIL, self.AVATAR_URL)
+        user2 = models.create_or_get_user(self.USERID, self.NAME, self.EMAIL,
+                                          self.AVATAR_URL)
        user2['email'] += 'X'
        models. save_user(user2)
        hash = models.hash_email(self.EMAIL)
@@ -105,7 +113,8 @@ def test___update___no_such_user(self):
        self.assertEquals(ret.get('error'), 'Unknown User')

    def test___update___new_user(self):
-        models.create_or_get_user(self.USERID, self.NAME, self.EMAIL, self.AVATAR_URL)
+        models.create_or_get_user(self.USERID, self.NAME, self.EMAIL,
+                                  self.AVATAR_URL)
        hash = models.hash_email(self.EMAIL)
        token = {
            'userid': hash,
@@ -119,9 +128,9 @@ def test___update___new_user(self):
        user = models.get_user(hash)
        self.assertEquals(user['username'], 'new_username')

-
    def test___update___double_update(self):
-        models.create_or_get_user(self.USERID, self.NAME, self.EMAIL, self.AVATAR_URL)
+        models.create_or_get_user(self.USERID, self.NAME, self.EMAIL,
+                                  self.AVATAR_URL)
        hash = models.hash_email(self.EMAIL)
        token = {
            'userid': hash,
@@ -134,7 +143,8 @@ def test___update___double_update(self):
        self.assertEquals(ret.get('error'), None)
        ret = self.ctrl.update(client_token, 'new_username_@')
        self.assertFalse(ret.get('success'))
-        self.assertEquals(ret.get('error'), 'Cannot modify username, already set')
+        self.assertEquals(ret.get('error'),
+                          'Cannot modify username, already set')
        user = models.get_user(hash)
        self.assertEquals(user['username'], 'new_username')

@@ -155,21 +165,23 @@ def setUp(self):
        # Cleanup
        self.addCleanup(patch.stopall)

-        self.goog_provider = namedtuple("resp",['headers'])({'Location':'google'})
+        self.goog_provider = \
+            namedtuple("resp", ['headers'])({'Location': 'google'})
        self.oauth_response = {
            'access_token': 'access_token'
        }
        self.ctrl._google_remote_app = Mock(
            return_value=namedtuple('_google_remote_app',
-                                    ['authorize', 'authorized_response', 'name'])
+                                    ['authorize',
+                                     'authorized_response', 'name'])
            (authorize=lambda **kwargs: self.goog_provider,
             authorized_response=lambda **kwargs: self.oauth_response,
             name='google')
        )
        self.ctrl.get_user = Mock(
            return_value=namedtuple('User',
-                                    ['name','email','avatar_url'])
-            ('moshe','email@moshe.com','http://google.com')
+                                    ['name', 'email', 'avatar_url'])
+            ('moshe', 'email@moshe.com', 'http://google.com')
        )
        self.ctrl._get_user_profile = Mock(
            return_value={
@@ -186,12 +198,12 @@ def setUp(self):
    def test___check___no_jwt(self):
        ret = self.ctrl.authenticate(None, 'next', 'callback')
        self.assertFalse(ret.get('authenticated'))
-        self.assertIsNotNone(ret.get('providers',{}).get('google'))
+        self.assertIsNotNone(ret.get('providers', {}).get('google'))

    def test___check___bad_jwt(self):
        ret = self.ctrl.authenticate('bla', 'next', 'callback')
        self.assertFalse(ret.get('authenticated'))
-        self.assertIsNotNone(ret.get('providers',{}).get('google'))
+        self.assertIsNotNone(ret.get('providers', {}).get('google'))

    def test___check___good_jwt_no_such_user(self):
        self.ctrl.get_user = Mock(
@@ -205,7 +217,7 @@ def test___check___good_jwt_no_such_user(self):
        client_token = jwt.encode(token, self.private_key)
        ret = self.ctrl.authenticate(client_token, 'next', 'callback')
        self.assertFalse(ret.get('authenticated'))
-        self.assertIsNotNone(ret.get('providers',{}).get('google'))
+        self.assertIsNotNone(ret.get('providers', {}).get('google'))

    def test___check___expired_jwt(self):
        token = {
@@ -216,7 +228,7 @@ def test___check___expired_jwt(self):
        client_token = jwt.encode(token, self.private_key)
        ret = self.ctrl.authenticate(client_token, 'next', 'callback')
        self.assertFalse(ret.get('authenticated'))
-        self.assertIsNotNone(ret.get('providers',{}).get('google'))
+        self.assertIsNotNone(ret.get('providers', {}).get('google'))

    def test___check___good_jwt(self):
        token = {
@@ -228,9 +240,9 @@ def test___check___good_jwt(self):
        ret = self.ctrl.authenticate(client_token, 'next', 'callback')
        self.assertTrue(ret.get('authenticated'))
        self.assertIsNotNone(ret.get('profile'))
-        self.assertEquals(ret['profile'].email,'email@moshe.com')
-        self.assertEquals(ret['profile'].avatar_url,'http://google.com')
-        self.assertEquals(ret['profile'].name,'moshe')
+        self.assertEquals(ret['profile'].email, 'email@moshe.com')
+        self.assertEquals(ret['profile'].avatar_url, 'http://google.com')
+        self.assertEquals(ret['profile'].name, 'moshe')

    def test___callback___good_response(self):
        token = {
@@ -271,4 +283,3 @@ def test___callback___bad_response(self):
    def test___callback___bad_state(self):
        ret = self.ctrl.oauth_callback("das", 'callback')
        self.assertFalse('jwt' in ret)
-
diff --git a/tox.ini b/tox.ini
@@ -4,7 +4,9 @@ envlist =

 [testenv]
 setenv =
-  OS_CONDUCTOR_ENGINE=postgresql://postgres@/postgres
+  OS_ES_USERS_INDEX_NAME=test_users
+  OS_ES_PACKAGES_INDEX_NAME=test_packages
+  OS_CONDUCTOR_ENGINE=postgresql://postgres@localhost/postgres
  OS_ELASTICSEARCH_ADDRESS=localhost:9200
  OS_ACCESS_KEY_ID=access_key
  OS_SECRET_ACCESS_KEY=secret_key