diff --git a/osm_mon/test/OpenStack/test_alarm_req.py b/osm_mon/test/OpenStack/test_alarm_req.py
index 2303506..023b31a 100644
--- a/osm_mon/test/OpenStack/test_alarm_req.py
+++ b/osm_mon/test/OpenStack/test_alarm_req.py
@@ -4,14 +4,14 @@
 # This file is part of OSM Monitoring module
 # All Rights Reserved to Intel Corporation
 
-# Licensed under the Apache License, Version 2.0 (the "License"); you may
+# Licensed under the Apache License, Version 2.0 (the 'License'); you may
 # not use this file except in compliance with the License. You may obtain
 # a copy of the License at
 
 #         http://www.apache.org/licenses/LICENSE-2.0
 
 # Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
+# distributed under the License is distributed on an 'AS IS' BASIS, WITHOUT
 # WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
 # License for the specific language governing permissions and limitations
 # under the License.
@@ -40,9 +40,9 @@
 
     def __init__(self):
         """Initialize a mocked message instance."""
-        self.topic = "alarm_request"
+        self.topic = 'alarm_request'
         self.key = None
-        self.value = json.dumps({"mock_value": "mock_details"})
+        self.value = json.dumps({'vim_uuid': 'test_id', 'mock_value': 'mock_details'})
 
 
 class TestAlarmKeys(unittest.TestCase):
@@ -54,74 +54,75 @@
         self.alarming = alarm_req.Alarming()
         self.alarming.common = Common()
 
-    @mock.patch.object(Common, "_authenticate")
-    def test_alarming_env_authentication(self, auth):
+    @mock.patch.object(Common, 'get_endpoint')
+    @mock.patch.object(Common, 'get_auth_token')
+    def test_alarming_authentication(self, get_token, get_endpoint):
         """Test getting an auth_token and endpoint for alarm requests."""
-        # if auth_token is None environment variables are used to authenticare
+        # if auth_token is None environment variables are used to authenticate
         message = Message()
 
-        self.alarming.alarming(message, self.alarming.common, None)
+        self.alarming.alarming(message)
 
-        auth.assert_called_with()
+        get_token.assert_called_with('test_id')
+        get_endpoint.assert_any_call('alarming', 'test_id')
 
-    @mock.patch.object(Common, "_authenticate")
-    def test_acccess_cred_auth(self, auth):
-        """Test receiving auth_token from access creds."""
-        message = Message()
-
-        self.alarming.alarming(message, self.alarming.common, "my_auth_token")
-
-        auth.assert_not_called
-        self.assertEqual(self.alarming.auth_token, "my_auth_token")
-
-    @mock.patch.object(alarm_req.Alarming, "delete_alarm")
+    @mock.patch.object(Common, 'get_endpoint', mock.Mock())
+    @mock.patch.object(Common, 'get_auth_token', mock.Mock())
+    @mock.patch.object(alarm_req.Alarming, 'delete_alarm')
     def test_delete_alarm_key(self, del_alarm):
         """Test the functionality for a create alarm request."""
         # Mock a message value and key
         message = Message()
-        message.key = "delete_alarm_request"
-        message.value = json.dumps({"alarm_delete_request":
-                                   {"alarm_uuid": "my_alarm_id"}})
+        message.key = 'delete_alarm_request'
+        message.value = json.dumps({'vim_uuid': 'test_id',
+                                    'alarm_delete_request':
+                                        {'alarm_uuid': 'my_alarm_id'}})
 
         # Call the alarming functionality and check delete request
-        self.alarming.alarming(message, self.alarming.common, "my_auth_token")
+        self.alarming.alarming(message)
+        del_alarm.assert_called_with(mock.ANY, mock.ANY, 'my_alarm_id')
 
-        del_alarm.assert_called_with(mock.ANY, mock.ANY, "my_alarm_id")
-
-    @mock.patch.object(alarm_req.Alarming, "list_alarms")
+    @mock.patch.object(Common, 'get_endpoint', mock.Mock())
+    @mock.patch.object(Common, 'get_auth_token', mock.Mock())
+    @mock.patch.object(alarm_req.Alarming, 'list_alarms')
     def test_list_alarm_key(self, list_alarm):
         """Test the functionality for a list alarm request."""
         # Mock a message with list alarm key and value
         message = Message()
-        message.key = "list_alarm_request"
-        message.value = json.dumps({"alarm_list_request": "my_alarm_details"})
+        message.key = 'list_alarm_request'
+        message.value = json.dumps({'vim_uuid': 'test_id', 'alarm_list_request': 'my_alarm_details'})
 
         # Call the alarming functionality and check list functionality
-        self.alarming.alarming(message, self.alarming.common, "my_auth_token")
-        list_alarm.assert_called_with(mock.ANY, mock.ANY, "my_alarm_details")
+        self.alarming.alarming(message)
+        list_alarm.assert_called_with(mock.ANY, mock.ANY, 'my_alarm_details')
 
-    @mock.patch.object(alarm_req.Alarming, "update_alarm_state")
+    @mock.patch.object(Common, 'get_auth_token', mock.Mock())
+    @mock.patch.object(Common, 'get_endpoint', mock.Mock())
+    @mock.patch.object(alarm_req.Alarming, 'update_alarm_state')
     def test_ack_alarm_key(self, ack_alarm):
         """Test the functionality for an acknowledge alarm request."""
         # Mock a message with acknowledge alarm key and value
         message = Message()
-        message.key = "acknowledge_alarm"
-        message.value = json.dumps({"ack_details":
-                                    {"alarm_uuid": "my_alarm_id"}})
+        message.key = 'acknowledge_alarm'
+        message.value = json.dumps({'vim_uuid': 'test_id',
+                                    'ack_details':
+                                        {'alarm_uuid': 'my_alarm_id'}})
 
         # Call alarming functionality and check acknowledge functionality
-        self.alarming.alarming(message, self.alarming.common, "my_auth_token")
-        ack_alarm.assert_called_with(mock.ANY, mock.ANY, "my_alarm_id")
+        self.alarming.alarming(message)
+        ack_alarm.assert_called_with(mock.ANY, mock.ANY, 'my_alarm_id')
 
