auth/auth-cass/src/test/java/com/att/dao/aaf/test/JU_RoleDAO.java

   1 /**
   2  * ============LICENSE_START====================================================
   3  * org.onap.aaf
   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
  10  *
  11  *      http://www.apache.org/licenses/LICENSE-2.0
  12  *
  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====================================================
  19  *
  20  */
  21
  22
  23 package com.att.dao.aaf.test;
  24
  25 import static junit.framework.Assert.assertEquals;
  26 import static junit.framework.Assert.assertTrue;
  27
  28 import java.io.IOException;
  29 import java.nio.ByteBuffer;
  30 import java.util.List;
  31
  32 import org.junit.Test;
  33 import org.onap.aaf.auth.dao.cass.PermDAO;
  34 import org.onap.aaf.auth.dao.cass.RoleDAO;
  35 import org.onap.aaf.auth.dao.cass.RoleDAO.Data;
  36 import org.onap.aaf.auth.layer.Result;
  37 import org.onap.aaf.misc.env.APIException;
  38
  39
  40 public class JU_RoleDAO extends AbsJUCass {
  41
  42         @Test
  43         public void test()  throws IOException, APIException {
  44                 RoleDAO rd = new RoleDAO(trans, cluster, AUTHZ);
  45                 try {
  46                         Data data = new RoleDAO.Data();
  47                         data.ns = "com.test.ju_role";
  48                         data.name = "role1";
  49
  50 //              Bytification
  51                 ByteBuffer bb = data.bytify();
  52                 Data bdata = new RoleDAO.Data();
  53                 bdata.reconstitute(bb);
  54                 compare(data, bdata);
  55
  56                         // CREATE
  57                         Result<Data> rdc = rd.create(trans, data);
  58                         assertTrue(rdc.isOK());
  59                         Result<List<Data>> rdrr;
  60                         try {
  61                                 // READ
  62                                 rdrr = rd.read(trans, data);
  63                                 assertTrue(rdrr.isOKhasData());
  64                                 assertEquals(rdrr.value.size(),1);
  65                                 Data d = rdrr.value.get(0);
  66                                 assertEquals(d.perms.size(),0);
  67                                 assertEquals(d.name,data.name);
  68                                 assertEquals(d.ns,data.ns);
  69
  70                                 PermDAO.Data perm = new PermDAO.Data();
  71                                 perm.ns = data.ns;
  72                                 perm.type = "Perm";
  73                                 perm.instance = "perm1";
  74                                 perm.action = "write";
  75
  76                                 // ADD Perm
  77                                 Result<Void> rdar = rd.addPerm(trans, data, perm);
  78                                 assertTrue(rdar.isOK());
  79                                 rdrr = rd.read(trans, data);
  80                                 assertTrue(rdrr.isOKhasData());
  81                                 assertEquals(rdrr.value.size(),1);
  82                                 assertEquals(rdrr.value.get(0).perms.size(),1);
  83                                 assertTrue(rdrr.value.get(0).perms.contains(perm.encode()));
  84
  85                                 // DEL Perm
  86                                 rdar = rd.delPerm(trans, data,perm);
  87                                 assertTrue(rdar.isOK());
  88                                 rdrr = rd.read(trans, data);
  89                                 assertTrue(rdrr.isOKhasData());
  90                                 assertEquals(rdrr.value.size(),1);
  91                                 assertEquals(rdrr.value.get(0).perms.size(),0);
  92
  93                                 // Add Child
  94                                 Data data2 = new Data();
  95                                 data2.ns = data.ns;
  96                                 data2.name = data.name + ".2";
  97
  98                                 rdc = rd.create(trans, data2);
  99                                 assertTrue(rdc.isOK());
 100                                 try {
 101                                         rdrr = rd.readChildren(trans, data.ns,data.name);
 102                                         assertTrue(rdrr.isOKhasData());
 103                                         assertEquals(rdrr.value.size(),1);
 104                                         assertEquals(rdrr.value.get(0).name,data.name + ".2");
 105
 106                                         rdrr = rd.readChildren(trans, data.ns,"*");
 107                                         assertTrue(rdrr.isOKhasData());
 108                                         assertEquals(rdrr.value.size(),2);
 109
 110                                 } finally {
 111                                         // Delete Child
 112                                         rd.delete(trans, data2, true);
 113                                 }
 114
 115                         } finally {
 116                                 // DELETE
 117                                 Result<Void> rddr = rd.delete(trans, data, true);
 118                                 assertTrue(rddr.isOK());
 119                                 rdrr = rd.read(trans, data);
 120                                 assertTrue(rdrr.isOK() && rdrr.isEmpty());
 121                                 assertEquals(rdrr.value.size(),0);
 122                         }
 123                 } finally {
 124                         rd.close(trans);
 125                 }
 126         }
 127
 128         private void compare(Data a, Data b) {
 129                 assertEquals(a.name,b.name);
 130                 assertEquals(a.description, b.description);
 131                 assertEquals(a.ns,b.ns);
 132                 assertEquals(a.perms(false).size(),b.perms(false).size());
 133                 for(String p : a.perms(false)) {
 134                         assertTrue(b.perms(false).contains(p));
 135                 }
 136         }
 137
 138 }