Merge branch 'master' of https://github.com/NORDUnet/opennsa into stable

test/db.py

@@ -15,6 +15,6 @@ def setupDatabase(config_file=CONFIG_FILE):
 
     tc = json.load( open(config_file) )
 
-    database.setupDatabase( tc['database'], tc['user'], tc['password'], host='127.0.0.1')
+    database.setupDatabase( tc['database'], tc['user'], tc['password'], host=tc['hostname'])
 
 

test/test_config.py

@@ -3,12 +3,12 @@ from twisted.trial import unittest
 import json
 import tempfile
 import configparser
+from io import StringIO
 
 from opennsa import config, setup
+from opennsa.config import Config
 from . import db
 
-
-
 ARUBA_DUD_CONFIG_NO_DATABASE = """
 [service]
 domain=aruba.net
@@ -37,11 +37,15 @@ dbpassword={db_password}
 tls=false
 
 [dud]
+
+[backends:dummy]
+name=foobar
 """
 
 ARUBA_DUD_CONFIG = """
 [service]
 domain=aruba.net
+host=dummy
 logfile=
 rest=true
 port=4080
@@ -105,31 +109,49 @@ ethernet    bon     bonaire.net:topology#arb(-in|-out)  vlan:1780-1799
 
 class ConfigTest(unittest.TestCase):
 
+    def _reset_instance(self):
+        try:
+            self.configIns._instance.cfg = None
+            self.configIns._instance.vc = None
+        except:
+            pass
 
     def setUp(self):
-
-        tc = json.load( open(db.CONFIG_FILE) )
-        self.database    = tc['database']
-        self.db_user     = tc['user']
+        self.configIns = Config.instance()
+        self._reset_instance()
+        tc = json.load(open(db.CONFIG_FILE))
+        self.database = tc['database']
+        self.db_user = tc['user']
         self.db_password = tc['password']
-        self.db_host     = '127.0.0.1'
+        self.db_host = tc['hostname']
 
+    def _generate_temp_file(self, buffer):
+        """
+        Helper utility to generate a temp file and write buffer to it.
+        """
+        tmp = tempfile.NamedTemporaryFile('w+t')
+        tmp.write(buffer)
+        tmp.flush()
+        return tmp
 
     def testConfigParsingNoDatabase(self):
 
         config_file_content = ARUBA_DUD_CONFIG_NO_DATABASE
 
-        raw_cfg = configparser.SafeConfigParser()
-        raw_cfg.read_string(config_file_content)
+        expectedError = "No database specified in configuration file (mandatory)"
+        tmp = None
 
         try:
-            cfg = config.readVerifyConfig(raw_cfg)
+            tmp = self._generate_temp_file(config_file_content)
+            cfg, vc = self.configIns.read_config(tmp.name)
             nsa_service = setup.OpenNSAService(cfg)
             factory, _ = nsa_service.setupServiceFactory()
             self.fail('Should have raised config.ConfigurationError')
         except config.ConfigurationError as e:
-            pass
-
+            self.assertEquals(expectedError, e.args[0])
+        finally:
+            if tmp is not None:
+                tmp.close()
 
     def testConfigParsingNoNetworkName(self):
 
@@ -137,17 +159,18 @@ class ConfigTest(unittest.TestCase):
                                                                       db_host=self.db_host,
                                                                       db_user=self.db_user,
                                                                       db_password=self.db_password)
-        raw_cfg = configparser.SafeConfigParser()
-        raw_cfg.read_string(config_file_content)
-
+        tmp = None
         try:
-            cfg = config.readVerifyConfig(raw_cfg)
-            nsa_service = setup.OpenNSAService(cfg)
+            tmp = self._generate_temp_file(config_file_content)
+            cfg, vc = self.configIns.read_config(tmp.name)
+            nsa_service = setup.OpenNSAService(self.configIns.config_dict())
             factory, _ = nsa_service.setupServiceFactory()
             self.fail('Should have raised config.ConfigurationError')
         except config.ConfigurationError as e:
             pass
-
+        finally:
+            if tmp is not None:
+                tmp.close()
 
     def testConfigParsing(self):
 
@@ -161,24 +184,28 @@ class ConfigTest(unittest.TestCase):
                                                       db_password=self.db_password,
                                                       nrm_map=aruba_ojs.name)
 
-        raw_cfg = configparser.SafeConfigParser()
-        raw_cfg.read_string(config_file_content)
-
-        cfg = config.readVerifyConfig(raw_cfg)
-        nsa_service = setup.OpenNSAService(cfg)
-        factory, _ = nsa_service.setupServiceFactory()
+        tmp = self._generate_temp_file(config_file_content)
+        cfg, vc = self.configIns.read_config(tmp.name)
 
+        try:
+            nsa_service = setup.OpenNSAService(vc)
+            factory, _ = nsa_service.setupServiceFactory()
+        finally:
+            tmp.close()
+            aruba_ojs.close()
 
     def testInvalidLegacyConfig(self):
 
-        raw_cfg = configparser.SafeConfigParser()
-        raw_cfg.read_string(INVALID_LEGACY_CONFIG)
+        config_file_content = INVALID_LEGACY_CONFIG
+        tmp = self._generate_temp_file(config_file_content)
+
         try:
-            cfg = config.readVerifyConfig(raw_cfg)
+            cfg, vc = self.configIns.read_config(tmp.name)
             self.fail('Should have raised ConfigurationError')
         except config.ConfigurationError:
             pass
-
+        finally:
+            tmp.close()
 
     def testConfigParsingMultiBackend(self):
 
@@ -201,13 +228,13 @@ class ConfigTest(unittest.TestCase):
                                                             nrm_ojs=aruba_ojs.name,
                                                             nrm_san=aruba_san.name)
         # parse and verify config
+        tmp = self._generate_temp_file(config_file_content)
 
-        cfg = configparser.SafeConfigParser()
-        cfg.read_string(config_file_content)
-
-        verified_config = config.readVerifyConfig(cfg)
-
-        # do the setup dance to see if all the wiring is working, but don't start anything
-        nsa_service = setup.OpenNSAService(verified_config)
-        factory, _ = nsa_service.setupServiceFactory()
+        try:
+            cfg, verified_config = self.configIns.read_config(tmp.name)
 
+            # do the setup dance to see if all the wiring is working, but don't start anything
+            nsa_service = setup.OpenNSAService(verified_config)
+            factory, _ = nsa_service.setupServiceFactory()
+        finally:
+            tmp.close()

test/test_multiple.py

@@ -16,17 +16,15 @@ from twisted.application import internet, service
 
 from twisted.trial import unittest
 
+from opennsa.config import Config
 from opennsa import constants, config, setup, nsa
 from opennsa.protocols.shared import httpclient
-#from opennsa.protocols.nsi2 import requesterservice, requesterclient
+# from opennsa.protocols.nsi2 import requesterservice, requesterclient
 from opennsa.protocols.nsi2 import requesterclient
 from opennsa.discovery.bindings import discovery
 
-
 from . import db
 
-
-
 ARUBA_CONFIG = """
 [service]
 domain=aruba.net
