Merge "Add new modules: Resource Lock and Doorman"

10 files changed, 680 insertions, 0 deletions

diff --git a/lib/doorman/src/test/java/org/onap/ccsdk/features/lib/doorman/it/MessageQueueDataItem.java b/lib/doorman/src/test/java/org/onap/ccsdk/features/lib/doorman/it/MessageQueueDataItem.java
new file mode 100644
index 000000000..32e94e5d3
--- /dev/null
+++ b/lib/doorman/src/test/java/org/onap/ccsdk/features/lib/doorman/it/MessageQueueDataItem.java
@@ -0,0 +1,91 @@
+package org.onap.ccsdk.features.lib.doorman.it;
+
+import java.text.SimpleDateFormat;
+import java.util.Date;
+import org.onap.ccsdk.features.lib.doorman.data.MessageAction;
+import org.onap.ccsdk.features.lib.doorman.data.MessageActionValue;
+import org.onap.ccsdk.features.lib.doorman.data.MessageStatus;
+
+public class MessageQueueDataItem implements Comparable<MessageQueueDataItem> {
+
+	public Date timeStamp;
+	public String extMessageId;
+	public MessageStatus status;
+	public MessageAction action;
+
+	@Override
+	public int compareTo(MessageQueueDataItem other) {
+		int c = timeStamp.compareTo(other.timeStamp);
+		if (c == 0) {
+			if (action != null && other.status != null) {
+				return -1;
+			}
+			if (status != null && other.action != null) {
+				return 1;
+			}
+		}
+		return c;
+	}
+
+	@Override
+	public int hashCode() {
+		return System.identityHashCode(extMessageId);
+	}
+
+	@Override
+	public boolean equals(Object o) {
+		if (o == null || !(o instanceof MessageQueueDataItem)) {
+			return false;
+		}
+		MessageQueueDataItem other = (MessageQueueDataItem) o;
+		if (!extMessageId.equals(other.extMessageId)) {
+			return false;
+		}
+		if (status != null && (other.status == null || status.status != other.status.status)) {
+			return false;
+		}
+		if (action != null) {
+			if (other.action == null || action.action != other.action.action) {
+				return false;
+			}
+			if (action.action == MessageActionValue.HOLD || action.action == MessageActionValue.RETURN_HOLD) {
+				if (action.holdTime != other.action.holdTime) {
+					return false;
+				}
+			} else if (action.action == MessageActionValue.RETURN_COMPLETE) {
+				if (!action.resolution.equals(other.action.resolution)) {
+					return false;
+				}
+			}
+		}
+		return true;
+	}
+
+	@Override
+	public String toString() {
+		StringBuilder ss = new StringBuilder();
+		if (timeStamp != null) {
+			ss.append(df.format(timeStamp)).append(" | ");
+		}
+		if (status != null) {
+			ss.append("STATUS: ");
+		} else {
+			ss.append("ACTION: ");
+		}
+		ss.append(String.format("%-20s | ", extMessageId));
+		if (status != null) {
+			ss.append(status.status);
+		} else {
+			ss.append(action.action);
+			if (action.holdTime > 0) {
+				ss.append(" | ").append(action.holdTime);
+			}
+			if (action.resolution != null) {
+				ss.append(" | ").append(action.resolution);
+			}
+		}
+		return ss.toString();
+	}
+
+	private static SimpleDateFormat df = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss.SSS");
+}
diff --git a/lib/doorman/src/test/java/org/onap/ccsdk/features/lib/doorman/it/MessageQueueTest.java b/lib/doorman/src/test/java/org/onap/ccsdk/features/lib/doorman/it/MessageQueueTest.java
new file mode 100644
index 000000000..ca1c4910d
--- /dev/null
+++ b/lib/doorman/src/test/java/org/onap/ccsdk/features/lib/doorman/it/MessageQueueTest.java
@@ -0,0 +1,222 @@
+package org.onap.ccsdk.features.lib.doorman.it;
+
+import java.io.BufferedReader;
+import java.io.File;
+import java.io.InputStream;
+import java.io.InputStreamReader;
+import java.net.URL;
+import java.util.ArrayList;
+import java.util.Collection;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.junit.runners.Parameterized;
+import org.junit.runners.Parameterized.Parameters;
+import org.onap.ccsdk.features.lib.doorman.MessageClassifier;
+import org.onap.ccsdk.features.lib.doorman.MessageInterceptor;
+import org.onap.ccsdk.features.lib.doorman.MessageInterceptorFactory;
+import org.onap.ccsdk.features.lib.doorman.MessageProcessor;
+import org.onap.ccsdk.features.lib.doorman.MessageQueueHandler;
+import org.onap.ccsdk.features.lib.doorman.dao.MessageDaoImpl;
+import org.onap.ccsdk.features.lib.doorman.data.MessageData;
+import org.onap.ccsdk.features.lib.doorman.data.Queue;
+import org.onap.ccsdk.features.lib.doorman.impl.MessageInterceptorFactoryImpl;
+import org.onap.ccsdk.features.lib.doorman.testutil.DbUtil;
+import org.onap.ccsdk.features.lib.doorman.util.JsonUtil;
+import org.onap.ccsdk.features.lib.rlock.LockHelperImpl;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+@RunWith(Parameterized.class)
+public class MessageQueueTest {
+
+	private static final Logger log = LoggerFactory.getLogger(MessageQueueTest.class);
+
+	private String test;
+
+	public MessageQueueTest(String test) {
+		this.test = test;
+	}
+
+	@SuppressWarnings("unchecked")
+	@Test
+	public void test() throws Exception {
+		log.info("#########################################################################");
+		log.info("MessageQueueTest: " + test + " started");
+
+		String testSetupJson = readResource("it/" + test + "/test.json");
+		Map<String, Object> testSetup = (Map<String, Object>) JsonUtil.jsonToData(testSetupJson);
+
+		Map<String, MessageQueueHandler> handlerMap = new HashMap<>();
+
+		for (Object o : (List<Object>) testSetup.get("handler_list")) {
+			Map<String, Object> handlerSetup = (Map<String, Object>) o;
+			String queueType = (String) handlerSetup.get("queue_type");
+			String handlerClassName = (String) handlerSetup.get("handler_class");
+			try {
+				Class<?> handlerClass = Class.forName("org.onap.ccsdk.features.lib.doorman.it." + test + "." + handlerClassName);
+				MessageQueueHandler handler = (MessageQueueHandler) handlerClass.newInstance();
+				handlerMap.put(queueType, handler);
+				log.info("Handler found for queue type: " + queueType + ": " + handlerClass.getName());
+			} catch (Exception e) {
+			}
+		}
+
+		MessageInterceptorFactory factory = setupMessageInterceptorFactory(handlerMap, new Classifier(), new Processor());
+
+		List<Object> requestList = (List<Object>) testSetup.get("request_list");
+
+		List<Thread> threadList = new ArrayList<>();
+
+		for (int i = 0; i < requestList.size(); i++) {
+			Map<String, Object> requestSetup = (Map<String, Object>) requestList.get(i);
+
+			MessageData request = new MessageData();
+			request.param = (Map<String, Object>) requestSetup.get("request_param");
+			Map<String, Object> requestBodyData = (Map<String, Object>) requestSetup.get("request_body");
+			if (requestBodyData != null) {
+				request.body = JsonUtil.dataToJson(requestBodyData);
+			} else {
+				request.body = readResource("it/" + test + "/" + requestSetup.get("request_body_file"));
+			}
+
+			MessageData response = new MessageData();
+			response.param = (Map<String, Object>) requestSetup.get("response_param");
+			Map<String, Object> responseBodyData = (Map<String, Object>) requestSetup.get("response_body");
+			if (responseBodyData != null) {
+				response.body = JsonUtil.dataToJson(responseBodyData);
+			} else {
+				response.body = readResource("it/" + test + "/" + requestSetup.get("response_body_file"));
+			}
+
+			long startTime = (Long) requestSetup.get("start_time");
+			long processTime = (Long) requestSetup.get("process_time");
+
+			MessageInterceptor interceptor = factory.create();
+
+			Thread t = new Thread((Runnable) () -> {
+				try {
+					Thread.sleep(startTime);
+				} catch (InterruptedException e) {
+				}
+
+				MessageData r = interceptor.processRequest(request);
+
+				if (r == null) {
+					try {
+						Thread.sleep(processTime);
+					} catch (InterruptedException e) {
+					}
+
+					interceptor.processResponse(response);
+				}
+
+			}, "Message-" + i);
+
+			threadList.add(t);
+			t.start();
+		}
+
+		for (Thread t : threadList) {
+			t.join();
+		}
+
+		log.info("MessageQueueTest: " + test + " completed");
+		log.info("Result:");
+
+		String testResultJson = readResource("it/" + test + "/result.json");
+		Map<String, Object> testResult = (Map<String, Object>) JsonUtil.jsonToData(testResultJson);
+		MessageQueueTestResult.checkResult(testResult);
+	}
+
+	private static class Classifier implements MessageClassifier {
+
+		@Override
+		public Queue determineQueue(MessageData request) {
+			Queue q = new Queue();
+			q.type = (String) request.param.get("queue_type");
+			q.id = (String) request.param.get("queue_id");
+			return q;
+		}
+
+		@Override
+		public String getExtMessageId(MessageData request) {
+			return (String) request.param.get("request_id");
+		}
+	}
+
+	private static class Processor implements MessageProcessor {
+
+		@Override
+		public void processMessage(MessageData request) {
+			long processTime = (Long) request.param.get("process_time");
+			try {
+				Thread.sleep(processTime);
+			} catch (InterruptedException e) {
+			}
+		}
+	}
+
+	public static MessageInterceptorFactory setupMessageInterceptorFactory(Map<String, MessageQueueHandler> handlerMap, MessageClassifier classifier, MessageProcessor processor) {
+		LockHelperImpl lockHelper = new LockHelperImpl();
+		lockHelper.setDataSource(DbUtil.getDataSource());
+		lockHelper.setLockWait(5);
+		lockHelper.setRetryCount(10);
+
+		MessageDaoImpl messageDao = new MessageDaoImpl();
+		messageDao.setDataSource(DbUtil.getDataSource());
+
+		MessageInterceptorFactoryImpl f = new MessageInterceptorFactoryImpl();
+		f.setMessageDao(messageDao);
+		f.setLockHelper(lockHelper);
+		f.setLockTimeout(20);
+		f.setHandlerMap(handlerMap);
+		f.setMessageClassifier(classifier);
+		f.setMessageProcessor(processor);
+		return f;
+	}
+
+	@Parameters(name = "{0}")
+	public static Collection<Object[]> allTests() {
+		List<Object[]> ll = new ArrayList<>();
+
+		String[] tcList = list("it");
+		for (String tc : tcList) {
+			ll.add(new Object[] { tc });
+		}
+		return ll;
+	}
+
+	private static String[] list(String dir) {
+		try {
+			ClassLoader loader = Thread.currentThread().getContextClassLoader();
+			URL url = loader.getResource(dir);
+			String path = url.getPath();
+			return new File(path).list();
+		} catch (Exception e) {
+			log.warn("Error getting directory list for: " + dir + ": " + e.getMessage(), e);
+			return new String[0];
+		}
+	}
+
+	private static String readResource(String resource) {
+		try {
+			ClassLoader loader = Thread.currentThread().getContextClassLoader();
+			InputStream ins = loader.getResourceAsStream(resource);
+			BufferedReader in = new BufferedReader(new InputStreamReader(ins));
+			StringBuilder ss = new StringBuilder();
+			String line = in.readLine();
+			while (line != null) {
+				ss.append(line).append('\n');
+				line = in.readLine();
+			}
+			in.close();
+			return ss.toString();
+		} catch (Exception e) {
+			log.warn("Error reading resource: " + resource + ": " + e.getMessage(), e);
+			return null;
+		}
+	}
+}
diff --git a/lib/doorman/src/test/java/org/onap/ccsdk/features/lib/doorman/it/MessageQueueTestResult.java b/lib/doorman/src/test/java/org/onap/ccsdk/features/lib/doorman/it/MessageQueueTestResult.java
new file mode 100644
index 000000000..71a2eeafb
--- /dev/null
+++ b/lib/doorman/src/test/java/org/onap/ccsdk/features/lib/doorman/it/MessageQueueTestResult.java
@@ -0,0 +1,120 @@
+package org.onap.ccsdk.features.lib.doorman.it;
+
+import static org.junit.Assert.fail;
+
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.List;
+import java.util.Map;
+import org.onap.ccsdk.features.lib.doorman.dao.MessageDaoImpl;
+import org.onap.ccsdk.features.lib.doorman.data.Message;
+import org.onap.ccsdk.features.lib.doorman.data.MessageAction;
+import org.onap.ccsdk.features.lib.doorman.data.MessageActionValue;
+import org.onap.ccsdk.features.lib.doorman.data.MessageStatus;
+import org.onap.ccsdk.features.lib.doorman.data.MessageStatusValue;
+import org.onap.ccsdk.features.lib.doorman.data.Queue;
+import org.onap.ccsdk.features.lib.doorman.testutil.DbUtil;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+public class MessageQueueTestResult {
+
+	private static final Logger log = LoggerFactory.getLogger(MessageQueueTest.class);
+
+	public static List<MessageQueueDataItem> readResult(String queueType, String queueId) {
+		MessageDaoImpl messageDao = new MessageDaoImpl();
+		messageDao.setDataSource(DbUtil.getDataSource());
+
+		Queue q = new Queue();
+		q.type = queueType;
+		q.id = queueId;
+
+		List<Message> messageList = messageDao.readMessageQueue(q);
+
+		List<MessageQueueDataItem> ll = new ArrayList<>();
+		if (messageList != null) {
+			for (Message m : messageList) {
+				if (m.statusHistory != null) {
+					for (MessageStatus s : m.statusHistory) {
+						MessageQueueDataItem item = new MessageQueueDataItem();
+						item.extMessageId = m.extMessageId;
+						item.status = s;
+						item.timeStamp = s.timestamp;
+						ll.add(item);
+					}
+				}
+				if (m.actionHistory != null) {
+					for (MessageAction a : m.actionHistory) {
+						MessageQueueDataItem item = new MessageQueueDataItem();
+						item.extMessageId = m.extMessageId;
+						item.action = a;
+						item.timeStamp = a.timestamp;
+						ll.add(item);
+					}
+				}
+			}
+		}
+		Collections.sort(ll);
+		return ll;
+	}
+
+	@SuppressWarnings("unchecked")
+	public static void checkResult(Map<String, Object> testResult) {
+		List<Object> resultSetupList = (List<Object>) testResult.get("queue_list");
+		if (resultSetupList != null) {
+			for (Object o : resultSetupList) {
+				Map<String, Object> resultSetup = (Map<String, Object>) o;
+				String queueType = (String) resultSetup.get("queue_type");
+				String queueId = (String) resultSetup.get("queue_id");
+				log.info(queueType + "::" + queueId);
+				List<MessageQueueDataItem> itemList = MessageQueueTestResult.readResult(queueType, queueId);
+				for (MessageQueueDataItem item : itemList) {
+					log.info("    --- " + item);
+				}
+
+				List<Object> checkSequenceList = (List<Object>) resultSetup.get("check_sequence_list");
+				for (int i = 0; i < checkSequenceList.size(); i++) {
+					List<Object> checkSequence = (List<Object>) checkSequenceList.get(i);
+					List<MessageQueueDataItem> checkItemList = new ArrayList<>();
+					for (Object o2 : checkSequence) {
+						String[] ss = ((String) o2).split("\\|");
+						MessageQueueDataItem item = new MessageQueueDataItem();
+						item.extMessageId = ss[1].trim();
+						if (ss[0].trim().equals("STATUS")) {
+							item.status = new MessageStatus();
+							item.status.status = MessageStatusValue.valueOf(ss[2].trim());
+						} else {
+							item.action = new MessageAction();
+							item.action.action = MessageActionValue.valueOf(ss[2].trim());
+							if (item.action.action == MessageActionValue.HOLD || item.action.action == MessageActionValue.RETURN_HOLD) {
+								item.action.holdTime = Integer.parseInt(ss[3].trim());
+							} else if (item.action.action == MessageActionValue.RETURN_COMPLETE) {
+								item.action.resolution = ss[3].trim();
+							}
+						}
+						checkItemList.add(item);
+					}
+					List<MessageQueueDataItem> itemList1 = new ArrayList<>(itemList);
+					itemList1.retainAll(checkItemList);
+					if (!itemList1.equals(checkItemList)) {
+						log.info("Expected sequence #" + i + " not found");
+						log.info("Expected sequence:");
+						for (MessageQueueDataItem item : checkItemList) {
+							log.info("    --- " + item);
+						}
+						log.info("Found sequence:");
+						for (MessageQueueDataItem item : itemList1) {
+							log.info("    --- " + item);
+						}
+						fail("Expected sequence #" + i + " not found");
+					} else {
+						log.info("Expected sequence #" + i + " found in the result:");
+						for (MessageQueueDataItem item : checkItemList) {
+							log.info("    --- " + item);
+						}
+					}
+				}
+			}
+		}
+	}
+}
diff --git a/lib/doorman/src/test/java/org/onap/ccsdk/features/lib/doorman/it/tc1/Classifier.java b/lib/doorman/src/test/java/org/onap/ccsdk/features/lib/doorman/it/tc1/Classifier.java
new file mode 100644
index 000000000..254fd4ce4
--- /dev/null
+++ b/lib/doorman/src/test/java/org/onap/ccsdk/features/lib/doorman/it/tc1/Classifier.java
@@ -0,0 +1,21 @@
+package org.onap.ccsdk.features.lib.doorman.it.tc1;
+
+import org.onap.ccsdk.features.lib.doorman.MessageClassifier;
+import org.onap.ccsdk.features.lib.doorman.data.MessageData;
+import org.onap.ccsdk.features.lib.doorman.data.Queue;
+
+public class Classifier implements MessageClassifier {
+
+	@Override
+	public Queue determineQueue(MessageData request) {
+		Queue q = new Queue();
+		q.type = "Cluster";
+		q.id = "test-queue";
+		return q;
+	}
+
+	@Override
+	public String getExtMessageId(MessageData request) {
+		return (String) request.param.get("request_id");
+	}
+}
diff --git a/lib/doorman/src/test/java/org/onap/ccsdk/features/lib/doorman/it/tc1/Handler.java b/lib/doorman/src/test/java/org/onap/ccsdk/features/lib/doorman/it/tc1/Handler.java
new file mode 100644
index 000000000..f57fdbc36
--- /dev/null
+++ b/lib/doorman/src/test/java/org/onap/ccsdk/features/lib/doorman/it/tc1/Handler.java
@@ -0,0 +1,10 @@
+package org.onap.ccsdk.features.lib.doorman.it.tc1;
+
+import org.onap.ccsdk.features.lib.doorman.impl.MessageHandlerBaseImpl;
+
+public class Handler extends MessageHandlerBaseImpl {
+
+	public Handler() {
+
+	}
+}
diff --git a/lib/doorman/src/test/java/org/onap/ccsdk/features/lib/doorman/it/tc2/Classifier.java b/lib/doorman/src/test/java/org/onap/ccsdk/features/lib/doorman/it/tc2/Classifier.java
new file mode 100644
index 000000000..a32f74650
--- /dev/null
+++ b/lib/doorman/src/test/java/org/onap/ccsdk/features/lib/doorman/it/tc2/Classifier.java
@@ -0,0 +1,21 @@
+package org.onap.ccsdk.features.lib.doorman.it.tc2;
+
+import org.onap.ccsdk.features.lib.doorman.MessageClassifier;
+import org.onap.ccsdk.features.lib.doorman.data.MessageData;
+import org.onap.ccsdk.features.lib.doorman.data.Queue;
+
+public class Classifier implements MessageClassifier {
+
+	@Override
+	public Queue determineQueue(MessageData request) {
+		Queue q = new Queue();
+		q.type = "Cluster";
+		q.id = "test-queue";
+		return q;
+	}
+
+	@Override
+	public String getExtMessageId(MessageData request) {
+		return (String) request.param.get("request_id");
+	}
+}
diff --git a/lib/doorman/src/test/java/org/onap/ccsdk/features/lib/doorman/it/tc2/Handler.java b/lib/doorman/src/test/java/org/onap/ccsdk/features/lib/doorman/it/tc2/Handler.java
new file mode 100644
index 000000000..35b811c5f
--- /dev/null
+++ b/lib/doorman/src/test/java/org/onap/ccsdk/features/lib/doorman/it/tc2/Handler.java
@@ -0,0 +1,53 @@
+package org.onap.ccsdk.features.lib.doorman.it.tc2;
+
+import java.util.HashMap;
+import java.util.Map;
+import org.onap.ccsdk.features.lib.doorman.data.Message;
+import org.onap.ccsdk.features.lib.doorman.data.MessageData;
+import org.onap.ccsdk.features.lib.doorman.impl.MessageHandlerBaseImpl;
+import org.onap.ccsdk.features.lib.doorman.util.JsonUtil;
+
+public class Handler extends MessageHandlerBaseImpl {
+
+	public Handler() {
+		setMaxParallelCount(100);
+		setUpdateWaitTime(20);
+	}
+
+	@SuppressWarnings("unchecked")
+	@Override
+	protected String determineUpdateGroup(Message msg) {
+		if (msg.request.body != null) {
+			Map<String, Object> body = (Map<String, Object>) JsonUtil.jsonToData(msg.request.body);
+			String op = (String) body.get("operation");
+			String entityId = (String) body.get("entity_id");
+			if ("update".equals(op)) {
+				return entityId;
+			}
+		}
+		return super.determineUpdateGroup(msg);
+	}
+
+	@Override
+	protected long determineUpdateSequence(Message msg) {
+		if (msg.request.param != null) {
+			Long n = (Long) msg.request.param.get("sequence_number");
+			if (n != null) {
+				return n;
+			}
+		}
+		return super.determineUpdateSequence(msg);
+	}
+
+	@Override
+	protected MessageData completeResponse(Resolution r, Message msg) {
+		if (r == Resolution.SKIPPED) {
+			MessageData response = new MessageData();
+			response.param = new HashMap<>();
+			response.param.put("http_code", 200L);
+			response.body = "{ \"status\": \"success\" }";
+			return response;
+		}
+		return super.completeResponse(r, msg);
+	}
+}
diff --git a/lib/doorman/src/test/java/org/onap/ccsdk/features/lib/doorman/testutil/DbUtil.java b/lib/doorman/src/test/java/org/onap/ccsdk/features/lib/doorman/testutil/DbUtil.java
new file mode 100644
index 000000000..1e525b4b2
--- /dev/null
+++ b/lib/doorman/src/test/java/org/onap/ccsdk/features/lib/doorman/testutil/DbUtil.java
@@ -0,0 +1,92 @@
+package org.onap.ccsdk.features.lib.doorman.testutil;
+
+import java.io.PrintWriter;
+import java.sql.Connection;
+import java.sql.DriverManager;
+import java.sql.PreparedStatement;
+import java.sql.SQLException;
+import java.sql.SQLFeatureNotSupportedException;
+
+import javax.sql.DataSource;
+
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+public class DbUtil {
+
+	private static final Logger log = LoggerFactory.getLogger(DbUtil.class);
+
+	private static DataSource dataSource = null;
+
+	public static synchronized DataSource getDataSource() {
+		if (dataSource == null) {
+			String url = "jdbc:h2:mem:app;DB_CLOSE_DELAY=-1";
+
+			dataSource = new DataSource() {
+
+				@Override
+				public <T> T unwrap(Class<T> arg0) throws SQLException {
+					return null;
+				}
+
+				@Override
+				public boolean isWrapperFor(Class<?> arg0) throws SQLException {
+					return false;
+				}
+
+				@Override
+				public void setLoginTimeout(int arg0) throws SQLException {
+				}
+
+				@Override
+				public void setLogWriter(PrintWriter arg0) throws SQLException {
+				}
+
+				@Override
+				public java.util.logging.Logger getParentLogger() throws SQLFeatureNotSupportedException {
+					return null;
+				}
+
+				@Override
+				public int getLoginTimeout() throws SQLException {
+					return 0;
+				}
+
+				@Override
+				public PrintWriter getLogWriter() throws SQLException {
+					return null;
+				}
+
+				@Override
+				public Connection getConnection(String username, String password) throws SQLException {
+					return null;
+				}
+
+				@Override
+				public Connection getConnection() throws SQLException {
+					return DriverManager.getConnection(url);
+				}
+			};
+
+			try {
+				String script = FileUtil.read("/schema.sql");
+
+				String[] sqlList = script.split(";");
+				try (Connection con = dataSource.getConnection()) {
+					for (String sql : sqlList) {
+						if (!sql.trim().isEmpty()) {
+							sql = sql.trim();
+							try (PreparedStatement ps = con.prepareStatement(sql)) {
+								log.info("Executing statement:\n" + sql);
+								ps.execute();
+							}
+						}
+					}
+				}
+			} catch (Exception e) {
+				throw new RuntimeException(e);
+			}
+		}
+		return dataSource;
+	}
+}
diff --git a/lib/doorman/src/test/java/org/onap/ccsdk/features/lib/doorman/testutil/FileUtil.java b/lib/doorman/src/test/java/org/onap/ccsdk/features/lib/doorman/testutil/FileUtil.java
new file mode 100644
index 000000000..5ae92b4fc
--- /dev/null
+++ b/lib/doorman/src/test/java/org/onap/ccsdk/features/lib/doorman/testutil/FileUtil.java
@@ -0,0 +1,24 @@
+package org.onap.ccsdk.features.lib.doorman.testutil;
+
+import java.io.BufferedReader;
+import java.io.InputStream;
+import java.io.InputStreamReader;
+
+public class FileUtil {
+
+	public static String read(String fileName) throws Exception {
+		String ss = "";
+		try (InputStream is = DbUtil.class.getResourceAsStream(fileName)) {
+			try (InputStreamReader isr = new InputStreamReader(is)) {
+				try (BufferedReader in = new BufferedReader(isr)) {
+					String s = in.readLine();
+					while (s != null) {
+						ss += s + '\n';
+						s = in.readLine();
+					}
+				}
+			}
+		}
+		return ss;
+	}
+}
diff --git a/lib/doorman/src/test/java/org/onap/ccsdk/features/lib/doorman/util/TestJsonUtil.java b/lib/doorman/src/test/java/org/onap/ccsdk/features/lib/doorman/util/TestJsonUtil.java
new file mode 100644
index 000000000..f0ac87e24
--- /dev/null
+++ b/lib/doorman/src/test/java/org/onap/ccsdk/features/lib/doorman/util/TestJsonUtil.java
@@ -0,0 +1,26 @@
+package org.onap.ccsdk.features.lib.doorman.util;
+
+import java.util.Map;
+
+import org.junit.Assert;
+import org.junit.Test;
+import org.onap.ccsdk.features.lib.doorman.testutil.FileUtil;
+import org.onap.ccsdk.features.lib.doorman.util.JsonUtil;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+public class TestJsonUtil {
+
+	private static final Logger log = LoggerFactory.getLogger(TestJsonUtil.class);
+
+	@SuppressWarnings("unchecked")
+	@Test
+	public void testJsonConversion() throws Exception {
+		String json1 = FileUtil.read("/test1.json");
+		Map<String, Object> data1 = (Map<String, Object>) JsonUtil.jsonToData(json1);
+		String convJson1 = JsonUtil.dataToJson(data1);
+		log.info("Converted JSON:\n" + convJson1);
+		Map<String, Object> convData1 = (Map<String, Object>) JsonUtil.jsonToData(convJson1);
+		Assert.assertEquals(data1, convData1);
+	}
+}