auth/auth-cass/src/test/java/org/onap/aaf/auth/dao/aaf/test/JU_RoleDAO.java

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