@@ -95,15 +93,31 @@ ethernet    cur     curacao.net:topology#bon(-in|-out)  vlan:1780-1799      1000
 
 class MultipleInstancesTestMultipleInstancesTest(unittest.TestCase):
 
+    def load_config(self, buffer):
+        cfgIns = Config.instance()
+
+        try:
+            cfgIns._instance.cfg = None
+            cfgIns._instance.vc = None
+        except:
+            pass
+
+        tmp = tempfile.NamedTemporaryFile('w+t')
+        tmp.write(buffer)
+        tmp.flush()
+        cfg, vc = cfgIns.read_config(tmp.name)
+        tmp.close()
+        return cfg, vc
+
     def setUp(self):
 
         # database
 
-        tc = json.load( open(db.CONFIG_FILE) )
-        self.database    = tc['database']
-        self.db_user     = tc['user']
+        tc = json.load(open(db.CONFIG_FILE))
+        self.database = tc['database']
+        self.db_user = tc['user']
         self.db_password = tc['password']
-        self.db_host     = '127.0.0.1'
+        self.db_host = tc['hostname']
 
         # make temporary files for nrm map files
 
@@ -135,14 +149,8 @@ class MultipleInstancesTestMultipleInstancesTest(unittest.TestCase):
                                                bonaire_nrm=bonaire_nrm_file.name)
 
         # parse and verify config
