cadi/core/src/test/java/org/onap/aaf/cadi/config/test/JU_MapBathConverter.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 package org.onap.aaf.cadi.config.test;
  22
  23 import java.io.File;
  24 import java.io.IOException;
  25 import java.sql.Date;
  26 import java.text.SimpleDateFormat;
  27 import java.util.ArrayList;
  28 import java.util.GregorianCalendar;
  29 import java.util.Iterator;
  30 import java.util.List;
  31
  32 import org.junit.Before;
  33 import org.junit.BeforeClass;
  34 import org.junit.Test;
  35 import org.onap.aaf.cadi.Access;
  36 import org.onap.aaf.cadi.CadiException;
  37 import org.onap.aaf.cadi.PropAccess;
  38 import org.onap.aaf.cadi.Symm;
  39 import org.onap.aaf.cadi.filter.MapBathConverter;
  40 import org.onap.aaf.cadi.util.CSV;
  41 import org.onap.aaf.cadi.util.CSV.Visitor;
  42 import org.onap.aaf.cadi.util.CSV.Writer;
  43
  44 import junit.framework.Assert;
  45
  46 /**
  47  * Test a simple Migration conversion tool for CADI
  48  *
  49  * @author Instrumental(Jonathan)
  50  *
  51  */
  52 public class JU_MapBathConverter {
  53         private static final String NEW_USER_SOMETHING_ORG = "NEW_USER@Something.org";
  54         private static final String OLD_ID = "OLD_ID";
  55         private static final String SHARED_PASS = "SHARED_PASS";
  56         private static CSV csv;
  57         private static ArrayList<String> expected;
  58         private static final Access access = new PropAccess();
  59     private final static SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd");
  60
  61         @BeforeClass
  62         public static void createFile() throws IOException {
  63                 // Note, you cate a "MapBathConverter" by access to a File.
  64                 // We will create that file now.  Local is fine.
  65                 csv = new CSV("JU_MapBathConverter.csv");
  66         }
  67
  68         @BeforeClass
  69         public static void beforeClass() {
  70                 expected = new ArrayList<>();
  71         }
  72
  73         @Before
  74         public void before() {
  75                 expected.clear();
  76         }
  77
  78         @Test
  79         public void test() throws IOException, CadiException {
  80                 CSV.Writer cw = csv.writer();
  81                 GregorianCalendar gc = new GregorianCalendar();
  82                 gc.add(GregorianCalendar.MONTH, 6);
  83                 try {
  84                         try {
  85                                 // CSV can simply be OLD ID and NEW,  no passwords
  86                                 cw.row(exp(OLD_ID), exp(NEW_USER_SOMETHING_ORG),sdf.format(gc.getTime()));
  87
  88                                 // Style 1 - Incoming ID/pass, create new cred with NweID and same Pass
  89                                 cw.row(exp(bath(OLD_ID,SHARED_PASS)), exp(NEW_USER_SOMETHING_ORG),sdf.format(gc.getTime()));
  90                                 // the response should be Basic with NEW_ID and OLD_PASS
  91
  92                                 // Style 2
  93                                 cw.row(exp(bath(OLD_ID,"OLD_PASS")), exp(bath(NEW_USER_SOMETHING_ORG,"NEW_PASS")),sdf.format(gc.getTime()));
  94
  95                         } finally {
  96                                 cw.close();
  97                         }
  98
  99                         final Iterator<String> exp = expected.iterator();
 100                         csv.visit(new Visitor() {
 101                                 @Override
 102                                 public void visit(List<String> row) {
 103                                         int i=0;
 104                                         for(String s : row) {
 105                                                 switch(i++) {
 106                                                         case 0:
 107                                                         case 1:
 108                                                                 Assert.assertEquals(exp.next(), s);
 109                                                                 break;
 110                                                         case 2:
 111                                                                 try {
 112                                                                         Date d = Date.valueOf(s);
 113                                                                 } catch (Exception e) {
 114                                                                         Assert.assertTrue("Last entry should be a date",false);
 115                                                                 }
 116                                                                 break;
 117                                                         default:
 118                                                                 Assert.fail("There should only be 3 columns in this test case.");
 119                                                 }
 120                                         }
 121                                 }
 122                         });
 123
 124                         MapBathConverter mbc = new MapBathConverter(access, csv);
 125
 126                         // Check no lookup just returns the same
 127                         Assert.assertEquals("NonKey", "NonKey"); // if not in map, expect same value
 128
 129                         Iterator<String> exp1 = expected.iterator();
 130                         // there's no passwords in CSV
 131                         String old = exp1.next();
 132                         String nw = exp1.next();
 133                         Assert.assertEquals(nw, mbc.convert(access,old));
 134
 135                         Assert.assertEquals(bath(NEW_USER_SOMETHING_ORG,SHARED_PASS), mbc.convert(access,bath(OLD_ID,SHARED_PASS)));
 136
 137                         // Style 1 (new cred, old password)
 138                         old = exp1.next();
 139                         nw = bath(exp1.next(),SHARED_PASS);
 140                         Assert.assertEquals(nw, mbc.convert(access,old));
 141
 142                         // Style 2
 143                         old = exp1.next();
 144                         nw = exp1.next();
 145                         Assert.assertEquals(nw, mbc.convert(access,old));
 146
 147                 } finally {
 148                         csv.delete();
 149                 }
 150         }
 151
 152         @Test
 153         public void testInsecureRole() throws IOException {
 154                 CSV.Writer cw = csv.writer();
 155                 GregorianCalendar gc = new GregorianCalendar();
 156                 gc.add(GregorianCalendar.MONTH, 6);
 157                 try {
 158                         try {
 159                                 // Invalid Scenario - Non Authenticated ID to authenticated User
 160                                 cw.row(exp(OLD_ID), exp(bath(NEW_USER_SOMETHING_ORG,"NEW_PASS")),sdf.format(gc.getTime()));
 161
 162                         } finally {
 163                                 cw.close();
 164                         }
 165
 166                         try {
 167                                 new MapBathConverter(access, csv);
 168                                 Assert.fail("Invalid Data should throw Exception");
 169                         } catch (CadiException e) {
 170                                 Assert.assertTrue("Invalid Data should throw Exception",true);
 171                         }
 172
 173                 } finally {
 174                         csv.delete();
 175                 }
 176         }
 177
 178         @Test
 179         public void testTooFewColumns() throws IOException, CadiException {
 180                 CSV.Writer cw = csv.writer();
 181                 try {
 182                         try {
 183                                 cw.row(exp(bath(OLD_ID,"OLD_PASS")), exp(bath(NEW_USER_SOMETHING_ORG,"NEW_PASS")));
 184                         } finally {
 185                                 cw.close();
 186                         }
 187
 188                         try {
 189                                 new MapBathConverter(access, csv);
 190                                 Assert.fail("file with too few rows should throw exception");
 191                         } catch(CadiException | IOException e) {
 192                                 Assert.assertTrue("Correctly thrown Exception",true);
 193                         }
 194                 } finally {
 195                         csv.delete();
 196                 }
 197         }
 198
 199         @Test
 200         public void testNoFile() {
 201                 try {
 202                         new MapBathConverter(access, new CSV("Bogus"));
 203                         Assert.fail("Non Existent File should throw exception");
 204                 } catch(CadiException | IOException e) {
 205                         Assert.assertTrue("Correctly thrown Exception",true);
 206                 }
 207         }
 208
 209         @Test
 210         public void testBadRows() throws IOException {
 211                 try {
 212                         Writer cw = csv.writer();
 213                         try {
 214                                 cw.row("Single Column");
 215                         } finally {
 216                                 cw.close();
 217                         }
 218
 219                         try {
 220                                 new MapBathConverter(access,csv);
 221                                 Assert.fail("Non Existent File should throw exception");
 222                         } catch(CadiException | IOException e) {
 223                                 Assert.assertTrue("Correctly thrown Exception",true);
 224                         }
 225                 } finally {
 226                         csv.delete();
 227                 }
 228
 229                 // Check for deletion
 230                 Assert.assertFalse(csv.toString() + "should have been deleted",new File(csv.toString()).exists());
 231         }
 232
 233         private String bath(String user, String password) throws IOException {
 234                 StringBuilder sb = new StringBuilder(user);
 235                 sb.append(':');
 236                 sb.append(password);
 237                 byte[] encoded = Symm.base64noSplit.encode(sb.toString().getBytes());
 238                 sb.setLength(0);
 239                 sb.append("Basic ");
 240                 sb.append(new String(encoded));
 241                 return sb.toString();
 242         }
 243
 244         private String exp(String s) {
 245                 expected.add(s);
 246                 return s;
 247         }
 248 }