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