-
-        aruba_cfg = configparser.SafeConfigParser()
-        aruba_cfg.read_string(aruba_config)
-        aruba_vc = config.readVerifyConfig(aruba_cfg)
-
-        bonaire_cfg = configparser.SafeConfigParser()
-        bonaire_cfg.read_string(bonaire_config)
-        bonaire_vc = config.readVerifyConfig(bonaire_cfg)
+        aruba_cfg, aruba_vc = self.load_config(aruba_config)
+        bonaire_cfg, bonaire_vc = self.load_config(bonaire_config)
 
         # setup service
 
@@ -159,12 +167,10 @@ class MultipleInstancesTestMultipleInstancesTest(unittest.TestCase):
 
         return self.top_service.startService()
 
-
     def tearDown(self):
 
         return self.top_service.stopService()
 
-
     @defer.inlineCallbacks
     def testDiscovery(self):
 
@@ -194,9 +200,8 @@ class MultipleInstancesTestMultipleInstancesTest(unittest.TestCase):
 
         self.failIfEqual(cs_service_url, None, 'No service url found')
 
-        #header = nsa.NSIHeader(requester_agent.urn(), aruba_discovery.id_)
-        #header.newCorrelationId()
-
-        #provider = requesterclient.RequesterClient(self.provider_agent.endpoint, self.requester_agent.endpoint)
-        #response_cid = yield self.provider.reserve(self.header, None, None, None, self.criteria)
+        # header = nsa.NSIHeader(requester_agent.urn(), aruba_discovery.id_)
+        # header.newCorrelationId()
 
+        # provider = requesterclient.RequesterClient(self.provider_agent.endpoint, self.requester_agent.endpoint)
+        # response_cid = yield self.provider.reserve(self.header, None, None, None, self.criteria)

test/test_ncsvpn.py

@@ -32,7 +32,7 @@ class NCSVPNBackendTest(unittest.TestCase):
 
         self.backend.startService()
 
-        database.setupDatabase( tc['database'], tc['database-user'], tc['database-password'])
+        database.setupDatabase(tc['database'], tc['database-user'], tc['database-password'], host=tc['hostname'])
 
         self.requester_nsa = nsa.NetworkServiceAgent('test-requester', 'http://example.org/nsa-test-requester')
         self.provider_nsa  = nsa.NetworkServiceAgent('test-provider',  'http://example.org/nsa-test-provider')

util/integration-config.json

+{
+    "container" : "opennsa-test-database",
+    "database"  : "opennsatest",
+    "user"      : "opennsa",
+    "hostname"  : "database",
+    "password"  : "w1gWIn7NDGXjXMguiI2Qe05X"
+}

util/pg-test-psql

 #!/bin/sh
+set -e 
 
 # Run psql on the PostgreSQL test database
 
@@ -8,6 +9,6 @@ user=$(cat .opennsa-test.json | jq  -r '.user')
 password=$(cat .opennsa-test.json | jq  -r '.password')
 
 
-docker run --rm --name opennsa-test-psql --link=$container -it -e PGPASSWORD=$password postgres:9.6.5 \
+docker run --rm --name opennsa-test-psql --link=$container -it -e PGPASSWORD=$password postgres:12 \
     psql -h $container -U $user $database
 

util/pg-test-run

 #!/bin/sh
-
 set -e
 
 # Run a PostgreSQL database for testing
@@ -22,7 +21,8 @@ echo "{
     \"container\" : \"$container\",
     \"database\"  : \"$database\",
     \"user\"      : \"$user\",
-    \"password\"  : \"$password\"
+    \"password\"  : \"$password\",
+    \"hostname\"  : \"127.0.0.1\"
 }" > "$configfile"