diff --git a/RO-VIM-openstack/osm_rovim_openstack/tests/test_vimconn_openstack.py b/RO-VIM-openstack/osm_rovim_openstack/tests/test_vimconn_openstack.py
index 1de45fd..eb8da2f 100644
--- a/RO-VIM-openstack/osm_rovim_openstack/tests/test_vimconn_openstack.py
+++ b/RO-VIM-openstack/osm_rovim_openstack/tests/test_vimconn_openstack.py
@@ -23,13 +23,17 @@
 This module contains unit tests for the OpenStack VIM connector
 Run this directly with python2 or python3.
 """
+import copy
 from copy import deepcopy
 import logging
 import unittest
 
+import mock
 from mock import MagicMock, patch
+from neutronclient.v2_0.client import Client
 from novaclient import exceptions as nvExceptions
 from novaclient.exceptions import ClientException, Conflict
+from osm_ro_plugin import vimconn
 from osm_ro_plugin.vimconn import (
     VimConnConnectionException,
     VimConnException,
@@ -103,6 +107,1026 @@
 }
 
 
+class TestSfcOperations(unittest.TestCase):
+    @mock.patch("logging.getLogger", autospec=True)
+    def setUp(self, mock_logger):
+        # Instantiate dummy VIM connector so we can test it
+        # It throws exception because of dummy parameters,
+        # We are disabling the logging of exception not to print them to console.
+        mock_logger = logging.getLogger()
+        mock_logger.disabled = True
+        self.vimconn = vimconnector(
+            "123",
+            "openstackvim",
+            "456",
+            "789",
+            "http://dummy.url",
+            None,
+            "user",
+            "pass",
+        )
+
+    def _test_new_sfi(
+        self,
+        create_sfc_port_pair,
+        sfc_encap,
+        ingress_ports=["5311c75d-d718-4369-bbda-cdcc6da60fcc"],
+        egress_ports=["230cdf1b-de37-4891-bc07-f9010cf1f967"],
+    ):
+        # input to VIM connector
+        name = "osm_sfi"
+        # + ingress_ports
+        # + egress_ports
+        # TODO(igordc): must be changed to NSH in Queens (MPLS is a workaround)
+        correlation = "nsh"
+        if sfc_encap is not None:
+            if not sfc_encap:
+                correlation = None
+
+        # what OpenStack is assumed to respond (patch OpenStack"s return value)
+        dict_from_neutron = {
+            "port_pair": {
+                "id": "3d7ddc13-923c-4332-971e-708ed82902ce",
+                "name": name,
+                "description": "",
+                "tenant_id": "130b1e97-b0f1-40a8-8804-b6ad9b8c3e0c",
+                "project_id": "130b1e97-b0f1-40a8-8804-b6ad9b8c3e0c",
+                "ingress": ingress_ports[0] if len(ingress_ports) else None,
+                "egress": egress_ports[0] if len(egress_ports) else None,
+                "service_function_parameters": {"correlation": correlation},
+            }
+        }
+        create_sfc_port_pair.return_value = dict_from_neutron
+
+        # what the VIM connector is expected to
+        # send to OpenStack based on the input
+        dict_to_neutron = {
+            "port_pair": {
+                "name": name,
+                "ingress": "5311c75d-d718-4369-bbda-cdcc6da60fcc",
+                "egress": "230cdf1b-de37-4891-bc07-f9010cf1f967",
+                "service_function_parameters": {"correlation": correlation},
+            }
+        }
+
+        # call the VIM connector
+        if sfc_encap is None:
+            result = self.vimconn.new_sfi(name, ingress_ports, egress_ports)
+        else:
+            result = self.vimconn.new_sfi(name, ingress_ports, egress_ports, sfc_encap)
+
+        # assert that the VIM connector made the expected call to OpenStack
+        create_sfc_port_pair.assert_called_with(dict_to_neutron)
+        # assert that the VIM connector had the expected result / return value
+        self.assertEqual(result, dict_from_neutron["port_pair"]["id"])
+
+    def _test_new_sf(self, create_sfc_port_pair_group):
+        # input to VIM connector
+        name = "osm_sf"
+        instances = [
+            "bbd01220-cf72-41f2-9e70-0669c2e5c4cd",
+            "12ba215e-3987-4892-bd3a-d0fd91eecf98",
+            "e25a7c79-14c8-469a-9ae1-f601c9371ffd",
+        ]
+
+        # what OpenStack is assumed to respond (patch OpenStack"s return value)
+        dict_from_neutron = {
+            "port_pair_group": {
+                "id": "3d7ddc13-923c-4332-971e-708ed82902ce",
+                "name": name,
+                "description": "",
+                "tenant_id": "130b1e97-b0f1-40a8-8804-b6ad9b8c3e0c",
+                "project_id": "130b1e97-b0f1-40a8-8804-b6ad9b8c3e0c",
+                "port_pairs": instances,
+                "group_id": 1,
+                "port_pair_group_parameters": {
+                    "lb_fields": [],
+                    "ppg_n_tuple_mapping": {
+                        "ingress_n_tuple": {},
+                        "egress_n_tuple": {},
+                    },
+                },
+            }
+        }
+        create_sfc_port_pair_group.return_value = dict_from_neutron
+
+        # what the VIM connector is expected to
+        # send to OpenStack based on the input
+        dict_to_neutron = {
+            "port_pair_group": {
+                "name": name,
+                "port_pairs": [
+                    "bbd01220-cf72-41f2-9e70-0669c2e5c4cd",
+                    "12ba215e-3987-4892-bd3a-d0fd91eecf98",
+                    "e25a7c79-14c8-469a-9ae1-f601c9371ffd",
+                ],
+            }
+        }
+
+        # call the VIM connector
+        result = self.vimconn.new_sf(name, instances)
+
+        # assert that the VIM connector made the expected call to OpenStack
+        create_sfc_port_pair_group.assert_called_with(dict_to_neutron)
+        # assert that the VIM connector had the expected result / return value
+        self.assertEqual(result, dict_from_neutron["port_pair_group"]["id"])
+
+    def _test_new_sfp(self, create_sfc_port_chain, sfc_encap, spi):
+        # input to VIM connector
+        name = "osm_sfp"
+        classifications = [
+            "2bd2a2e5-c5fd-4eac-a297-d5e255c35c19",
+            "00f23389-bdfa-43c2-8b16-5815f2582fa8",
+        ]
+        sfs = [
+            "2314daec-c262-414a-86e3-69bb6fa5bc16",
+            "d8bfdb5d-195e-4f34-81aa-6135705317df",
+        ]
+
+        # TODO(igordc): must be changed to NSH in Queens (MPLS is a workaround)
+        correlation = "nsh"
+        chain_id = 33
+        if spi:
+            chain_id = spi
+
+        # what OpenStack is assumed to respond (patch OpenStack"s return value)
+        dict_from_neutron = {
+            "port_chain": {
+                "id": "5bc05721-079b-4b6e-a235-47cac331cbb6",
+                "name": name,
+                "description": "",
+                "tenant_id": "130b1e97-b0f1-40a8-8804-b6ad9b8c3e0c",
+                "project_id": "130b1e97-b0f1-40a8-8804-b6ad9b8c3e0c",
+                "chain_id": chain_id,
+                "flow_classifiers": classifications,
+                "port_pair_groups": sfs,
+                "chain_parameters": {"correlation": correlation},
+            }
+        }
+        create_sfc_port_chain.return_value = dict_from_neutron
+
+        # what the VIM connector is expected to
+        # send to OpenStack based on the input
+        dict_to_neutron = {
+            "port_chain": {
+                "name": name,
+                "flow_classifiers": [
+                    "2bd2a2e5-c5fd-4eac-a297-d5e255c35c19",
+                    "00f23389-bdfa-43c2-8b16-5815f2582fa8",
+                ],
+                "port_pair_groups": [
+                    "2314daec-c262-414a-86e3-69bb6fa5bc16",
+                    "d8bfdb5d-195e-4f34-81aa-6135705317df",
+                ],
+                "chain_parameters": {"correlation": correlation},
+            }
+        }
+        if spi:
+            dict_to_neutron["port_chain"]["chain_id"] = spi
+
+        # call the VIM connector
+        if sfc_encap is None:
+            dict_to_neutron["port_chain"]["chain_parameters"] = {"correlation": "mpls"}
+            if spi is None:
+                result = self.vimconn.new_sfp(
+                    name, classifications, sfs, sfc_encap=False
+                )
+            else:
+                result = self.vimconn.new_sfp(
+                    name, classifications, sfs, sfc_encap=False, spi=spi
+                )
+        else:
+            if spi is None:
+                result = self.vimconn.new_sfp(name, classifications, sfs, sfc_encap)
+            else:
+                result = self.vimconn.new_sfp(
+                    name, classifications, sfs, sfc_encap, spi
+                )
+
+        # assert that the VIM connector made the expected call to OpenStack
+        create_sfc_port_chain.assert_called_with(dict_to_neutron)
+        # assert that the VIM connector had the expected result / return value
+        self.assertEqual(result, dict_from_neutron["port_chain"]["id"])
+
+    def _test_new_classification(self, create_sfc_flow_classifier, ctype):
+        # input to VIM connector
+        name = "osm_classification"
+        definition = {
+            "ethertype": "IPv4",
+            "logical_source_port": "aaab0ab0-1452-4636-bb3b-11dca833fa2b",
+            "protocol": "tcp",
+            "source_ip_prefix": "192.168.2.0/24",
+            "source_port_range_max": 99,
+            "source_port_range_min": 50,
+        }
+
+        # what OpenStack is assumed to respond (patch OpenStack"s return value)
+        dict_from_neutron = {"flow_classifier": copy.copy(definition)}
+        dict_from_neutron["flow_classifier"][
+            "id"
+        ] = "7735ec2c-fddf-4130-9712-32ed2ab6a372"
+        dict_from_neutron["flow_classifier"]["name"] = name
+        dict_from_neutron["flow_classifier"]["description"] = ""
+        dict_from_neutron["flow_classifier"][
+            "tenant_id"
+        ] = "130b1e97-b0f1-40a8-8804-b6ad9b8c3e0c"
+        dict_from_neutron["flow_classifier"][
+            "project_id"
+        ] = "130b1e97-b0f1-40a8-8804-b6ad9b8c3e0c"
+        create_sfc_flow_classifier.return_value = dict_from_neutron
+
+        # what the VIM connector is expected to
+        # send to OpenStack based on the input
+        dict_to_neutron = {"flow_classifier": copy.copy(definition)}
+        dict_to_neutron["flow_classifier"]["name"] = "osm_classification"
+
+        # call the VIM connector
+        result = self.vimconn.new_classification(name, ctype, definition)
+
+        # assert that the VIM connector made the expected call to OpenStack
+        create_sfc_flow_classifier.assert_called_with(dict_to_neutron)
+        # assert that the VIM connector had the expected result / return value
+        self.assertEqual(result, dict_from_neutron["flow_classifier"]["id"])
+
+    @mock.patch.object(Client, "create_sfc_flow_classifier")
+    def test_new_classification(self, create_sfc_flow_classifier):
+        self._test_new_classification(
+            create_sfc_flow_classifier, "legacy_flow_classifier"
+        )
+
+    @mock.patch.object(Client, "create_sfc_flow_classifier")
+    def test_new_classification_unsupported_type(self, create_sfc_flow_classifier):
+        self.assertRaises(
+            vimconn.VimConnNotSupportedException,
+            self._test_new_classification,
+            create_sfc_flow_classifier,
+            "h265",
+        )
+
+    @mock.patch.object(Client, "create_sfc_port_pair")
+    def test_new_sfi_with_sfc_encap(self, create_sfc_port_pair):
+        self._test_new_sfi(create_sfc_port_pair, True)
+
+    @mock.patch.object(Client, "create_sfc_port_pair")
+    def test_new_sfi_without_sfc_encap(self, create_sfc_port_pair):
+        self._test_new_sfi(create_sfc_port_pair, False)
+
+    @mock.patch.object(Client, "create_sfc_port_pair")
+    def test_new_sfi_default_sfc_encap(self, create_sfc_port_pair):
+        self._test_new_sfi(create_sfc_port_pair, None)
+
+    @mock.patch.object(Client, "create_sfc_port_pair")
+    def test_new_sfi_bad_ingress_ports(self, create_sfc_port_pair):
+        ingress_ports = [
+            "5311c75d-d718-4369-bbda-cdcc6da60fcc",
+            "a0273f64-82c9-11e7-b08f-6328e53f0fa7",
+        ]
+        self.assertRaises(
+            vimconn.VimConnNotSupportedException,
+            self._test_new_sfi,
+            create_sfc_port_pair,
+            True,
+            ingress_ports=ingress_ports,
+        )
+        ingress_ports = []
+        self.assertRaises(
+            vimconn.VimConnNotSupportedException,
+            self._test_new_sfi,
+            create_sfc_port_pair,
+            True,
+            ingress_ports=ingress_ports,
+        )
+
+    @mock.patch.object(Client, "create_sfc_port_pair")
+    def test_new_sfi_bad_egress_ports(self, create_sfc_port_pair):
+        egress_ports = [
+            "230cdf1b-de37-4891-bc07-f9010cf1f967",
+            "b41228fe-82c9-11e7-9b44-17504174320b",
+        ]
+        self.assertRaises(
+            vimconn.VimConnNotSupportedException,
+            self._test_new_sfi,
+            create_sfc_port_pair,
+            True,
+            egress_ports=egress_ports,
+        )
+        egress_ports = []
+        self.assertRaises(
+            vimconn.VimConnNotSupportedException,
+            self._test_new_sfi,
+            create_sfc_port_pair,
+            True,
+            egress_ports=egress_ports,
+        )
+
+    @mock.patch.object(vimconnector, "get_sfi")
+    @mock.patch.object(Client, "create_sfc_port_pair_group")
+    def test_new_sf(self, create_sfc_port_pair_group, get_sfi):
+        get_sfi.return_value = {"sfc_encap": True}
+        self._test_new_sf(create_sfc_port_pair_group)
+
+    @mock.patch.object(vimconnector, "get_sfi")
+    @mock.patch.object(Client, "create_sfc_port_pair_group")
+    def test_new_sf_inconsistent_sfc_encap(self, create_sfc_port_pair_group, get_sfi):
+        get_sfi.return_value = {"sfc_encap": "nsh"}
+        self.assertRaises(
+            vimconn.VimConnNotSupportedException,
+            self._test_new_sf,
+            create_sfc_port_pair_group,
+        )
+
+    @mock.patch.object(Client, "create_sfc_port_chain")
+    def test_new_sfp_with_sfc_encap(self, create_sfc_port_chain):
+        self._test_new_sfp(create_sfc_port_chain, True, None)
+
+    @mock.patch.object(Client, "create_sfc_port_chain")
+    def test_new_sfp_without_sfc_encap(self, create_sfc_port_chain):
+        self._test_new_sfp(create_sfc_port_chain, None, None)
+        self._test_new_sfp(create_sfc_port_chain, None, 25)
+
+    @mock.patch.object(Client, "create_sfc_port_chain")
+    def test_new_sfp_default_sfc_encap(self, create_sfc_port_chain):
+        self._test_new_sfp(create_sfc_port_chain, None, None)
+
+    @mock.patch.object(Client, "create_sfc_port_chain")
+    def test_new_sfp_with_sfc_encap_spi(self, create_sfc_port_chain):
+        self._test_new_sfp(create_sfc_port_chain, True, 25)
+
+    @mock.patch.object(Client, "create_sfc_port_chain")
+    def test_new_sfp_default_sfc_encap_spi(self, create_sfc_port_chain):
+        self._test_new_sfp(create_sfc_port_chain, None, 25)
+
+    @mock.patch.object(Client, "list_sfc_flow_classifiers")
+    def test_get_classification_list(self, list_sfc_flow_classifiers):
+        # what OpenStack is assumed to return to the VIM connector
+        list_sfc_flow_classifiers.return_value = {
+            "flow_classifiers": [
+                {
+                    "source_port_range_min": 2000,
+                    "destination_ip_prefix": "192.168.3.0/24",
+                    "protocol": "udp",
+                    "description": "",
+                    "ethertype": "IPv4",
+                    "l7_parameters": {},
+                    "source_port_range_max": 2000,
+                    "destination_port_range_min": 3000,
+                    "source_ip_prefix": "192.168.2.0/24",
+                    "logical_destination_port": None,
+                    "tenant_id": "8f3019ef06374fa880a0144ad4bc1d7b",
+                    "destination_port_range_max": None,
+                    "project_id": "8f3019ef06374fa880a0144ad4bc1d7b",
+                    "logical_source_port": "aaab0ab0-1452-4636-bb3b-11dca833fa2b",
+                    "id": "22198366-d4e8-4d6b-b4d2-637d5d6cbb7d",
+                    "name": "fc1",
+                }
+            ]
+        }
+
+        # call the VIM connector
+        filter_dict = {"protocol": "tcp", "ethertype": "IPv4"}
+        result = self.vimconn.get_classification_list(filter_dict.copy())
+
+        # assert that VIM connector called OpenStack with the expected filter
+        list_sfc_flow_classifiers.assert_called_with(**filter_dict)
+        # assert that the VIM connector successfully
+        # translated and returned the OpenStack result
+        self.assertEqual(
+            result,
+            [
+                {
+                    "id": "22198366-d4e8-4d6b-b4d2-637d5d6cbb7d",
+                    "name": "fc1",
+                    "description": "",
+                    "project_id": "8f3019ef06374fa880a0144ad4bc1d7b",
+                    "tenant_id": "8f3019ef06374fa880a0144ad4bc1d7b",
+                    "ctype": "legacy_flow_classifier",
+                    "definition": {
+                        "source_port_range_min": 2000,
+                        "destination_ip_prefix": "192.168.3.0/24",
+                        "protocol": "udp",
+                        "ethertype": "IPv4",
+                        "l7_parameters": {},
+                        "source_port_range_max": 2000,
+                        "destination_port_range_min": 3000,
+                        "source_ip_prefix": "192.168.2.0/24",
+                        "logical_destination_port": None,
+                        "destination_port_range_max": None,
+                        "logical_source_port": "aaab0ab0-1452-4636-bb3b-11dca833fa2b",
+                    },
+                }
+            ],
+        )
+
+    def _test_get_sfi_list(self, list_port_pair, correlation, sfc_encap):
+        # what OpenStack is assumed to return to the VIM connector
+        list_port_pair.return_value = {
+            "port_pairs": [
+                {
+                    "ingress": "5311c75d-d718-4369-bbda-cdcc6da60fcc",
+                    "description": "",
+                    "tenant_id": "8f3019ef06374fa880a0144ad4bc1d7b",
+                    "egress": "5311c75d-d718-4369-bbda-cdcc6da60fcc",
+                    "service_function_parameters": {"correlation": correlation},
+                    "project_id": "8f3019ef06374fa880a0144ad4bc1d7b",
+                    "id": "c121ebdd-7f2d-4213-b933-3325298a6966",
+                    "name": "osm_sfi",
+                }
+            ]
+        }
+
+        # call the VIM connector
+        filter_dict = {"name": "osm_sfi", "description": ""}
+        result = self.vimconn.get_sfi_list(filter_dict.copy())
+
+        # assert that VIM connector called OpenStack with the expected filter
+        list_port_pair.assert_called_with(**filter_dict)
+        # assert that the VIM connector successfully
+        # translated and returned the OpenStack result
+        self.assertEqual(
+            result,
+            [
+                {
+                    "ingress_ports": ["5311c75d-d718-4369-bbda-cdcc6da60fcc"],
+                    "description": "",
+                    "tenant_id": "8f3019ef06374fa880a0144ad4bc1d7b",
+                    "egress_ports": ["5311c75d-d718-4369-bbda-cdcc6da60fcc"],
+                    "sfc_encap": sfc_encap,
+                    "project_id": "8f3019ef06374fa880a0144ad4bc1d7b",
+                    "id": "c121ebdd-7f2d-4213-b933-3325298a6966",
+                    "name": "osm_sfi",
+                }
+            ],
+        )
+
+    @mock.patch.object(Client, "list_sfc_port_pairs")
+    def test_get_sfi_list_with_sfc_encap(self, list_sfc_port_pairs):
+        self._test_get_sfi_list(list_sfc_port_pairs, "nsh", True)
+
+    @mock.patch.object(Client, "list_sfc_port_pairs")
+    def test_get_sfi_list_without_sfc_encap(self, list_sfc_port_pairs):
+        self._test_get_sfi_list(list_sfc_port_pairs, None, False)
+
+    @mock.patch.object(Client, "list_sfc_port_pair_groups")
+    def test_get_sf_list(self, list_sfc_port_pair_groups):
+        # what OpenStack is assumed to return to the VIM connector
+        list_sfc_port_pair_groups.return_value = {
+            "port_pair_groups": [
+                {
+                    "port_pairs": [
+                        "08fbdbb0-82d6-11e7-ad95-9bb52fbec2f2",
+                        "0d63799c-82d6-11e7-8deb-a746bb3ae9f5",
+                    ],
+                    "description": "",
+                    "tenant_id": "8f3019ef06374fa880a0144ad4bc1d7b",
+                    "port_pair_group_parameters": {},
+                    "project_id": "8f3019ef06374fa880a0144ad4bc1d7b",
+                    "id": "f4a0bde8-82d5-11e7-90e1-a72b762fa27f",
+                    "name": "osm_sf",
+                }
+            ]
+        }
+
+        # call the VIM connector
+        filter_dict = {"name": "osm_sf", "description": ""}
+        result = self.vimconn.get_sf_list(filter_dict.copy())
+
+        # assert that VIM connector called OpenStack with the expected filter
+        list_sfc_port_pair_groups.assert_called_with(**filter_dict)
+        # assert that the VIM connector successfully
+        # translated and returned the OpenStack result
+        self.assertEqual(
+            result,
+            [
+                {
+                    "sfis": [
+                        "08fbdbb0-82d6-11e7-ad95-9bb52fbec2f2",
+                        "0d63799c-82d6-11e7-8deb-a746bb3ae9f5",
+                    ],
+                    "description": "",
+                    "tenant_id": "8f3019ef06374fa880a0144ad4bc1d7b",
+                    "project_id": "8f3019ef06374fa880a0144ad4bc1d7b",
+                    "id": "f4a0bde8-82d5-11e7-90e1-a72b762fa27f",
+                    "name": "osm_sf",
+                }
+            ],
+        )
+
+    def _test_get_sfp_list(self, list_sfc_port_chains, correlation, sfc_encap):
+        # what OpenStack is assumed to return to the VIM connector
+        list_sfc_port_chains.return_value = {
+            "port_chains": [
+                {
+                    "port_pair_groups": [
+                        "7d8e3bf8-82d6-11e7-a032-8ff028839d25",
+                        "7dc9013e-82d6-11e7-a5a6-a3a8d78a5518",
+                    ],
+                    "flow_classifiers": [
+                        "1333c2f4-82d7-11e7-a5df-9327f33d104e",
+                        "1387ab44-82d7-11e7-9bb0-476337183905",
+                    ],
+                    "description": "",
+                    "tenant_id": "8f3019ef06374fa880a0144ad4bc1d7b",
+                    "chain_parameters": {"correlation": correlation},
+                    "chain_id": 40,
+                    "project_id": "8f3019ef06374fa880a0144ad4bc1d7b",
+                    "id": "821bc9be-82d7-11e7-8ce3-23a08a27ab47",
+                    "name": "osm_sfp",
+                }
+            ]
+        }
+
+        # call the VIM connector
+        filter_dict = {"name": "osm_sfp", "description": ""}
+        result = self.vimconn.get_sfp_list(filter_dict.copy())
+
+        # assert that VIM connector called OpenStack with the expected filter
+        list_sfc_port_chains.assert_called_with(**filter_dict)
+        # assert that the VIM connector successfully
+        # translated and returned the OpenStack result
+        self.assertEqual(
+            result,
+            [
+                {
+                    "service_functions": [
+                        "7d8e3bf8-82d6-11e7-a032-8ff028839d25",
+                        "7dc9013e-82d6-11e7-a5a6-a3a8d78a5518",
+                    ],
+                    "classifications": [
+                        "1333c2f4-82d7-11e7-a5df-9327f33d104e",
+                        "1387ab44-82d7-11e7-9bb0-476337183905",
+                    ],
+                    "description": "",
+                    "tenant_id": "8f3019ef06374fa880a0144ad4bc1d7b",
+                    "project_id": "8f3019ef06374fa880a0144ad4bc1d7b",
+                    "sfc_encap": sfc_encap,
+                    "spi": 40,
+                    "id": "821bc9be-82d7-11e7-8ce3-23a08a27ab47",
+                    "name": "osm_sfp",
+                }
+            ],
+        )
+
+    @mock.patch.object(Client, "list_sfc_port_chains")
+    def test_get_sfp_list_with_sfc_encap(self, list_sfc_port_chains):
+        self._test_get_sfp_list(list_sfc_port_chains, "nsh", True)
+
+    @mock.patch.object(Client, "list_sfc_port_chains")
+    def test_get_sfp_list_without_sfc_encap(self, list_sfc_port_chains):
+        self._test_get_sfp_list(list_sfc_port_chains, None, False)
+
+    @mock.patch.object(Client, "list_sfc_flow_classifiers")
+    def test_get_classification(self, list_sfc_flow_classifiers):
+        # what OpenStack is assumed to return to the VIM connector
+        list_sfc_flow_classifiers.return_value = {
+            "flow_classifiers": [
+                {
+                    "source_port_range_min": 2000,
+                    "destination_ip_prefix": "192.168.3.0/24",
+                    "protocol": "udp",
+                    "description": "",
+                    "ethertype": "IPv4",
+                    "l7_parameters": {},
+                    "source_port_range_max": 2000,
+                    "destination_port_range_min": 3000,
+                    "source_ip_prefix": "192.168.2.0/24",
+                    "logical_destination_port": None,
+                    "tenant_id": "8f3019ef06374fa880a0144ad4bc1d7b",
+                    "destination_port_range_max": None,
+                    "project_id": "8f3019ef06374fa880a0144ad4bc1d7b",
+                    "logical_source_port": "aaab0ab0-1452-4636-bb3b-11dca833fa2b",
+                    "id": "22198366-d4e8-4d6b-b4d2-637d5d6cbb7d",
+                    "name": "fc1",
+                }
+            ]
+        }
+
+        # call the VIM connector
+        result = self.vimconn.get_classification("22198366-d4e8-4d6b-b4d2-637d5d6cbb7d")
+
+        # assert that VIM connector called OpenStack with the expected filter
+        list_sfc_flow_classifiers.assert_called_with(
+            id="22198366-d4e8-4d6b-b4d2-637d5d6cbb7d"
+        )
+        # assert that VIM connector successfully returned the OpenStack result
+        self.assertEqual(
+            result,
+            {
+                "id": "22198366-d4e8-4d6b-b4d2-637d5d6cbb7d",
+                "name": "fc1",
+                "description": "",
+                "project_id": "8f3019ef06374fa880a0144ad4bc1d7b",
+                "tenant_id": "8f3019ef06374fa880a0144ad4bc1d7b",
+                "ctype": "legacy_flow_classifier",
+                "definition": {
+                    "source_port_range_min": 2000,
+                    "destination_ip_prefix": "192.168.3.0/24",
+                    "protocol": "udp",
+                    "ethertype": "IPv4",
+                    "l7_parameters": {},
+                    "source_port_range_max": 2000,
+                    "destination_port_range_min": 3000,
+                    "source_ip_prefix": "192.168.2.0/24",
+                    "logical_destination_port": None,
+                    "destination_port_range_max": None,
+                    "logical_source_port": "aaab0ab0-1452-4636-bb3b-11dca833fa2b",
+                },
+            },
+        )
+
+    @mock.patch.object(Client, "list_sfc_flow_classifiers")
+    def test_get_classification_many_results(self, list_sfc_flow_classifiers):
+        # what OpenStack is assumed to return to the VIM connector
+        list_sfc_flow_classifiers.return_value = {
+            "flow_classifiers": [
+                {
+                    "source_port_range_min": 2000,
+                    "destination_ip_prefix": "192.168.3.0/24",
+                    "protocol": "udp",
+                    "description": "",
+                    "ethertype": "IPv4",
+                    "l7_parameters": {},
+                    "source_port_range_max": 2000,
+                    "destination_port_range_min": 3000,
+                    "source_ip_prefix": "192.168.2.0/24",
+                    "logical_destination_port": None,
+                    "tenant_id": "8f3019ef06374fa880a0144ad4bc1d7b",
+                    "destination_port_range_max": None,
+                    "project_id": "8f3019ef06374fa880a0144ad4bc1d7b",
+                    "logical_source_port": "aaab0ab0-1452-4636-bb3b-11dca833fa2b",
+                    "id": "22198366-d4e8-4d6b-b4d2-637d5d6cbb7d",
+                    "name": "fc1",
+                },
+                {
+                    "source_port_range_min": 1000,
+                    "destination_ip_prefix": "192.168.3.0/24",
+                    "protocol": "udp",
+                    "description": "",
+                    "ethertype": "IPv4",
+                    "l7_parameters": {},
+                    "source_port_range_max": 1000,
+                    "destination_port_range_min": 3000,
+                    "source_ip_prefix": "192.168.2.0/24",
+                    "logical_destination_port": None,
+                    "tenant_id": "8f3019ef06374fa880a0144ad4bc1d7b",
+                    "destination_port_range_max": None,
+                    "project_id": "8f3019ef06374fa880a0144ad4bc1d7b",
+                    "logical_source_port": "aaab0ab0-1452-4636-bb3b-11dca833fa2b",
+                    "id": "3196bafc-82dd-11e7-a205-9bf6c14b0721",
+                    "name": "fc2",
+                },
+            ]
+        }
+
+        # call the VIM connector
+        self.assertRaises(
+            vimconn.VimConnConflictException,
+            self.vimconn.get_classification,
+            "3196bafc-82dd-11e7-a205-9bf6c14b0721",
+        )
+
+        # assert the VIM connector called OpenStack with the expected filter
+        list_sfc_flow_classifiers.assert_called_with(
+            id="3196bafc-82dd-11e7-a205-9bf6c14b0721"
+        )
+
+    @mock.patch.object(Client, "list_sfc_flow_classifiers")
+    def test_get_classification_no_results(self, list_sfc_flow_classifiers):
+        # what OpenStack is assumed to return to the VIM connector
+        list_sfc_flow_classifiers.return_value = {"flow_classifiers": []}
+
+        # call the VIM connector
+        self.assertRaises(
+            vimconn.VimConnNotFoundException,
+            self.vimconn.get_classification,
+            "3196bafc-82dd-11e7-a205-9bf6c14b0721",
+        )
+
+        # assert the VIM connector called OpenStack with the expected filter
+        list_sfc_flow_classifiers.assert_called_with(
+            id="3196bafc-82dd-11e7-a205-9bf6c14b0721"
+        )
+
+    @mock.patch.object(Client, "list_sfc_port_pairs")
+    def test_get_sfi(self, list_sfc_port_pairs):
+        # what OpenStack is assumed to return to the VIM connector
+        list_sfc_port_pairs.return_value = {
+            "port_pairs": [
+                {
+                    "ingress": "5311c75d-d718-4369-bbda-cdcc6da60fcc",
+                    "description": "",
+                    "tenant_id": "8f3019ef06374fa880a0144ad4bc1d7b",
+                    "egress": "5311c75d-d718-4369-bbda-cdcc6da60fcc",
+                    "service_function_parameters": {"correlation": "nsh"},
+                    "project_id": "8f3019ef06374fa880a0144ad4bc1d7b",
+                    "id": "c121ebdd-7f2d-4213-b933-3325298a6966",
+                    "name": "osm_sfi1",
+                },
+            ]
+        }
+
+        # call the VIM connector
+        result = self.vimconn.get_sfi("c121ebdd-7f2d-4213-b933-3325298a6966")
+
+        # assert the VIM connector called OpenStack with the expected filter
+        list_sfc_port_pairs.assert_called_with(
+            id="c121ebdd-7f2d-4213-b933-3325298a6966"
+        )
+        # assert the VIM connector successfully returned the OpenStack result
+        self.assertEqual(
+            result,
+            {
+                "ingress_ports": ["5311c75d-d718-4369-bbda-cdcc6da60fcc"],
+                "egress_ports": ["5311c75d-d718-4369-bbda-cdcc6da60fcc"],
+                "sfc_encap": True,
+                "description": "",
+                "tenant_id": "8f3019ef06374fa880a0144ad4bc1d7b",
+                "project_id": "8f3019ef06374fa880a0144ad4bc1d7b",
+                "id": "c121ebdd-7f2d-4213-b933-3325298a6966",
+                "name": "osm_sfi1",
+            },
+        )
+
+    @mock.patch.object(Client, "list_sfc_port_pairs")
+    def test_get_sfi_many_results(self, list_sfc_port_pairs):
+        # what OpenStack is assumed to return to the VIM connector
+        list_sfc_port_pairs.return_value = {
+            "port_pairs": [
+                {
+                    "ingress": "5311c75d-d718-4369-bbda-cdcc6da60fcc",
+                    "description": "",
+                    "tenant_id": "8f3019ef06374fa880a0144ad4bc1d7b",
+                    "egress": "5311c75d-d718-4369-bbda-cdcc6da60fcc",
+                    "service_function_parameters": {"correlation": "nsh"},
+                    "project_id": "8f3019ef06374fa880a0144ad4bc1d7b",
+                    "id": "c121ebdd-7f2d-4213-b933-3325298a6966",
+                    "name": "osm_sfi1",
+                },
+                {
+                    "ingress": "5311c75d-d718-4369-bbda-cdcc6da60fcc",
+                    "description": "",
+                    "tenant_id": "8f3019ef06374fa880a0144ad4bc1d7b",
+                    "egress": "5311c75d-d718-4369-bbda-cdcc6da60fcc",
+                    "service_function_parameters": {"correlation": "nsh"},
+                    "project_id": "8f3019ef06374fa880a0144ad4bc1d7b",
+                    "id": "c0436d92-82db-11e7-8f9c-5fa535f1261f",
+                    "name": "osm_sfi2",
+                },
+            ]
+        }
+
+        # call the VIM connector
+        self.assertRaises(
+            vimconn.VimConnConflictException,
+            self.vimconn.get_sfi,
+            "c0436d92-82db-11e7-8f9c-5fa535f1261f",
+        )
+
+        # assert that VIM connector called OpenStack with the expected filter
+        list_sfc_port_pairs.assert_called_with(
+            id="c0436d92-82db-11e7-8f9c-5fa535f1261f"
+        )
+
+    @mock.patch.object(Client, "list_sfc_port_pairs")
+    def test_get_sfi_no_results(self, list_sfc_port_pairs):
+        # what OpenStack is assumed to return to the VIM connector
+        list_sfc_port_pairs.return_value = {"port_pairs": []}
+
+        # call the VIM connector
+        self.assertRaises(
+            vimconn.VimConnNotFoundException,
+            self.vimconn.get_sfi,
+            "b22892fc-82d9-11e7-ae85-0fea6a3b3757",
+        )
+
+        # assert that VIM connector called OpenStack with the expected filter
+        list_sfc_port_pairs.assert_called_with(
+            id="b22892fc-82d9-11e7-ae85-0fea6a3b3757"
+        )
+
+    @mock.patch.object(Client, "list_sfc_port_pair_groups")
+    def test_get_sf(self, list_sfc_port_pair_groups):
+        # what OpenStack is assumed to return to the VIM connector
+        list_sfc_port_pair_groups.return_value = {
+            "port_pair_groups": [
+                {
+                    "port_pairs": ["08fbdbb0-82d6-11e7-ad95-9bb52fbec2f2"],
+                    "description": "",
+                    "tenant_id": "8f3019ef06374fa880a0144ad4bc1d7b",
+                    "port_pair_group_parameters": {},
+                    "project_id": "8f3019ef06374fa880a0144ad4bc1d7b",
+                    "id": "aabba8a6-82d9-11e7-a18a-d3c7719b742d",
+                    "name": "osm_sf1",
+                }
+            ]
+        }
+
+        # call the VIM connector
+        result = self.vimconn.get_sf("b22892fc-82d9-11e7-ae85-0fea6a3b3757")
+
+        # assert that VIM connector called OpenStack with the expected filter
+        list_sfc_port_pair_groups.assert_called_with(
+            id="b22892fc-82d9-11e7-ae85-0fea6a3b3757"
+        )
+        # assert that VIM connector successfully returned the OpenStack result
+        self.assertEqual(
+            result,
+            {
+                "description": "",
+                "tenant_id": "8f3019ef06374fa880a0144ad4bc1d7b",
+                "project_id": "8f3019ef06374fa880a0144ad4bc1d7b",
+                "sfis": ["08fbdbb0-82d6-11e7-ad95-9bb52fbec2f2"],
+                "id": "aabba8a6-82d9-11e7-a18a-d3c7719b742d",
+                "name": "osm_sf1",
+            },
+        )
+
+    @mock.patch.object(Client, "list_sfc_port_pair_groups")
+    def test_get_sf_many_results(self, list_sfc_port_pair_groups):
+        # what OpenStack is assumed to return to the VIM connector
+        list_sfc_port_pair_groups.return_value = {
+            "port_pair_groups": [
+                {
+                    "port_pairs": ["08fbdbb0-82d6-11e7-ad95-9bb52fbec2f2"],
+                    "description": "",
+                    "tenant_id": "8f3019ef06374fa880a0144ad4bc1d7b",
+                    "port_pair_group_parameters": {},
+                    "project_id": "8f3019ef06374fa880a0144ad4bc1d7b",
+                    "id": "aabba8a6-82d9-11e7-a18a-d3c7719b742d",
+                    "name": "osm_sf1",
+                },
+                {
+                    "port_pairs": ["0d63799c-82d6-11e7-8deb-a746bb3ae9f5"],
+                    "description": "",
+                    "tenant_id": "8f3019ef06374fa880a0144ad4bc1d7b",
+                    "port_pair_group_parameters": {},
+                    "project_id": "8f3019ef06374fa880a0144ad4bc1d7b",
+                    "id": "b22892fc-82d9-11e7-ae85-0fea6a3b3757",
+                    "name": "osm_sf2",
+                },
+            ]
+        }
+
+        # call the VIM connector
+        self.assertRaises(
+            vimconn.VimConnConflictException,
+            self.vimconn.get_sf,
+            "b22892fc-82d9-11e7-ae85-0fea6a3b3757",
+        )
+
+        # assert that VIM connector called OpenStack with the expected filter
+        list_sfc_port_pair_groups.assert_called_with(
+            id="b22892fc-82d9-11e7-ae85-0fea6a3b3757"
+        )
+
+    @mock.patch.object(Client, "list_sfc_port_pair_groups")
+    def test_get_sf_no_results(self, list_sfc_port_pair_groups):
+        # what OpenStack is assumed to return to the VIM connector
+        list_sfc_port_pair_groups.return_value = {"port_pair_groups": []}
+
+        # call the VIM connector
+        self.assertRaises(
+            vimconn.VimConnNotFoundException,
+            self.vimconn.get_sf,
+            "b22892fc-82d9-11e7-ae85-0fea6a3b3757",
+        )
+
+        # assert that VIM connector called OpenStack with the expected filter
+        list_sfc_port_pair_groups.assert_called_with(
+            id="b22892fc-82d9-11e7-ae85-0fea6a3b3757"
+        )
+
+    @mock.patch.object(Client, "list_sfc_port_chains")
+    def test_get_sfp(self, list_sfc_port_chains):
+        # what OpenStack is assumed to return to the VIM connector
+        list_sfc_port_chains.return_value = {
+            "port_chains": [
+                {
+                    "port_pair_groups": ["7d8e3bf8-82d6-11e7-a032-8ff028839d25"],
+                    "flow_classifiers": ["1333c2f4-82d7-11e7-a5df-9327f33d104e"],
+                    "description": "",
+                    "tenant_id": "8f3019ef06374fa880a0144ad4bc1d7b",
+                    "chain_parameters": {"correlation": "nsh"},
+                    "chain_id": 40,
+                    "project_id": "8f3019ef06374fa880a0144ad4bc1d7b",
+                    "id": "821bc9be-82d7-11e7-8ce3-23a08a27ab47",
+                    "name": "osm_sfp1",
+                }
+            ]
+        }
+
+        # call the VIM connector
+        result = self.vimconn.get_sfp("821bc9be-82d7-11e7-8ce3-23a08a27ab47")
+
+        # assert that VIM connector called OpenStack with the expected filter
+        list_sfc_port_chains.assert_called_with(
+            id="821bc9be-82d7-11e7-8ce3-23a08a27ab47"
+        )
+        # assert that VIM connector successfully returned the OpenStack result
+        self.assertEqual(
+            result,
+            {
+                "service_functions": ["7d8e3bf8-82d6-11e7-a032-8ff028839d25"],
+                "classifications": ["1333c2f4-82d7-11e7-a5df-9327f33d104e"],
+                "description": "",
+                "tenant_id": "8f3019ef06374fa880a0144ad4bc1d7b",
+                "project_id": "8f3019ef06374fa880a0144ad4bc1d7b",
+                "sfc_encap": True,
+                "spi": 40,
+                "id": "821bc9be-82d7-11e7-8ce3-23a08a27ab47",
+                "name": "osm_sfp1",
+            },
+        )
+
+    @mock.patch.object(Client, "list_sfc_port_chains")
+    def test_get_sfp_many_results(self, list_sfc_port_chains):
+        # what OpenStack is assumed to return to the VIM connector
+        list_sfc_port_chains.return_value = {
+            "port_chains": [
+                {
+                    "port_pair_groups": ["7d8e3bf8-82d6-11e7-a032-8ff028839d25"],
+                    "flow_classifiers": ["1333c2f4-82d7-11e7-a5df-9327f33d104e"],
+                    "description": "",
+                    "tenant_id": "8f3019ef06374fa880a0144ad4bc1d7b",
+                    "chain_parameters": {"correlation": "nsh"},
+                    "chain_id": 40,
+                    "project_id": "8f3019ef06374fa880a0144ad4bc1d7b",
+                    "id": "821bc9be-82d7-11e7-8ce3-23a08a27ab47",
+                    "name": "osm_sfp1",
+                },
+                {
+                    "port_pair_groups": ["7d8e3bf8-82d6-11e7-a032-8ff028839d25"],
+                    "flow_classifiers": ["1333c2f4-82d7-11e7-a5df-9327f33d104e"],
+                    "description": "",
+                    "tenant_id": "8f3019ef06374fa880a0144ad4bc1d7b",
+                    "chain_parameters": {"correlation": "nsh"},
+                    "chain_id": 50,
+                    "project_id": "8f3019ef06374fa880a0144ad4bc1d7b",
+                    "id": "5d002f38-82de-11e7-a770-f303f11ce66a",
+                    "name": "osm_sfp2",
+                },
+            ]
+        }
+
+        # call the VIM connector
+        self.assertRaises(
+            vimconn.VimConnConflictException,
+            self.vimconn.get_sfp,
+            "5d002f38-82de-11e7-a770-f303f11ce66a",
+        )
+
+        # assert that VIM connector called OpenStack with the expected filter
+        list_sfc_port_chains.assert_called_with(
+            id="5d002f38-82de-11e7-a770-f303f11ce66a"
+        )
+
+    @mock.patch.object(Client, "list_sfc_port_chains")
+    def test_get_sfp_no_results(self, list_sfc_port_chains):
+        # what OpenStack is assumed to return to the VIM connector
+        list_sfc_port_chains.return_value = {"port_chains": []}
+
+        # call the VIM connector
+        self.assertRaises(
+            vimconn.VimConnNotFoundException,
+            self.vimconn.get_sfp,
+            "5d002f38-82de-11e7-a770-f303f11ce66a",
+        )
+
+        # assert that VIM connector called OpenStack with the expected filter
+        list_sfc_port_chains.assert_called_with(
+            id="5d002f38-82de-11e7-a770-f303f11ce66a"
+        )
+
+    @mock.patch.object(Client, "delete_sfc_flow_classifier")
+    def test_delete_classification(self, delete_sfc_flow_classifier):
+        result = self.vimconn.delete_classification(
+            "638f957c-82df-11e7-b7c8-132706021464"
+        )
+        delete_sfc_flow_classifier.assert_called_with(
+            "638f957c-82df-11e7-b7c8-132706021464"
+        )
+        self.assertEqual(result, "638f957c-82df-11e7-b7c8-132706021464")
+
+    @mock.patch.object(Client, "delete_sfc_port_pair")
+    def test_delete_sfi(self, delete_sfc_port_pair):
+        result = self.vimconn.delete_sfi("638f957c-82df-11e7-b7c8-132706021464")
+        delete_sfc_port_pair.assert_called_with("638f957c-82df-11e7-b7c8-132706021464")
+        self.assertEqual(result, "638f957c-82df-11e7-b7c8-132706021464")
+
+    @mock.patch.object(Client, "delete_sfc_port_pair_group")
+    def test_delete_sf(self, delete_sfc_port_pair_group):
+        result = self.vimconn.delete_sf("638f957c-82df-11e7-b7c8-132706021464")
+        delete_sfc_port_pair_group.assert_called_with(
+            "638f957c-82df-11e7-b7c8-132706021464"
+        )
+        self.assertEqual(result, "638f957c-82df-11e7-b7c8-132706021464")
+
+    @mock.patch.object(Client, "delete_sfc_port_chain")
+    def test_delete_sfp(self, delete_sfc_port_chain):
+        result = self.vimconn.delete_sfp("638f957c-82df-11e7-b7c8-132706021464")
+        delete_sfc_port_chain.assert_called_with("638f957c-82df-11e7-b7c8-132706021464")
+        self.assertEqual(result, "638f957c-82df-11e7-b7c8-132706021464")
+
+
 class Status:
     def __init__(self, s):
         self.status = s
diff --git a/RO-VIM-openstack/osm_rovim_openstack/vimconn_openstack.py b/RO-VIM-openstack/osm_rovim_openstack/vimconn_openstack.py
index 9faf98d..25e58d5 100644
--- a/RO-VIM-openstack/osm_rovim_openstack/vimconn_openstack.py
+++ b/RO-VIM-openstack/osm_rovim_openstack/vimconn_openstack.py
@@ -3451,6 +3451,45 @@
                     )
                 )
 
+    def delete_user(self, user_id):
+        """Delete a user from openstack VIM
+        Returns the user identifier"""
+        if self.debug:
+            print("osconnector: Deleting  a  user from VIM")
+
+        try:
+            self._reload_connection()
+            self.keystone.users.delete(user_id)
+
+            return 1, user_id
+        except ksExceptions.ConnectionError as e:
+            error_value = -vimconn.HTTP_Bad_Request
+            error_text = (
+                type(e).__name__
+                + ": "
+                + (str(e) if len(e.args) == 0 else str(e.args[0]))
+            )
+        except ksExceptions.NotFound as e:
+            error_value = -vimconn.HTTP_Not_Found
+            error_text = (
+                type(e).__name__
+                + ": "
+                + (str(e) if len(e.args) == 0 else str(e.args[0]))
+            )
+        except ksExceptions.ClientException as e:  # TODO remove
+            error_value = -vimconn.HTTP_Bad_Request
+            error_text = (
+                type(e).__name__
+                + ": "
+                + (str(e) if len(e.args) == 0 else str(e.args[0]))
+            )
+
+        # TODO insert exception vimconn.HTTP_Unauthorized
+        # if reaching here is because an exception
+        self.logger.debug("delete_tenant " + error_text)
+
+        return error_value, error_text
+
     def get_hosts_info(self):
         """Get the information of deployed hosts
         Returns the hosts content"""
@@ -3524,6 +3563,619 @@
 
         return error_value, error_text
 
+    def new_classification(self, name, ctype, definition):
+        self.logger.debug(
+            "Adding a new (Traffic) Classification to VIM, named %s", name
+        )
+
+        try:
+            new_class = None
+            self._reload_connection()
+
+            if ctype not in supportedClassificationTypes:
+                raise vimconn.VimConnNotSupportedException(
+                    "OpenStack VIM connector does not support provided "
+                    "Classification Type {}, supported ones are: {}".format(
+                        ctype, supportedClassificationTypes
+                    )
+                )
+
+            if not self._validate_classification(ctype, definition):
+                raise vimconn.VimConnException(
+                    "Incorrect Classification definition for the type specified."
+                )
+
+            classification_dict = definition
+            classification_dict["name"] = name
+            new_class = self.neutron.create_sfc_flow_classifier(
+                {"flow_classifier": classification_dict}
+            )
+
+            return new_class["flow_classifier"]["id"]
+        except (
+            neExceptions.ConnectionFailed,
+            ksExceptions.ClientException,
+            neExceptions.NeutronException,
+            ConnectionError,
+        ) as e:
+            self.logger.error("Creation of Classification failed.")
+            self._format_exception(e)
+
+    def get_classification(self, class_id):
+        self.logger.debug(" Getting Classification %s from VIM", class_id)
+        filter_dict = {"id": class_id}
+        class_list = self.get_classification_list(filter_dict)
+
+        if len(class_list) == 0:
+            raise vimconn.VimConnNotFoundException(
+                "Classification '{}' not found".format(class_id)
+            )
+        elif len(class_list) > 1:
+            raise vimconn.VimConnConflictException(
+                "Found more than one Classification with this criteria"
+            )
+
+        classification = class_list[0]
+
+        return classification
+
+    def get_classification_list(self, filter_dict={}):
+        self.logger.debug(
+            "Getting Classifications from VIM filter: '%s'", str(filter_dict)
+        )
+
+        try:
+            filter_dict_os = filter_dict.copy()
+            self._reload_connection()
+
+            if self.api_version3 and "tenant_id" in filter_dict_os:
+                filter_dict_os["project_id"] = filter_dict_os.pop("tenant_id")
+
+            classification_dict = self.neutron.list_sfc_flow_classifiers(
+                **filter_dict_os
+            )
+            classification_list = classification_dict["flow_classifiers"]
+            self.__classification_os2mano(classification_list)
+
+            return classification_list
+        except (
+            neExceptions.ConnectionFailed,
+            ksExceptions.ClientException,
+            neExceptions.NeutronException,
+            ConnectionError,
+        ) as e:
+            self._format_exception(e)
+
+    def delete_classification(self, class_id):
+        self.logger.debug("Deleting Classification '%s' from VIM", class_id)
+
+        try:
+            self._reload_connection()
+            self.neutron.delete_sfc_flow_classifier(class_id)
+
+            return class_id
+        except (
+            neExceptions.ConnectionFailed,
+            neExceptions.NeutronException,
+            ksExceptions.ClientException,
+            neExceptions.NeutronException,
+            ConnectionError,
+        ) as e:
+            self._format_exception(e)
+
+    def new_sfi(self, name, ingress_ports, egress_ports, sfc_encap=True):
+        self.logger.debug(
+            "Adding a new Service Function Instance to VIM, named '%s'", name
+        )
+
+        try:
+            new_sfi = None
+            self._reload_connection()
+            correlation = None
+
+            if sfc_encap:
+                correlation = "nsh"
+
+            if len(ingress_ports) != 1:
+                raise vimconn.VimConnNotSupportedException(
+                    "OpenStack VIM connector can only have 1 ingress port per SFI"
+                )
+
+            if len(egress_ports) != 1:
+                raise vimconn.VimConnNotSupportedException(
+                    "OpenStack VIM connector can only have 1 egress port per SFI"
+                )
+
+            sfi_dict = {
+                "name": name,
+                "ingress": ingress_ports[0],
+                "egress": egress_ports[0],
+                "service_function_parameters": {"correlation": correlation},
+            }
+            new_sfi = self.neutron.create_sfc_port_pair({"port_pair": sfi_dict})
+
+            return new_sfi["port_pair"]["id"]
+        except (
+            neExceptions.ConnectionFailed,
+            ksExceptions.ClientException,
+            neExceptions.NeutronException,
+            ConnectionError,
+        ) as e:
+            if new_sfi:
+                try:
+                    self.neutron.delete_sfc_port_pair(new_sfi["port_pair"]["id"])
+                except Exception:
+                    self.logger.error(
+                        "Creation of Service Function Instance failed, with "
+                        "subsequent deletion failure as well."
+                    )
+
+            self._format_exception(e)
+
+    def get_sfi(self, sfi_id):
+        self.logger.debug("Getting Service Function Instance %s from VIM", sfi_id)
+        filter_dict = {"id": sfi_id}
+        sfi_list = self.get_sfi_list(filter_dict)
+
+        if len(sfi_list) == 0:
+            raise vimconn.VimConnNotFoundException(
+                "Service Function Instance '{}' not found".format(sfi_id)
+            )
+        elif len(sfi_list) > 1:
+            raise vimconn.VimConnConflictException(
+                "Found more than one Service Function Instance with this criteria"
+            )
+
+        sfi = sfi_list[0]
+
+        return sfi
+
+    def get_sfi_list(self, filter_dict={}):
+        self.logger.debug(
+            "Getting Service Function Instances from VIM filter: '%s'", str(filter_dict)
+        )
+
+        try:
+            self._reload_connection()
+            filter_dict_os = filter_dict.copy()
+
+            if self.api_version3 and "tenant_id" in filter_dict_os:
+                filter_dict_os["project_id"] = filter_dict_os.pop("tenant_id")
+
+            sfi_dict = self.neutron.list_sfc_port_pairs(**filter_dict_os)
+            sfi_list = sfi_dict["port_pairs"]
+            self.__sfi_os2mano(sfi_list)
+
+            return sfi_list
+        except (
+            neExceptions.ConnectionFailed,
+            ksExceptions.ClientException,
+            neExceptions.NeutronException,
+            ConnectionError,
+        ) as e:
+            self._format_exception(e)
+
+    def delete_sfi(self, sfi_id):
+        self.logger.debug("Deleting Service Function Instance '%s' from VIM", sfi_id)
+
+        try:
+            self._reload_connection()
+            self.neutron.delete_sfc_port_pair(sfi_id)
+
+            return sfi_id
+        except (
+            neExceptions.ConnectionFailed,
+            neExceptions.NeutronException,
+            ksExceptions.ClientException,
+            neExceptions.NeutronException,
+            ConnectionError,
+        ) as e:
+            self._format_exception(e)
+
+    def new_sf(self, name, sfis, sfc_encap=True):
+        self.logger.debug("Adding a new Service Function to VIM, named '%s'", name)
+
+        try:
+            new_sf = None
+            self._reload_connection()
+            # correlation = None
+            # if sfc_encap:
+            #     correlation = "nsh"
+
+            for instance in sfis:
+                sfi = self.get_sfi(instance)
+
+                if sfi.get("sfc_encap") != sfc_encap:
+                    raise vimconn.VimConnNotSupportedException(
+                        "OpenStack VIM connector requires all SFIs of the "
+                        "same SF to share the same SFC Encapsulation"
+                    )
+
+            sf_dict = {"name": name, "port_pairs": sfis}
+            new_sf = self.neutron.create_sfc_port_pair_group(
+                {"port_pair_group": sf_dict}
+            )
+
+            return new_sf["port_pair_group"]["id"]
+        except (
+            neExceptions.ConnectionFailed,
+            ksExceptions.ClientException,
+            neExceptions.NeutronException,
+            ConnectionError,
+        ) as e:
+            if new_sf:
+                try:
+                    self.neutron.delete_sfc_port_pair_group(
+                        new_sf["port_pair_group"]["id"]
+                    )
+                except Exception:
+                    self.logger.error(
+                        "Creation of Service Function failed, with "
+                        "subsequent deletion failure as well."
+                    )
+
+            self._format_exception(e)
+
+    def get_sf(self, sf_id):
+        self.logger.debug("Getting Service Function %s from VIM", sf_id)
+        filter_dict = {"id": sf_id}
+        sf_list = self.get_sf_list(filter_dict)
+
+        if len(sf_list) == 0:
+            raise vimconn.VimConnNotFoundException(
+                "Service Function '{}' not found".format(sf_id)
+            )
+        elif len(sf_list) > 1:
+            raise vimconn.VimConnConflictException(
+                "Found more than one Service Function with this criteria"
+            )
+
+        sf = sf_list[0]
+
+        return sf
+
+    def get_sf_list(self, filter_dict={}):
+        self.logger.debug(
+            "Getting Service Function from VIM filter: '%s'", str(filter_dict)
+        )
+
+        try:
+            self._reload_connection()
+            filter_dict_os = filter_dict.copy()
+
+            if self.api_version3 and "tenant_id" in filter_dict_os:
+                filter_dict_os["project_id"] = filter_dict_os.pop("tenant_id")
+
+            sf_dict = self.neutron.list_sfc_port_pair_groups(**filter_dict_os)
+            sf_list = sf_dict["port_pair_groups"]
+            self.__sf_os2mano(sf_list)
+
+            return sf_list
+        except (
+            neExceptions.ConnectionFailed,
+            ksExceptions.ClientException,
+            neExceptions.NeutronException,
+            ConnectionError,
+        ) as e:
+            self._format_exception(e)
+
+    def delete_sf(self, sf_id):
+        self.logger.debug("Deleting Service Function '%s' from VIM", sf_id)
+
+        try:
+            self._reload_connection()
+            self.neutron.delete_sfc_port_pair_group(sf_id)
+
+            return sf_id
+        except (
+            neExceptions.ConnectionFailed,
+            neExceptions.NeutronException,
+            ksExceptions.ClientException,
+            neExceptions.NeutronException,
+            ConnectionError,
+        ) as e:
+            self._format_exception(e)
+
+    def new_sfp(self, name, classifications, sfs, sfc_encap=True, spi=None):
+        self.logger.debug("Adding a new Service Function Path to VIM, named '%s'", name)
+
+        try:
+            new_sfp = None
+            self._reload_connection()
+            # In networking-sfc the MPLS encapsulation is legacy
+            # should be used when no full SFC Encapsulation is intended
+            correlation = "mpls"
+
+            if sfc_encap:
+                correlation = "nsh"
+
+            sfp_dict = {
+                "name": name,
+                "flow_classifiers": classifications,
+                "port_pair_groups": sfs,
+                "chain_parameters": {"correlation": correlation},
+            }
+
+            if spi:
+                sfp_dict["chain_id"] = spi
+
+            new_sfp = self.neutron.create_sfc_port_chain({"port_chain": sfp_dict})
+
+            return new_sfp["port_chain"]["id"]
+        except (
+            neExceptions.ConnectionFailed,
+            ksExceptions.ClientException,
+            neExceptions.NeutronException,
+            ConnectionError,
+        ) as e:
+            if new_sfp:
+                try:
+                    self.neutron.delete_sfc_port_chain(new_sfp["port_chain"]["id"])
+                except Exception:
+                    self.logger.error(
+                        "Creation of Service Function Path failed, with "
+                        "subsequent deletion failure as well."
+                    )
+
+            self._format_exception(e)
+
+    def get_sfp(self, sfp_id):
+        self.logger.debug(" Getting Service Function Path %s from VIM", sfp_id)
+
+        filter_dict = {"id": sfp_id}
+        sfp_list = self.get_sfp_list(filter_dict)
+
+        if len(sfp_list) == 0:
+            raise vimconn.VimConnNotFoundException(
+                "Service Function Path '{}' not found".format(sfp_id)
+            )
+        elif len(sfp_list) > 1:
+            raise vimconn.VimConnConflictException(
+                "Found more than one Service Function Path with this criteria"
+            )
+
+        sfp = sfp_list[0]
+
+        return sfp
+
+    def get_sfp_list(self, filter_dict={}):
+        self.logger.debug(
+            "Getting Service Function Paths from VIM filter: '%s'", str(filter_dict)
+        )
+
+        try:
+            self._reload_connection()
+            filter_dict_os = filter_dict.copy()
+
+            if self.api_version3 and "tenant_id" in filter_dict_os:
+                filter_dict_os["project_id"] = filter_dict_os.pop("tenant_id")
+
+            sfp_dict = self.neutron.list_sfc_port_chains(**filter_dict_os)
+            sfp_list = sfp_dict["port_chains"]
+            self.__sfp_os2mano(sfp_list)
+
+            return sfp_list
+        except (
+            neExceptions.ConnectionFailed,
+            ksExceptions.ClientException,
+            neExceptions.NeutronException,
+            ConnectionError,
+        ) as e:
+            self._format_exception(e)
+
+    def delete_sfp(self, sfp_id):
+        self.logger.debug("Deleting Service Function Path '%s' from VIM", sfp_id)
+
+        try:
+            self._reload_connection()
+            self.neutron.delete_sfc_port_chain(sfp_id)
+
+            return sfp_id
+        except (
+            neExceptions.ConnectionFailed,
+            neExceptions.NeutronException,
+            ksExceptions.ClientException,
+            neExceptions.NeutronException,
+            ConnectionError,
+        ) as e:
+            self._format_exception(e)
+
+    def refresh_sfps_status(self, sfp_list):
+        """Get the status of the service function path
+        Params: the list of sfp identifiers
+        Returns a dictionary with:
+            vm_id:          #VIM id of this service function path
+                status:     #Mandatory. Text with one of:
+                            #  DELETED (not found at vim)
+                            #  VIM_ERROR (Cannot connect to VIM, VIM response error, ...)
+                            #  OTHER (Vim reported other status not understood)
+                            #  ERROR (VIM indicates an ERROR status)
+                            #  ACTIVE,
+                            #  CREATING (on building process)
+                error_msg:  #Text with VIM error message, if any. Or the VIM connection ERROR
+                vim_info:   #Text with plain information obtained from vim (yaml.safe_dump)F
+        """
+        sfp_dict = {}
+        self.logger.debug(
+            "refresh_sfps status: Getting tenant SFP information from VIM"
+        )
+
+        for sfp_id in sfp_list:
+            sfp = {}
+
+            try:
+                sfp_vim = self.get_sfp(sfp_id)
+
+                if sfp_vim["spi"]:
+                    sfp["status"] = vmStatus2manoFormat["ACTIVE"]
+                else:
+                    sfp["status"] = "OTHER"
+                    sfp["error_msg"] = "VIM status reported " + sfp["status"]
+
+                sfp["vim_info"] = self.serialize(sfp_vim)
+
+                if sfp_vim.get("fault"):
+                    sfp["error_msg"] = str(sfp_vim["fault"])
+            except vimconn.VimConnNotFoundException as e:
+                self.logger.error("Exception getting sfp status: %s", str(e))
+                sfp["status"] = "DELETED"
+                sfp["error_msg"] = str(e)
+            except vimconn.VimConnException as e:
+                self.logger.error("Exception getting sfp status: %s", str(e))
+                sfp["status"] = "VIM_ERROR"
+                sfp["error_msg"] = str(e)
+
+            sfp_dict[sfp_id] = sfp
+
+        return sfp_dict
+
+    def refresh_sfis_status(self, sfi_list):
+        """Get the status of the service function instances
+        Params: the list of sfi identifiers
+        Returns a dictionary with:
+            vm_id:          #VIM id of this service function instance
+                status:     #Mandatory. Text with one of:
+                            #  DELETED (not found at vim)
+                            #  VIM_ERROR (Cannot connect to VIM, VIM response error, ...)
+                            #  OTHER (Vim reported other status not understood)
+                            #  ERROR (VIM indicates an ERROR status)
+                            #  ACTIVE,
+                            #  CREATING (on building process)
+                error_msg:  #Text with VIM error message, if any. Or the VIM connection ERROR
+                vim_info:   #Text with plain information obtained from vim (yaml.safe_dump)
+        """
+        sfi_dict = {}
+        self.logger.debug(
+            "refresh_sfis status: Getting tenant sfi information from VIM"
+        )
+
+        for sfi_id in sfi_list:
+            sfi = {}
+
+            try:
+                sfi_vim = self.get_sfi(sfi_id)
+
+                if sfi_vim:
+                    sfi["status"] = vmStatus2manoFormat["ACTIVE"]
+                else:
+                    sfi["status"] = "OTHER"
+                    sfi["error_msg"] = "VIM status reported " + sfi["status"]
+
+                sfi["vim_info"] = self.serialize(sfi_vim)
+
+                if sfi_vim.get("fault"):
+                    sfi["error_msg"] = str(sfi_vim["fault"])
+            except vimconn.VimConnNotFoundException as e:
+                self.logger.error("Exception getting sfi status: %s", str(e))
+                sfi["status"] = "DELETED"
+                sfi["error_msg"] = str(e)
+            except vimconn.VimConnException as e:
+                self.logger.error("Exception getting sfi status: %s", str(e))
+                sfi["status"] = "VIM_ERROR"
+                sfi["error_msg"] = str(e)
+
+            sfi_dict[sfi_id] = sfi
+
+        return sfi_dict
+
+    def refresh_sfs_status(self, sf_list):
+        """Get the status of the service functions
+        Params: the list of sf identifiers
+        Returns a dictionary with:
+            vm_id:          #VIM id of this service function
+                status:     #Mandatory. Text with one of:
+                            #  DELETED (not found at vim)
+                            #  VIM_ERROR (Cannot connect to VIM, VIM response error, ...)
+                            #  OTHER (Vim reported other status not understood)
+                            #  ERROR (VIM indicates an ERROR status)
+                            #  ACTIVE,
+                            #  CREATING (on building process)
+                error_msg:  #Text with VIM error message, if any. Or the VIM connection ERROR
+                vim_info:   #Text with plain information obtained from vim (yaml.safe_dump)
+        """
+        sf_dict = {}
+        self.logger.debug("refresh_sfs status: Getting tenant sf information from VIM")
+
+        for sf_id in sf_list:
+            sf = {}
+
+            try:
+                sf_vim = self.get_sf(sf_id)
+
+                if sf_vim:
+                    sf["status"] = vmStatus2manoFormat["ACTIVE"]
+                else:
+                    sf["status"] = "OTHER"
+                    sf["error_msg"] = "VIM status reported " + sf_vim["status"]
+
+                sf["vim_info"] = self.serialize(sf_vim)
+
+                if sf_vim.get("fault"):
+                    sf["error_msg"] = str(sf_vim["fault"])
+            except vimconn.VimConnNotFoundException as e:
+                self.logger.error("Exception getting sf status: %s", str(e))
+                sf["status"] = "DELETED"
+                sf["error_msg"] = str(e)
+            except vimconn.VimConnException as e:
+                self.logger.error("Exception getting sf status: %s", str(e))
+                sf["status"] = "VIM_ERROR"
+                sf["error_msg"] = str(e)
+
+            sf_dict[sf_id] = sf
+
+        return sf_dict
+
+    def refresh_classifications_status(self, classification_list):
+        """Get the status of the classifications
+        Params: the list of classification identifiers
+        Returns a dictionary with:
+            vm_id:          #VIM id of this classifier
+                status:     #Mandatory. Text with one of:
+                            #  DELETED (not found at vim)
+                            #  VIM_ERROR (Cannot connect to VIM, VIM response error, ...)
+                            #  OTHER (Vim reported other status not understood)
+                            #  ERROR (VIM indicates an ERROR status)
+                            #  ACTIVE,
+                            #  CREATING (on building process)
+                error_msg:  #Text with VIM error message, if any. Or the VIM connection ERROR
+                vim_info:   #Text with plain information obtained from vim (yaml.safe_dump)
+        """
+        classification_dict = {}
+        self.logger.debug(
+            "refresh_classifications status: Getting tenant classification information from VIM"
+        )
+
+        for classification_id in classification_list:
+            classification = {}
+
+            try:
+                classification_vim = self.get_classification(classification_id)
+
+                if classification_vim:
+                    classification["status"] = vmStatus2manoFormat["ACTIVE"]
+                else:
+                    classification["status"] = "OTHER"
+                    classification["error_msg"] = (
+                        "VIM status reported " + classification["status"]
+                    )
+
+                classification["vim_info"] = self.serialize(classification_vim)
+
+                if classification_vim.get("fault"):
+                    classification["error_msg"] = str(classification_vim["fault"])
+            except vimconn.VimConnNotFoundException as e:
+                self.logger.error("Exception getting classification status: %s", str(e))
+                classification["status"] = "DELETED"
+                classification["error_msg"] = str(e)
+            except vimconn.VimConnException as e:
+                self.logger.error("Exception getting classification status: %s", str(e))
+                classification["status"] = "VIM_ERROR"
+                classification["error_msg"] = str(e)
+
+            classification_dict[classification_id] = classification
+
+        return classification_dict
+
     def new_affinity_group(self, affinity_group_data):
         """Adds a server group to VIM
             affinity_group_data contains a dictionary with information, keys: