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.assertNull;
  26 import static org.junit.Assert.assertTrue;
  27 import static org.junit.Assert.fail;
  28 import static org.mockito.BDDMockito.given;
  29 import static org.mockito.Matchers.any;
  30 import static org.mockito.Matchers.anyString;
  31 import static org.mockito.Matchers.eq;
  32 import static org.mockito.Mockito.verify;
  33
  34 import aaf.v2_0.NsRequest;
  35 import aaf.v2_0.Nss;
  36 import aaf.v2_0.Nss.Ns;
  37 import aaf.v2_0.Perm;
  38 import aaf.v2_0.Perms;
  39 import aaf.v2_0.Request;
  40 import com.google.common.collect.ImmutableMap;
  41 import com.google.common.collect.Iterables;
  42 import com.google.common.collect.Lists;
  43 import com.google.common.collect.Sets;
  44 import java.io.IOException;
  45 import java.util.List;
  46 import java.util.Map;
  47 import java.util.Set;
  48 import org.junit.Assert;
  49 import org.junit.Before;
  50 import org.junit.Test;
  51 import org.junit.runner.RunWith;
  52 import org.mockito.Mock;
  53 import org.mockito.runners.MockitoJUnitRunner;
  54 import org.onap.aaf.auth.dao.cass.Namespace;
  55 import org.onap.aaf.auth.dao.cass.NsDAO;
  56 import org.onap.aaf.auth.dao.cass.NsSplit;
  57 import org.onap.aaf.auth.dao.cass.NsType;
  58 import org.onap.aaf.auth.dao.cass.PermDAO;
  59 import org.onap.aaf.auth.dao.cass.PermDAO.Data;
  60 import org.onap.aaf.auth.dao.hl.Question;
  61 import org.onap.aaf.auth.dao.hl.Question.Access;
  62 import org.onap.aaf.auth.env.AuthzTrans;
  63 import org.onap.aaf.auth.env.AuthzTrans.REQD_TYPE;
  64 import org.onap.aaf.auth.layer.Result;
  65 import org.onap.aaf.auth.rserv.Pair;
  66 import org.onap.aaf.auth.service.mapper.Mapper.API;
  67 import org.onap.aaf.auth.service.mapper.Mapper_2_0;
  68 import org.onap.aaf.cadi.CadiException;
  69 import org.onap.aaf.misc.env.APIException;
  70 import org.onap.aaf.misc.env.Env;
  71 import org.onap.aaf.misc.env.TimeTaken;
  72
  73 @RunWith(MockitoJUnitRunner.class)
  74 public class JU_Mapper_2_0 {
  75
  76   private static final String USER = "John";
  77
  78         private Mapper_2_0 mapper;
  79         @Mock
  80         private Question question;
  81         @Mock
  82         private AuthzTrans transaction;
  83         @Mock
  84   private TimeTaken tt;
  85
  86
  87         @Before
  88         public void setUp() throws APIException, IOException, CadiException {
  89           given(transaction.start(anyString(), eq(Env.SUB))).willReturn(tt);
  90           given(transaction.user()).willReturn(USER);
  91                 this.mapper = new Mapper_2_0(question);
  92         }
  93
  94         @Test(expected = ClassCastException.class)
  95         public void ns_willThrowException_whenInvalidRequestType() {
  96                 //given
  97                 Request rq = new Request();
  98
  99                 //when
 100                 mapper.ns(transaction, rq);
 101
 102                 //then
 103                 fail("Expected ClassCastException");
 104         }
 105
 106         @Test
 107         public void ns_shouldConvertNamespaceRequest_whenValidTypeIsExplicitlyProvided() {
 108                 //given
 109                 String namespaceName = "org.companyA.app1";
 110                 String namespaceType = "APP";
 111                 NsType expectedNsType = NsType.APP;
 112                 NsRequest nsRequest = createNsRequestForType(namespaceName, namespaceType);
 113
 114                 //when
 115                 Result<Namespace> result = mapper.ns(transaction,nsRequest);
 116
 117                 //then
 118                 assertTrue(result.isOK());
 119                 assertNamespaceValues(result.value, expectedNsType, namespaceName);
 120                 verify(transaction).checkpoint(namespaceName,Env.ALWAYS);
 121         }
 122
 123         @Test
 124         public void ns_shouldConvertNamespaceRequest_whenInValidTypeIsExplicitlyProvided() {
 125                 //given
 126                 String namespaceName = "org.companyA.app1.service0";
 127                 String invalidNsType = "BLUE";
 128                 NsType expectedNsType = NsType.APP;
 129                 NsRequest nsRequest = createNsRequestForType(namespaceName, invalidNsType);
 130
 131                 //when
 132                 Result<Namespace> result = mapper.ns(transaction,nsRequest);
 133
 134                 //then
 135                 assertTrue(result.isOK());
 136                 assertNamespaceValues(result.value, expectedNsType, namespaceName);
 137                 verify(transaction).checkpoint(namespaceName,Env.ALWAYS);
 138         }
 139
 140         @Test
 141         public void ns_shouldConvertRootNamespaceRequest_whenTypeNotProvided() {
 142                 //given
 143                 String rootNsName = "org";
 144                 NsType expectedNsType = NsType.ROOT;
 145                 NsRequest nsRequest = createNsRequestForType(rootNsName, null);
 146
 147                 //when
 148                 Result<Namespace> result = mapper.ns(transaction,nsRequest);
 149
 150                 //then
 151                 assertTrue(result.isOK());
 152                 assertNamespaceValues(result.value, expectedNsType, rootNsName);
 153                 verify(transaction).checkpoint(rootNsName,Env.ALWAYS);
 154         }
 155
 156         @Test
 157         public void ns_shouldConvertCompanyNamespaceRequest_whenTypeNotProvided() {
 158                 //given
 159                 String companyNsName = "org.companyA";
 160                 NsType expectedNsType = NsType.COMPANY;
 161                 NsRequest nsRequest = createNsRequestForType(companyNsName, null);
 162
 163                 //when
 164                 Result<Namespace> result = mapper.ns(transaction,nsRequest);
 165
 166                 //then
 167                 assertTrue(result.isOK());
 168                 assertNamespaceValues(result.value, expectedNsType, companyNsName);
 169                 verify(transaction).checkpoint(companyNsName,Env.ALWAYS);
 170         }
 171
 172         private void assertNamespaceValues(Namespace value, NsType nsType, String namespaceName) {
 173                 List<String> people = Lists.newArrayList("tk007@people.osaaf.org");
 174                 assertEquals(Integer.valueOf(nsType.type), value.type);
 175                 assertEquals(namespaceName, value.name);
 176                 assertEquals("some namespace description", value.description);
 177                 assertEquals(people, value.admin);
 178                 assertEquals(people, value.owner);
 179         }
 180
 181         private NsRequest createNsRequestForType(String nsName, String nsType) {
 182                 NsRequest req = mapper.newInstance(API.NS_REQ);
 183                 req.setType(nsType);
 184                 req.setName(nsName);
 185                 req.setDescription("some namespace description");
 186                 req.getAdmin().add("tk007@people.osaaf.org");
 187                 req.getResponsible().add("tk007@people.osaaf.org");
 188                 return req;
 189         }
 190
 191         @Test
 192         public void nss_shouldConvertNamespaceToNss_withoutAttributes() {
 193                 //given
 194                 Nss nss = mapper.newInstance(API.NSS);
 195                 Namespace ns = mapper.ns(transaction, createNsRequestForType("org.onap",  null)).value;
 196
 197                 //when
 198                 Result<Nss> result = mapper.nss(transaction, ns, nss);
 199
 200                 //then
 201                 assertTrue(result.isOK());
 202                 assertEquals("Only one Ns should be added",1, result.value.getNs().size());
 203                 Ns addedNs = Iterables.getOnlyElement(result.value.getNs());
 204                 assertEquals(ns.admin, addedNs.getAdmin());
 205                 assertEquals(ns.name, addedNs.getName());
 206                 assertEquals(ns.owner, addedNs.getResponsible());
 207                 assertEquals(ns.description, addedNs.getDescription());
 208                 assertTrue(addedNs.getAttrib().isEmpty());
 209         }
 210
 211         @Test
 212         public void nss_shouldConvertNamespaceToNss_withAttributes() {
 213                 //given
 214                 Nss nss = mapper.newInstance(API.NSS);
 215                 Namespace ns = mapper.ns(transaction, createNsRequestForType("org.onap",  null)).value;
 216                 ns.attrib = Lists.newArrayList();
 217                 int attribNum = 5;
 218                 Map<String, String> attribs = ImmutableMap.of("key1", "value1", "key2", "value2", "key3", "value3", "key4", "value4", "key5", "value5");
 219                 attribs.forEach((key,val) -> ns.attrib.add(new Pair<>(key,val)));
 220
 221                 //when
 222                 Result<Nss> result = mapper.nss(transaction, ns, nss);
 223
 224                 //then
 225                 assertTrue(result.isOK());
 226                 assertEquals("Only one Ns should be added",1, result.value.getNs().size());
 227                 Ns addedNs = Iterables.getOnlyElement(result.value.getNs());
 228                 assertEquals(attribNum, addedNs.getAttrib().size());
 229                 addedNs.getAttrib().forEach( attr -> {
 230                         assertEquals(attr.getValue(), attribs.get(attr.getKey()));
 231                 });
 232         }
 233
 234         @Test
 235         public void nss_shouldAddSeveralNamespacesToNss() {
 236                 //given
 237                 Nss nss = mapper.newInstance(API.NSS);
 238                 Namespace ns1 = mapper.ns(transaction, createNsRequestForType("org.onap",  "COMPANY")).value;
 239                 Namespace ns2 = mapper.ns(transaction, createNsRequestForType("org.onap.prh",  "APP")).value;
 240
 241                 //when
 242                 Result<Nss> result = mapper.nss(transaction, Lists.newArrayList(ns1,ns2), nss);
 243
 244                 //then
 245                 assertTrue(result.isOK());
 246                 assertEquals("Two namespaces should be added",2, result.value.getNs().size());
 247         }
 248
 249         @Test
 250         public void perm_shouldNotAddPerms_whenFilterIsSet_andUserIsNotAuthorized() {
 251                 //given
 252     given(question.mayUser(eq(transaction), eq(USER), any(PermDAO.Data.class), eq(Access.read)))
 253         .willReturn(Result.err(9, "error"));
 254     Perms permsContainer = mapper.newInstance(API.PERMS);
 255     List<PermDAO.Data> permsData = Lists.newArrayList(new PermDAO.Data());
 256     boolean filter = true;
 257
 258                 //when
 259     Result<Perms> result = mapper.perms(transaction, permsData, permsContainer, filter);
 260
 261                 //then
 262     assertTrue(result.isOK());
 263     assertEquals("No perms added",0,result.value.getPerm().size());
 264         }
 265
 266         @Test
 267   public void perm_shouldAddPerm_withNamespaceSet_whenUserIsAuthorized_AndNamespaceIsRequestedType() {
 268       //given
 269       given(question.mayUser(eq(transaction), eq(USER), any(PermDAO.Data.class), eq(Access.read)))
 270           .willReturn(Result.ok(new NsDAO.Data()));
 271       given(transaction.requested(REQD_TYPE.ns)).willReturn(true);
 272       Perms permsContainer = mapper.newInstance(API.PERMS);
 273       Set<String> roles = Sets.newHashSet("org.onap.portal.owner","org.onap.portal.designer"
 274                                 ,"org.onap.portal.tester");
 275       String namespace = "org.onap.portal";
 276       String type = "access";
 277       String fullType = namespace + "." +type;
 278       String action = "read";
 279       String description = "Portal Read Access";
 280                   List<PermDAO.Data> permsData = Lists.newArrayList(createPermDAOobj(namespace, type, "*",action, roles, description));
 281       boolean filter = true;
 282
 283       //when
 284       Result<Perms> result = mapper.perms(transaction, permsData, permsContainer, filter);
 285
 286       //then
 287       assertTrue(result.isOK());
 288       assertEquals("Perm is added",1,result.value.getPerm().size());
 289       Perm perm = Iterables.getOnlyElement(result.value.getPerm());
 290       assertEquals(namespace, perm.getNs());
 291       assertEquals(fullType, perm.getType());
 292       assertEquals(action, perm.getAction());
 293       assertEquals("*", perm.getInstance());
 294       assertEquals(description, perm.getDescription());
 295       assertEquals(Lists.newArrayList(roles), perm.getRoles());
 296   }
 297
 298         @Test
 299         public void perm_shouldAddPerm_withoutNamespaceSet_whenUserIsAuthorized_AndNamespaceIsNotRequestedType() {
 300                 //given
 301                 given(question.mayUser(eq(transaction), eq(USER), any(PermDAO.Data.class), eq(Access.read)))
 302                         .willReturn(Result.ok(new NsDAO.Data()));
 303                 given(transaction.requested(REQD_TYPE.ns)).willReturn(false);
 304                 Perms permsContainer = mapper.newInstance(API.PERMS);
 305                 String namespace = "org.onap.portal";
 306                 String type = "access";
 307                 String fullType = namespace + "." + type;
 308                 String action = "read";
 309                 List<PermDAO.Data> permsData = Lists.newArrayList(createPermDAOobj(namespace, type, "*",action, null, null));
 310                 boolean filter = true;
 311
 312                 //when
 313                 Result<Perms> result = mapper.perms(transaction, permsData, permsContainer, filter);
 314
 315                 //then
 316                 assertTrue(result.isOK());
 317                 assertEquals("Perm is added",1,result.value.getPerm().size());
 318                 Perm perm = Iterables.getOnlyElement(result.value.getPerm());
 319                 assertNull(perm.getNs());
 320                 assertEquals(fullType, perm.getType());
 321                 assertEquals(action, perm.getAction());
 322         }
 323
 324         @Test
 325         public void perm_shouldAddPermsWithCorrectSortedOrder() {
 326                 //given
 327                 given(question.mayUser(eq(transaction), eq(USER), any(PermDAO.Data.class), eq(Access.read)))
 328                         .willReturn(Result.ok(new NsDAO.Data()));
 329                 Perms permsContainer = mapper.newInstance(API.PERMS);
 330                 PermDAO.Data perm1 = createPermDAOobj("org.onap.portal", "access", "*", "read", null, null);
 331                 PermDAO.Data perm2 = createPermDAOobj("org.onap.portal", "access", "*", "write", null, null);
 332                 PermDAO.Data perm3 = createPermDAOobj("org.onap.portal", "design", "*", "new", null, null);
 333                 PermDAO.Data perm4 = createPermDAOobj("org.onap.portal", "workflow", "1", "edit", null, null);
 334                 PermDAO.Data perm5 = createPermDAOobj("org.onap.portal", "workflow", "2", "edit", null, null);
 335                 List<PermDAO.Data> permsData = Lists.newArrayList(perm4, perm1, perm5, perm3, perm2);
 336                 List<PermDAO.Data> correctOrderPerms = Lists.newArrayList(perm1, perm2, perm3, perm4, perm5);
 337
 338                 //when
 339                 Result<Perms> result = mapper.perms(transaction, permsData, permsContainer, true);
 340
 341                 //then
 342                 assertTrue(result.isOK());
 343                 assertEquals("Alls Perms added",5,result.value.getPerm().size());
 344                 List<Perm> mappedPerms = result.value.getPerm();
 345                 for(int i=0; i<5; i++) {
 346                         comparePerm(correctOrderPerms.get(i), mappedPerms.get(i));
 347                 }
 348         }
 349
 350         private void comparePerm(Data data, Perm perm) {
 351                 assertEquals(data.ns + "." + data.type, perm.getType());
 352                 assertEquals(data.instance, perm.getInstance());
 353                 assertEquals(data.action, perm.getAction());
 354         }
 355
 356         private PermDAO.Data createPermDAOobj(String ns, String name, String instance, String action, Set<String> roles, String description) {
 357                         NsSplit nss = new NsSplit(ns, name);
 358       PermDAO.Data perm = new PermDAO.Data(nss, instance, action);
 359       perm.roles = roles;
 360       perm.description = description;
 361       return perm;
 362   }
 363
 364         @Test
 365         public void test() {
 366                 assertTrue(true);
 367         }
 368
 369         @Test
 370         public void testApprovals(){
 371                 assertTrue(true);
 372         }
 373
 374         @Test
 375         public void testCert(){
 376                 assertTrue(true);
 377
 378         }
 379
 380         @Test
 381         public void testCred(){
 382                 assertTrue(true);
 383
 384         }
 385
 386         @Test
 387         public void testDelegate(){
 388                 assertTrue(true);
 389         }
 390
 391         @Test
 392         public void testErrorFromMessage(){
 393                 assertTrue(true);
 394
 395         }
 396
 397         @Test
 398         public void testFuture(){
 399                 assertTrue(true);
 400         }
 401
 402         @Test
 403         public void testGetClass(){
 404                 assertTrue(true);
 405         }
 406
 407         @Test
 408         public void testGetExpires(){
 409                 assertTrue(true);
 410         }
 411
 412         @Test
 413         public void testGetMarshal(){
 414                 assertTrue(true);
 415
 416         }
 417
 418         @Test
 419         public void testHistory(){
 420                 assertTrue(true);
 421         }
 422
 423         @Test
 424         public void testKeys(){
 425                 assertTrue(true);
 426
 427         }
 428
 429         @Test
 430         public void testNewInstance(){
 431                 assertTrue(true);
 432         }
 433
 434         @Test
 435         public void testNs(){
 436                 assertTrue(true);
 437         }
 438
 439         @Test
 440         public void testNss(){
 441                 assertTrue(true);
 442         }
 443
 444         @Test
 445         public void testPerm(){
 446                 assertTrue(true);
 447         }
 448
 449         @Test
 450         public void testPermFromRPRequest(){
 451                 assertTrue(true);
 452         }
 453
 454         @Test
 455         public void testPermKey(){
 456                 assertTrue(true);
 457         }
 458
 459         @Test
 460         public void testPerms(){
 461                 assertTrue(true);
 462         }
 463
 464         @Test
 465         public void testRole(){
 466                 assertTrue(true);
 467         }
 468
 469         @Test
 470         public void testRoleFromRPRequest(){
 471                 assertTrue(true);
 472         }
 473
 474         @Test
 475         public void testRoles(){
 476                 assertTrue(true);
 477         }
 478
 479         @Test
 480         public void testUserRole(){
 481                 assertTrue(true);
 482         }
 483
 484         @Test
 485         public void testUserRoles(){
 486                 assertTrue(true);
 487         }
 488
 489         @Test
 490         public void testUsers(){
 491                 assertTrue(true);
 492         }
 493
 494
 495 }