-    @mock.patch.object(alarm_req.Alarming, "configure_alarm")
+    @mock.patch.object(Common, 'get_auth_token', mock.Mock())
+    @mock.patch.object(Common, 'get_endpoint', mock.Mock())
+    @mock.patch.object(alarm_req.Alarming, 'configure_alarm')
     def test_config_alarm_key(self, config_alarm):
         """Test the functionality for a create alarm request."""
         # Mock a message with config alarm key and value
         message = Message()
-        message.key = "create_alarm_request"
-        message.value = json.dumps({"alarm_create_request": "alarm_details"})
+        message.key = 'create_alarm_request'
+        message.value = json.dumps({'vim_uuid': 'test_id', 'alarm_create_request': 'alarm_details'})
 
         # Call alarming functionality and check config alarm call
-        config_alarm.return_value = "my_alarm_id", True
-        self.alarming.alarming(message, self.alarming.common, "my_auth_token")
-        config_alarm.assert_called_with(mock.ANY, mock.ANY, "alarm_details")
+        config_alarm.return_value = 'my_alarm_id', True
+        self.alarming.alarming(message)
+        config_alarm.assert_called_with(mock.ANY, mock.ANY, mock.ANY, 'alarm_details')
diff --git a/osm_mon/test/OpenStack/test_alarming.py b/osm_mon/test/OpenStack/test_alarming.py
index effd920..598ef2b 100644
--- a/osm_mon/test/OpenStack/test_alarming.py
+++ b/osm_mon/test/OpenStack/test_alarming.py
@@ -22,20 +22,20 @@
 """Tests for all alarm request message keys."""
 
 import json
-
 import logging
-
 import unittest
 
 import mock
 
 from osm_mon.plugins.OpenStack.Aodh import alarming as alarm_req
 from osm_mon.plugins.OpenStack.common import Common
+from osm_mon.plugins.OpenStack.settings import Config
 
 log = logging.getLogger(__name__)
 
 auth_token = mock.ANY
-endpoint = mock.ANY
+alarm_endpoint = "alarm_endpoint"
+metric_endpoint = "metric_endpoint"
 
 
 class Response(object):
@@ -56,19 +56,18 @@
         """Setup for tests."""
         super(TestAlarming, self).setUp()
         self.alarming = alarm_req.Alarming()
-        self.alarming.common = Common()
 
     @mock.patch.object(alarm_req.Alarming, "check_payload")
     @mock.patch.object(alarm_req.Alarming, "check_for_metric")
-    @mock.patch.object(Common, "_perform_request")
+    @mock.patch.object(Common, "perform_request")
     def test_config_invalid_alarm_req(self, perf_req, check_metric, check_pay):
         """Test configure an invalid alarm request."""
         # Configuring with invalid alarm name results in failure
         values = {"alarm_name": "my_alarm",
                   "metric_name": "my_metric",
                   "resource_uuid": "my_r_id"}
-        self.alarming.configure_alarm(endpoint, auth_token, values)
-        perf_req.assert_not_called
+        self.alarming.configure_alarm(alarm_endpoint, metric_endpoint, auth_token, values)
+        perf_req.assert_not_called()
         perf_req.reset_mock()
 
         # Correct alarm_name will check for metric in Gnocchi
@@ -79,12 +78,12 @@
 
         check_metric.return_value = None
 
-        self.alarming.configure_alarm(endpoint, auth_token, values)
-        perf_req.assert_not_called
+        self.alarming.configure_alarm(alarm_endpoint, metric_endpoint, auth_token, values)
+        perf_req.assert_not_called()
 
     @mock.patch.object(alarm_req.Alarming, "check_payload")
     @mock.patch.object(alarm_req.Alarming, "check_for_metric")
-    @mock.patch.object(Common, "_perform_request")
+    @mock.patch.object(Common, "perform_request")
     def test_config_valid_alarm_req(self, perf_req, check_metric, check_pay):
         """Test config a valid alarm."""
         # Correct alarm_name will check for metric in Gnocchi
@@ -96,70 +95,70 @@
         check_metric.return_value = "my_metric_id"
         check_pay.return_value = "my_payload"
 
-        self.alarming.configure_alarm(endpoint, auth_token, values)
+        self.alarming.configure_alarm(alarm_endpoint, metric_endpoint, auth_token, values)
         perf_req.assert_called_with(
-            "<ANY>/v2/alarms/", auth_token,
+            "alarm_endpoint/v2/alarms/", auth_token,
             req_type="post", payload="my_payload")
 
-    @mock.patch.object(Common, "_perform_request")
+    @mock.patch.object(Common, "perform_request")
     def test_delete_alarm_req(self, perf_req):
         """Test delete alarm request."""
-        self.alarming.delete_alarm(endpoint, auth_token, "my_alarm_id")
+        self.alarming.delete_alarm(alarm_endpoint, auth_token, "my_alarm_id")
 
         perf_req.assert_called_with(
-            "<ANY>/v2/alarms/my_alarm_id", auth_token, req_type="delete")
+            "alarm_endpoint/v2/alarms/my_alarm_id", auth_token, req_type="delete")
 
-    @mock.patch.object(Common, "_perform_request")
+    @mock.patch.object(Common, "perform_request")
     def test_invalid_list_alarm_req(self, perf_req):
         """Test invalid list alarm_req."""
         # Request will not be performed with out a resoure_id
         list_details = {"mock_details": "invalid_details"}
-        self.alarming.list_alarms(endpoint, auth_token, list_details)
+        self.alarming.list_alarms(alarm_endpoint, auth_token, list_details)
 
-        perf_req.assert_not_called
+        perf_req.assert_not_called()
 
-    @mock.patch.object(Common, "_perform_request")
+    @mock.patch.object(Common, "perform_request")
     def test_valid_list_alarm_req(self, perf_req):
         """Test valid list alarm request."""
         # Minimum requirement for an alarm list is resource_id
         list_details = {"resource_uuid": "mock_r_id"}
-        self.alarming.list_alarms(endpoint, auth_token, list_details)
+        self.alarming.list_alarms(alarm_endpoint, auth_token, list_details)
 
         perf_req.assert_called_with(
-            "<ANY>/v2/alarms/", auth_token, req_type="get")
+            "alarm_endpoint/v2/alarms/", auth_token, req_type="get")
         perf_req.reset_mock()
 
         # Check list with alarm_name defined
         list_details = {"resource_uuid": "mock_r_id",
                         "alarm_name": "my_alarm",
                         "severity": "critical"}
