auth/auth-service/src/test/java/org/onap/aaf/auth/service/mapper/JU_Mapper_2_0.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
  23 package org.onap.aaf.auth.service.mapper;
  24
  25 import static org.junit.Assert.assertEquals;
  26 import static org.junit.Assert.assertFalse;
  27 import static org.junit.Assert.assertNotNull;
  28 import static org.junit.Assert.assertNull;
  29 import static org.junit.Assert.assertTrue;
  30 import static org.junit.Assert.fail;
  31 import static org.mockito.BDDMockito.given;
  32 import static org.mockito.Matchers.any;
  33 import static org.mockito.Matchers.anyString;
  34 import static org.mockito.Matchers.eq;
  35 import static org.mockito.Matchers.isA;
  36 import static org.mockito.Mockito.mock;
  37 import static org.mockito.Mockito.never;
  38 import static org.mockito.Mockito.verify;
  39 import static org.mockito.Mockito.verifyZeroInteractions;
  40 import static org.onap.aaf.auth.layer.Result.ERR_BadData;
  41 import static org.onap.aaf.auth.layer.Result.ERR_General;
  42
  43 import java.io.IOException;
  44 import java.math.BigInteger;
  45 import java.util.ArrayList;
  46 import java.util.Calendar;
  47 import java.util.Collection;
  48 import java.util.Date;
  49 import java.util.GregorianCalendar;
  50 import java.util.HashMap;
  51 import java.util.HashSet;
  52 import java.util.List;
  53 import java.util.Map;
  54 import java.util.Set;
  55 import java.util.UUID;
  56 import java.util.stream.Collectors;
  57
  58 import org.junit.Before;
  59 import org.junit.Test;
  60 import org.junit.runner.RunWith;
  61 import org.mockito.Mock;
  62 import org.mockito.runners.MockitoJUnitRunner;
  63 import org.onap.aaf.auth.dao.cass.CertDAO;
  64 import org.onap.aaf.auth.dao.cass.CredDAO;
  65 import org.onap.aaf.auth.dao.cass.HistoryDAO;
  66 import org.onap.aaf.auth.dao.cass.Namespace;
  67 import org.onap.aaf.auth.dao.cass.NsDAO;
  68 import org.onap.aaf.auth.dao.cass.NsSplit;
  69 import org.onap.aaf.auth.dao.cass.NsType;
  70 import org.onap.aaf.auth.dao.cass.PermDAO;
  71 import org.onap.aaf.auth.dao.cass.PermDAO.Data;
  72 import org.onap.aaf.auth.dao.cass.RoleDAO;
  73 import org.onap.aaf.auth.dao.cass.UserRoleDAO;
  74 import org.onap.aaf.auth.dao.hl.Question;
  75 import org.onap.aaf.auth.dao.hl.Question.Access;
  76 import org.onap.aaf.auth.env.AuthzTrans;
  77 import org.onap.aaf.auth.env.AuthzTrans.REQD_TYPE;
  78 import org.onap.aaf.auth.layer.Result;
  79 import org.onap.aaf.auth.org.Organization;
  80 import org.onap.aaf.auth.org.Organization.Expiration;
  81 import org.onap.aaf.auth.rserv.Pair;
  82 import org.onap.aaf.auth.service.mapper.Mapper.API;
  83 import org.onap.aaf.cadi.CadiException;
  84 import org.onap.aaf.misc.env.APIException;
  85 import org.onap.aaf.misc.env.Env;
  86 import org.onap.aaf.misc.env.TimeTaken;
  87
  88 import aaf.v2_0.Certs;
  89 import aaf.v2_0.Certs.Cert;
  90 import aaf.v2_0.CredRequest;
  91 import aaf.v2_0.History;
  92 import aaf.v2_0.History.Item;
  93 import aaf.v2_0.NsRequest;
  94 import aaf.v2_0.Nss;
  95 import aaf.v2_0.Nss.Ns;
  96 import aaf.v2_0.Perm;
  97 import aaf.v2_0.PermRequest;
  98 import aaf.v2_0.Perms;
  99 import aaf.v2_0.Pkey;
 100 import aaf.v2_0.Request;
 101 import aaf.v2_0.Role;
 102 import aaf.v2_0.RoleRequest;
 103 import aaf.v2_0.Roles;
 104 import aaf.v2_0.UserRole;
 105 import aaf.v2_0.UserRoleRequest;
 106 import aaf.v2_0.UserRoles;
 107 import aaf.v2_0.Users;
 108 import aaf.v2_0.Users.User;
 109
 110 @RunWith(MockitoJUnitRunner.class)
 111 public class JU_Mapper_2_0 {
 112     private static final String USER = "John";
 113
 114     private Mapper_2_0 mapper;
 115     @Mock
 116     private Question question;
 117     @Mock
 118     private AuthzTrans transaction;
 119     @Mock
 120     private TimeTaken tt;
 121     @Mock
 122     private Organization org;
 123
 124
 125     @Before
 126     public void setUp() throws APIException, IOException, CadiException {
 127       given(transaction.start(anyString(), eq(Env.SUB))).willReturn(tt);
 128       given(transaction.user()).willReturn(USER);
 129       given(transaction.org()).willReturn(org);
 130         this.mapper = new Mapper_2_0(question);
 131     }
 132
 133     @Test(expected = ClassCastException.class)
 134     public void ns_willThrowException_whenInvalidRequestType() {
 135         //given
 136         Request rq = new Request();
 137
 138         //when
 139         mapper.ns(transaction, rq);
 140
 141         //then
 142         fail("Expected ClassCastException");
 143     }
 144
 145     @Test
 146     public void ns_shouldConvertNamespaceRequest_whenValidTypeIsExplicitlyProvided() {
 147         //given
 148         String namespaceName = "org.companyA.app1";
 149         String namespaceType = "APP";
 150         NsType expectedNsType = NsType.APP;
 151         NsRequest nsRequest = createNsRequestForType(namespaceName, namespaceType);
 152
 153         //when
 154         Result<Namespace> result = mapper.ns(transaction,nsRequest);
 155
 156         //then
 157         assertTrue(result.isOK());
 158         assertNamespaceValues(result.value, expectedNsType, namespaceName);
 159         verify(transaction).checkpoint(namespaceName,Env.ALWAYS);
 160     }
 161
 162     @Test
 163     public void ns_shouldConvertNamespaceRequest_whenInValidTypeIsExplicitlyProvided() {
 164         //given
 165         String namespaceName = "org.companyA.app1.service0";
 166         String invalidNsType = "BLUE";
 167         NsType expectedNsType = NsType.APP;
 168         NsRequest nsRequest = createNsRequestForType(namespaceName, invalidNsType);
 169
 170         //when
 171         Result<Namespace> result = mapper.ns(transaction,nsRequest);
 172
 173         //then
 174         assertTrue(result.isOK());
 175         assertNamespaceValues(result.value, expectedNsType, namespaceName);
 176         verify(transaction).checkpoint(namespaceName,Env.ALWAYS);
 177     }
 178
 179     @Test
 180     public void ns_shouldConvertRootNamespaceRequest_whenTypeNotProvided() {
 181         //given
 182         String rootNsName = "org";
 183         NsType expectedNsType = NsType.ROOT;
 184         NsRequest nsRequest = createNsRequestForType(rootNsName, null);
 185
 186         //when
 187         Result<Namespace> result = mapper.ns(transaction,nsRequest);
 188
 189         //then
 190         assertTrue(result.isOK());
 191         assertNamespaceValues(result.value, expectedNsType, rootNsName);
 192         verify(transaction).checkpoint(rootNsName,Env.ALWAYS);
 193     }
 194
 195     @Test
 196     public void ns_shouldConvertCompanyNamespaceRequest_whenTypeNotProvided() {
 197         //given
 198         String companyNsName = "org.companyA";
 199         NsType expectedNsType = NsType.COMPANY;
 200         NsRequest nsRequest = createNsRequestForType(companyNsName, null);
 201
 202         //when
 203         Result<Namespace> result = mapper.ns(transaction,nsRequest);
 204
 205         //then
 206         assertTrue(result.isOK());
 207         assertNamespaceValues(result.value, expectedNsType, companyNsName);
 208         verify(transaction).checkpoint(companyNsName,Env.ALWAYS);
 209     }
 210
 211     private void assertNamespaceValues(Namespace value, NsType nsType, String namespaceName) {
 212         List<String> people = Lists.newArrayList("tk007@people.osaaf.org");
 213         assertEquals(Integer.valueOf(nsType.type), value.type);
 214         assertEquals(namespaceName, value.name);
 215         assertEquals("some namespace description", value.description);
 216         assertEquals(people, value.admin);
 217         assertEquals(people, value.owner);
 218     }
 219
 220     private NsRequest createNsRequestForType(String nsName, String nsType) {
 221         NsRequest req = mapper.newInstance(API.NS_REQ);
 222         req.setType(nsType);
 223         req.setName(nsName);
 224         req.setDescription("some namespace description");
 225         req.getAdmin().add("tk007@people.osaaf.org");
 226         req.getResponsible().add("tk007@people.osaaf.org");
 227         return req;
 228     }
 229
 230     @Test
 231     public void nss_shouldConvertNamespaceToNss_withoutAttributes() {
 232         //given
 233         Nss nss = mapper.newInstance(API.NSS);
 234         Namespace ns = mapper.ns(transaction, createNsRequestForType("org.onap",  null)).value;
 235
 236         //when
 237         Result<Nss> result = mapper.nss(transaction, ns, nss);
 238
 239         //then
 240         assertTrue(result.isOK());
 241         assertEquals("Only one Ns should be added",1, result.value.getNs().size());
 242         Ns addedNs = Iterables.getOnlyElement(result.value.getNs());
 243         assertEquals(ns.admin, addedNs.getAdmin());
 244         assertEquals(ns.name, addedNs.getName());
 245         assertEquals(ns.owner, addedNs.getResponsible());
 246         assertEquals(ns.description, addedNs.getDescription());
 247         assertTrue(addedNs.getAttrib().isEmpty());
 248     }
 249
 250     @Test
 251     public void nss_shouldConvertNamespaceToNss_withAttributes() {
 252         //given
 253         Nss nss = mapper.newInstance(API.NSS);
 254         Namespace ns = mapper.ns(transaction, createNsRequestForType("org.onap",  null)).value;
 255         ns.attrib = Lists.newArrayList();
 256         int attribNum = 5;
 257         Map<String, String> attribs = ImmutableMap.of("key1", "value1", "key2", "value2", "key3", "value3", "key4", "value4", "key5", "value5");
 258         attribs.forEach((key,val) -> ns.attrib.add(new Pair<>(key,val)));
 259
 260         //when
 261         Result<Nss> result = mapper.nss(transaction, ns, nss);
 262
 263         //then
 264         assertTrue(result.isOK());
 265         assertEquals("Only one Ns should be added",1, result.value.getNs().size());
 266         Ns addedNs = Iterables.getOnlyElement(result.value.getNs());
 267         assertEquals(attribNum, addedNs.getAttrib().size());
 268         addedNs.getAttrib().forEach( attr -> {
 269             assertEquals(attr.getValue(), attribs.get(attr.getKey()));
 270         });
 271     }
 272
 273     @Test
 274     public void nss_shouldAddSeveralNamespacesToNss() {
 275         //given
 276         Nss nss = mapper.newInstance(API.NSS);
 277         Namespace ns1 = mapper.ns(transaction, createNsRequestForType("org.onap",  "COMPANY")).value;
 278         Namespace ns2 = mapper.ns(transaction, createNsRequestForType("org.onap.prh",  "APP")).value;
 279
 280         //when
 281         Result<Nss> result = mapper.nss(transaction, Lists.newArrayList(ns1,ns2), nss);
 282
 283         //then
 284         assertTrue(result.isOK());
 285         assertEquals("Two namespaces should be added",2, result.value.getNs().size());
 286     }
 287
 288     @Test
 289     public void perm_shouldNotAddPerms_whenFilterIsSet_andUserIsNotAuthorized() {
 290         //given
 291     given(question.mayUser(eq(transaction), eq(USER), any(PermDAO.Data.class), eq(Access.read)))
 292         .willReturn(Result.err(9, "error"));
 293     Perms permsContainer = mapper.newInstance(API.PERMS);
 294     List<PermDAO.Data> permsData = Lists.newArrayList(new PermDAO.Data());
 295     boolean filter = true;
 296
 297         //when
 298     Result<Perms> result = mapper.perms(transaction, permsData, permsContainer, filter);
 299
 300         //then
 301     assertTrue(result.isOK());
 302     assertEquals("No perms added",0,result.value.getPerm().size());
 303     }
 304
 305     @Test
 306   public void perm_shouldAddPerm_withNamespaceSet_whenUserIsAuthorized_AndNamespaceIsRequestedType() {
 307       //given
 308       given(question.mayUser(eq(transaction), eq(USER), any(PermDAO.Data.class), eq(Access.read)))
 309           .willReturn(Result.ok(new NsDAO.Data()));
 310       given(transaction.requested(REQD_TYPE.ns)).willReturn(true);
 311       Perms permsContainer = mapper.newInstance(API.PERMS);
 312       Set<String> roles = Sets.newHashSet("org.onap.portal.owner","org.onap.portal.designer"
 313                 ,"org.onap.portal.tester");
 314       String namespace = "org.onap.portal";
 315       String type = "access";
 316       String fullType = namespace + "." +type;
 317       String action = "read";
 318       String description = "Portal Read Access";
 319           List<PermDAO.Data> permsData = Lists.newArrayList(createPermDAOobj(namespace, type, "*",action, roles, description));
 320       boolean filter = true;
 321
 322       //when
 323       Result<Perms> result = mapper.perms(transaction, permsData, permsContainer, filter);
 324
 325       //then
 326       assertTrue(result.isOK());
 327       assertEquals("Perm is added",1,result.value.getPerm().size());
 328       Perm perm = Iterables.getOnlyElement(result.value.getPerm());
 329       assertEquals(namespace, perm.getNs());
 330       assertEquals(fullType, perm.getType());
 331       assertEquals(action, perm.getAction());
 332       assertEquals("*", perm.getInstance());
 333       assertEquals(description, perm.getDescription());
 334       assertEquals(Lists.newArrayList(roles), perm.getRoles());
 335   }
 336
 337     @Test
 338     public void perm_shouldAddPerm_withoutNamespaceSet_whenUserIsAuthorized_AndNamespaceIsNotRequestedType() {
 339         //given
 340         given(question.mayUser(eq(transaction), eq(USER), any(PermDAO.Data.class), eq(Access.read)))
 341             .willReturn(Result.ok(new NsDAO.Data()));
 342         given(transaction.requested(REQD_TYPE.ns)).willReturn(false);
 343         Perms permsContainer = mapper.newInstance(API.PERMS);
 344         String namespace = "org.onap.portal";
 345         String type = "access";
 346         String fullType = namespace + "." + type;
 347         String action = "read";
 348         List<PermDAO.Data> permsData = Lists.newArrayList(createPermDAOobj(namespace, type, "*",action, null, null));
 349         boolean filter = true;
 350
 351         //when
 352         Result<Perms> result = mapper.perms(transaction, permsData, permsContainer, filter);
 353
 354         //then
 355         assertTrue(result.isOK());
 356         assertEquals("Perm is added",1,result.value.getPerm().size());
 357         Perm perm = Iterables.getOnlyElement(result.value.getPerm());
 358         assertNull(perm.getNs());
 359         assertEquals(fullType, perm.getType());
 360         assertEquals(action, perm.getAction());
 361     }
 362
 363     @Test
 364     public void perm_shouldAddPermsWithCorrectSortedOrder() {
 365         //given
 366         given(question.mayUser(eq(transaction), eq(USER), any(PermDAO.Data.class), eq(Access.read)))
 367             .willReturn(Result.ok(new NsDAO.Data()));
 368         Perms permsContainer = mapper.newInstance(API.PERMS);
 369         PermDAO.Data perm1 = createPermDAOobj("org.onap.portal", "access", "*", "read", null, null);
 370         PermDAO.Data perm2 = createPermDAOobj("org.onap.portal", "access", "*", "write", null, null);
 371         PermDAO.Data perm3 = createPermDAOobj("org.onap.portal", "design", "*", "new", null, null);
 372         PermDAO.Data perm4 = createPermDAOobj("org.onap.portal", "workflow", "1", "edit", null, null);
 373         PermDAO.Data perm5 = createPermDAOobj("org.onap.portal", "workflow", "2", "edit", null, null);
 374         List<PermDAO.Data> permsData = Lists.newArrayList(perm4, perm1, perm5, perm3, perm2);
 375         List<PermDAO.Data> correctOrderPerms = Lists.newArrayList(perm1, perm2, perm3, perm4, perm5);
 376
 377         //when
 378         Result<Perms> result = mapper.perms(transaction, permsData, permsContainer, true);
 379
 380         //then
 381         assertTrue(result.isOK());
 382         assertEquals("Alls Perms added",5,result.value.getPerm().size());
 383         List<Perm> mappedPerms = result.value.getPerm();
 384         for (int i=0; i<5; i++) {
 385             comparePerm(correctOrderPerms.get(i), mappedPerms.get(i));
 386         }
 387     }
 388
 389     private void comparePerm(Data data, Perm perm) {
 390         assertEquals(data.ns + "." + data.type, perm.getType());
 391         assertEquals(data.instance, perm.getInstance());
 392         assertEquals(data.action, perm.getAction());
 393     }
 394
 395     private PermDAO.Data createPermDAOobj(String ns, String name, String instance, String action, Set<String> roles, String description) {
 396             NsSplit nss = new NsSplit(ns, name);
 397       PermDAO.Data perm = new PermDAO.Data(nss, instance, action);
 398       perm.roles = roles;
 399       perm.description = description;
 400       return perm;
 401   }
 402
 403   @Test
 404     public void role_shouldReturnErrorResult_whenNssIsNok() throws Exception {
 405         //given
 406         String roleName = "admin";
 407         RoleRequest request = createRoleRequest(roleName, "role description");
 408         given(question.deriveNsSplit(transaction, roleName)).willReturn(Result.err(new IllegalArgumentException()));
 409
 410         //when
 411         Result<RoleDAO.Data> result = mapper.role(transaction, request);
 412
 413         //then
 414         assertFalse(result.isOK());
 415         assertNull(result.value);
 416         assertEquals(ERR_General, result.status);
 417     }
 418
 419     @Test
 420     public void role_shouldReturnMappedRoleObject_whenNssIsOk() throws Exception {
 421         //given
 422         String roleName = "admin";
 423         String roleNs = "org.onap.roles";
 424         String roleFullName = roleNs + "." + roleName;
 425         String description =" role description";
 426         RoleRequest request = createRoleRequest(roleFullName, description);
 427         given(question.deriveNsSplit(transaction, roleFullName)).willReturn(Result.ok(new NsSplit(roleNs, roleName)));
 428
 429         //when
 430         Result<RoleDAO.Data> result = mapper.role(transaction, request);
 431
 432         //then
 433         assertTrue(result.isOK());
 434         assertEquals(roleName, result.value.name);
 435         assertEquals(roleNs, result.value.ns);
 436         assertEquals(description, result.value.description);
 437         verify(transaction).checkpoint(roleFullName, Env.ALWAYS);
 438     }
 439
 440     private RoleRequest createRoleRequest(String name, String description) {
 441         RoleRequest req = mapper.newInstance(API.ROLE_REQ);
 442         req.setName(name);
 443         req.setDescription(description);
 444         return req;
 445     }
 446
 447     @Test
 448     public void roles_shouldNotAddAnyRoles_whenFilterFlagIsNotSet() {
 449         //given
 450         Roles initialRoles = new Roles();
 451         RoleDAO.Data role = createRoleDAOobj("org.onap.app1", "org.onap.app1.admin", "description");
 452
 453         //when
 454         Result<Roles> result = mapper.roles(transaction, Lists.newArrayList(role), initialRoles, false);
 455
 456         //then
 457         assertTrue(result.isOK());
 458         assertEquals(initialRoles.getRole(), result.value.getRole());
 459     }
 460
 461     @Test
 462     public void roles_shouldNotAddAnyRoles_whenFilterFlagIsSet_andUserIsNotAuthorizedToReadRole() {
 463         //given
 464         Roles initialRoles = new Roles();
 465         RoleDAO.Data role = createRoleDAOobj("org.onap.app1", "org.onap.app1.admin", "description");
 466         given(question.mayUser(eq(transaction), eq(USER), any(RoleDAO.Data.class), eq(Access.read)))
 467             .willReturn(Result.err(9, "error"));
 468
 469         //when
 470         Result<Roles> result = mapper.roles(transaction, Lists.newArrayList(role), initialRoles, true);
 471
 472         //then
 473         assertTrue(result.isOK());
 474         assertEquals(initialRoles.getRole(), result.value.getRole());
 475     }
 476
 477     @Test
 478     public void roles_shouldAddRolesWithoutNamespace_whenNsNotRequested_andFilterFlagSet_andUserIsAuthorized() {
 479         test_roles_shouldAddRoles(false);
 480     }
 481
 482     @Test
 483     public void roles_shouldAddRolesWithNamespace_whenNsRequested_andFilterFlagSet_andUserIsAuthorized() {
 484         test_roles_shouldAddRoles(true);
 485     }
 486
 487     private void test_roles_shouldAddRoles(boolean namespaceRequested) {
 488         //given
 489         String namespace = "org.onap.app1";
 490         String description = "role description";
 491         Set<String> roleNames = Sets.newHashSet(namespace+".admin", namespace+".deployer");
 492         List<RoleDAO.Data> daoRoles = roleNames.stream().map( name -> createRoleDAOobj(namespace, name, description))
 493             .collect(Collectors.toList());
 494         given(question.mayUser(eq(transaction), eq(USER), any(RoleDAO.Data.class), eq(Access.read)))
 495             .willReturn(Result.ok(new NsDAO.Data()));
 496         given(transaction.requested(REQD_TYPE.ns)).willReturn(namespaceRequested);
 497
 498         //when
 499         Result<Roles> result = mapper.roles(transaction, daoRoles, new Roles(), true);
 500
 501         //then
 502         assertTrue(result.isOK());
 503         assertEquals(2, result.value.getRole().size());
 504         result.value.getRole().stream().forEach( role -> {
 505             assertTrue(role.getPerms().isEmpty());
 506             if (namespaceRequested) {
 507                 assertEquals(namespace, role.getNs());
 508             } else {
 509                 assertNull(role.getNs());
 510             }
 511             assertTrue(roleNames.contains(role.getName()));
 512             assertEquals(description, role.getDescription());
 513         });
 514     }
 515
 516     @Test
 517     public void roles_shouldReturnErrorResult_whenAnyPermHasInvalidFormat() {
 518         //given
 519         given(question.mayUser(eq(transaction), eq(USER), any(RoleDAO.Data.class), eq(Access.read)))
 520             .willReturn(Result.ok(new NsDAO.Data()));
 521         RoleDAO.Data role = createRoleDAOobj("org.onap.app", "org.onap.app.admin", "description");
 522         role.perms = Sets.newHashSet("invalidPermFormat");
 523
 524         //when
 525         Result<Roles> result = mapper.roles(transaction, Lists.newArrayList(role), new Roles(), true);
 526
 527         //then
 528         assertFalse(result.isOK());
 529         assertEquals(ERR_BadData, result.status);
 530     }
 531
 532     @Test
 533     public void roles_shouldAddPerms_whenAllPermsProperlyDefined_andUserCanViewIt() {
 534         //given
 535         given(question.mayUser(eq(transaction), eq(USER), any(RoleDAO.Data.class), eq(Access.read)))
 536             .willReturn(Result.ok(new NsDAO.Data()));
 537         given(question.deriveNsSplit(transaction, "org.onap.app")).willReturn(Result.ok(mock(NsSplit.class)));
 538         RoleDAO.Data role = createRoleDAOobj("org.onap.app", "org.onap.app.admin", "description");
 539         role.perms = Sets.newHashSet("org.onap.app|access|*|read,approve");
 540
 541         //when
 542         Result<Roles> result = mapper.roles(transaction, Lists.newArrayList(role), new Roles(), true);
 543
 544         //then
 545         assertTrue(result.isOK());
 546         Role mappedRole = Iterables.getOnlyElement(result.value.getRole());
 547         Pkey pKey =  Iterables.getOnlyElement(mappedRole.getPerms());
 548         assertEquals("org.onap.app.access", pKey.getType());
 549         assertEquals("*", pKey.getInstance());
 550         assertEquals("read,approve", pKey.getAction());
 551     }
 552
 553     private RoleDAO.Data createRoleDAOobj(String namespace, String rolename, String desc) {
 554         NsDAO.Data ns = new NsDAO.Data();
 555         ns.name = namespace;
 556         RoleDAO.Data role = RoleDAO.Data.create(ns, rolename);
 557         role.description = desc;
 558         return role;
 559     }
 560
 561     @Test
 562     public void userRoles_shouldMapUserRolesFromDAO() {
 563         //given
 564         String user = "john@people.osaaf.org";
 565         String role = "admin";
 566         String namespace = "org.osaaf.aaf";
 567         int year = 2020;
 568         int month = 10;
 569         int day = 31;
 570         Date expiration = new Calendar.Builder().setDate(year,month-1, day).build().getTime(); //month is 0-based
 571         UserRoles targetRoles = new UserRoles();
 572
 573         //when
 574         Result<UserRoles> result = mapper.userRoles(transaction, Lists.newArrayList(
 575             createUserRoleDAOobj(user, expiration, namespace, role)), targetRoles);
 576
 577         //then
 578         assertTrue(result.isOK());
 579         UserRole targetRole = Iterables.getOnlyElement(result.value.getUserRole());
 580         assertEquals(user, targetRole.getUser());
 581         assertEquals(role, targetRole.getRole());
 582         assertEquals(year, targetRole.getExpires().getYear());
 583         assertEquals(month, targetRole.getExpires().getMonth());
 584         assertEquals(day, targetRole.getExpires().getDay());
 585     }
 586
 587     @Test
 588     public void userRole_shouldReturnErrorResult_whenAnyExceptionOccurs() {
 589         //given
 590         PermRequest wrongRequestType = new PermRequest();
 591
 592         //when
 593         Result<UserRoleDAO.Data> result = mapper.userRole(transaction, wrongRequestType);
 594
 595         //then
 596         assertFalse(result.isOK());
 597         assertEquals(ERR_BadData, result.status);
 598         verifyZeroInteractions(transaction);
 599     }
 600
 601     @Test
 602     public void userRole_shouldReturnEmptyRoleDAOobj_whenRequestIsEmpty() {
 603         //given
 604         UserRoleRequest request = new UserRoleRequest();
 605         given(question.deriveNsSplit(any(), any())).willReturn(Result.err(new IllegalArgumentException()));
 606         Organization org = mock(Organization.class);
 607         given(org.expiration(any(), eq(Expiration.UserInRole), any())).willReturn(new GregorianCalendar());
 608         given(transaction.org()).willReturn(org);
 609
 610         //when
 611         Result<UserRoleDAO.Data> result = mapper.userRole(transaction, request);
 612
 613         //then
 614         assertTrue(result.isOK());
 615         assertNull(result.value.ns);
 616         assertNull(result.value.rname);
 617         assertNull(result.value.role);
 618         assertNull(result.value.user);
 619         assertNotNull(result.value.expires);
 620     }
 621
 622     @Test
 623     public void userRole_shouldReturnMappedRoleDAOobj_whenRequestIsFilled() {
 624         //given
 625         String user = "johny@people.osaaf.org";
 626         String role = "org.onap.app1.deployer";
 627         String rName = "deployer";
 628         String namespace = "org.onap.app1";
 629
 630         given(question.deriveNsSplit(transaction, role)).willReturn(Result.ok(new NsSplit(namespace, rName)));
 631         Organization org = mock(Organization.class);
 632         given(org.expiration(any(), eq(Expiration.UserInRole), any())).willReturn(new GregorianCalendar());
 633         given(transaction.org()).willReturn(org);
 634
 635         //when
 636         Result<UserRoleDAO.Data> result = mapper.userRole(transaction, createUserRoleRequest(role, user));
 637
 638         //then
 639         assertTrue(result.isOK());
 640         assertEquals(user, result.value.user);
 641         assertEquals(role, result.value.role);
 642         assertEquals(rName, result.value.rname);
 643         assertEquals(namespace, result.value.ns);
 644         assertNotNull(result.value.expires);
 645     }
 646
 647     private UserRoleRequest createUserRoleRequest(String role, String user) {
 648         UserRoleRequest request = new UserRoleRequest();
 649         request.setRole(role);
 650         request.setUser(user);
 651         return request;
 652     }
 653
 654     private UserRoleDAO.Data createUserRoleDAOobj(String userName, Date expires, String namespace, String roleName) {
 655         UserRoleDAO.Data userRole =  new UserRoleDAO.Data();
 656         userRole.user = userName;
 657         userRole.expires = expires;
 658         userRole.ns = namespace;
 659         userRole.role = roleName;
 660         return userRole;
 661     }
 662
 663     @Test
 664     public void cred_shouldReturnError_whenGivenPasswordDoesNotFulfillPolicy() {
 665         //given
 666         String id = "aaf@aaf.osaaf.org";
 667         String strp = "invalid";
 668         given(org.isValidPassword(transaction, id, strp)).willReturn("Password does not match org.osaaf Password Standards");
 669
 670         //when
 671         Result<CredDAO.Data> result = mapper.cred(transaction, createCredRequest(id, strp), true);
 672
 673         //then
 674         assertFalse(result.isOK());
 675         assertEquals(ERR_BadData, result.status);
 676     }
 677
 678     @Test
 679     public void cred_shouldNotCheckPassword_andSetProperType_whenPasswordNotRequired() {
 680         //given
 681         String id = "aaf@aaf.osaaf.org";
 682         GregorianCalendar expiration = new GregorianCalendar();
 683         given(org.expiration(isA(GregorianCalendar.class), eq(Expiration.Password), eq(id))).willReturn(expiration);
 684
 685         //when
 686         Result<CredDAO.Data> result = mapper.cred(transaction, createCredRequest(id, null), false);
 687
 688         //then
 689         assertTrue(result.isOK());
 690         verify(org, never()).isValidPassword(eq(transaction), eq(id), any());
 691         assertEquals(Integer.valueOf(0), result.value.type);
 692         assertNotNull(result.value.expires);
 693     }
 694
 695     @Test
 696     public void cred_shouldSetProperValues_whenPasswordRequired() {
 697         //given
 698         String ns = "org.osaaf.aaf";
 699         String id = "aaf@aaf.osaaf.org";
 700         String strp = "SomeValidPassword123!";
 701         GregorianCalendar expiration = new GregorianCalendar();
 702         given(org.expiration(isA(GregorianCalendar.class), eq(Expiration.Password), eq(id))).willReturn(expiration);
 703         given(org.isValidPassword(transaction, id, strp)).willReturn("");
 704
 705         //when
 706         Result<CredDAO.Data> result = mapper.cred(transaction, createCredRequest(id, strp), true);
 707
 708         //then
 709         assertTrue(result.isOK());
 710         assertNotNull(result.value.cred);
 711         assertEquals(id, result.value.id);
 712         assertEquals(ns, result.value.ns);
 713         assertEquals(Integer.valueOf(CredDAO.RAW), result.value.type);
 714         assertNotNull(result.value.expires);
 715     }
 716
 717     private CredRequest createCredRequest(String id, String password) {
 718         CredRequest credRequest = new CredRequest();
 719         credRequest.setId(id);
 720         credRequest.setPassword(password);
 721         return credRequest;
 722     }
 723
 724     @Test
 725     public void cred_shouldConvertCredDAOtoUser_andAddItToInitialObject() {
 726         //given
 727         String id = "aaf@aaf.osaaf.org";
 728         Integer type = 1;
 729         Date expiration = Calendar.getInstance().getTime();
 730         Users to = new Users();
 731
 732         //when
 733         Result<Users> result = mapper.cred(Lists.newArrayList(createCredData(id, type, expiration)), to);
 734
 735         //then
 736         assertTrue(result.isOK());
 737         User user = Iterables.getOnlyElement(result.value.getUser());
 738         assertEquals(id, user.getId());
 739         assertNotNull(user.getExpires());
 740         assertEquals(type, user.getType());
 741     }
 742
 743     @Test
 744     public void cred_shouldLeaveInitialUsers_whenAddingConvertedObject() {
 745         //given
 746         String id = "aaf@aaf.osaaf.org";
 747         Integer type = 0;
 748         Date expiration = Calendar.getInstance().getTime();
 749         Users to = new Users();
 750         to.getUser().add(new User());
 751         assertEquals(1, to.getUser().size());
 752
 753         //when
 754         Result<Users> result = mapper.cred(Lists.newArrayList(createCredData(id, type, expiration)), to);
 755
 756         //then
 757         assertTrue(result.isOK());
 758         assertEquals(2,result.value.getUser().size());
 759     }
 760
 761     private CredDAO.Data createCredData(String id, int type, Date expires) {
 762         CredDAO.Data credDao = new CredDAO.Data();
 763         credDao.id = id;
 764         credDao.type = type;
 765         credDao.expires = expires;
 766         return credDao;
 767     }
 768
 769     @Test
 770     public void cert_shouldConvertCertDAOtoUser_andAddItToInitialObject() {
 771         //given
 772         String x500 = provideTestCertificate();
 773         String id = "aaf@aaf.osaaf.org";
 774         BigInteger serial = new BigInteger("123456789987654321123456789987654321");
 775         Certs to = new Certs();
 776
 777         //when
 778         Result<Certs> result = mapper.cert(Lists.newArrayList(createCertData(id, x500, serial)), to);
 779
 780         //then
 781         assertTrue(result.isOK());
 782         Cert cert = Iterables.getOnlyElement(result.value.getCert());
 783         assertEquals(id, cert.getId());
 784         assertEquals(x500, cert.getX500());
 785         assertNotNull(cert.getFingerprint());
 786     }
 787
 788     @Test
 789     public void cert_shouldLeaveInitialCerts_whenAddingConvertedObject() {
 790         //given
 791         Certs to = new Certs();
 792         Cert initial = new Cert();
 793         to.getCert().add(initial);
 794         CertDAO.Data certDao = new CertDAO.Data();
 795         certDao.serial =  new BigInteger("123456789");
 796         assertEquals(1, to.getCert().size());
 797
 798         //when
 799         Result<Certs> result = mapper.cert(Lists.newArrayList(certDao), to);
 800
 801         //then
 802         assertTrue(result.isOK());
 803         assertEquals(2,result.value.getCert().size());
 804         assertTrue(result.value.getCert().contains(initial));
 805     }
 806
 807     private CertDAO.Data createCertData(String id, String x500, BigInteger serial) {
 808         CertDAO.Data certDao = new CertDAO.Data();
 809         certDao.x500 =  x500;
 810         certDao.id = id;
 811         certDao.serial= serial;
 812         return certDao;
 813     }
 814
 815     private String provideTestCertificate() {
 816         StringBuilder sb = new StringBuilder("-----BEGIN CERTIFICATE-----\n");
 817         return sb.append("MIIEdTCCAl2gAwIBAgIBBTANBgkqhkiG9w0BAQsFADAsMQ4wDAYDVQQLDAVPU0FB\n")
 818             .append("RjENMAsGA1UECgwET05BUDELMAkGA1UEBhMCVVMwHhcNMTgwNzAyMTEyNjMwWhcN\n")
 819             .append("MjMwNzAyMTEyNjMwWjBHMQswCQYDVQQGEwJVUzENMAsGA1UECgwET05BUDEOMAwG\n")
 820             .append("A1UECwwFT1NBQUYxGTAXBgNVBAMMEGludGVybWVkaWF0ZUNBXzcwggEiMA0GCSqG\n")
 821             .append("SIb3DQEBAQUAA4IBDwAwggEKAoIBAQDQAcZtvJ5j4wqaZHqU/NkG0CjflDRD3x9Y\n")
 822             .append("4a+C63dxuTyWZ6EtQanoM9l6vwb6Gj4SOHeBfOaQbxwiJfX3WP9+SWV/Rciei0EY\n")
 823             .append("w9C0ZOsDA8VVA5S4TK4OLXCLDSeTeMN8wrlydnwG5u/14m22yNTNxPX90bijc6WH\n")
 824             .append("zo7+z+3WarveN0CBYcDQkKkyR8rKafkCWlq+GzqLYQh0K4atnuyIZQ7kr9Od48vT\n")
 825             .append("KyVJzkyMS6HeH++3Ty0JmPREgzOUjUAoYvR2kI02LedFndr5ZdiBQGAXnLQsVuG6\n")
 826             .append("mJHfsRjQ+zTZ2Q5Xs++Bc/clSNlWz7Kqqcxto2bp8YOWC3RaXzfNAgMBAAGjgYYw\n")
 827             .append("gYMwHQYDVR0OBBYEFA8QFOfTZ/fEqwtuM4hlNYpwk0OTMB8GA1UdIwQYMBaAFFNV\n")
 828             .append("M/JL69BRscF4msEoMXvv6u1JMBIGA1UdEwEB/wQIMAYBAf8CAQEwDgYDVR0PAQH/\n")
 829             .append("BAQDAgGGMB0GA1UdJQQWMBQGCCsGAQUFBwMBBggrBgEFBQcDAjANBgkqhkiG9w0B\n")
 830             .append("AQsFAAOCAgEAsUvLinLLby1D+F+UKv/7jCqqrUYxlpNsdBm1dD8M3mIIpsjoTrlU\n")
 831             .append("2yywL9EPp4BhCN7rI0YbPX+DWu2RnxtbsEKdhutEvbTE2Sfg6a1+9dH7txdaGp3F\n")
 832             .append("qapojPqdZ7pjgtIhHVgepGJc08efsxSW6+Gv5easQXhn7XyaZf1MfZUobAPnEcaY\n")
 833             .append("p5cOee2gjMy6usB8AiKzVXrmGn6MAQQ9w6u8XKnvIoivQW3PLlKTMbLFVB7B4YH8\n")
 834             .append("90HQJnhnLJ9T5U+Gy1Mb5GpVKnI0ZIKURA9b/x8bVFixT83xugstbeVdxgS97Fcz\n")
 835             .append("9wOjG6d6YhrwnE/kz8aiXWs8KsTsrgk//kv3AqL4ykpvn545WJUj7EhuAK+Kmh1B\n")
 836             .append("LCC0wyny2RBZYVP92AMdLqgU7HEng2ZWsCGdf/QLKpXsawsR/0oM2uAT2KeDiSy4\n")
 837             .append("0WTfe3qirhJ9AKtfkj1NukymIcpx9Ld1kb3rapfT63LJ5kGkQpztuYoEa1FCsQwU\n")
 838             .append("z/UeknC00mqnH5X4ooGRMMkRyPp68+iWmTNlUaVfU2NUNwZiIsD9CbytR5y9rt2r\n")
 839             .append("XJM2BkKy5QEEvmr4GGfbGAYYOfdVpUXB/VBUYNf5uwENqhQB6q7OmiU39Vb/37Zf\n")
 840             .append("EWK8mju11Om2l1a4xYw6HH/SPIqqIDtS28XccDTMMiOVoR2HUAZMNdw=\n")
 841             .append("-----END CERTIFICATE-----").toString();
 842     }
 843
 844     @Test
 845     public void history_shouldConvertHistoryDAOdataToHistory() {
 846         //given
 847         UUID uuid = UUID.fromString("c81d4e2e-bcf2-11e6-869b-7df92533d2db");
 848         String user = "aaf";
 849         String subject = "cred";
 850         String action = "remove";
 851         String target = "john";
 852         String memo ="n/a";
 853         int yr_mon = 201809;
 854         HistoryDAO.Data input = createHistoryData(uuid, user, subject, action, target, memo, yr_mon);
 855
 856         //when
 857         Result<History> result = mapper.history(transaction, Lists.newArrayList(input), 0);
 858
 859         //then
 860         assertTrue(result.isOK());
 861         Item historyItem = Iterables.getOnlyElement(result.value.getItem());
 862         assertEquals(user, historyItem.getUser());
 863         assertEquals(subject, historyItem.getSubject());
 864         assertEquals(action, historyItem.getAction());
 865         assertEquals(target, historyItem.getTarget());
 866         assertEquals(memo, historyItem.getMemo());
 867         assertEquals(Integer.toString(yr_mon), historyItem.getYYYYMM());
 868         assertNotNull(historyItem.getTimestamp());
 869     }
 870
 871     @Test
 872     public void history_shouldReturnUnsortedData_whenNoSortingRequired() {
 873         //given
 874         int noSorting = 0;
 875         UUID firstUuid = UUID.fromString("c81d4e2e-bcf2-11e6-869b-7df92533d2db");
 876         UUID secondUuid = UUID.fromString("c81eadbf-bcf2-11e6-869b-7df92533d2db");
 877         String firstUser = "first";
 878         String secondUser = "second";
 879         HistoryDAO.Data firstItem = createMinimalHistoryData(firstUuid, firstUser);
 880         HistoryDAO.Data secondItem = createMinimalHistoryData(secondUuid, secondUser);
 881
 882         //when
 883         Result<History> result = mapper.history(transaction, Lists.newArrayList(secondItem, firstItem), noSorting);
 884
 885         //then
 886         assertTrue(result.isOK());
 887         List<Item> historyItems = result.value.getItem();
 888         assertEquals(2, historyItems.size());
 889         assertEquals(secondUser, historyItems.get(0).getUser());
 890         assertEquals(firstUser, historyItems.get(1).getUser());
 891     }
 892
 893     @Test
 894     public void history_shouldReturnSortedData_whenSortingIsRequired() {
 895         //given
 896         int withSorting = 1;
 897         UUID firstUuid = UUID.fromString("c81d4e2e-bcf2-11e6-869b-7df92533d2db");
 898         UUID secondUuid = UUID.fromString("c81eadbf-bcf2-11e6-869b-7df92533d2db");
 899         String firstUser = "first";
 900         String secondUser = "second";
 901         HistoryDAO.Data firstItem = createMinimalHistoryData(firstUuid, firstUser);
 902         HistoryDAO.Data secondItem = createMinimalHistoryData(secondUuid, secondUser);
 903
 904         //when
 905         Result<History> result = mapper.history(transaction, Lists.newArrayList(secondItem, firstItem), withSorting);
 906
 907         //then
 908         assertTrue(result.isOK());
 909         List<Item> historyItems = result.value.getItem();
 910         assertEquals(2, historyItems.size());
 911         assertEquals(firstUser, historyItems.get(0).getUser());
 912         assertEquals(secondUser, historyItems.get(1).getUser());
 913     }
 914
 915     private HistoryDAO.Data createHistoryData(UUID id, String user, String subject, String action, String target,
 916         String memo, int yr_mon) {
 917         HistoryDAO.Data historyDao = createMinimalHistoryData(id, user);
 918         historyDao.subject = subject;
 919         historyDao.action = action;
 920         historyDao.target = target;
 921         historyDao.memo = memo;
 922         historyDao.yr_mon = yr_mon;
 923         return historyDao;
 924     }
 925
 926     private HistoryDAO.Data createMinimalHistoryData(UUID uuid, String user) {
 927         HistoryDAO.Data historyDao = new HistoryDAO.Data();
 928         historyDao.id = uuid;
 929         historyDao.user = user;
 930         return historyDao;
 931     }
 932
 933
 934     //Why so? Is there any particular reason for removing guava dependency from the code, and even from the tests?
 935     /**
 936      * Need to do without Google stuff
 937      * @author Instrumental
 938      *
 939      */
 940     public static class ImmutableMap {
 941         @SuppressWarnings("unchecked")
 942         public static <T,U> Map<T,U> of(Object ... tag_value) {
 943             Map<T,U> rv = new HashMap<>();
 944             for(int i=0;i<tag_value.length-1;i+=2) {
 945                 rv.put((T)tag_value[i],(U)tag_value[i+1]);
 946             }
 947             return rv;
 948         }
 949
 950     }
 951
 952     /**
 953      * Need to do without Google stuff
 954      * @author Instrumental
 955      *
 956      */
 957     public static class Iterables {
 958         public static <T> T getOnlyElement(List<T> lt) {
 959             if(lt.isEmpty()) {
 960                 return null;
 961             } else {
 962                 return lt.get(0);
 963             }
 964         }
 965     }
 966
 967     /**
 968      * Need to do without Google stuff
 969      * @author Instrumental
 970      *
 971      */
 972     public static class Lists {
 973         @SafeVarargs
 974         public static <T> List<T> newArrayList(Collection<T> ... init ) {
 975             List<T> rv = new ArrayList<>();
 976             for(Collection<T> o : init) {
 977                 for(T t : o) {
 978                     rv.add(t);
 979                 }
 980             }
 981             return rv;
 982         }
 983
 984         @SuppressWarnings("unchecked")
 985         public static <T> List<T> newArrayList(Object ... init ) {
 986             List<T> rv = new ArrayList<>();
 987             for(Object o : init) {
 988                    rv.add((T)o);
 989             }
 990             return rv;
 991         }
 992
 993     }
 994
 995     /**
 996      * Need to do without Google stuff
 997      * @author Instrumental
 998      *
 999      */
1000     public static class Sets {
1001         @SuppressWarnings("unchecked")
1002         public static <T> Set<T> newHashSet(Object ... init ) {
1003             Set<T> rv = new HashSet<>();
1004             for(Object o : init) {
1005                 rv.add((T)o);
1006             }
1007             return rv;
1008         }
1009     }
1010 }