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