-        self.alarming.list_alarms(endpoint, auth_token, list_details)
+        self.alarming.list_alarms(alarm_endpoint, auth_token, list_details)
 
         perf_req.assert_called_with(
-            "<ANY>/v2/alarms/", auth_token, req_type="get")
+            "alarm_endpoint/v2/alarms/", auth_token, req_type="get")
 
-    @mock.patch.object(Common, "_perform_request")
+    @mock.patch.object(Common, "perform_request")
     def test_ack_alarm_req(self, perf_req):
         """Test update alarm state for acknowledge alarm request."""
-        self.alarming.update_alarm_state(endpoint, auth_token, "my_alarm_id")
+        self.alarming.update_alarm_state(alarm_endpoint, auth_token, "my_alarm_id")
 
         perf_req.assert_called_with(
-            "<ANY>/v2/alarms/my_alarm_id/state", auth_token, req_type="put",
+            "alarm_endpoint/v2/alarms/my_alarm_id/state", auth_token, req_type="put",
             payload=json.dumps("ok"))
 
     @mock.patch.object(alarm_req.Alarming, "check_payload")
-    @mock.patch.object(Common, "_perform_request")
+    @mock.patch.object(Common, "perform_request")
     def test_update_alarm_invalid(self, perf_req, check_pay):
         """Test update alarm with invalid get response."""
         values = {"alarm_uuid": "my_alarm_id"}
 
-        self.alarming.update_alarm(endpoint, auth_token, values)
+        self.alarming.update_alarm(alarm_endpoint, auth_token, values)
 
         perf_req.assert_called_with(mock.ANY, auth_token, req_type="get")
-        check_pay.assert_not_called
+        check_pay.assert_not_called()
 
     @mock.patch.object(alarm_req.Alarming, "check_payload")
-    @mock.patch.object(Common, "_perform_request")
+    @mock.patch.object(Common, "perform_request")
     def test_update_alarm_invalid_payload(self, perf_req, check_pay):
         """Test update alarm with invalid payload."""
         resp = Response({"name": "my_alarm",
@@ -171,35 +170,36 @@
         check_pay.return_value = None
         values = {"alarm_uuid": "my_alarm_id"}
 
-        self.alarming.update_alarm(endpoint, auth_token, values)
+        self.alarming.update_alarm(alarm_endpoint, auth_token, values)
 
         perf_req.assert_called_with(mock.ANY, auth_token, req_type="get")
         self.assertEqual(perf_req.call_count, 1)
 
     @mock.patch.object(alarm_req.Alarming, "check_payload")
-    @mock.patch.object(Common, "_perform_request")
+    @mock.patch.object(Common, "perform_request")
     def test_update_alarm_valid(self, perf_req, check_pay):
         """Test valid update alarm request."""
         resp = Response({"name": "my_alarm",
                          "state": "alarm",
                          "gnocchi_resources_threshold_rule":
                          {"resource_id": "my_resource_id",
-                          "metric": "my_metric"}})
+                          "metric": "disk.write.requests"}})
         perf_req.return_value = resp
         values = {"alarm_uuid": "my_alarm_id"}
 
-        self.alarming.update_alarm(endpoint, auth_token, values)
+        self.alarming.update_alarm(alarm_endpoint, auth_token, values)
 
-        check_pay.assert_called_with(values, "my_metric", "my_resource_id",
+        check_pay.assert_called_with(values, "disk_write_ops", "my_resource_id",
                                      "my_alarm", alarm_state="alarm")
 
         self.assertEqual(perf_req.call_count, 2)
         # Second call is the update request
         perf_req.assert_called_with(
-            '<ANY>/v2/alarms/my_alarm_id', auth_token,
+            'alarm_endpoint/v2/alarms/my_alarm_id', auth_token,
             req_type="put", payload=check_pay.return_value)
 
-    def test_check_valid_payload(self):
+    @mock.patch.object(Config, "instance")
+    def test_check_valid_payload(self, cfg):
         """Test the check payload function for a valid payload."""
         values = {"severity": "warning",
                   "statistic": "COUNT",
@@ -207,6 +207,7 @@
                   "operation": "GT",
                   "granularity": 300,
                   "resource_type": "generic"}
+        cfg.return_value.OS_NOTIFIER_URI = "http://localhost:8662"
         payload = self.alarming.check_payload(
             values, "disk_write_ops", "r_id", "alarm_name")
 
@@ -214,7 +215,7 @@
             json.loads(payload), {"name": "alarm_name",
                                   "gnocchi_resources_threshold_rule":
                                   {"resource_id": "r_id",
-                                   "metric": "disk.disk_ops",
+                                   "metric": "disk.write.requests",
                                    "comparison_operator": "gt",
                                    "aggregation_method": "count",
                                    "threshold": 12,
@@ -225,7 +226,9 @@
                                   "type": "gnocchi_resources_threshold",
                                   "alarm_actions": ["http://localhost:8662"]})
 
-    def test_check_valid_state_payload(self):
+    @mock.patch.object(Config, "instance")
+    @mock.patch.object(Common, "perform_request")
+    def test_check_valid_state_payload(self, perform_req, cfg):
         """Test the check payload function for a valid payload with state."""
         values = {"severity": "warning",
                   "statistic": "COUNT",
@@ -233,6 +236,7 @@
                   "operation": "GT",
                   "granularity": 300,
                   "resource_type": "generic"}
+        cfg.return_value.OS_NOTIFIER_URI = "http://localhost:8662"
         payload = self.alarming.check_payload(
             values, "disk_write_ops", "r_id", "alarm_name", alarm_state="alarm")
 
@@ -240,7 +244,7 @@
             json.loads(payload), {"name": "alarm_name",
                                   "gnocchi_resources_threshold_rule":
                                   {"resource_id": "r_id",
-                                   "metric": "disk.disk_ops",
+                                   "metric": "disk.write.requests",
                                    "comparison_operator": "gt",
                                    "aggregation_method": "count",
                                    "threshold": 12,
@@ -259,21 +263,21 @@
 
         self.assertEqual(payload, None)
 
-    @mock.patch.object(Common, "_perform_request")
+    @mock.patch.object(Common, "perform_request")
     def test_get_alarm_state(self, perf_req):
         """Test the get alarm state function."""
-        self.alarming.get_alarm_state(endpoint, auth_token, "alarm_id")
+        self.alarming.get_alarm_state(alarm_endpoint, auth_token, "alarm_id")
 
         perf_req.assert_called_with(
-            "<ANY>/v2/alarms/alarm_id/state", auth_token, req_type="get")
+            "alarm_endpoint/v2/alarms/alarm_id/state", auth_token, req_type="get")
 
     @mock.patch.object(Common, "get_endpoint")
-    @mock.patch.object(Common, "_perform_request")
+    @mock.patch.object(Common, "perform_request")
     def test_check_for_metric(self, perf_req, get_endpoint):
         """Test the check for metric function."""
         get_endpoint.return_value = "gnocchi_endpoint"
 
-        self.alarming.check_for_metric(auth_token, "metric_name", "r_id")
+        self.alarming.check_for_metric(auth_token, metric_endpoint, "metric_name", "r_id")
 
         perf_req.assert_called_with(
-            "gnocchi_endpoint/v1/metric?sort=name:asc", auth_token, req_type="get")
+            "metric_endpoint/v1/metric?sort=name:asc", auth_token, req_type="get")
diff --git a/osm_mon/test/OpenStack/test_common.py b/osm_mon/test/OpenStack/test_common.py
index 983128b..9853d15 100644
--- a/osm_mon/test/OpenStack/test_common.py
+++ b/osm_mon/test/OpenStack/test_common.py
@@ -31,6 +31,8 @@
 
 import mock
 
+from osm_mon.core.auth import AuthManager
+from osm_mon.core.database import VimCredentials
 from osm_mon.plugins.OpenStack.common import Common
 from osm_mon.plugins.OpenStack.settings import Config
 
@@ -50,10 +52,10 @@
         self.value = json.dumps({"mock_value": "mock_details",
                                  "vim_type": "OPENSTACK",
                                  "access_config":
-                                 {"openstack_site": "my_site",
-                                  "user": "my_user",
-                                  "password": "my_password",
-                                  "vim_tenant_name": "my_tenant"}})
+                                     {"openstack_site": "my_site",
+                                      "user": "my_user",
+                                      "password": "my_password",
+                                      "vim_tenant_name": "my_tenant"}})
 
 
 class TestCommon(unittest.TestCase):
