auth/auth-service/src/test/java/org/onap/aaf/authz/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 package org.onap.aaf.authz.service.mapper;
  23
  24 import static org.junit.Assert.assertEquals;
  25 import static org.junit.Assert.assertFalse;
  26 import static org.junit.Assert.assertNotNull;
  27 import static org.junit.Assert.assertNull;
  28 import static org.junit.Assert.assertTrue;
  29 import static org.junit.Assert.fail;
  30 import static org.mockito.BDDMockito.given;
  31 import static org.mockito.Matchers.any;
  32 import static org.mockito.Matchers.anyString;
  33 import static org.mockito.Matchers.eq;
  34 import static org.mockito.Mockito.mock;
  35 import static org.mockito.Mockito.spy;
  36 import static org.mockito.Mockito.verify;
  37 import static org.mockito.Mockito.verifyZeroInteractions;
  38 import static org.onap.aaf.auth.layer.Result.ERR_BadData;
  39 import static org.onap.aaf.auth.layer.Result.ERR_General;
  40
  41 import aaf.v2_0.NsRequest;
  42 import aaf.v2_0.Nss;
  43 import aaf.v2_0.Nss.Ns;
  44 import aaf.v2_0.Perm;
  45 import aaf.v2_0.PermKey;
  46 import aaf.v2_0.PermRequest;
  47 import aaf.v2_0.Perms;
  48 import aaf.v2_0.Pkey;
  49 import aaf.v2_0.Request;
  50 import aaf.v2_0.Role;
  51 import aaf.v2_0.RoleRequest;
  52 import aaf.v2_0.Roles;
  53 import aaf.v2_0.UserRole;
  54 import aaf.v2_0.UserRoleRequest;
  55 import aaf.v2_0.UserRoles;
  56 import com.google.common.collect.ImmutableMap;
  57 import com.google.common.collect.Iterables;
  58 import com.google.common.collect.Lists;
  59 import com.google.common.collect.Sets;
  60 import java.io.IOException;
  61 import java.text.SimpleDateFormat;
  62 import java.util.Calendar;
  63 import java.util.Collection;
  64 import java.util.Date;
  65 import java.util.GregorianCalendar;
  66 import java.util.List;
  67 import java.util.Map;
  68 import java.util.Set;
  69 import java.util.stream.Collectors;
  70 import org.junit.Assert;
  71 import org.junit.Before;
  72 import org.junit.Test;
  73 import org.junit.runner.RunWith;
  74 import org.mockito.Mock;
  75 import org.mockito.runners.MockitoJUnitRunner;
  76 import org.onap.aaf.auth.dao.cass.Namespace;
  77 import org.onap.aaf.auth.dao.cass.NsDAO;
  78 import org.onap.aaf.auth.dao.cass.NsSplit;
  79 import org.onap.aaf.auth.dao.cass.NsType;
  80 import org.onap.aaf.auth.dao.cass.PermDAO;
  81 import org.onap.aaf.auth.dao.cass.PermDAO.Data;
  82 import org.onap.aaf.auth.dao.cass.RoleDAO;
  83 import org.onap.aaf.auth.dao.cass.UserRoleDAO;
  84 import org.onap.aaf.auth.dao.hl.Question;
  85 import org.onap.aaf.auth.dao.hl.Question.Access;
  86 import org.onap.aaf.auth.env.AuthzTrans;
  87 import org.onap.aaf.auth.env.AuthzTrans.REQD_TYPE;
  88 import org.onap.aaf.auth.layer.Result;
  89 import org.onap.aaf.auth.org.Organization;
  90 import org.onap.aaf.auth.org.Organization.Expiration;
  91 import org.onap.aaf.auth.rserv.Pair;
  92 import org.onap.aaf.auth.service.mapper.Mapper.API;
  93 import org.onap.aaf.auth.service.mapper.Mapper_2_0;
  94 import org.onap.aaf.cadi.CadiException;
  95 import org.onap.aaf.misc.env.APIException;
  96 import org.onap.aaf.misc.env.Env;
  97 import org.onap.aaf.misc.env.TimeTaken;
  98 import org.onap.aaf.org.DefaultOrg;
  99
 100 @RunWith(MockitoJUnitRunner.class)
 101 public class JU_Mapper_2_0 {
 102
 103   private static final String USER = "John";
 104
 105     private Mapper_2_0 mapper;
 106     @Mock
 107     private Question question;
 108     @Mock
 109     private AuthzTrans transaction;
 110     @Mock
 111   private TimeTaken tt;
 112
 113
 114     @Before
 115     public void setUp() throws APIException, IOException, CadiException {
 116       given(transaction.start(anyString(), eq(Env.SUB))).willReturn(tt);
 117       given(transaction.user()).willReturn(USER);
 118         this.mapper = new Mapper_2_0(question);
 119     }
 120
 121     @Test(expected = ClassCastException.class)
 122     public void ns_willThrowException_whenInvalidRequestType() {
 123         //given
 124         Request rq = new Request();
 125
 126         //when
 127         mapper.ns(transaction, rq);
 128
 129         //then
 130         fail("Expected ClassCastException");
 131     }
 132
 133     @Test
 134     public void ns_shouldConvertNamespaceRequest_whenValidTypeIsExplicitlyProvided() {
 135         //given
 136         String namespaceName = "org.companyA.app1";
 137         String namespaceType = "APP";
 138         NsType expectedNsType = NsType.APP;
 139         NsRequest nsRequest = createNsRequestForType(namespaceName, namespaceType);
 140
 141         //when
 142         Result<Namespace> result = mapper.ns(transaction,nsRequest);
 143
 144         //then
 145         assertTrue(result.isOK());
 146         assertNamespaceValues(result.value, expectedNsType, namespaceName);
 147         verify(transaction).checkpoint(namespaceName,Env.ALWAYS);
 148     }
 149
 150     @Test
 151     public void ns_shouldConvertNamespaceRequest_whenInValidTypeIsExplicitlyProvided() {
 152         //given
 153         String namespaceName = "org.companyA.app1.service0";
 154         String invalidNsType = "BLUE";
 155         NsType expectedNsType = NsType.APP;
 156         NsRequest nsRequest = createNsRequestForType(namespaceName, invalidNsType);
 157
 158         //when
 159         Result<Namespace> result = mapper.ns(transaction,nsRequest);
 160
 161         //then
 162         assertTrue(result.isOK());
 163         assertNamespaceValues(result.value, expectedNsType, namespaceName);
 164         verify(transaction).checkpoint(namespaceName,Env.ALWAYS);
 165     }
 166
 167     @Test
 168     public void ns_shouldConvertRootNamespaceRequest_whenTypeNotProvided() {
 169         //given
 170         String rootNsName = "org";
 171         NsType expectedNsType = NsType.ROOT;
 172         NsRequest nsRequest = createNsRequestForType(rootNsName, null);
 173
 174         //when
 175         Result<Namespace> result = mapper.ns(transaction,nsRequest);
 176
 177         //then
 178         assertTrue(result.isOK());
 179         assertNamespaceValues(result.value, expectedNsType, rootNsName);
 180         verify(transaction).checkpoint(rootNsName,Env.ALWAYS);
 181     }
 182
 183     @Test
 184     public void ns_shouldConvertCompanyNamespaceRequest_whenTypeNotProvided() {
 185         //given
 186         String companyNsName = "org.companyA";
 187         NsType expectedNsType = NsType.COMPANY;
 188         NsRequest nsRequest = createNsRequestForType(companyNsName, null);
 189
 190         //when
 191         Result<Namespace> result = mapper.ns(transaction,nsRequest);
 192
 193         //then
 194         assertTrue(result.isOK());
 195         assertNamespaceValues(result.value, expectedNsType, companyNsName);
 196         verify(transaction).checkpoint(companyNsName,Env.ALWAYS);
 197     }
 198
 199     private void assertNamespaceValues(Namespace value, NsType nsType, String namespaceName) {
 200         List<String> people = Lists.newArrayList("tk007@people.osaaf.org");
 201         assertEquals(Integer.valueOf(nsType.type), value.type);
 202         assertEquals(namespaceName, value.name);
 203         assertEquals("some namespace description", value.description);
 204         assertEquals(people, value.admin);
 205         assertEquals(people, value.owner);
 206     }
 207
 208     private NsRequest createNsRequestForType(String nsName, String nsType) {
 209         NsRequest req = mapper.newInstance(API.NS_REQ);
 210         req.setType(nsType);
 211         req.setName(nsName);
 212         req.setDescription("some namespace description");
 213         req.getAdmin().add("tk007@people.osaaf.org");
 214         req.getResponsible().add("tk007@people.osaaf.org");
 215         return req;
 216     }
 217
 218     @Test
 219     public void nss_shouldConvertNamespaceToNss_withoutAttributes() {
 220         //given
 221         Nss nss = mapper.newInstance(API.NSS);
 222         Namespace ns = mapper.ns(transaction, createNsRequestForType("org.onap",  null)).value;
 223
 224         //when
 225         Result<Nss> result = mapper.nss(transaction, ns, nss);
 226
 227         //then
 228         assertTrue(result.isOK());
 229         assertEquals("Only one Ns should be added",1, result.value.getNs().size());
 230         Ns addedNs = Iterables.getOnlyElement(result.value.getNs());
 231         assertEquals(ns.admin, addedNs.getAdmin());
 232         assertEquals(ns.name, addedNs.getName());
 233         assertEquals(ns.owner, addedNs.getResponsible());
 234         assertEquals(ns.description, addedNs.getDescription());
 235         assertTrue(addedNs.getAttrib().isEmpty());
 236     }
 237
 238     @Test
 239     public void nss_shouldConvertNamespaceToNss_withAttributes() {
 240         //given
 241         Nss nss = mapper.newInstance(API.NSS);
 242         Namespace ns = mapper.ns(transaction, createNsRequestForType("org.onap",  null)).value;
 243         ns.attrib = Lists.newArrayList();
 244         int attribNum = 5;
 245         Map<String, String> attribs = ImmutableMap.of("key1", "value1", "key2", "value2", "key3", "value3", "key4", "value4", "key5", "value5");
 246         attribs.forEach((key,val) -> ns.attrib.add(new Pair<>(key,val)));
 247
 248         //when
 249         Result<Nss> result = mapper.nss(transaction, ns, nss);
 250
 251         //then
 252         assertTrue(result.isOK());
 253         assertEquals("Only one Ns should be added",1, result.value.getNs().size());
 254         Ns addedNs = Iterables.getOnlyElement(result.value.getNs());
 255         assertEquals(attribNum, addedNs.getAttrib().size());
 256         addedNs.getAttrib().forEach( attr -> {
 257             assertEquals(attr.getValue(), attribs.get(attr.getKey()));
 258         });
 259     }
 260
 261     @Test
 262     public void nss_shouldAddSeveralNamespacesToNss() {
 263         //given
 264         Nss nss = mapper.newInstance(API.NSS);
 265         Namespace ns1 = mapper.ns(transaction, createNsRequestForType("org.onap",  "COMPANY")).value;
 266         Namespace ns2 = mapper.ns(transaction, createNsRequestForType("org.onap.prh",  "APP")).value;
 267
 268         //when
 269         Result<Nss> result = mapper.nss(transaction, Lists.newArrayList(ns1,ns2), nss);
 270
 271         //then
 272         assertTrue(result.isOK());
 273         assertEquals("Two namespaces should be added",2, result.value.getNs().size());
 274     }
 275
 276     @Test
 277     public void perm_shouldNotAddPerms_whenFilterIsSet_andUserIsNotAuthorized() {
 278         //given
 279     given(question.mayUser(eq(transaction), eq(USER), any(PermDAO.Data.class), eq(Access.read)))
 280         .willReturn(Result.err(9, "error"));
 281     Perms permsContainer = mapper.newInstance(API.PERMS);
 282     List<PermDAO.Data> permsData = Lists.newArrayList(new PermDAO.Data());
 283     boolean filter = true;
 284
 285         //when
 286     Result<Perms> result = mapper.perms(transaction, permsData, permsContainer, filter);
 287
 288         //then
 289     assertTrue(result.isOK());
 290     assertEquals("No perms added",0,result.value.getPerm().size());
 291     }
 292
 293     @Test
 294   public void perm_shouldAddPerm_withNamespaceSet_whenUserIsAuthorized_AndNamespaceIsRequestedType() {
 295       //given
 296       given(question.mayUser(eq(transaction), eq(USER), any(PermDAO.Data.class), eq(Access.read)))
 297           .willReturn(Result.ok(new NsDAO.Data()));
 298       given(transaction.requested(REQD_TYPE.ns)).willReturn(true);
 299       Perms permsContainer = mapper.newInstance(API.PERMS);
 300       Set<String> roles = Sets.newHashSet("org.onap.portal.owner","org.onap.portal.designer"
 301                 ,"org.onap.portal.tester");
 302       String namespace = "org.onap.portal";
 303       String type = "access";
 304       String fullType = namespace + "." +type;
 305       String action = "read";
 306       String description = "Portal Read Access";
 307           List<PermDAO.Data> permsData = Lists.newArrayList(createPermDAOobj(namespace, type, "*",action, roles, description));
 308       boolean filter = true;
 309
 310       //when
 311       Result<Perms> result = mapper.perms(transaction, permsData, permsContainer, filter);
 312
 313       //then
 314       assertTrue(result.isOK());
 315       assertEquals("Perm is added",1,result.value.getPerm().size());
 316       Perm perm = Iterables.getOnlyElement(result.value.getPerm());
 317       assertEquals(namespace, perm.getNs());
 318       assertEquals(fullType, perm.getType());
 319       assertEquals(action, perm.getAction());
 320       assertEquals("*", perm.getInstance());
 321       assertEquals(description, perm.getDescription());
 322       assertEquals(Lists.newArrayList(roles), perm.getRoles());
 323   }
 324
 325     @Test
 326     public void perm_shouldAddPerm_withoutNamespaceSet_whenUserIsAuthorized_AndNamespaceIsNotRequestedType() {
 327         //given
 328         given(question.mayUser(eq(transaction), eq(USER), any(PermDAO.Data.class), eq(Access.read)))
 329             .willReturn(Result.ok(new NsDAO.Data()));
 330         given(transaction.requested(REQD_TYPE.ns)).willReturn(false);
 331         Perms permsContainer = mapper.newInstance(API.PERMS);
 332         String namespace = "org.onap.portal";
 333         String type = "access";
 334         String fullType = namespace + "." + type;
 335         String action = "read";
 336         List<PermDAO.Data> permsData = Lists.newArrayList(createPermDAOobj(namespace, type, "*",action, null, null));
 337         boolean filter = true;
 338
 339         //when
 340         Result<Perms> result = mapper.perms(transaction, permsData, permsContainer, filter);
 341
 342         //then
 343         assertTrue(result.isOK());
 344         assertEquals("Perm is added",1,result.value.getPerm().size());
 345         Perm perm = Iterables.getOnlyElement(result.value.getPerm());
 346         assertNull(perm.getNs());
 347         assertEquals(fullType, perm.getType());
 348         assertEquals(action, perm.getAction());
 349     }
 350
 351     @Test
 352     public void perm_shouldAddPermsWithCorrectSortedOrder() {
 353         //given
 354         given(question.mayUser(eq(transaction), eq(USER), any(PermDAO.Data.class), eq(Access.read)))
 355             .willReturn(Result.ok(new NsDAO.Data()));
 356         Perms permsContainer = mapper.newInstance(API.PERMS);
 357         PermDAO.Data perm1 = createPermDAOobj("org.onap.portal", "access", "*", "read", null, null);
 358         PermDAO.Data perm2 = createPermDAOobj("org.onap.portal", "access", "*", "write", null, null);
 359         PermDAO.Data perm3 = createPermDAOobj("org.onap.portal", "design", "*", "new", null, null);
 360         PermDAO.Data perm4 = createPermDAOobj("org.onap.portal", "workflow", "1", "edit", null, null);
 361         PermDAO.Data perm5 = createPermDAOobj("org.onap.portal", "workflow", "2", "edit", null, null);
 362         List<PermDAO.Data> permsData = Lists.newArrayList(perm4, perm1, perm5, perm3, perm2);
 363         List<PermDAO.Data> correctOrderPerms = Lists.newArrayList(perm1, perm2, perm3, perm4, perm5);
 364
 365         //when
 366         Result<Perms> result = mapper.perms(transaction, permsData, permsContainer, true);
 367
 368         //then
 369         assertTrue(result.isOK());
 370         assertEquals("Alls Perms added",5,result.value.getPerm().size());
 371         List<Perm> mappedPerms = result.value.getPerm();
 372         for(int i=0; i<5; i++) {
 373             comparePerm(correctOrderPerms.get(i), mappedPerms.get(i));
 374         }
 375     }
 376
 377     private void comparePerm(Data data, Perm perm) {
 378         assertEquals(data.ns + "." + data.type, perm.getType());
 379         assertEquals(data.instance, perm.getInstance());
 380         assertEquals(data.action, perm.getAction());
 381     }
 382
 383     private PermDAO.Data createPermDAOobj(String ns, String name, String instance, String action, Set<String> roles, String description) {
 384             NsSplit nss = new NsSplit(ns, name);
 385       PermDAO.Data perm = new PermDAO.Data(nss, instance, action);
 386       perm.roles = roles;
 387       perm.description = description;
 388       return perm;
 389   }
 390
 391   @Test
 392     public void role_shouldReturnErrorResult_whenNssIsNok() throws Exception {
 393         //given
 394         String roleName = "admin";
 395         RoleRequest request = createRoleRequest(roleName, "role description");
 396         given(question.deriveNsSplit(transaction, roleName)).willReturn(Result.err(new IllegalArgumentException()));
 397
 398         //when
 399         Result<RoleDAO.Data> result = mapper.role(transaction, request);
 400
 401         //then
 402         assertFalse(result.isOK());
 403         assertNull(result.value);
 404         assertEquals(ERR_General, result.status);
 405     }
 406
 407     @Test
 408     public void role_shouldReturnMappedRoleObject_whenNssIsOk() throws Exception {
 409         //given
 410         String roleName = "admin";
 411         String roleNs = "org.onap.roles";
 412         String roleFullName = roleNs + "." + roleName;
 413         String description =" role description";
 414         RoleRequest request = createRoleRequest(roleFullName, description);
 415         given(question.deriveNsSplit(transaction, roleFullName)).willReturn(Result.ok(new NsSplit(roleNs, roleName)));
 416
 417         //when
 418         Result<RoleDAO.Data> result = mapper.role(transaction, request);
 419
 420         //then
 421         assertTrue(result.isOK());
 422         assertEquals(roleName, result.value.name);
 423         assertEquals(roleNs, result.value.ns);
 424         assertEquals(description, result.value.description);
 425         verify(transaction).checkpoint(roleFullName, Env.ALWAYS);
 426     }
 427
 428     private RoleRequest createRoleRequest(String name, String description) {
 429         RoleRequest req = mapper.newInstance(API.ROLE_REQ);
 430         req.setName(name);
 431         req.setDescription(description);
 432         return req;
 433     }
 434
 435     @Test
 436     public void roles_shouldNotAddAnyRoles_whenFilterFlagIsNotSet() {
 437         //given
 438         Roles initialRoles = new Roles();
 439         RoleDAO.Data role = createRoleDAOobj("org.onap.app1", "org.onap.app1.admin", "description");
 440
 441         //when
 442         Result<Roles> result = mapper.roles(transaction, Lists.newArrayList(role), initialRoles, false);
 443
 444         //then
 445         assertTrue(result.isOK());
 446         assertEquals(initialRoles.getRole(), result.value.getRole());
 447     }
 448
 449     @Test
 450     public void roles_shouldNotAddAnyRoles_whenFilterFlagIsSet_andUserIsNotAuthorizedToReadRole() {
 451         //given
 452         Roles initialRoles = new Roles();
 453         RoleDAO.Data role = createRoleDAOobj("org.onap.app1", "org.onap.app1.admin", "description");
 454         given(question.mayUser(eq(transaction), eq(USER), any(RoleDAO.Data.class), eq(Access.read)))
 455             .willReturn(Result.err(9, "error"));
 456
 457         //when
 458         Result<Roles> result = mapper.roles(transaction, Lists.newArrayList(role), initialRoles, true);
 459
 460         //then
 461         assertTrue(result.isOK());
 462         assertEquals(initialRoles.getRole(), result.value.getRole());
 463     }
 464
 465     @Test
 466     public void roles_shouldAddRolesWithoutNamespace_whenNsNotRequested_andFilterFlagSet_andUserIsAuthorized() {
 467         test_roles_shouldAddRoles(false);
 468     }
 469
 470     @Test
 471     public void roles_shouldAddRolesWithNamespace_whenNsRequested_andFilterFlagSet_andUserIsAuthorized() {
 472         test_roles_shouldAddRoles(true);
 473     }
 474
 475     private void test_roles_shouldAddRoles(boolean namespaceRequested) {
 476         //given
 477         String namespace = "org.onap.app1";
 478         String description = "role description";
 479         Set<String> roleNames = Sets.newHashSet(namespace+".admin", namespace+".deployer");
 480         List<RoleDAO.Data> daoRoles = roleNames.stream().map( name -> createRoleDAOobj(namespace, name, description))
 481             .collect(Collectors.toList());
 482         given(question.mayUser(eq(transaction), eq(USER), any(RoleDAO.Data.class), eq(Access.read)))
 483             .willReturn(Result.ok(new NsDAO.Data()));
 484         given(transaction.requested(REQD_TYPE.ns)).willReturn(namespaceRequested);
 485
 486         //when
 487         Result<Roles> result = mapper.roles(transaction, daoRoles, new Roles(), true);
 488
 489         //then
 490         assertTrue(result.isOK());
 491         assertEquals(2, result.value.getRole().size());
 492         result.value.getRole().stream().forEach( role -> {
 493             assertTrue(role.getPerms().isEmpty());
 494             if(namespaceRequested) {
 495                 assertEquals(namespace, role.getNs());
 496             } else {
 497                 assertNull(role.getNs());
 498             }
 499             assertTrue(roleNames.contains(role.getName()));
 500             assertEquals(description, role.getDescription());
 501         });
 502     }
 503
 504     @Test
 505     public void roles_shouldReturnErrorResult_whenAnyPermHasInvalidFormat() {
 506         //given
 507         given(question.mayUser(eq(transaction), eq(USER), any(RoleDAO.Data.class), eq(Access.read)))
 508             .willReturn(Result.ok(new NsDAO.Data()));
 509         RoleDAO.Data role = createRoleDAOobj("org.onap.app", "org.onap.app.admin", "description");
 510         role.perms = Sets.newHashSet("invalidPermFormat");
 511
 512         //when
 513         Result<Roles> result = mapper.roles(transaction, Lists.newArrayList(role), new Roles(), true);
 514
 515         //then
 516         assertFalse(result.isOK());
 517         assertEquals(ERR_BadData, result.status);
 518     }
 519
 520     @Test
 521     public void roles_shouldAddPerms_whenAllPermsProperlyDefined_andUserCanViewIt() {
 522         //given
 523         given(question.mayUser(eq(transaction), eq(USER), any(RoleDAO.Data.class), eq(Access.read)))
 524             .willReturn(Result.ok(new NsDAO.Data()));
 525         given(question.deriveNsSplit(transaction, "org.onap.app")).willReturn(Result.ok(mock(NsSplit.class)));
 526         RoleDAO.Data role = createRoleDAOobj("org.onap.app", "org.onap.app.admin", "description");
 527         role.perms = Sets.newHashSet("org.onap.app|access|*|read,approve");
 528
 529         //when
 530         Result<Roles> result = mapper.roles(transaction, Lists.newArrayList(role), new Roles(), true);
 531
 532         //then
 533         assertTrue(result.isOK());
 534         Role mappedRole = Iterables.getOnlyElement(result.value.getRole());
 535         Pkey pKey =  Iterables.getOnlyElement(mappedRole.getPerms());
 536         assertEquals("org.onap.app.access", pKey.getType());
 537         assertEquals("*", pKey.getInstance());
 538         assertEquals("read,approve", pKey.getAction());
 539     }
 540
 541     private RoleDAO.Data createRoleDAOobj(String namespace, String rolename, String desc) {
 542         NsDAO.Data ns = new NsDAO.Data();
 543         ns.name = namespace;
 544         RoleDAO.Data role = RoleDAO.Data.create(ns, rolename);
 545         role.description = desc;
 546         return role;
 547     }
 548
 549     @Test
 550     public void userRoles_shouldMapUserRolesFromDAO() {
 551         //given
 552         String user = "john@people.osaaf.org";
 553         String role = "admin";
 554         String namespace = "org.osaaf.aaf";
 555         int year = 2020;
 556         int month = 10;
 557         int day = 31;
 558         Date expiration = new Calendar.Builder().setDate(year,month-1, day).build().getTime(); //month is 0-based
 559         UserRoles targetRoles = new UserRoles();
 560
 561         //when
 562         Result<UserRoles> result = mapper.userRoles(transaction, Lists.newArrayList(
 563             createUserRoleDAOobj(user, expiration, namespace, role)), targetRoles);
 564
 565         //then
 566         assertTrue(result.isOK());
 567         UserRole targetRole = Iterables.getOnlyElement(result.value.getUserRole());
 568         assertEquals(user, targetRole.getUser());
 569         assertEquals(role, targetRole.getRole());
 570         assertEquals(year, targetRole.getExpires().getYear());
 571         assertEquals(month, targetRole.getExpires().getMonth());
 572         assertEquals(day, targetRole.getExpires().getDay());
 573     }
 574
 575     @Test
 576     public void userRole_shouldReturnErrorResult_whenAnyExceptionOccurs() {
 577         //given
 578         PermRequest wrongRequestType = new PermRequest();
 579
 580         //when
 581         Result<UserRoleDAO.Data> result = mapper.userRole(transaction, wrongRequestType);
 582
 583         //then
 584         assertFalse(result.isOK());
 585         assertEquals(ERR_BadData, result.status);
 586         verifyZeroInteractions(transaction);
 587     }
 588
 589     @Test
 590     public void userRole_shouldReturnEmptyRoleDAOobj_whenRequestIsEmpty() {
 591         //given
 592         UserRoleRequest request = new UserRoleRequest();
 593         given(question.deriveNsSplit(any(), any())).willReturn(Result.err(new IllegalArgumentException()));
 594         Organization org = mock(Organization.class);
 595         given(org.expiration(any(), eq(Expiration.UserInRole), any())).willReturn(new GregorianCalendar());
 596         given(transaction.org()).willReturn(org);
 597
 598         //when
 599         Result<UserRoleDAO.Data> result = mapper.userRole(transaction, request);
 600
 601         //then
 602         assertTrue(result.isOK());
 603         assertNull(result.value.ns);
 604         assertNull(result.value.rname);
 605         assertNull(result.value.role);
 606         assertNull(result.value.user);
 607         assertNotNull(result.value.expires);
 608     }
 609
 610     @Test
 611     public void userRole_shouldReturnMappedRoleDAOobj_whenRequestIsFilled() {
 612         //given
 613         String user = "johny@people.osaaf.org";
 614         String role = "org.onap.app1.deployer";
 615         String rName = "deployer";
 616         String namespace = "org.onap.app1";
 617
 618         given(question.deriveNsSplit(transaction, role)).willReturn(Result.ok(new NsSplit(namespace, rName)));
 619         Organization org = mock(Organization.class);
 620         given(org.expiration(any(), eq(Expiration.UserInRole), any())).willReturn(new GregorianCalendar());
 621         given(transaction.org()).willReturn(org);
 622
 623         //when
 624         Result<UserRoleDAO.Data> result = mapper.userRole(transaction, createUserRoleRequest(role, user));
 625
 626         //then
 627         assertTrue(result.isOK());
 628         assertEquals(user, result.value.user);
 629         assertEquals(role, result.value.role);
 630         assertEquals(rName, result.value.rname);
 631         assertEquals(namespace, result.value.ns);
 632         assertNotNull(result.value.expires);
 633     }
 634
 635     private UserRoleRequest createUserRoleRequest(String role, String user) {
 636         UserRoleRequest request = new UserRoleRequest();
 637         request.setRole(role);
 638         request.setUser(user);
 639         return request;
 640     }
 641
 642     private UserRoleDAO.Data createUserRoleDAOobj(String userName, Date expires, String namespace, String roleName) {
 643         UserRoleDAO.Data userRole =  new UserRoleDAO.Data();
 644         userRole.user = userName;
 645         userRole.expires = expires;
 646         userRole.ns = namespace;
 647         userRole.role = roleName;
 648         return userRole;
 649     }
 650
 651 }