2 * ============LICENSE_START====================================================
4 * ===========================================================================
5 * Copyright (c) 2018 AT&T Intellectual Property. All rights reserved.
6 * ===========================================================================
7 * Licensed under the Apache License, Version 2.0 (the "License");
8 * you may not use this file except in compliance with the License.
9 * You may obtain a copy of the License at
11 * http://www.apache.org/licenses/LICENSE-2.0
13 * Unless required by applicable law or agreed to in writing, software
14 * distributed under the License is distributed on an "AS IS" BASIS,
15 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
16 * See the License for the specific language governing permissions and
17 * limitations under the License.
18 * ============LICENSE_END====================================================
22 package org.onap.aaf.auth.dao.cass;
24 import static org.junit.Assert.assertNull;
25 import static org.junit.Assert.assertTrue;
26 import static org.mockito.MockitoAnnotations.initMocks;
28 import java.io.ByteArrayInputStream;
29 import java.io.ByteArrayOutputStream;
30 import java.io.DataInputStream;
31 import java.io.DataOutputStream;
32 import java.io.FileNotFoundException;
33 import java.io.IOException;
34 import java.lang.reflect.Constructor;
35 import java.lang.reflect.Field;
36 import java.lang.reflect.InvocationTargetException;
37 import java.lang.reflect.Method;
38 import java.nio.ByteBuffer;
39 import java.util.ArrayList;
40 import java.util.HashMap;
41 import java.util.Iterator;
42 import java.util.List;
44 import java.util.concurrent.ConcurrentHashMap;
46 import org.junit.Before;
47 import org.junit.Test;
48 import org.mockito.Mock;
49 import org.mockito.Mockito;
50 import org.onap.aaf.auth.dao.AbsCassDAO;
51 import org.onap.aaf.auth.dao.AbsCassDAO.CRUD;
52 import org.onap.aaf.auth.dao.AbsCassDAO.PSInfo;
53 import org.onap.aaf.auth.dao.CassAccess;
54 import org.onap.aaf.auth.dao.CassDAOImpl;
55 import org.onap.aaf.auth.dao.cass.NsDAO.Data;
56 import org.onap.aaf.auth.env.AuthzTrans;
57 import org.onap.aaf.auth.layer.Result;
58 import org.onap.aaf.cadi.config.Config;
59 import org.onap.aaf.misc.env.APIException;
60 import org.onap.aaf.misc.env.Env;
61 import org.onap.aaf.misc.env.LogTarget;
62 import org.onap.aaf.misc.env.TimeTaken;
64 import com.datastax.driver.core.Cluster;
65 import com.datastax.driver.core.ResultSet;
66 import com.datastax.driver.core.Row;
67 import com.datastax.driver.core.Session;
69 public class JU_NsDAO {
81 public void setUp() throws APIException, IOException {
83 Mockito.doReturn(Mockito.mock(LogTarget.class)).when(trans).warn();
84 Mockito.doReturn(Mockito.mock(LogTarget.class)).when(trans).error();
85 Mockito.doReturn(Mockito.mock(LogTarget.class)).when(trans).debug();
86 Mockito.doReturn(Mockito.mock(LogTarget.class)).when(trans).info();
87 Mockito.doReturn(Mockito.mock(LogTarget.class)).when(trans).init();
88 Mockito.doReturn(session).when(cluster).connect("test");
89 Mockito.doReturn(Mockito.mock(TimeTaken.class)).when(trans).start(Mockito.anyString(), Mockito.anyInt());
90 Mockito.doReturn("100").when(trans).getProperty(Config.CADI_LATITUDE);
91 Mockito.doReturn("100").when(trans).getProperty(Config.CADI_LONGITUDE);
93 Iterator<Row> ite = Mockito.mock(Iterator.class);
94 Mockito.doReturn(ite).when(rs).iterator();
95 Mockito.doReturn(rs).when(session).execute(Mockito.anyString());
99 public void testInit() {
101 Session session = Mockito.mock(Session.class);
102 new NsDAOImpl(trans, cluster, "test", session);
103 } catch (APIException | IOException e) {
104 // TODO Auto-generated catch block
109 public void setPsByStartAndTarget(NsDAO NsDAOObj, PSInfo psInfoObj, String fieldName) {
112 nsDaoField = NsDAO.class.getDeclaredField(fieldName);
114 nsDaoField.setAccessible(true);
115 // remove final modifier from field
116 Field modifiersField = Field.class.getDeclaredField("modifiers");
117 modifiersField.setAccessible(true);
118 // modifiersField.setInt(nsDaoField, nsDaoField.getModifiers() & ~Modifier.FINAL);
120 nsDaoField.set(NsDAOObj, psInfoObj);
121 } catch (NoSuchFieldException | SecurityException e) {
122 // TODO Auto-generated catch block
124 } catch (IllegalArgumentException e) {
125 // TODO Auto-generated catch block
127 } catch (IllegalAccessException e) {
128 // TODO Auto-generated catch block
134 public void testWasMOdified() {
135 TimeTaken tt = Mockito.mock(TimeTaken.class);
136 Mockito.doReturn(tt).when(trans).start("NsDAO CREATE", Env.REMOTE);
137 Mockito.doReturn(tt).when(trans).start("Clear Reset Deque", Env.SUB);
138 Mockito.doReturn(tt).when(trans).start("New Cassandra Session", Env.SUB);
139 Mockito.doReturn(tt).when(trans).start("Preparing PSInfo CREATE on NsDAO", Env.SUB);
140 Mockito.doReturn(tt).when(trans).start("DELETE Future",Env.REMOTE);
141 Mockito.doReturn(Mockito.mock(LogTarget.class)).when(trans).error();
142 Mockito.doNothing().when(tt).done();
143 NsDAO.Data data = new NsDAO.Data();
145 HistoryDAO historyDAO = Mockito.mock(HistoryDAO.class);
146 Result<ResultSet> rs1 = new Result<ResultSet>(null,0,"test",new Object[0]);
147 Mockito.doReturn(rs1).when(historyDAO).create(Mockito.any(), Mockito.any());
148 CacheInfoDAO cacheInfoDAO = Mockito.mock(CacheInfoDAO.class);
149 Mockito.doReturn(rs1).when(cacheInfoDAO).touch(Mockito.any(), Mockito.anyString(), Mockito.anyInt());
153 daoObj = new NsDAO(trans, historyDAO, cacheInfoDAO);
154 } catch (APIException | IOException e) {
155 // TODO Auto-generated catch block
158 daoObj.wasModified(trans, CRUD.create, data, new String[] {"test"});
160 daoObj.wasModified(trans, CRUD.create, data, new String[] {});
161 daoObj.wasModified(trans, CRUD.create, data, new String[] {null});
162 daoObj.wasModified(trans, CRUD.create, data, new String[] {"test",null});
163 daoObj.wasModified(trans, CRUD.create, data, new String[] {"test","test"});
165 rs1 = new Result<ResultSet>(null,1,"test",new Object[0]);
166 Mockito.doReturn(rs1).when(historyDAO).create(Mockito.any(), Mockito.any());
167 daoObj.wasModified(trans, CRUD.create, data, new String[] {"test","test"});
171 public void testSecondConstructor() {
172 HistoryDAO historyDAO = Mockito.mock(HistoryDAO.class);
173 CacheInfoDAO cacheInfoDAO = Mockito.mock(CacheInfoDAO.class);
176 new NsDAO(trans, historyDAO, cacheInfoDAO);
177 } catch (APIException | IOException e) {
178 // TODO Auto-generated catch block
185 public void testNSLoader(){
186 Class<?> innerClass = null;
187 Class<?>[] innerClassArr = NsDAO.class.getDeclaredClasses();
188 for(Class<?> indCls:innerClassArr) {
189 if(indCls.getName().contains("NSLoader")) {
195 Constructor<?> constructor = innerClass.getDeclaredConstructors()[0];
196 constructor.setAccessible(true);
200 Object obj = constructor.newInstance(1);
201 Method innnerClassMtd;
203 NsDAO.Data data = new NsDAO.Data();
204 Row row = Mockito.mock(Row.class);
205 ByteBuffer bbObj = ByteBuffer.allocateDirect(10);
207 bbObj.put(0, new Byte("0"));
208 bbObj.put(1, new Byte("1"));
209 bbObj.put(2, new Byte("2"));
210 Mockito.doReturn(bbObj).when(row).getBytesUnsafe(1);
212 innnerClassMtd = innerClass.getMethod("load", new Class[] {NsDAO.Data.class, Row.class});
213 innnerClassMtd.invoke(obj, new Object[] {data, row});
215 innnerClassMtd = innerClass.getDeclaredMethod("key", new Class[] {NsDAO.Data.class, Integer.TYPE, Object[].class });
216 innnerClassMtd.invoke(obj, new Object[] {data, 1, new Object[] {"test","test","test"} });
218 innnerClassMtd = innerClass.getDeclaredMethod("body", new Class[] {NsDAO.Data.class, Integer.TYPE, Object[].class });
219 innnerClassMtd.invoke(obj, new Object[] {data, 1, new Object[] {"test","test","test","test","test","test","test","test","test","test","test"} });
221 ByteArrayOutputStream baos = new ByteArrayOutputStream();
222 DataOutputStream dos = new DataOutputStream(baos);
223 innnerClassMtd = innerClass.getDeclaredMethod("marshal", new Class[] {NsDAO.Data.class, DataOutputStream.class });
224 innnerClassMtd.invoke(obj, new Object[] {data, dos });
226 ByteArrayInputStream bais = new ByteArrayInputStream(baos.toByteArray());
227 DataInputStream dis = new DataInputStream(bais);
228 innnerClassMtd = innerClass.getDeclaredMethod("unmarshal", new Class[] {NsDAO.Data.class, DataInputStream.class });
229 innnerClassMtd.invoke(obj, new Object[] {data, dis });
231 } catch (InstantiationException e) {
232 // TODO Auto-generated catch block
234 } catch (IllegalAccessException e) {
235 // TODO Auto-generated catch block
237 } catch (IllegalArgumentException e) {
238 // TODO Auto-generated catch block
240 } catch (InvocationTargetException e) {
241 // TODO Auto-generated catch block
243 } catch (NoSuchMethodException e) {
244 // TODO Auto-generated catch block
246 } catch (SecurityException e) {
247 // TODO Auto-generated catch block
252 public void testCreate() {
253 PSInfo psObj = Mockito.mock(PSInfo.class);
255 HistoryDAO historyDAO = Mockito.mock(HistoryDAO.class);
256 NsDAO.Data data = new NsDAO.Data();
258 Result<ResultSet> rs1 = new Result<ResultSet>(null,0,"test",new Object[0]);
259 Mockito.doReturn(rs1).when(psObj).exec(trans, "NsDAOImpl CREATE", data);
260 Mockito.doReturn(rs1).when(historyDAO).create(Mockito.any(), Mockito.any());
261 CacheInfoDAO cacheInfoDAO = Mockito.mock(CacheInfoDAO.class);
262 NsDAOImpl daoObj=null;
264 daoObj = new NsDAOImpl(trans, historyDAO, cacheInfoDAO, psObj, session);
265 } catch (APIException | IOException e) {
266 // TODO Auto-generated catch block
269 Mockito.doReturn("test user").when(trans).user();
271 Result<NsDAO.Data> retVal = daoObj.create(trans,data);
272 assertTrue(retVal.status == 4);
274 Mockito.doReturn("100").when(trans).getProperty(CassAccess.CASSANDRA_CLUSTERS_PORT,"100");
275 Mockito.doReturn("100").when(trans).getProperty(CassAccess.CASSANDRA_CLUSTERS_PORT,"9042");
276 Mockito.doReturn("100").when(trans).getProperty(CassAccess.CASSANDRA_CLUSTERS_USER_NAME,"100");
277 Mockito.doReturn("100").when(trans).getProperty(CassAccess.CASSANDRA_CLUSTERS_USER_NAME,null);
278 data.parent = "parent";
279 data.attrib = new HashMap<>();
280 data.attrib.put("test", "test");
283 Mockito.doReturn(rs1).when(cacheInfoDAO).touch(Mockito.any(), Mockito.anyString(), Mockito.anyInt());
285 cbField = CassAccess.class.getDeclaredField("cb");
286 cbField.setAccessible(true);
287 cbField.set(daoObj, null);
288 } catch (NoSuchFieldException | SecurityException e) {
289 // TODO Auto-generated catch block
291 } catch (IllegalArgumentException e) {
292 // TODO Auto-generated catch block
294 } catch (IllegalAccessException e) {
295 // TODO Auto-generated catch block
299 retVal = daoObj.create(trans,data);
300 assertTrue(retVal.status == 9);
303 Mockito.doReturn(rs1).when(cacheInfoDAO).touch(Mockito.any(), Mockito.anyString(), Mockito.anyInt());
305 owningField = AbsCassDAO.class.getDeclaredField("owningDAO");
306 owningField.setAccessible(true);
307 owningField.set(daoObj, null);
308 } catch (NoSuchFieldException | SecurityException e) {
309 // TODO Auto-generated catch block
311 } catch (IllegalArgumentException e) {
312 // TODO Auto-generated catch block
314 } catch (IllegalAccessException e) {
315 // TODO Auto-generated catch block
318 retVal = daoObj.create(trans,data);
319 assertTrue(retVal.status == 0);
324 public void testUpdate() {
325 PSInfo psObj = Mockito.mock(PSInfo.class);
327 HistoryDAO historyDAO = Mockito.mock(HistoryDAO.class);
328 NsDAO.Data data = new NsDAO.Data();
330 Result<ResultSet> rs1 = new Result<ResultSet>(null,0,"test",new Object[0]);
331 Mockito.doReturn(rs1).when(psObj).exec(trans, "NsDAOImpl CREATE", data);
332 Mockito.doReturn(rs1).when(psObj).exec(trans, "NsDAOImpl UPDATE", data);
333 Mockito.doReturn(rs1).when(historyDAO).create(Mockito.any(), Mockito.any());
334 CacheInfoDAO cacheInfoDAO = Mockito.mock(CacheInfoDAO.class);
335 NsDAOImpl daoObj=null;
337 daoObj = new NsDAOImpl(trans, historyDAO, cacheInfoDAO, psObj, session);
338 } catch (APIException | IOException e) {
339 // TODO Auto-generated catch block
342 Mockito.doReturn("test user").when(trans).user();
344 Result<Void> retVal = daoObj.update(trans,data);
345 assertTrue(retVal.status == 4);
347 Mockito.doReturn("100").when(trans).getProperty(CassAccess.CASSANDRA_CLUSTERS_PORT,"100");
348 Mockito.doReturn("100").when(trans).getProperty(CassAccess.CASSANDRA_CLUSTERS_PORT,"9042");
349 Mockito.doReturn("100").when(trans).getProperty(CassAccess.CASSANDRA_CLUSTERS_USER_NAME,"100");
350 Mockito.doReturn("100").when(trans).getProperty(CassAccess.CASSANDRA_CLUSTERS_USER_NAME,null);
351 data.parent = "parent";
352 data.attrib = new HashMap<>();
353 data.attrib.put("test", "test");
355 Mockito.doReturn(rs1).when(cacheInfoDAO).touch(Mockito.any(), Mockito.anyString(), Mockito.anyInt());
357 cbField = AbsCassDAO.class.getDeclaredField("owningDAO");
358 cbField.setAccessible(true);
359 cbField.set(daoObj, null);
360 } catch (NoSuchFieldException | SecurityException e) {
361 // TODO Auto-generated catch block
363 } catch (IllegalArgumentException e) {
364 // TODO Auto-generated catch block
366 } catch (IllegalAccessException e) {
367 // TODO Auto-generated catch block
371 retVal = daoObj.update(trans,data);
372 assertTrue(retVal.status == 0);
374 ResultSet rsMock = Mockito.mock(ResultSet.class);
375 Iterator<Row> iteMock = Mockito.mock(Iterator.class);
376 Mockito.doReturn(iteMock).when(rsMock).iterator();
377 Row rowMock = Mockito.mock(Row.class);
378 Mockito.doReturn(rowMock).when(iteMock).next();
379 Mockito.when(iteMock.hasNext()).thenReturn(true, false);
380 Mockito.doReturn("test").when(rowMock).getString(Mockito.anyInt());
381 Mockito.doReturn(rsMock).when(session).execute(Mockito.anyString());
382 retVal = daoObj.update(trans,data);
383 assertTrue(retVal.status == 0);
387 public void testRead() {
388 PSInfo psObj = Mockito.mock(PSInfo.class);
389 Mockito.doReturn("100").when(trans).getProperty(CassAccess.CASSANDRA_CLUSTERS_PORT,"100");
390 Mockito.doReturn("100").when(trans).getProperty(CassAccess.CASSANDRA_CLUSTERS_PORT,"9042");
391 Mockito.doReturn("100").when(trans).getProperty(CassAccess.CASSANDRA_CLUSTERS_USER_NAME,"100");
392 Mockito.doReturn("100").when(trans).getProperty(CassAccess.CASSANDRA_CLUSTERS_USER_NAME,null);
394 HistoryDAO historyDAO = Mockito.mock(HistoryDAO.class);
395 NsDAO.Data data = new NsDAO.Data();
397 Result<List<Data>> rs1 = new Result<List<Data>>(null,0,"test",new Object[0]);
398 Mockito.doReturn(rs1).when(psObj).exec(trans, "NsDAOImpl CREATE", data);
399 Mockito.doReturn(rs1).when(psObj).exec(trans, "NsDAOImpl UPDATE", data);
400 Mockito.doReturn(rs1).when(psObj).read(trans, "NsDAOImpl READ", data);
401 Mockito.doReturn(rs1).when(historyDAO).create(Mockito.any(), Mockito.any());
402 CacheInfoDAO cacheInfoDAO = Mockito.mock(CacheInfoDAO.class);
403 NsDAOImpl daoObj=null;
405 daoObj = new NsDAOImpl(trans, historyDAO, cacheInfoDAO, psObj, session);
406 } catch (APIException | IOException e) {
407 // TODO Auto-generated catch block
410 Mockito.doReturn("test user").when(trans).user();
412 Result<List<Data>> retVal = daoObj.read(trans,data);
413 assertTrue(retVal.status == 0);
415 List<Data> dataAL= new ArrayList<>();
417 rs1 = new Result<List<Data>>(dataAL,0,"test",new Object[0]);
418 Mockito.doReturn(rs1).when(psObj).read(trans, "NsDAOImpl READ", data);
420 Mockito.doReturn(rs1).when(cacheInfoDAO).touch(Mockito.any(), Mockito.anyString(), Mockito.anyInt());
422 cbField = AbsCassDAO.class.getDeclaredField("owningDAO");
423 cbField.setAccessible(true);
424 cbField.set(daoObj, null);
425 } catch (NoSuchFieldException | SecurityException e) {
426 // TODO Auto-generated catch block
428 } catch (IllegalArgumentException e) {
429 // TODO Auto-generated catch block
431 } catch (IllegalAccessException e) {
432 // TODO Auto-generated catch block
435 retVal = daoObj.read(trans,data);
436 assertTrue(retVal.status == 0);
441 public void testReadByObject() {
442 PSInfo psObj = Mockito.mock(PSInfo.class);
443 Mockito.doReturn("100").when(trans).getProperty(CassAccess.CASSANDRA_CLUSTERS_PORT,"100");
444 Mockito.doReturn("100").when(trans).getProperty(CassAccess.CASSANDRA_CLUSTERS_PORT,"9042");
445 Mockito.doReturn("100").when(trans).getProperty(CassAccess.CASSANDRA_CLUSTERS_USER_NAME,"100");
446 Mockito.doReturn("100").when(trans).getProperty(CassAccess.CASSANDRA_CLUSTERS_USER_NAME,null);
448 HistoryDAO historyDAO = Mockito.mock(HistoryDAO.class);
449 NsDAO.Data data = new NsDAO.Data();
451 Result<List<Data>> rs1 = new Result<List<Data>>(null,0,"test",new Object[0]);
452 Mockito.doReturn(rs1).when(psObj).exec(trans, "NsDAOImpl CREATE", data);
453 Mockito.doReturn(rs1).when(psObj).exec(trans, "NsDAOImpl UPDATE", data);
454 Mockito.doReturn(rs1).when(psObj).read(trans, "NsDAOImpl READ", new Object[] {});
455 Mockito.doReturn(rs1).when(historyDAO).create(Mockito.any(), Mockito.any());
456 CacheInfoDAO cacheInfoDAO = Mockito.mock(CacheInfoDAO.class);
457 NsDAOImpl daoObj=null;
459 daoObj = new NsDAOImpl(trans, historyDAO, cacheInfoDAO, psObj, session);
460 } catch (APIException | IOException e) {
461 // TODO Auto-generated catch block
464 Mockito.doReturn("test user").when(trans).user();
466 Result<List<Data>> retVal = daoObj.read(trans,new Object[] {});
467 assertTrue(retVal.status == 0);
469 List<Data> dataAL= new ArrayList<>();
471 rs1 = new Result<List<Data>>(dataAL,0,"test",new Object[0]);
472 Mockito.doReturn(rs1).when(psObj).read(trans, "NsDAOImpl READ", new Object[] {});
474 Mockito.doReturn(rs1).when(cacheInfoDAO).touch(Mockito.any(), Mockito.anyString(), Mockito.anyInt());
476 cbField = AbsCassDAO.class.getDeclaredField("owningDAO");
477 cbField.setAccessible(true);
478 cbField.set(daoObj, null);
479 } catch (NoSuchFieldException | SecurityException e) {
480 // TODO Auto-generated catch block
482 } catch (IllegalArgumentException e) {
483 // TODO Auto-generated catch block
485 } catch (IllegalAccessException e) {
486 // TODO Auto-generated catch block
489 retVal = daoObj.read(trans,new Object[] {});
490 assertTrue(retVal.status == 0);
495 public void testDelete() {
496 PSInfo psObj = Mockito.mock(PSInfo.class);
497 Mockito.doReturn("100").when(trans).getProperty(CassAccess.CASSANDRA_CLUSTERS_PORT,"100");
498 Mockito.doReturn("100").when(trans).getProperty(CassAccess.CASSANDRA_CLUSTERS_PORT,"9042");
499 Mockito.doReturn("100").when(trans).getProperty(CassAccess.CASSANDRA_CLUSTERS_USER_NAME,"100");
500 Mockito.doReturn("100").when(trans).getProperty(CassAccess.CASSANDRA_CLUSTERS_USER_NAME,null);
502 HistoryDAO historyDAO = Mockito.mock(HistoryDAO.class);
503 NsDAO.Data data = new NsDAO.Data();
505 Result<List<Data>> rs1 = new Result<List<Data>>(null,0,"test",new Object[0]);
506 Mockito.doReturn(rs1).when(psObj).exec(trans, "NsDAOImpl CREATE", data);
507 Mockito.doReturn(rs1).when(psObj).exec(trans, "NsDAOImpl UPDATE", data);
508 Mockito.doReturn(rs1).when(psObj).read(trans, "NsDAOImpl READ", data);
509 Mockito.doReturn(rs1).when(psObj).exec(trans, "NsDAOImpl DELETE", data);
510 Mockito.doReturn(rs1).when(historyDAO).create(Mockito.any(), Mockito.any());
511 CacheInfoDAO cacheInfoDAO = Mockito.mock(CacheInfoDAO.class);
512 NsDAOImpl daoObj=null;
514 daoObj = new NsDAOImpl(trans, historyDAO, cacheInfoDAO, psObj, session);
515 } catch (APIException | IOException e) {
516 // TODO Auto-generated catch block
519 Mockito.doReturn("test user").when(trans).user();
521 Mockito.doReturn(rs1).when(cacheInfoDAO).touch(Mockito.any(), Mockito.anyString(), Mockito.anyInt());
523 cbField = AbsCassDAO.class.getDeclaredField("owningDAO");
524 cbField.setAccessible(true);
525 cbField.set(daoObj, null);
526 } catch (NoSuchFieldException | SecurityException e) {
527 // TODO Auto-generated catch block
529 } catch (IllegalArgumentException e) {
530 // TODO Auto-generated catch block
532 } catch (IllegalAccessException e) {
533 // TODO Auto-generated catch block
537 Result<Void> retVal = daoObj.delete(trans,data, false);
538 assertTrue(retVal.status == 0);
540 List<Data> dataAL= new ArrayList<>();
542 rs1 = new Result<List<Data>>(dataAL,0,"test",new Object[0]);
543 Mockito.doReturn(rs1).when(psObj).read(trans, "NsDAOImpl READ", data);
545 retVal = daoObj.delete(trans,data, false);
546 assertTrue(retVal.status == 0);
551 public void testReadNsByAttrib() {
552 PSInfo psObj = Mockito.mock(PSInfo.class);
553 HistoryDAO historyDAO = Mockito.mock(HistoryDAO.class);
554 NsDAO.Data data = new NsDAO.Data();
555 CacheInfoDAO cacheInfoDAO = Mockito.mock(CacheInfoDAO.class);
556 NsDAOImpl daoObj=null;
558 daoObj = new NsDAOImpl(trans, historyDAO, cacheInfoDAO, psObj, session);
559 } catch (APIException | IOException e) {
560 // TODO Auto-generated catch block
564 Mockito.doReturn("100").when(trans).getProperty(CassAccess.CASSANDRA_CLUSTERS_PORT,"100");
565 Mockito.doReturn("100").when(trans).getProperty(CassAccess.CASSANDRA_CLUSTERS_PORT,"9042");
566 Mockito.doReturn("100").when(trans).getProperty(CassAccess.CASSANDRA_CLUSTERS_USER_NAME,"100");
567 Mockito.doReturn("100").when(trans).getProperty(CassAccess.CASSANDRA_CLUSTERS_USER_NAME,null);
569 Result<List<Data>> rs1 = new Result<List<Data>>(null,0,"test",new Object[0]);
570 Mockito.doReturn(rs1).when(psObj).exec(trans, "NsDAOImpl CREATE", data);
571 Mockito.doReturn(rs1).when(psObj).exec(trans, "NsDAOImpl UPDATE", data);
572 Mockito.doReturn(rs1).when(psObj).read(trans, "NsDAOImpl READ", data);
573 Mockito.doReturn(rs1).when(psObj).exec(trans, "NsDAOImpl DELETE", data);
574 Mockito.doReturn(rs1).when(historyDAO).create(Mockito.any(), Mockito.any());
576 Mockito.doReturn("test user").when(trans).user();
579 cbField = AbsCassDAO.class.getDeclaredField("owningDAO");
580 cbField.setAccessible(true);
581 cbField.set(daoObj, null);
582 } catch (NoSuchFieldException | SecurityException e) {
583 // TODO Auto-generated catch block
585 } catch (IllegalArgumentException e) {
586 // TODO Auto-generated catch block
588 } catch (IllegalAccessException e) {
589 // TODO Auto-generated catch block
593 Result<Set<String>> retVal = daoObj.readNsByAttrib(trans,"test");
594 assertTrue(retVal.status == 0);
596 ResultSet rsMock = Mockito.mock(ResultSet.class);
597 Iterator<Row> iteMock = Mockito.mock(Iterator.class);
598 Mockito.doReturn(iteMock).when(rsMock).iterator();
599 Row rowMock = Mockito.mock(Row.class);
600 Mockito.doReturn(rowMock).when(iteMock).next();
601 Mockito.when(iteMock.hasNext()).thenReturn(true, false);
602 Mockito.doReturn("test").when(rowMock).getString(Mockito.anyInt());
603 Mockito.doReturn(rsMock).when(session).execute(Mockito.anyString());
605 retVal = daoObj.readNsByAttrib(trans,"test");
606 assertTrue(retVal.status == 0);
610 public void testAttribAdd() {
611 PSInfo psObj = Mockito.mock(PSInfo.class);
612 HistoryDAO historyDAO = Mockito.mock(HistoryDAO.class);
613 NsDAO.Data data = new NsDAO.Data();
614 CacheInfoDAO cacheInfoDAO = Mockito.mock(CacheInfoDAO.class);
615 NsDAOImpl daoObj=null;
617 daoObj = new NsDAOImpl(trans, historyDAO, cacheInfoDAO, psObj, session);
618 } catch (APIException | IOException e) {
619 // TODO Auto-generated catch block
623 Mockito.doReturn("100").when(trans).getProperty(CassAccess.CASSANDRA_CLUSTERS_PORT,"100");
624 Mockito.doReturn("100").when(trans).getProperty(CassAccess.CASSANDRA_CLUSTERS_PORT,"9042");
625 Mockito.doReturn("100").when(trans).getProperty(CassAccess.CASSANDRA_CLUSTERS_USER_NAME,"100");
626 Mockito.doReturn("100").when(trans).getProperty(CassAccess.CASSANDRA_CLUSTERS_USER_NAME,null);
628 Result<List<Data>> rs1 = new Result<List<Data>>(null,0,"test",new Object[0]);
629 Mockito.doReturn(rs1).when(psObj).exec(trans, "NsDAOImpl CREATE", data);
630 Mockito.doReturn(rs1).when(psObj).exec(trans, "NsDAOImpl UPDATE", data);
631 Mockito.doReturn(rs1).when(psObj).read(trans, "NsDAOImpl READ", data);
632 Mockito.doReturn(rs1).when(psObj).exec(trans, "NsDAOImpl DELETE", data);
633 Mockito.doReturn(rs1).when(historyDAO).create(Mockito.any(), Mockito.any());
635 Mockito.doReturn("test user").when(trans).user();
638 cbField = AbsCassDAO.class.getDeclaredField("owningDAO");
639 cbField.setAccessible(true);
640 cbField.set(daoObj, null);
641 } catch (NoSuchFieldException | SecurityException e) {
642 // TODO Auto-generated catch block
644 } catch (IllegalArgumentException e) {
645 // TODO Auto-generated catch block
647 } catch (IllegalAccessException e) {
648 // TODO Auto-generated catch block
652 Result<Void> retVal = daoObj.attribAdd(trans, "test", "test", "test");
653 assertTrue(retVal.status == 0);
657 public void testAttribRemove() {
658 PSInfo psObj = Mockito.mock(PSInfo.class);
659 HistoryDAO historyDAO = Mockito.mock(HistoryDAO.class);
660 NsDAO.Data data = new NsDAO.Data();
661 CacheInfoDAO cacheInfoDAO = Mockito.mock(CacheInfoDAO.class);
662 NsDAOImpl daoObj=null;
664 daoObj = new NsDAOImpl(trans, historyDAO, cacheInfoDAO, psObj, session);
665 } catch (APIException | IOException e) {
666 // TODO Auto-generated catch block
670 Mockito.doReturn("100").when(trans).getProperty(CassAccess.CASSANDRA_CLUSTERS_PORT,"100");
671 Mockito.doReturn("100").when(trans).getProperty(CassAccess.CASSANDRA_CLUSTERS_PORT,"9042");
672 Mockito.doReturn("100").when(trans).getProperty(CassAccess.CASSANDRA_CLUSTERS_USER_NAME,"100");
673 Mockito.doReturn("100").when(trans).getProperty(CassAccess.CASSANDRA_CLUSTERS_USER_NAME,null);
675 Result<List<Data>> rs1 = new Result<List<Data>>(null,0,"test",new Object[0]);
676 Mockito.doReturn(rs1).when(psObj).exec(trans, "NsDAOImpl CREATE", data);
677 Mockito.doReturn(rs1).when(psObj).exec(trans, "NsDAOImpl UPDATE", data);
678 Mockito.doReturn(rs1).when(psObj).read(trans, "NsDAOImpl READ", data);
679 Mockito.doReturn(rs1).when(psObj).exec(trans, "NsDAOImpl DELETE", data);
680 Mockito.doReturn(rs1).when(historyDAO).create(Mockito.any(), Mockito.any());
682 Mockito.doReturn("test user").when(trans).user();
685 cbField = AbsCassDAO.class.getDeclaredField("owningDAO");
686 cbField.setAccessible(true);
687 cbField.set(daoObj, null);
688 } catch (NoSuchFieldException | SecurityException e) {
689 // TODO Auto-generated catch block
691 } catch (IllegalArgumentException e) {
692 // TODO Auto-generated catch block
694 } catch (IllegalAccessException e) {
695 // TODO Auto-generated catch block
699 Result<Void> retVal = daoObj.attribRemove(trans, "test", "test");
700 assertTrue(retVal.status == 0);
704 public void testAddDescription() {
705 PSInfo psObj = Mockito.mock(PSInfo.class);
706 HistoryDAO historyDAO = Mockito.mock(HistoryDAO.class);
707 NsDAO.Data data = new NsDAO.Data();
708 CacheInfoDAO cacheInfoDAO = Mockito.mock(CacheInfoDAO.class);
709 NsDAOImpl daoObj=null;
711 daoObj = new NsDAOImpl(trans, historyDAO, cacheInfoDAO, psObj, session);
712 } catch (APIException | IOException e) {
713 // TODO Auto-generated catch block
717 Mockito.doReturn("100").when(trans).getProperty(CassAccess.CASSANDRA_CLUSTERS_PORT,"100");
718 Mockito.doReturn("100").when(trans).getProperty(CassAccess.CASSANDRA_CLUSTERS_PORT,"9042");
719 Mockito.doReturn("100").when(trans).getProperty(CassAccess.CASSANDRA_CLUSTERS_USER_NAME,"100");
720 Mockito.doReturn("100").when(trans).getProperty(CassAccess.CASSANDRA_CLUSTERS_USER_NAME,null);
722 Result<List<Data>> rs1 = new Result<List<Data>>(null,0,"test",new Object[0]);
723 Mockito.doReturn(rs1).when(psObj).exec(trans, "NsDAOImpl CREATE", data);
724 Mockito.doReturn(rs1).when(psObj).exec(trans, "NsDAOImpl UPDATE", data);
725 Mockito.doReturn(rs1).when(psObj).read(trans, "NsDAOImpl READ", data);
726 Mockito.doReturn(rs1).when(psObj).exec(trans, "NsDAOImpl DELETE", data);
727 Mockito.doReturn(rs1).when(historyDAO).create(Mockito.any(), Mockito.any());
729 rs1 = new Result<List<Data>>(null,1,"test",new String[0]);
730 Mockito.doReturn(rs1).when(cacheInfoDAO).touch(Mockito.any(), Mockito.anyString(), Mockito.anyInt());
731 Mockito.doReturn("test user").when(trans).user();
734 cbField = AbsCassDAO.class.getDeclaredField("owningDAO");
735 cbField.setAccessible(true);
736 cbField.set(daoObj, null);
737 } catch (NoSuchFieldException | SecurityException e) {
738 // TODO Auto-generated catch block
740 } catch (IllegalArgumentException e) {
741 // TODO Auto-generated catch block
743 } catch (IllegalAccessException e) {
744 // TODO Auto-generated catch block
748 Result<Void> retVal = daoObj.addDescription(trans, "test", "test");
749 assertTrue(retVal.status == 0);
753 public void testGetChildren() {
754 PSInfo psObj = Mockito.mock(PSInfo.class);
755 HistoryDAO historyDAO = Mockito.mock(HistoryDAO.class);
756 CacheInfoDAO cacheInfoDAO = Mockito.mock(CacheInfoDAO.class);
757 NsDAOImpl daoObj=null;
759 daoObj = new NsDAOImpl(trans, historyDAO, cacheInfoDAO, psObj, session);
760 } catch (APIException | IOException e) {
761 // TODO Auto-generated catch block
765 Result<List<Data>> retVal = daoObj.getChildren(trans, "test");
770 public void testData() {
771 NsDAO.Data data = new NsDAO.Data();
775 data.attrib = new HashMap<>();
779 data.attrib = new ConcurrentHashMap<>();
790 class NsDAOImpl extends NsDAO{
793 // public NsDAOImpl(AuthzTrans trans, HistoryDAO historyDAO,PSInfo readPS ) throws APIException, IOException {
794 // super(trans, historyDAO);
795 // setSession(this, Mockito.mock(Session.class));
799 public NsDAOImpl(AuthzTrans trans, Cluster cluster, String keySpace, Session session)throws APIException, IOException {
800 super(trans, cluster, keySpace);
801 setSession(this, session);
805 public NsDAOImpl(AuthzTrans trans, HistoryDAO historyDAO, CacheInfoDAO cacheInfoDAO,
806 org.onap.aaf.auth.dao.AbsCassDAO.PSInfo psObj, Session session) throws APIException, IOException {
807 super(trans, historyDAO, cacheInfoDAO);
808 setPs(this, psObj, "createPS");
809 setPs(this, psObj, "updatePS");
810 setPs(this, psObj, "readPS");
811 setPs(this, psObj, "deletePS");
812 setPsNs(this, psObj, "psNS");
813 setSession(this, session);
815 public void setPsNs(NsDAOImpl NsDAOObj, PSInfo psInfoObj, String methodName) {
818 nsDaoField = NsDAO.class.getDeclaredField(methodName);
820 nsDaoField.setAccessible(true);
821 // remove final modifier from field
822 Field modifiersField = Field.class.getDeclaredField("modifiers");
823 modifiersField.setAccessible(true);
824 // modifiersField.setInt(nsDaoField, nsDaoField.getModifiers() & ~Modifier.FINAL);
826 nsDaoField.set(NsDAOObj, psInfoObj);
827 } catch (NoSuchFieldException | SecurityException e) {
828 // TODO Auto-generated catch block
830 } catch (IllegalArgumentException e) {
831 // TODO Auto-generated catch block
833 } catch (IllegalAccessException e) {
834 // TODO Auto-generated catch block
839 public void setPs(NsDAOImpl NsDAOObj, PSInfo psInfoObj, String methodName) {
842 nsDaoField = CassDAOImpl.class.getDeclaredField(methodName);
844 nsDaoField.setAccessible(true);
845 // remove final modifier from field
846 Field modifiersField = Field.class.getDeclaredField("modifiers");
847 modifiersField.setAccessible(true);
848 // modifiersField.setInt(nsDaoField, nsDaoField.getModifiers() & ~Modifier.FINAL);
850 nsDaoField.set(NsDAOObj, psInfoObj);
851 } catch (NoSuchFieldException | SecurityException e) {
852 // TODO Auto-generated catch block
854 } catch (IllegalArgumentException e) {
855 // TODO Auto-generated catch block
857 } catch (IllegalAccessException e) {
858 // TODO Auto-generated catch block
862 public void setSession(NsDAOImpl approvalDaoObj, Session session) {
865 nsDaoField = AbsCassDAO.class.getDeclaredField("session");
867 nsDaoField.setAccessible(true);
868 // remove final modifier from field
869 Field modifiersField = Field.class.getDeclaredField("modifiers");
870 modifiersField.setAccessible(true);
871 // modifiersField.setInt(nsDaoField, nsDaoField.getModifiers() & ~Modifier.FINAL);
873 nsDaoField.set(approvalDaoObj, session);
874 } catch (NoSuchFieldException | SecurityException e) {
875 // TODO Auto-generated catch block
877 } catch (IllegalArgumentException e) {
878 // TODO Auto-generated catch block
880 } catch (IllegalAccessException e) {
881 // TODO Auto-generated catch block