@@ -63,58 +65,28 @@
         """Test Setup."""
         super(TestCommon, self).setUp()
         self.common = Common()
+        self.creds = VimCredentials()
+        self.creds.id = 'test_id'
+        self.creds.user = 'user'
+        self.creds.url = 'url'
+        self.creds.password = 'password'
+        self.creds.tenant_name = 'tenant_name'
 
-    @mock.patch.object(client, "Client")
-    def test_authenticate_exists(self, key_client):
-        """Testing if an authentication token already exists."""
-        # If the auth_token is already generated a new one will not be creates
-        self.common._auth_token = "my_auth_token"
-        token = self.common._authenticate()
-
-        self.assertEqual(token, "my_auth_token")
-
+    @mock.patch.object(AuthManager, "get_credentials")
     @mock.patch.object(Config, "instance")
     @mock.patch.object(client, "Client")
-    def test_authenticate_none(self, key_client, cfg):
+    def test_get_auth_token(self, key_client, cfg, get_creds):
         """Test generating a new authentication token."""
-        # If auth_token doesn't exist one will try to be created with keystone
-        # With the configuration values from the environment
-        self.common._auth_token = None
-        config = cfg.return_value
-        url = config.OS_AUTH_URL
-        user = config.OS_USERNAME
-        pword = config.OS_PASSWORD
-        tenant = config.OS_TENANT_NAME
-
-        self.common._authenticate()
-
-        key_client.assert_called_with(auth_url=url,
-                                      username=user,
-                                      password=pword,
-                                      tenant_name=tenant)
-        key_client.reset_mock()
-
-    @mock.patch.object(client, "Client")
-    def test_authenticate_access_cred(self, key_client):
-        """Test generating an auth_token using access_credentials from SO."""
-        # Mock valid message from SO
-        self.common._auth_token = None
-        message = Message()
-
-        self.common._authenticate(message=message)
-
-        # The class variables are set for each consifugration
-        self.assertEqual(self.common.openstack_url, "my_site")
-        self.assertEqual(self.common.user, "my_user")
-        self.assertEqual(self.common.password, "my_password")
-        self.assertEqual(self.common.tenant, "my_tenant")
-        key_client.assert_called
+        get_creds.return_value = self.creds
+        Common.get_auth_token('test_id')
+        get_creds.assert_called_with('test_id')
+        key_client.assert_called_with(auth_url='url', password='password', tenant_name='tenant_name', username='user')
 
     @mock.patch.object(requests, 'post')
     def test_post_req(self, post):
         """Testing a post request."""
-        self.common._perform_request("url", "auth_token", req_type="post",
-                                     payload="payload")
+        Common.perform_request("url", "auth_token", req_type="post",
+                                    payload="payload")
 
         post.assert_called_with("url", data="payload", headers=mock.ANY,
                                 timeout=mock.ANY)
@@ -123,15 +95,15 @@
     def test_get_req(self, get):
         """Testing a get request."""
         # Run the defualt get request without any parameters
-        self.common._perform_request("url", "auth_token", req_type="get")
+        Common.perform_request("url", "auth_token", req_type="get")
 
         get.assert_called_with("url", params=None, headers=mock.ANY,
                                timeout=mock.ANY)
 
         # Test with some parameters specified
         get.reset_mock()
-        self.common._perform_request("url", "auth_token", req_type="get",
-                                     params="some parameters")
+        Common.perform_request("url", "auth_token", req_type="get",
+                                    params="some parameters")
 
         get.assert_called_with("url", params="some parameters",
                                headers=mock.ANY, timeout=mock.ANY)
@@ -139,14 +111,14 @@
     @mock.patch.object(requests, 'put')
     def test_put_req(self, put):
         """Testing a put request."""
