2 * ============LICENSE_START=======================================================
4 * ================================================================================
5 * Copyright (C) 2017-2018 AT&T Intellectual Property. All rights reserved.
6 * ================================================================================
7 * Copyright (C) 2017 Amdocs
8 * ================================================================================
9 * Modifications Copyright (C) 2019 Ericsson
10 * =============================================================================
11 * Licensed under the Apache License, Version 2.0 (the "License");
12 * you may not use this file except in compliance with the License.
13 * You may obtain a copy of the License at
15 * http://www.apache.org/licenses/LICENSE-2.0
17 * Unless required by applicable law or agreed to in writing, software
18 * distributed under the License is distributed on an "AS IS" BASIS,
19 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
20 * See the License for the specific language governing permissions and
21 * limitations under the License.
23 * ============LICENSE_END=========================================================
26 package org.onap.appc.transactionrecorder.impl;
28 import static org.mockito.Matchers.anyObject;
29 import static org.mockito.Matchers.anyString;
30 import static org.hamcrest.CoreMatchers.isA;
31 import java.sql.Connection;
32 import java.sql.PreparedStatement;
33 import java.sql.ResultSet;
34 import java.sql.SQLException;
35 import java.sql.Statement;
36 import java.text.ParseException;
37 import java.time.Instant;
38 import java.time.ZoneOffset;
39 import java.time.format.DateTimeFormatter;
40 import java.time.temporal.ChronoUnit;
41 import java.util.ArrayList;
42 import java.util.HashMap;
43 import java.util.List;
45 import java.util.UUID;
46 import javax.sql.rowset.CachedRowSet;
47 import org.junit.After;
48 import org.junit.Assert;
49 import org.junit.Before;
50 import org.junit.Rule;
51 import org.junit.Test;
52 import org.junit.rules.ExpectedException;
53 import org.mockito.Mockito;
54 import org.onap.appc.dao.util.dbcp.DBConnectionPool;
55 import org.onap.appc.dao.util.helper.DBHelper;
56 import org.onap.appc.domainmodel.lcm.Flags;
57 import org.onap.appc.domainmodel.lcm.RequestStatus;
58 import org.onap.appc.domainmodel.lcm.TransactionRecord;
59 import org.onap.appc.domainmodel.lcm.VNFOperation;
60 import org.onap.appc.exceptions.APPCException;
61 import org.onap.appc.transactionrecorder.objects.TransactionConstants;
62 import org.onap.appc.transactionrecorder.objects.TransactionConstants.TRANSACTION_ATTRIBUTES;
63 import org.onap.ccsdk.sli.core.dblib.DbLibService;
64 import com.sun.rowset.CachedRowSetImpl;
67 * Test class for TransactionRecorder
69 public class TransactionRecorderImplTest {
71 private String dbUrl = "jdbc:h2:mem:test;MODE=MYSQL;DB_CLOSE_DELAY=-1";
72 private String username = "sa";
73 private String password = "sa";
74 private String driver = "org.h2.Driver";
76 private TransactionRecorderImpl transactionRecorderImpl;
77 private DbLibService dbLibService;
79 private DBConnectionPool dbConnectionPool;
83 * Ideally JUnit should grab the SQL to create the transaction table from the same source used in deployments;
84 * however, at the time of writing this that was not possible. Should it become possible in the future please
85 * update this JUnit test to use the deployment source.
87 * Please ensure this table create script is identical to the source script used in a deployment.
89 private String TRANSACTION_CREATE_TABLE = "CREATE TABLE TRANSACTIONS (" +
90 " TRANSACTION_ID VARCHAR(75) NOT NULL PRIMARY KEY," +
91 " ORIGIN_TIMESTAMP DATETIME(3) NOT NULL," +
92 " REQUEST_ID VARCHAR(256) NOT NULL," +
93 " SUBREQUEST_ID VARCHAR(256) DEFAULT NULL," +
94 " ORIGINATOR_ID VARCHAR(256) DEFAULT NULL," +
95 " START_TIME DATETIME(3) NOT NULL," +
96 " END_TIME DATETIME(3) DEFAULT NULL," +
97 " TARGET_ID VARCHAR(256) NOT NULL," +
98 " TARGET_TYPE VARCHAR(256) DEFAULT NULL," +
99 " OPERATION VARCHAR(256) NOT NULL," +
100 " RESULT_CODE INT(11) DEFAULT NULL," +
101 " DESCRIPTION TEXT," +
102 " STATE VARCHAR(50) NOT NULL," +
103 " SERVICE_INSTANCE_ID VARCHAR(256) DEFAULT NULL," +
104 " VNFC_NAME VARCHAR(256) DEFAULT NULL," +
105 " VSERVER_ID VARCHAR(256) DEFAULT NULL," +
106 " VF_MODULE_ID VARCHAR(256) DEFAULT NULL," +
107 " MODE VARCHAR(50) NOT NULL," +
109 private String TRANSACTION_DROP_TABLE = "DROP TABLE IF EXISTS TRANSACTIONS";
112 public ExpectedException expectedEx = ExpectedException.none();
115 public void setUp() throws Exception {
116 transactionRecorderImpl = new TransactionRecorderImpl();
117 transactionRecorderImpl.setAppcInstanceId("123");
118 dbLibService = Mockito.mock(DbLibService.class);
119 transactionRecorderImpl.setDbLibService(dbLibService);
120 dbConnectionPool = new DBConnectionPool(dbUrl, username, password, driver);
121 executeUpdate(TRANSACTION_CREATE_TABLE);
126 public void shutdown() {
127 if (dbConnectionPool != null) {
128 executeUpdate(TRANSACTION_DROP_TABLE);
129 dbConnectionPool.shutdown();
133 private void executeUpdate(String updateSQL) {
134 Connection connection = null;
135 Statement stmt = null;
137 connection = dbConnectionPool.getConnection();
138 stmt = connection.createStatement();
139 stmt.executeUpdate(updateSQL);
140 } catch (SQLException e) {
141 throw new RuntimeException(e);
143 DBHelper.close(null, stmt, connection);
148 * Verify the transactionRecorderImpl.sore() store the TransactionRecord correctly in the database.
151 public void testStore() throws Exception {
153 TransactionRecord input = prepareTransactionsInput();
154 Mockito.when(dbLibService.writeData(anyString(), anyObject(), anyString())).thenAnswer(invocation ->
155 testStoreInMemory(invocation.getArguments()));
156 transactionRecorderImpl.store(input);
161 public void testStoreExceptionFlow() throws SQLException, APPCException {
163 TransactionRecord input = prepareTransactionsInput();
164 Mockito.when(dbLibService.writeData(anyString(), anyObject(), anyString())).thenThrow(new SQLException());
165 expectedEx.expect(APPCException.class);
166 expectedEx.expectMessage(TransactionConstants.ERROR_ACCESSING_DATABASE);
167 expectedEx.expectCause(isA(SQLException.class));
168 transactionRecorderImpl.store(input);
173 public void testGetInProgressRequests() throws SQLException, APPCException {
174 TransactionRecord record1 = prepareTransactionsInput();
175 insertRecord(record1);
176 TransactionRecord input = prepareTransactionsInput();
177 input.setStartTime(Instant.now());
178 Mockito.when(dbLibService.getData(anyString(), anyObject(), anyString())).thenAnswer(invocation ->
179 inMemoryExecutionWithResultSet(invocation.getArguments()));
180 Assert.assertEquals(1, transactionRecorderImpl.getInProgressRequests(input, 0).size());
185 public void testGetInProgressRequestsSqlException() throws SQLException, APPCException {
186 TransactionRecord record1 = prepareTransactionsInput();
187 insertRecord(record1);
188 TransactionRecord input = prepareTransactionsInput();
189 input.setStartTime(Instant.now());
190 Mockito.when(dbLibService.getData(anyString(), anyObject(), anyString())).thenThrow(new SQLException());
191 expectedEx.expect(APPCException.class);
192 expectedEx.expectMessage(TransactionConstants.ERROR_ACCESSING_DATABASE);
193 expectedEx.expectCause(isA(SQLException.class));
194 transactionRecorderImpl.getInProgressRequests(input, 0);
198 public void testGetInProgressRequestsWithinTimeInterval() throws SQLException, APPCException {
199 TransactionRecord record1 = prepareTransactionsInput();
200 record1.setStartTime(Instant.now().minus(4,ChronoUnit.HOURS));
201 insertRecord(record1);
202 TransactionRecord input = prepareTransactionsInput();
203 input.setStartTime(Instant.now());
204 Mockito.when(dbLibService.getData(anyString(), anyObject(), anyString())).thenAnswer(invocation ->
205 inMemoryExecutionWithResultSet(invocation.getArguments()));
206 List<TransactionRecord> aList= transactionRecorderImpl.getInProgressRequests(input,12);
207 Assert.assertEquals(1, transactionRecorderImpl.getInProgressRequests(input,12).size());
212 public void testIsTransactionDuplicate() throws SQLException, APPCException {
213 TransactionRecord input = prepareTransactionsInput();
214 Mockito.when(dbLibService.getData(anyString(), anyObject(), anyString())).thenAnswer(invocation ->
215 inMemoryExecutionWithResultSet(invocation.getArguments()));
216 Assert.assertFalse(transactionRecorderImpl.isTransactionDuplicate(input));
221 public void testIsTransactionDuplicateExceptionFlow() throws SQLException, APPCException {
222 TransactionRecord input = prepareTransactionsInput();
223 Mockito.when(dbLibService.getData(anyString(), anyObject(), anyString())).thenThrow(new SQLException());
224 expectedEx.expect(APPCException.class);
225 expectedEx.expectMessage(TransactionConstants.ERROR_ACCESSING_DATABASE);
226 expectedEx.expectCause(isA(SQLException.class));
227 transactionRecorderImpl.isTransactionDuplicate(input);
231 public void testIsTransactionDuplicateAlternativeFlow() throws SQLException, APPCException {
232 TransactionRecord input = prepareTransactionsInput();
233 input.setSubRequestId(null);
234 input.setOriginatorId(null);
235 CachedRowSetImpl rowset = Mockito.mock(CachedRowSetImpl.class);
236 Mockito.when(rowset.first()).thenReturn(true);
237 Mockito.when(rowset.getString(TransactionConstants.TRANSACTION_ATTRIBUTES.TRANSACTION_ID.getColumnName()))
239 Mockito.when(dbLibService.getData(anyString(), anyObject(), anyString())).thenReturn(rowset);
240 Assert.assertTrue(transactionRecorderImpl.isTransactionDuplicate(input));
244 public void testGetInProgressRequestsCount() throws SQLException, APPCException {
245 TransactionRecord input = prepareTransactionsInput();
246 Mockito.when(dbLibService.getData(anyString(), anyObject(), anyString())).thenAnswer(invocation ->
247 inMemoryExecutionWithResultSet(invocation.getArguments()));
248 Assert.assertEquals(0, transactionRecorderImpl.getInProgressRequestsCount().intValue());
252 public void testGetInProgressRequestsCountSqlException() throws SQLException, APPCException {
253 TransactionRecord input = prepareTransactionsInput();
254 Mockito.when(dbLibService.getData(anyString(), anyObject(), anyString())).thenThrow(new SQLException());
255 expectedEx.expect(APPCException.class);
256 expectedEx.expectMessage(TransactionConstants.ERROR_ACCESSING_DATABASE);
257 expectedEx.expectCause(isA(SQLException.class));
258 transactionRecorderImpl.getInProgressRequestsCount();
262 public void testGetInProgressRequestsCountNoRecords() throws SQLException, APPCException {
263 CachedRowSetImpl rowset = Mockito.mock(CachedRowSetImpl.class);
264 Mockito.when(rowset.first()).thenReturn(false);
265 Mockito.when(dbLibService.getData(anyString(), anyObject(), anyString())).thenReturn(rowset);
266 expectedEx.expect(APPCException.class);
267 expectedEx.expectMessage(TransactionConstants.ERROR_ACCESSING_DATABASE);
268 transactionRecorderImpl.getInProgressRequestsCount();
272 public void testUpdate() throws APPCException, SQLException {
273 TransactionRecord input = prepareTransactionsInput();
275 Map<TransactionConstants.TRANSACTION_ATTRIBUTES, String> updateColumns = new HashMap<>();
276 updateColumns.put(TransactionConstants.TRANSACTION_ATTRIBUTES.TARGET_TYPE, "Firewall");
277 Mockito.when(dbLibService.writeData(anyString(), anyObject(), anyString())).thenAnswer(invocation ->
278 testUpdateInMemory(invocation.getArguments()));
279 transactionRecorderImpl.update(input.getTransactionId(), updateColumns);
283 public void testUpdateExceptionFlow() throws APPCException, SQLException {
284 TransactionRecord input = prepareTransactionsInput();
286 Map<TransactionConstants.TRANSACTION_ATTRIBUTES, String> updateColumns = new HashMap<>();
287 updateColumns.put(TransactionConstants.TRANSACTION_ATTRIBUTES.TARGET_TYPE, "Firewall");
288 Mockito.when(dbLibService.writeData(anyString(), anyObject(), anyString())).thenThrow(new SQLException());
289 expectedEx.expect(APPCException.class);
290 expectedEx.expectMessage(TransactionConstants.ERROR_ACCESSING_DATABASE);
291 expectedEx.expectCause(isA(SQLException.class));
292 transactionRecorderImpl.update(input.getTransactionId(), updateColumns);
296 public void testMarkTransactionsAborted() throws SQLException {
297 TransactionRecord input = prepareTransactionsInput();
299 Mockito.when(dbLibService.writeData(anyString(), anyObject(), anyString())).thenAnswer(invocation ->
300 testMarkAbortedInMemory(invocation.getArguments()));
301 transactionRecorderImpl.markTransactionsAborted("123~");
305 public void testMarkTransactionsAbortedExceptionFlow() throws SQLException {
306 TransactionRecord input = prepareTransactionsInput();
308 Mockito.when(dbLibService.writeData(anyString(), anyObject(), anyString())).thenThrow(new SQLException());
309 expectedEx.expect(RuntimeException.class);
310 expectedEx.expectMessage("In progress transactions couldn't be marked aborted on server start up");
311 expectedEx.expectCause(isA(SQLException.class));
312 transactionRecorderImpl.markTransactionsAborted("123~");
316 public void testGetRecords() throws SQLException, APPCException {
317 CachedRowSetImpl rowset = Mockito.mock(CachedRowSetImpl.class);
318 Mockito.when(rowset.next()).thenReturn(true).thenReturn(false);
319 Mockito.when(rowset.getString(TRANSACTION_ATTRIBUTES.STATE.getColumnName())).thenReturn("NAME");
320 Mockito.when(dbLibService.getData(anyString(), anyObject(), anyString())).thenReturn(rowset);
321 Assert.assertEquals(RequestStatus.UNKNOWN,
322 transactionRecorderImpl.getRecords(null, "SUBREQUEST_ID", "ORIGINATOR_ID", null).get(0));
326 public void testGetRecordsSqlException() throws SQLException, APPCException {
327 Mockito.when(dbLibService.getData(anyString(), anyObject(), anyString())).thenThrow(new SQLException());
328 expectedEx.expect(APPCException.class);
329 expectedEx.expectMessage("Error retrieving record for requestID null and vnfId null");
330 expectedEx.expectCause(isA(SQLException.class));
331 transactionRecorderImpl.getRecords(null, null, null, null);
334 private ResultSet inMemoryExecutionWithResultSet(Object[] obj) throws Exception {
335 String query = (String) obj[0];
336 ArrayList<String> args = (ArrayList<String>) obj[1];
337 Connection con = dbConnectionPool.getConnection();
338 PreparedStatement ps = con.prepareStatement(query);
339 for (int i = 1; i <= args.size(); i++) {
340 ps.setString(i, args.get(i - 1));
342 CachedRowSet rowSet = new CachedRowSetImpl();
343 rowSet.populate(ps.executeQuery());
347 private boolean testMarkAbortedInMemory(Object[] obj) throws Exception {
348 String query = (String) obj[0];
349 ArrayList<String> args = (ArrayList<String>) obj[1];
350 Connection con = dbConnectionPool.getConnection();
351 PreparedStatement ps = con.prepareStatement(query);
352 for (int i = 1; i <= args.size(); i++) {
353 ps.setString(i, args.get(i - 1));
356 return isTransactionAborted();
359 private boolean isTransactionAborted() throws Exception {
360 String query = "SELECT COUNT(*) FROM TRANSACTIONS WHERE STATE = ?";
361 Connection con = dbConnectionPool.getConnection();
362 PreparedStatement ps = con.prepareStatement(query);
363 ps.setString(1, RequestStatus.ABORTED.toString());
364 ResultSet rs = ps.executeQuery();
366 int value = rs.getInt(1);
368 System.out.println("Non terminal Transactions are aborted");
372 throw new Exception("Transactions are not aborted");
375 private boolean testUpdateInMemory(Object[] obj) throws Exception {
376 String query = (String) obj[0];
377 ArrayList<String> args = (ArrayList<String>) obj[1];
378 Connection con = dbConnectionPool.getConnection();
379 PreparedStatement ps = con.prepareStatement(query);
380 for (int i = 1; i <= args.size(); i++) {
381 ps.setString(i, args.get(i - 1));
384 String updatedValue = checkIfValueIsUpdated(args.get(1));
385 System.out.println("updated Value is " + updatedValue);
386 if (updatedValue.equals("Firewall")) {
389 throw new Exception("Not Updated");
392 private boolean testStoreInMemory(Object[] obj) throws Exception {
393 String query = (String) obj[0];
394 ArrayList<String> args = (ArrayList<String>) obj[1];
395 Connection con = dbConnectionPool.getConnection();
396 PreparedStatement ps = con.prepareStatement(query);
397 for (int i = 1; i <= args.size(); i++) {
398 ps.setString(i, args.get(i - 1));
401 if (checkIfRowIsPresent(args.get(0))) {
404 throw new Exception("Failed to update");
407 private TransactionRecord prepareTransactionsInput() {
408 TransactionRecord input = new TransactionRecord();
409 input.setTransactionId(UUID.randomUUID().toString());
410 input.setOriginTimestamp(Instant.parse("2017-09-11T00:00:01.00Z"));
411 input.setRequestId("REQUEST_ID");
412 input.setSubRequestId("SUB_REQUEST_ID");
413 input.setOriginatorId("ORIGINATOR_ID");
414 input.setStartTime(Instant.parse("2017-09-11T00:00:02.00Z"));
415 input.setTargetId("TARGET_ID");
416 input.setTargetType("TARGET_TYPE");
417 input.setServiceInstanceId("SERVICE_INSTANCE_ID");
418 input.setOperation(VNFOperation.ActionStatus);
419 input.setResultCode(200);
420 input.setRequestState(RequestStatus.ACCEPTED);
421 input.setDescription("DESCRIPTION");
422 input.setMode(Flags.Mode.EXCLUSIVE);
426 private void insertRecord(TransactionRecord input) throws SQLException {
427 final String STORE_DATE_QUERY = TransactionConstants.INSERT_INTO + TransactionConstants.TRANSACTIONS +
428 " values (?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?)";
429 Connection con = dbConnectionPool.getConnection();
430 PreparedStatement ps = con.prepareStatement(STORE_DATE_QUERY);
431 ArrayList<String> args = prepareArguments(input);
433 args.add(0, "123~" + input.getTransactionId());
434 for (int i = 1; i <= 18; i++) {
435 ps.setString(i, args.get(i - 1));
438 if (checkIfRowIsPresent(args.get(0))) {
439 System.out.println("RECORD INSERTED " + args.get(0));
444 private ArrayList<String> prepareArguments(TransactionRecord input) {
445 ArrayList<String> arguments = new ArrayList<>();
446 arguments.add(input.getTransactionId());
447 arguments.add(dateToStringConverterMillis(input.getOriginTimestamp()));
448 arguments.add(input.getRequestId());
449 arguments.add(input.getSubRequestId());
450 arguments.add(input.getOriginatorId());
451 arguments.add(dateToStringConverterMillis(input.getStartTime()));
452 arguments.add(dateToStringConverterMillis(input.getEndTime()));
453 arguments.add(input.getTargetId());
454 arguments.add(input.getTargetType());
455 arguments.add(input.getOperation().name());
456 arguments.add(String.valueOf(input.getResultCode()));
457 arguments.add(input.getDescription());
458 arguments.add(input.getRequestState());
459 arguments.add(input.getServiceInstanceId());
460 arguments.add(input.getVnfcName());
461 arguments.add(input.getVserverId());
462 arguments.add(input.getVfModuleId());
463 arguments.add(input.getMode());
468 private static String dateToStringConverterMillis(Instant date) {
472 DateTimeFormatter formatter = DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss.SSS").withZone(ZoneOffset.UTC);
473 return formatter.format(date);
476 private boolean checkIfRowIsPresent(String key) {
477 Connection con = null;
479 PreparedStatement ps = null;
481 con = dbConnectionPool.getConnection();
482 ps = con.prepareStatement("SELECT COUNT(*) FROM TRANSACTIONS WHERE TRANSACTION_ID = ?");
483 ps.setString(1, key);
484 rs = ps.executeQuery();
486 int value = rs.getInt(1);
487 System.out.println("KEY checked is " + key + " COUNT RETURNED IS " + value);
492 } catch (SQLException e) {
495 DBHelper.close(rs, ps, con);
500 private String checkIfValueIsUpdated(String key) throws Exception {
501 Connection con = dbConnectionPool.getConnection();
502 PreparedStatement ps = con.prepareStatement("SELECT TARGET_TYPE FROM TRANSACTIONS WHERE TRANSACTION_ID = ?");
503 ps.setString(1, key);
504 ResultSet rs = ps.executeQuery();
506 String value = rs.getString("TARGET_TYPE");
509 throw new Exception("Value not found");
514 * Verify the transactionRecorderImpl. getRecords () can be fetch with each of the parameter combinations
518 public void test_api_getRecords() throws Exception {
521 final int requestId = 0;
522 final int subrequestId = 1;
523 final int originatorId = 2;
525 final int requestStatus = 4;
528 String[][] trCreateMatrix = {
529 {"request1", "subrequestId1", "originatorId1", "vnfId1", RequestStatus.UNKNOWN.name()},
530 {"request1", "subrequestId2", "originatorId1", "vnfId1", RequestStatus.RECEIVED.name()},
531 {"request2", "subrequestId1", "originatorId1", "vnfId1", RequestStatus.ACCEPTED.name()},
532 {"request2", "subrequestId2", "originatorId1", "vnfId1", RequestStatus.REJECTED.name()},
533 {"request1", "subrequestId1", "originatorId1", "vnfId2", RequestStatus.SUCCESSFUL.name()},
534 {"request1", "subrequestId2", "originatorId1", "vnfId2", RequestStatus.FAILED.name()},
535 {"request2", "subrequestId1", "originatorId1", "vnfId2", RequestStatus.TIMEOUT.name()},
536 {"request2", "subrequestId2", "originatorId1", "vnfId2", RequestStatus.ABORTED.name()},
537 {"request1", "subrequestId1", "originatorId2", "vnfId1", RequestStatus.UNKNOWN.name()},
538 {"request1", "subrequestId2", "originatorId2", "vnfId1", RequestStatus.RECEIVED.name()},
539 {"request2", "subrequestId1", "originatorId2", "vnfId1", RequestStatus.ACCEPTED.name()},
540 {"request2", "subrequestId2", "originatorId2", "vnfId1", RequestStatus.REJECTED.name()},
541 {"request1", "subrequestId1", "originatorId2", "vnfId2", RequestStatus.SUCCESSFUL.name()},
542 {"request1", "subrequestId2", "originatorId2", "vnfId2", RequestStatus.FAILED.name()},
543 {"request2", "subrequestId1", "originatorId2", "vnfId2", RequestStatus.TIMEOUT.name()},
544 {"request2", "subrequestId2", "originatorId2", "vnfId2", RequestStatus.ABORTED.name()},
548 TransactionRecord tr = new TransactionRecord();
549 tr.setTimeStamp(Instant.parse("2017-09-11T00:00:01.00Z"));
550 tr.setStartTime(Instant.parse("2017-09-11T00:00:02.00Z"));
551 tr.setEndTime(Instant.parse("2017-09-11T00:00:03.00Z"));
552 tr.setTargetType("TARGET_TYPE");
553 tr.setSubComponent("SUB_COMPONENT");
554 tr.setOperation(VNFOperation.ActionStatus);
555 tr.setResultCode("RESULT_CODE");
556 tr.setDescription("DESCRIPTION");
558 for (int row = 0; row < trCreateMatrix.length; row++) {
559 tr.setRequestID(trCreateMatrix[row][requestId]);
560 tr.setSubRequestID(trCreateMatrix[row][subrequestId]);
561 tr.setOriginatorId(trCreateMatrix[row][originatorId]);
562 tr.setTargetID(trCreateMatrix[row][vnfId]);
563 tr.setRequestStatus(RequestStatus.valueOf(trCreateMatrix[row][requestStatus]));
564 transactionRecorderImpl.store(tr);
568 String[][] trSearchMatrix = {
569 {"request1", null, null, "vnfId1"},
570 {"request2", "subrequestId1", null, "vnfId1"},
571 {"request1", null, "originatorId1", "vnfId1"},
572 {"request2", "subrequestId2", "originatorId1", "vnfId1"},
576 for (int i = 0; i < trSearchMatrix.length; i++) {
578 List<RequestStatus> actualList = transactionRecorderImpl
579 .getRecords(trSearchMatrix[row][requestId], trSearchMatrix[row][subrequestId],
580 trSearchMatrix[row][originatorId], trSearchMatrix[row][vnfId])
583 .collect(Collectors.toList());
585 List<RequestStatus> expectedList = Arrays.stream(trCreateMatrix)
586 .filter(entry -> entry[requestId].equals(trSearchMatrix[row][requestId]))
587 .filter(entry -> trSearchMatrix[row][subrequestId] == null || entry[subrequestId].equals
588 (trSearchMatrix[row][subrequestId]))
589 .filter(entry -> trSearchMatrix[row][originatorId] == null || entry[originatorId].equals
590 (trSearchMatrix[row][originatorId]))
591 .filter(entry -> entry[vnfId].equals(trSearchMatrix[row][vnfId]))
592 .map(entry -> RequestStatus.valueOf(entry[requestStatus]))
594 .collect(Collectors.toList());
595 System.out.println(expectedList);
596 System.out.println(actualList);
597 Assert.assertEquals("Unexpected results: ", expectedList, actualList);