auth/auth-cass/src/test/java/org/onap/aaf/auth/dao/aaf/test/JU_ApprovalDAO.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
  25 import static org.junit.Assert.assertEquals;
  26 import static org.junit.Assert.assertNotSame;
  27 import static org.junit.Assert.assertTrue;
  28
  29 import java.util.Date;
  30 import java.util.List;
  31 import java.util.UUID;
  32
  33 import org.junit.Test;
  34 import org.onap.aaf.auth.dao.cass.ApprovalDAO;
  35 import org.onap.aaf.auth.dao.cass.ApprovalDAO.Data;
  36 import org.onap.aaf.auth.layer.Result;
  37
  38 public class JU_ApprovalDAO  extends AbsJUCass {
  39         @Test
  40         public void testCRUD() throws Exception {
  41                 ApprovalDAO rrDAO = new ApprovalDAO(trans, cluster, AUTHZ);
  42                 ApprovalDAO.Data data = new ApprovalDAO.Data();
  43
  44                 data.ticket = UUID.randomUUID(); // normally, read from Future object
  45                 data.user = "testid@test.com";
  46                 data.approver = "mySuper@att.com";
  47                 data.type = "supervisor";
  48                 data.status = "pending";
  49                 data.operation = "C";
  50                 data.updated = new Date();
  51
  52                 try {
  53                         // Test create
  54                         rrDAO.create(trans, data);
  55
  56                         // Test Read by Ticket
  57                         Result<List<ApprovalDAO.Data>> rlad;
  58                         rlad = rrDAO.readByTicket(trans, data.ticket);
  59                         assertTrue(rlad.isOK());
  60                         assertEquals(1,rlad.value.size());
  61                         compare(data,rlad.value.get(0));
  62
  63                         // Hold onto original ID for deletion, and read tests
  64                         UUID id = rlad.value.get(0).id;
  65
  66                         try {
  67                                 // Test Read by User
  68                                 rlad = rrDAO.readByUser(trans, data.user);
  69                                 assertTrue(rlad.isOKhasData());
  70                                 boolean ok = false;
  71                                 for(ApprovalDAO.Data a : rlad.value) {
  72                                         if(a.id.equals(id)) {
  73                                                 ok = true;
  74                                                 compare(data,a);
  75                                         }
  76                                 }
  77                                 assertTrue(ok);
  78
  79                                 // Test Read by Approver
  80                                 rlad = rrDAO.readByApprover(trans, data.approver);
  81                                 assertTrue(rlad.isOKhasData());
  82                                 ok = false;
  83                                 for(ApprovalDAO.Data a : rlad.value) {
  84                                         if(a.id.equals(id)) {
  85                                                 ok = true;
  86                                                 compare(data,a);
  87                                         }
  88                                 }
  89                                 assertTrue(ok);
  90
  91                                 // Test Read by ID
  92                                 rlad = rrDAO.read(trans, id);
  93                                 assertTrue(rlad.isOKhasData());
  94                                 ok = false;
  95                                 for(ApprovalDAO.Data a : rlad.value) {
  96                                         if(a.id.equals(id)) {
  97                                                 ok = true;
  98                                                 compare(data,a);
  99                                         }
 100                                 }
 101                                 assertTrue(ok);
 102
 103                                 // Test Update
 104                                 data.status = "approved";
 105                                 data.id = id;
 106                                 assertTrue(rrDAO.update(trans, data).isOK());
 107
 108                                 rlad = rrDAO.read(trans, id);
 109                                 assertTrue(rlad.isOKhasData());
 110                                 ok = false;
 111                                 for(ApprovalDAO.Data a : rlad.value) {
 112                                         if(a.id.equals(id)) {
 113                                                 ok = true;
 114                                                 compare(data,a);
 115                                         }
 116                                 }
 117                                 assertTrue(ok);
 118
 119                         } finally {
 120                                 // Delete
 121                                 data.id = id;
 122                                 rrDAO.delete(trans, data, true);
 123                                 rlad = rrDAO.read(trans, id);
 124                                 assertTrue(rlad.isOK());
 125                                 assertTrue(rlad.isEmpty());
 126                         }
 127
 128                 } finally {
 129                         rrDAO.close(trans);
 130                 }
 131         }
 132
 133         private void compare(Data d1, Data d2) {
 134                 assertNotSame(d1.id,d2.id);
 135                 assertEquals(d1.ticket,d2.ticket);
 136                 assertEquals(d1.user,d2.user);
 137                 assertEquals(d1.approver,d2.approver);
 138                 assertEquals(d1.type,d2.type);
 139                 assertEquals(d1.status,d2.status);
 140                 assertEquals(d1.operation,d2.operation);
 141                 assertNotSame(d1.updated,d2.updated);
 142         }
 143
 144
 145
 146 }