-        self.common._perform_request("url", "auth_token", req_type="put",
-                                     payload="payload")
+        Common.perform_request("url", "auth_token", req_type="put",
+                                    payload="payload")
         put.assert_called_with("url", data="payload", headers=mock.ANY,
                                timeout=mock.ANY)
 
     @mock.patch.object(requests, 'delete')
     def test_delete_req(self, delete):
         """Testing a delete request."""
-        self.common._perform_request("url", "auth_token", req_type="delete")
+        Common.perform_request("url", "auth_token", req_type="delete")
 
         delete.assert_called_with("url", headers=mock.ANY, timeout=mock.ANY)
diff --git a/osm_mon/test/OpenStack/test_metric_calls.py b/osm_mon/test/OpenStack/test_metric_calls.py
index d209f61..b77df5e 100644
--- a/osm_mon/test/OpenStack/test_metric_calls.py
+++ b/osm_mon/test/OpenStack/test_metric_calls.py
@@ -56,6 +56,13 @@
         self.status_code = "STATUS_CODE"
 
 
+def perform_request_side_effect(*args, **kwargs):
+    resp = Response()
+    if 'marker' in args[0]:
+        resp.text = json.dumps([])
+    return resp
+
+
 class TestMetricCalls(unittest.TestCase):
     """Integration test for metric request keys."""
 
@@ -67,7 +74,7 @@
 
     @mock.patch.object(metric_req.Metrics, "get_metric_name")
     @mock.patch.object(metric_req.Metrics, "get_metric_id")
-    @mock.patch.object(Common, "_perform_request")
+    @mock.patch.object(Common, "perform_request")
     def test_invalid_config_metric_req(
             self, perf_req, get_metric, get_metric_name):
         """Test the configure metric function, for an invalid metric."""
@@ -77,7 +84,7 @@
         m_id, r_id, status = self.metrics.configure_metric(
             endpoint, auth_token, values)
 
-        perf_req.assert_not_called
+        perf_req.assert_not_called()
         self.assertEqual(m_id, None)
         self.assertEqual(r_id, None)
         self.assertEqual(status, False)
@@ -89,7 +96,7 @@
         m_id, r_id, status = self.metrics.configure_metric(
             endpoint, auth_token, values)
 
-        perf_req.assert_not_called
+        perf_req.assert_not_called()
         self.assertEqual(m_id, None)
         self.assertEqual(r_id, "r_id")
         self.assertEqual(status, False)
@@ -102,14 +109,14 @@
         m_id, r_id, status = self.metrics.configure_metric(
             endpoint, auth_token, values)
 
-        perf_req.assert_not_called
+        perf_req.assert_not_called()
         self.assertEqual(m_id, "metric_id")
         self.assertEqual(r_id, "r_id")
         self.assertEqual(status, False)
 
     @mock.patch.object(metric_req.Metrics, "get_metric_name")
     @mock.patch.object(metric_req.Metrics, "get_metric_id")
-    @mock.patch.object(Common, "_perform_request")
+    @mock.patch.object(Common, "perform_request")
     def test_valid_config_metric_req(
             self, perf_req, get_metric, get_metric_name):
         """Test the configure metric function, for a valid metric."""
@@ -120,9 +127,9 @@
         get_metric.return_value = None
         payload = {"id": "r_id",
                    "metrics": {"metric_name":
-                               {"archive_policy_name": "high",
-                                "name": "metric_name",
-                                "unit": "units"}}}
+                                   {"archive_policy_name": "high",
+                                    "name": "metric_name",
+                                    "unit": "units"}}}
 
         self.metrics.configure_metric(endpoint, auth_token, values)
 
@@ -130,7 +137,7 @@
             "<ANY>/v1/resource/generic", auth_token, req_type="post",
             payload=json.dumps(payload))
 
-    @mock.patch.object(Common, "_perform_request")
+    @mock.patch.object(Common, "perform_request")
     def test_delete_metric_req(self, perf_req):
         """Test the delete metric function."""
         self.metrics.delete_metric(endpoint, auth_token, "metric_id")
@@ -138,7 +145,7 @@
         perf_req.assert_called_with(
             "<ANY>/v1/metric/metric_id", auth_token, req_type="delete")
 
-    @mock.patch.object(Common, "_perform_request")
+    @mock.patch.object(Common, "perform_request")
     def test_delete_metric_invalid_status(self, perf_req):
         """Test invalid response for delete request."""
         perf_req.return_value = "404"
@@ -148,67 +155,64 @@
         self.assertEqual(status, False)
 
     @mock.patch.object(metric_req.Metrics, "response_list")
-    @mock.patch.object(Common, "_perform_request")
+    @mock.patch.object(Common, "perform_request")
     def test_complete_list_metric_req(self, perf_req, resp_list):
         """Test the complete list metric function."""
         # Test listing metrics without any configuration options
         values = {}
-        resp = Response()
-        perf_req.return_value = resp
+        perf_req.side_effect = perform_request_side_effect
         self.metrics.list_metrics(endpoint, auth_token, values)
 
-        perf_req.assert_called_with(
+        perf_req.assert_any_call(
             "<ANY>/v1/metric?sort=name:asc", auth_token, req_type="get")
         resp_list.assert_called_with([{u'id': u'test_id'}])
 
     @mock.patch.object(metric_req.Metrics, "response_list")
-    @mock.patch.object(Common, "_perform_request")
+    @mock.patch.object(Common, "perform_request")
     def test_resource_list_metric_req(self, perf_req, resp_list):
         """Test the resource list metric function."""
         # Test listing metrics with a resource id specified
         values = {"resource_uuid": "resource_id"}
-        resp = Response()
-        perf_req.return_value = resp
+        perf_req.side_effect = perform_request_side_effect
         self.metrics.list_metrics(endpoint, auth_token, values)
 
-        perf_req.assert_called_with(
+        perf_req.assert_any_call(
             "<ANY>/v1/metric?sort=name:asc", auth_token, req_type="get")
         resp_list.assert_called_with(
             [{u'id': u'test_id'}], resource="resource_id")
 
     @mock.patch.object(metric_req.Metrics, "response_list")
-    @mock.patch.object(Common, "_perform_request")
+    @mock.patch.object(Common, "perform_request")
     def test_name_list_metric_req(self, perf_req, resp_list):
         """Test the metric_name list metric function."""
         # Test listing metrics with a metric_name specified
         values = {"metric_name": "disk_write_bytes"}
-        resp = Response()
-        perf_req.return_value = resp
+        perf_req.side_effect = perform_request_side_effect
         self.metrics.list_metrics(endpoint, auth_token, values)
 
-        perf_req.assert_called_with(
+        perf_req.assert_any_call(
             "<ANY>/v1/metric?sort=name:asc", auth_token, req_type="get")
         resp_list.assert_called_with(
             [{u'id': u'test_id'}], metric_name="disk_write_bytes")
 
     @mock.patch.object(metric_req.Metrics, "response_list")
-    @mock.patch.object(Common, "_perform_request")
+    @mock.patch.object(Common, "perform_request")
     def test_combined_list_metric_req(self, perf_req, resp_list):
         """Test the combined resource and metric list metric function."""
         # Test listing metrics with a resource id and metric name specified
+
         values = {"resource_uuid": "resource_id",
                   "metric_name": "packets_sent"}
-        resp = Response()
-        perf_req.return_value = resp
+        perf_req.side_effect = perform_request_side_effect
         self.metrics.list_metrics(endpoint, auth_token, values)
 
-        perf_req.assert_called_with(
+        perf_req.assert_any_call(
             "<ANY>/v1/metric?sort=name:asc", auth_token, req_type="get")
         resp_list.assert_called_with(
             [{u'id': u'test_id'}], resource="resource_id",
             metric_name="packets_sent")
 
-    @mock.patch.object(Common, "_perform_request")
+    @mock.patch.object(Common, "perform_request")
     def test_get_metric_id(self, perf_req):
         """Test get_metric_id function."""
         self.metrics.get_metric_id(endpoint, auth_token, "my_metric", "r_id")
@@ -234,7 +238,7 @@
         self.assertEqual(metric_name, "my_invalid_metric")
         self.assertEqual(norm_name, None)
 
-    @mock.patch.object(Common, "_perform_request")
+    @mock.patch.object(Common, "perform_request")
     def test_valid_read_data_req(self, perf_req):
         """Test the read metric data function, for a valid call."""
         values = {"metric_uuid": "metric_id",
@@ -243,9 +247,9 @@
 
         self.metrics.read_metric_data(endpoint, auth_token, values)
 
-        perf_req.assert_called_once
+        perf_req.assert_called_once()
 
-    @mock.patch.object(Common, "_perform_request")
+    @mock.patch.object(Common, "perform_request")
     def test_invalid_read_data_req(self, perf_req):
         """Test the read metric data function, for an invalid call."""
         # Teo empty lists wil be returned because the values are invalid
@@ -264,7 +268,7 @@
 
         # Check for the expected values in the resulting list
         for l in result_list:
-            self.assertIn(l, resp_list[0])
+            self.assertIn(l, resp_list[0].values())
 
     def test_name_response_list(self):
         """Test the response list with metric name configured."""
@@ -283,7 +287,7 @@
 
         # Check for the expected values in the resulting list
         for l in result_list:
-            self.assertIn(l, resp_list[0])
+            self.assertIn(l, resp_list[0].values())
 
     def test_resource_response_list(self):
         """Test the response list with resource_id configured."""
@@ -300,12 +304,12 @@
 
         # Check for the expected values in the resulting list
         for l in result_list:
-            self.assertIn(l, resp_list[0])
+            self.assertIn(l, resp_list[0].values())
 
     def test_combined_response_list(self):
         """Test the response list function with resource_id and metric_name."""
         # Test for a combined resource and name list
-        # resource and name are on the lisat
+        # resource and name are on the list
         valid_name = "disk_write_ops"
         valid_id = "r_id"
         resp_list = self.metrics.response_list(
@@ -313,7 +317,7 @@
 
         # Check for the expected values in the resulting list
         for l in result_list:
-            self.assertIn(l, resp_list[0])
+            self.assertIn(l, resp_list[0].values())
 
         # resource not on list
         invalid_id = "mock_resource"
diff --git a/osm_mon/test/OpenStack/test_metric_req.py b/osm_mon/test/OpenStack/test_metric_req.py
index 2a3cbc3..6a924d9 100644
--- a/osm_mon/test/OpenStack/test_metric_req.py
+++ b/osm_mon/test/OpenStack/test_metric_req.py
@@ -43,7 +43,7 @@
         """Initialize a mocked message instance."""
         self.topic = "metric_request"
         self.key = None
-        self.value = json.dumps({"mock_message": "message_details"})
+        self.value = json.dumps({"vim_uuid": "test_id", "mock_message": "message_details"})
 
 
 class TestMetricReq(unittest.TestCase):
@@ -52,53 +52,49 @@
     def setUp(self):
         """Setup the tests for metric request keys."""
         super(TestMetricReq, self).setUp()
-        self.common = Common()
         self.metrics = metric_req.Metrics()
 
-    @mock.patch.object(Common, "_authenticate")
-    def test_access_cred_metric_auth(self, auth):
+    @mock.patch.object(Common, 'get_endpoint')
+    @mock.patch.object(Common, "get_auth_token")
+    def test_access_cred_metric_auth(self, get_token, get_endpoint):
         """Test authentication with access credentials."""
         message = Message()
 
-        self.metrics.metric_calls(message, self.common, "my_auth_token")
+        self.metrics.metric_calls(message)
 
-        auth.assert_not_called
-        self.assertEqual(self.metrics.auth_token, "my_auth_token")
+        get_token.assert_called_with('test_id')
+        get_endpoint.assert_any_call('metric', 'test_id')
 
-    @mock.patch.object(Common, "_authenticate")
-    def test_env_metric_auth(self, auth):
-        """Test authentication with environment variables."""
-        message = Message()
-
-        self.metrics.metric_calls(message, self.common, None)
-
-        auth.assert_called_with()
-
+    @mock.patch.object(Common, "get_auth_token", mock.Mock())
+    @mock.patch.object(Common, 'get_endpoint', mock.Mock())
     @mock.patch.object(metric_req.Metrics, "delete_metric")
     def test_delete_metric_key(self, del_metric):
         """Test the functionality for a delete metric request."""
         # Mock a message value and key
         message = Message()
         message.key = "delete_metric_request"
-        message.value = json.dumps({"metric_uuid": "my_metric_id"})
+        message.value = json.dumps({"vim_uuid": "test_id", "metric_uuid": "my_metric_id"})
 
         # Call the metric functionality and check delete request
-        self.metrics.metric_calls(message, self.common, "my_auth_token")
-
+        self.metrics.metric_calls(message)
         del_metric.assert_called_with(mock.ANY, mock.ANY, "my_metric_id")
 
+    @mock.patch.object(Common, "get_auth_token", mock.Mock())
+    @mock.patch.object(Common, 'get_endpoint', mock.Mock())
     @mock.patch.object(metric_req.Metrics, "list_metrics")
     def test_list_metric_key(self, list_metrics):
         """Test the functionality for a list metric request."""
         # Mock a message with list metric key and value
         message = Message()
         message.key = "list_metric_request"
-        message.value = json.dumps({"metrics_list_request": "metric_details"})
+        message.value = json.dumps({"vim_uuid": "test_id", "metrics_list_request": "metric_details"})
 
         # Call the metric functionality and check list functionality
-        self.metrics.metric_calls(message, self.common, "my_auth_token")
+        self.metrics.metric_calls(message)
         list_metrics.assert_called_with(mock.ANY, mock.ANY, "metric_details")
 
+    @mock.patch.object(Common, "get_auth_token", mock.Mock())
+    @mock.patch.object(Common, 'get_endpoint', mock.Mock())
     @mock.patch.object(metric_req.Metrics, "read_metric_data")
     @mock.patch.object(metric_req.Metrics, "list_metrics")
     @mock.patch.object(metric_req.Metrics, "delete_metric")
@@ -109,41 +105,46 @@
         # Mock a message with update metric key and value
         message = Message()
         message.key = "update_metric_request"
-        message.value = json.dumps({"metric_create":
-                                    {"metric_name": "my_metric",
-                                     "resource_uuid": "my_r_id"}})
+        message.value = json.dumps({"vim_uuid": "test_id",
+                                    "metric_create":
+                                        {"metric_name": "my_metric",
+                                         "resource_uuid": "my_r_id"}})
 
         # Call metric functionality and confirm no function is called
         # Gnocchi does not support updating a metric configuration
-        self.metrics.metric_calls(message, self.common, "my_auth_token")
-        config_metric.assert_not_called
-        list_metrics.assert_not_called
-        delete_metric.assert_not_called
-        read_data.assert_not_called
+        self.metrics.metric_calls(message)
+        config_metric.assert_not_called()
+        list_metrics.assert_not_called()
+        delete_metric.assert_not_called()
+        read_data.assert_not_called()
 
+    @mock.patch.object(Common, "get_auth_token", mock.Mock())
+    @mock.patch.object(Common, 'get_endpoint', mock.Mock())
     @mock.patch.object(metric_req.Metrics, "configure_metric")
     def test_config_metric_key(self, config_metric):
         """Test the functionality for a create metric request."""
         # Mock a message with create metric key and value
         message = Message()
         message.key = "create_metric_request"
-        message.value = json.dumps({"metric_create": "metric_details"})
+        message.value = json.dumps({"vim_uuid": "test_id", "metric_create": "metric_details"})
 
         # Call metric functionality and check config metric
         config_metric.return_value = "metric_id", "resource_id", True
-        self.metrics.metric_calls(message, self.common, "my_auth_token")
+        self.metrics.metric_calls(message)
         config_metric.assert_called_with(mock.ANY, mock.ANY, "metric_details")
 
+    @mock.patch.object(Common, "get_auth_token", mock.Mock())
+    @mock.patch.object(Common, 'get_endpoint', mock.Mock())
     @mock.patch.object(metric_req.Metrics, "read_metric_data")
     def test_read_data_key(self, read_data):
         """Test the functionality for a read metric data request."""
         # Mock a message with a read data key and value
         message = Message()
         message.key = "read_metric_data_request"
-        message.value = json.dumps({"alarm_uuid": "alarm_id"})
+        message.value = json.dumps({"vim_uuid": "test_id", "alarm_uuid": "alarm_id"})
 
         # Call metric functionality and check read data metrics
         read_data.return_value = "time_stamps", "data_values"
-        self.metrics.metric_calls(message, self.common, "my_auth_token")
+        self.metrics.metric_calls(message)
         read_data.assert_called_with(
             mock.ANY, mock.ANY, json.loads(message.value))
diff --git a/osm_mon/test/OpenStack/test_notifier.py b/osm_mon/test/OpenStack/test_notifier.py
index 97b3c2a..81ef2e8 100644
--- a/osm_mon/test/OpenStack/test_notifier.py
+++ b/osm_mon/test/OpenStack/test_notifier.py
@@ -52,7 +52,7 @@
                    {"resource_id": "my_resource_id"}}'
 
 invalid_get_resp = '{"gnocchi_resources_threshold_rule":\
-                     {"resource_id": "None"}}'
+                     {"resource_id": null}}'
 
 valid_notify_resp = '{"notify_details": {"status": "current_state",\
                                          "severity": "critical",\
@@ -117,22 +117,24 @@
     def notify_alarm(self, values):
         """Mock the notify_alarm functionality to generate a valid response."""
         config = Config.instance()
-        config.read_environ("aodh")
+        config.read_environ()
         self._alarming = Alarming()
         self._common = Common()
         self._response = OpenStack_Response()
         self._producer = KafkaProducer('alarm_response')
         alarm_id = values['alarm_id']
 
-        auth_token = self._common._authenticate()
-        endpoint = self._common.get_endpoint("alarming")
+        vim_uuid = 'test_id'
+
+        auth_token = Common.get_auth_token(vim_uuid)
+        endpoint = Common.get_endpoint("alarming", vim_uuid)
 
         # If authenticated generate and send response message
-        if (auth_token is not None and endpoint is not None):
+        if auth_token is not None and endpoint is not None:
             url = "{}/v2/alarms/%s".format(endpoint) % alarm_id
 
             # Get the resource_id of the triggered alarm and the date
-            result = self._common._perform_request(
+            result = Common.perform_request(
                 url, auth_token, req_type="get")
             alarm_details = json.loads(result.text)
             gnocchi_rule = alarm_details['gnocchi_resources_threshold_rule']
@@ -168,7 +170,7 @@
         """Test do_GET, generates headers for get request."""
         self.handler.do_GET()
 
-        set_head.assert_called_once
+        set_head.assert_called_once()
 
     @mock.patch.object(NotifierHandler, "notify_alarm")
     @mock.patch.object(NotifierHandler, "_set_headers")
@@ -176,12 +178,12 @@
         """Test do_POST functionality for a POST request."""
         self.handler.do_POST()
 
-        set_head.assert_called_once
+        set_head.assert_called_once()
         notify.assert_called_with(json.loads(post_data))
 
     @mock.patch.object(Common, "get_endpoint")
-    @mock.patch.object(Common, "_authenticate")
-    @mock.patch.object(Common, "_perform_request")
+    @mock.patch.object(Common, "get_auth_token")
+    @mock.patch.object(Common, "perform_request")
     def test_notify_alarm_unauth(self, perf_req, auth, endpoint):
         """Test notify alarm when not authenticated with keystone."""
         # Response request will not be performed unless there is a valid
@@ -191,26 +193,26 @@
         endpoint.return_value = None
         self.handler.notify_alarm(json.loads(post_data))
 
-        perf_req.assert_not_called
+        perf_req.assert_not_called()
 
         # Valid endpoint
         auth.return_value = None
         endpoint.return_value = "my_endpoint"
         self.handler.notify_alarm(json.loads(post_data))
 
-        perf_req.assert_not_called
+        perf_req.assert_not_called()
 
         # Valid auth_token
         auth.return_value = "my_auth_token"
         endpoint.return_value = None
         self.handler.notify_alarm(json.loads(post_data))
 
-        perf_req.assert_not_called
+        perf_req.assert_not_called()
 
     @mock.patch.object(Common, "get_endpoint")
     @mock.patch.object(OpenStack_Response, "generate_response")
-    @mock.patch.object(Common, "_authenticate")
-    @mock.patch.object(Common, "_perform_request")
+    @mock.patch.object(Common, "get_auth_token")
+    @mock.patch.object(Common, "perform_request")
     def test_notify_alarm_invalid_alarm(self, perf_req, auth, resp, endpoint):
         """Test valid authentication, invalid alarm details."""
         # Mock valid auth_token and endpoint
@@ -221,13 +223,14 @@
         self.handler.notify_alarm(json.loads(post_data))
 
         # Response is not generated
-        resp.assert_not_called
+        resp.assert_not_called()
 
+    @mock.patch.object(KafkaProducer, "notify_alarm")
     @mock.patch.object(Common, "get_endpoint")
     @mock.patch.object(OpenStack_Response, "generate_response")
-    @mock.patch.object(Common, "_authenticate")
-    @mock.patch.object(Common, "_perform_request")
-    def test_notify_alarm_resp_call(self, perf_req, auth, response, endpoint):
+    @mock.patch.object(Common, "get_auth_token")
+    @mock.patch.object(Common, "perform_request")
+    def test_notify_alarm_resp_call(self, perf_req, auth, response, endpoint, notify):
         """Test notify_alarm tries to generate a response for SO."""
         # Mock valid auth token and endpoint, valid response from aodh
         auth.return_value = "my_auth_token"
@@ -235,6 +238,7 @@
         perf_req.return_value = Response(valid_get_resp)
         self.handler.notify_alarm(json.loads(post_data))
 
+        notify.assert_called()
         response.assert_called_with('notify_alarm', a_id="my_alarm_id",
                                     r_id="my_resource_id", sev="critical",
                                     date="dd-mm-yyyy 00:00",
@@ -244,8 +248,9 @@
     @mock.patch.object(Common, "get_endpoint")
     @mock.patch.object(KafkaProducer, "notify_alarm")
     @mock.patch.object(OpenStack_Response, "generate_response")
-    @mock.patch.object(Common, "_authenticate")
-    @mock.patch.object(Common, "_perform_request")
+    @mock.patch.object(Common, "get_auth_token")
+    @mock.patch.object(Common, "perform_request")
+    @unittest.skip("Schema validation not implemented yet.")
     def test_notify_alarm_invalid_resp(
             self, perf_req, auth, response, notify, endpoint):
         """Test the notify_alarm function, sends response to the producer."""
@@ -257,13 +262,13 @@
 
         self.handler.notify_alarm(json.loads(post_data))
 
-        notify.assert_not_called
+        notify.assert_not_called()
 
     @mock.patch.object(Common, "get_endpoint")
     @mock.patch.object(KafkaProducer, "notify_alarm")
     @mock.patch.object(OpenStack_Response, "generate_response")
-    @mock.patch.object(Common, "_authenticate")
-    @mock.patch.object(Common, "_perform_request")
+    @mock.patch.object(Common, "get_auth_token")
+    @mock.patch.object(Common, "perform_request")
     def test_notify_alarm_valid_resp(
             self, perf_req, auth, response, notify, endpoint):
         """Test the notify_alarm function, sends response to the producer."""
diff --git a/osm_mon/test/OpenStack/test_settings.py b/osm_mon/test/OpenStack/test_settings.py
index 66da6af..0f924ce 100644
--- a/osm_mon/test/OpenStack/test_settings.py
+++ b/osm_mon/test/OpenStack/test_settings.py
@@ -44,15 +44,7 @@
 
     def test_set_os_username(self):
         """Test reading the environment for OpenStack plugin configuration."""
-        os.environ["OS_USERNAME"] = "test"
-        self.cfg.read_environ("my_service")
+        os.environ["OS_NOTIFIER_URI"] = "test"
+        self.cfg.read_environ()
 
-        self.assertEqual(self.cfg.OS_USERNAME, "test")
-
-    @mock.patch.object(os, "environ")
-    def test_read_environ(self, environ):
-        """Test reading environment variables for configuration."""
-        self.cfg.read_environ("my_service")
-
-        # Called for each key in the configuration dictionary
-        environ.assert_called_once
+        self.assertEqual(self.cfg.OS_NOTIFIER_URI, "test")