ECOMP-PDP/src/test/java/org/openecomp/policy/pdp/test/FunctionDefinitionBagTest.java

   1 /*-
   2  * ============LICENSE_START=======================================================
   3  * ECOMP-PDP
   4  * ================================================================================
   5  * Copyright (C) 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 package org.openecomp.policy.pdp.test;
  22
  23 import static org.junit.Assert.assertEquals;
  24 import static org.junit.Assert.assertFalse;
  25 import static org.junit.Assert.assertNotNull;
  26 import static org.junit.Assert.assertTrue;
  27 import static org.junit.Assert.fail;
  28
  29 import java.math.BigInteger;
  30 import java.util.ArrayList;
  31 import java.util.Iterator;
  32 import java.util.List;
  33
  34 import org.junit.Test;
  35
  36 import com.att.research.xacml.api.AttributeValue;
  37 import com.att.research.xacml.api.XACML3;
  38 import com.att.research.xacml.std.datatypes.DataTypes;
  39 import com.att.research.xacmlatt.pdp.policy.Bag;
  40 import com.att.research.xacmlatt.pdp.policy.ExpressionResult;
  41 import com.att.research.xacmlatt.pdp.policy.FunctionArgument;
  42 import com.att.research.xacmlatt.pdp.policy.FunctionArgumentAttributeValue;
  43 import com.att.research.xacmlatt.pdp.std.StdFunctions;
  44 import com.att.research.xacmlatt.pdp.std.functions.*;
  45
  46 /**
  47  * Test of PDP Functions (See XACML core spec section A.3)
  48  *
  49  * TO RUN - use jUnit
  50  * In Eclipse select this file or the enclosing directory, right-click and select Run As/JUnit Test
  51  *
  52  *
  53  */
  54 public class FunctionDefinitionBagTest {
  55
  56
  57         /*
  58          * variables useful in the following tests
  59          */
  60         List<FunctionArgument> arguments = new ArrayList<>();
  61
  62
  63         FunctionArgumentAttributeValue attrInteger = null;
  64         FunctionArgumentAttributeValue attrString = null;
  65
  66         public FunctionDefinitionBagTest() {
  67                 try {
  68                         attrInteger = new FunctionArgumentAttributeValue(DataTypes.DT_INTEGER.createAttributeValue(1111111111));
  69                         attrString = new FunctionArgumentAttributeValue(DataTypes.DT_STRING.createAttributeValue("a string value"));
  70                 } catch (Exception e) {
  71                         fail("creating attributes e="+e);
  72                 }
  73         }
  74
  75         @Test
  76         public void testString() {
  77
  78                 String s1 = "abc";
  79                 String s2 = "def";
  80                 FunctionArgumentAttributeValue attr1 = null;
  81                 FunctionArgumentAttributeValue attr2 = null;
  82                 try {
  83                         attr1 = new FunctionArgumentAttributeValue(DataTypes.DT_STRING.createAttributeValue(s1));
  84                         attr2 = new FunctionArgumentAttributeValue(DataTypes.DT_STRING.createAttributeValue(s2));
  85                 } catch (Exception e) {
  86                         fail("creating attributes e="+e);
  87                 }
  88
  89                 FunctionDefinitionBag<?> fd = (FunctionDefinitionBag<?>) StdFunctions.FD_STRING_BAG;
  90
  91                 // check identity and type of the thing created
  92                 assertEquals(XACML3.ID_FUNCTION_STRING_BAG, fd.getId());
  93                 assertEquals(DataTypes.DT_STRING.getId(), fd.getDataTypeId());
  94
  95                 // just to be safe...  If tests take too long these can probably be eliminated
  96                 assertTrue(fd.returnsBag());
  97
  98                 // bag with only one
  99                 arguments.clear();
 100                 arguments.add(attr1);
 101                 ExpressionResult res = fd.evaluate(null, arguments);
 102                 assertTrue(res.isOk());
 103                 Bag bag = res.getBag();
 104                 assertNotNull(bag);
 105                 Iterator<AttributeValue<?>> it = bag.getAttributeValues();
 106                 assertEquals(1, bag.size());
 107                 AttributeValue<?> attrValueObject = it.next();
 108                 assertEquals(DataTypes.DT_STRING.getId(), attrValueObject.getDataTypeId());
 109                 assertEquals(s1, attrValueObject.getValue());
 110
 111                 // zero args => empty bag
 112                 arguments.clear();
 113                 res = fd.evaluate(null, arguments);
 114                 assertTrue(res.isOk());
 115                 bag = res.getBag();
 116                 assertNotNull(bag);
 117                 assertEquals(0, bag.size());
 118
 119
 120                 // null argument
 121                 arguments.clear();
 122                 arguments.add(null);
 123                 res = fd.evaluate(null, arguments);
 124                 assertFalse(res.isOk());
 125                 assertEquals("function:string-bag Got null argument", res.getStatus().getStatusMessage());
 126                 assertEquals("urn:oasis:names:tc:xacml:1.0:status:processing-error", res.getStatus().getStatusCode().getStatusCodeValue().stringValue());
 127
 128                 // argument of other type
 129                 arguments.clear();
 130                 arguments.add(attrInteger);
 131                 res = fd.evaluate(null, arguments);
 132                 assertFalse(res.isOk());
 133                 assertEquals("function:string-bag Expected data type 'string' saw 'integer'", res.getStatus().getStatusMessage());
 134                 assertEquals("urn:oasis:names:tc:xacml:1.0:status:processing-error", res.getStatus().getStatusCode().getStatusCodeValue().stringValue());
 135
 136                 // 2 args (check response is correct)
 137                 arguments.clear();
 138                 arguments.add(attr1);
 139                 arguments.add(attr2);
 140                 res = fd.evaluate(null, arguments);
 141                 assertTrue(res.isOk());
 142                 bag = res.getBag();
 143                 assertNotNull(bag);
 144                 it = bag.getAttributeValues();
 145                 assertEquals(2, bag.size());
 146                 attrValueObject = it.next();
 147                 assertEquals(DataTypes.DT_STRING.getId(), attrValueObject.getDataTypeId());
 148                 assertEquals(s1, attrValueObject.getValue());
 149                 attrValueObject = it.next();
 150                 assertEquals(DataTypes.DT_STRING.getId(), attrValueObject.getDataTypeId());
 151                 assertEquals(s2, attrValueObject.getValue());
 152
 153                 // duplicate args (verify return)
 154                 arguments.clear();
 155                 arguments.add(attr1);
 156                 arguments.add(attr2);
 157                 arguments.add(attr1);
 158                 res = fd.evaluate(null, arguments);
 159                 assertTrue(res.isOk());
 160                 bag = res.getBag();
 161                 assertNotNull(bag);
 162                 it = bag.getAttributeValues();
 163                 assertEquals(3, bag.size());
 164                 attrValueObject = it.next();
 165                 assertEquals(DataTypes.DT_STRING.getId(), attrValueObject.getDataTypeId());
 166                 assertEquals(s1, attrValueObject.getValue());
 167                 attrValueObject = it.next();
 168                 assertEquals(DataTypes.DT_STRING.getId(), attrValueObject.getDataTypeId());
 169                 assertEquals(s2, attrValueObject.getValue());
 170                 attrValueObject = it.next();
 171                 assertEquals(DataTypes.DT_STRING.getId(), attrValueObject.getDataTypeId());
 172                 assertEquals(s1, attrValueObject.getValue());
 173
 174                 // lots of args
 175                 arguments.clear();
 176                 for (int i = 0; i < 1000; i++) {
 177                         arguments.add(attr1);
 178                 }
 179                 res = fd.evaluate(null, arguments);
 180                 assertTrue(res.isOk());
 181                 bag = res.getBag();
 182                 assertNotNull(bag);
 183                 it = bag.getAttributeValues();
 184                 assertEquals(1000, bag.size());
 185
 186         }
 187
 188
 189         @Test
 190         public void testBoolean() {
 191
 192                 Boolean s1 = true;
 193                 Boolean s2 = false;
 194                 FunctionArgumentAttributeValue attr1 = null;
 195                 FunctionArgumentAttributeValue attr2 = null;
 196                 try {
 197                         attr1 = new FunctionArgumentAttributeValue(DataTypes.DT_BOOLEAN.createAttributeValue(s1));
 198                         attr2 = new FunctionArgumentAttributeValue(DataTypes.DT_BOOLEAN.createAttributeValue(s2));
 199                 } catch (Exception e) {
 200                         fail("creating attributes e="+e);
 201                 }
 202
 203                 FunctionDefinitionBag<?> fd = (FunctionDefinitionBag<?>) StdFunctions.FD_BOOLEAN_BAG;
 204
 205                 // check identity and type of the thing created
 206                 assertEquals(XACML3.ID_FUNCTION_BOOLEAN_BAG, fd.getId());
 207                 assertEquals(DataTypes.DT_BOOLEAN.getId(), fd.getDataTypeId());
 208
 209                 // just to be safe...  If tests take too long these can probably be eliminated
 210                 assertTrue(fd.returnsBag());
 211
 212                 // bag with only one
 213                 arguments.clear();
 214                 arguments.add(attr1);
 215                 ExpressionResult res = fd.evaluate(null, arguments);
 216                 assertTrue(res.isOk());
 217                 Bag bag = res.getBag();
 218                 assertNotNull(bag);
 219                 Iterator<AttributeValue<?>> it = bag.getAttributeValues();
 220                 assertEquals(1, bag.size());
 221                 AttributeValue<?> attrValueObject = it.next();
 222                 assertEquals(DataTypes.DT_BOOLEAN.getId(), attrValueObject.getDataTypeId());
 223                 assertEquals(s1, attrValueObject.getValue());
 224
 225                 // zero args => empty bag
 226                 arguments.clear();
 227                 res = fd.evaluate(null, arguments);
 228                 assertTrue(res.isOk());
 229                 bag = res.getBag();
 230                 assertNotNull(bag);
 231                 assertEquals(0, bag.size());
 232
 233
 234                 // null argument
 235                 arguments.clear();
 236                 arguments.add(null);
 237                 res = fd.evaluate(null, arguments);
 238                 assertFalse(res.isOk());
 239                 assertEquals("function:boolean-bag Got null argument", res.getStatus().getStatusMessage());
 240                 assertEquals("urn:oasis:names:tc:xacml:1.0:status:processing-error", res.getStatus().getStatusCode().getStatusCodeValue().stringValue());
 241
 242                 // argument of other type
 243                 arguments.clear();
 244                 arguments.add(attrInteger);
 245                 res = fd.evaluate(null, arguments);
 246                 assertFalse(res.isOk());
 247                 assertEquals("function:boolean-bag Expected data type 'boolean' saw 'integer'", res.getStatus().getStatusMessage());
 248                 assertEquals("urn:oasis:names:tc:xacml:1.0:status:processing-error", res.getStatus().getStatusCode().getStatusCodeValue().stringValue());
 249
 250                 // 2 args (check response is correct)
 251                 arguments.clear();
 252                 arguments.add(attr1);
 253                 arguments.add(attr2);
 254                 res = fd.evaluate(null, arguments);
 255                 assertTrue(res.isOk());
 256                 bag = res.getBag();
 257                 assertNotNull(bag);
 258                 it = bag.getAttributeValues();
 259                 assertEquals(2, bag.size());
 260                 attrValueObject = it.next();
 261                 assertEquals(DataTypes.DT_BOOLEAN.getId(), attrValueObject.getDataTypeId());
 262                 assertEquals(s1, attrValueObject.getValue());
 263                 attrValueObject = it.next();
 264                 assertEquals(DataTypes.DT_BOOLEAN.getId(), attrValueObject.getDataTypeId());
 265                 assertEquals(s2, attrValueObject.getValue());
 266
 267                 // duplicate args (verify return)
 268                 arguments.clear();
 269                 arguments.add(attr1);
 270                 arguments.add(attr2);
 271                 arguments.add(attr1);
 272                 res = fd.evaluate(null, arguments);
 273                 assertTrue(res.isOk());
 274                 bag = res.getBag();
 275                 assertNotNull(bag);
 276                 it = bag.getAttributeValues();
 277                 assertEquals(3, bag.size());
 278                 attrValueObject = it.next();
 279                 assertEquals(DataTypes.DT_BOOLEAN.getId(), attrValueObject.getDataTypeId());
 280                 assertEquals(s1, attrValueObject.getValue());
 281                 attrValueObject = it.next();
 282                 assertEquals(DataTypes.DT_BOOLEAN.getId(), attrValueObject.getDataTypeId());
 283                 assertEquals(s2, attrValueObject.getValue());
 284                 attrValueObject = it.next();
 285                 assertEquals(DataTypes.DT_BOOLEAN.getId(), attrValueObject.getDataTypeId());
 286                 assertEquals(s1, attrValueObject.getValue());
 287
 288                 // lots of args
 289                 arguments.clear();
 290                 for (int i = 0; i < 1000; i++) {
 291                         arguments.add(attr1);
 292                 }
 293                 res = fd.evaluate(null, arguments);
 294                 assertTrue(res.isOk());
 295                 bag = res.getBag();
 296                 assertNotNull(bag);
 297                 it = bag.getAttributeValues();
 298                 assertEquals(1000, bag.size());
 299
 300         }
 301
 302
 303
 304         @Test
 305         public void testInteger() {
 306
 307                 BigInteger s1 = new BigInteger("123");
 308                 BigInteger s2 = new BigInteger("456");
 309                 FunctionArgumentAttributeValue attr1 = null;
 310                 FunctionArgumentAttributeValue attr2 = null;
 311                 try {
 312                         attr1 = new FunctionArgumentAttributeValue(DataTypes.DT_INTEGER.createAttributeValue(s1));
 313                         attr2 = new FunctionArgumentAttributeValue(DataTypes.DT_INTEGER.createAttributeValue(s2));
 314                 } catch (Exception e) {
 315                         fail("creating attributes e="+e);
 316                 }
 317
 318                 FunctionDefinitionBag<?> fd = (FunctionDefinitionBag<?>) StdFunctions.FD_INTEGER_BAG;
 319
 320                 // check identity and type of the thing created
 321                 assertEquals(XACML3.ID_FUNCTION_INTEGER_BAG, fd.getId());
 322                 assertEquals(DataTypes.DT_INTEGER.getId(), fd.getDataTypeId());
 323
 324                 // just to be safe...  If tests take too long these can probably be eliminated
 325                 assertTrue(fd.returnsBag());
 326
 327                 // bag with only one
 328                 arguments.clear();
 329                 arguments.add(attr1);
 330                 ExpressionResult res = fd.evaluate(null, arguments);
 331                 assertTrue(res.isOk());
 332                 Bag bag = res.getBag();
 333                 assertNotNull(bag);
 334                 Iterator<AttributeValue<?>> it = bag.getAttributeValues();
 335                 assertEquals(1, bag.size());
 336                 AttributeValue<?> attrValueObject = it.next();
 337                 assertEquals(DataTypes.DT_INTEGER.getId(), attrValueObject.getDataTypeId());
 338                 assertEquals(s1, attrValueObject.getValue());
 339
 340                 // zero args => empty bag
 341                 arguments.clear();
 342                 res = fd.evaluate(null, arguments);
 343                 assertTrue(res.isOk());
 344                 bag = res.getBag();
 345                 assertNotNull(bag);
 346                 assertEquals(0, bag.size());
 347
 348
 349                 // null argument
 350                 arguments.clear();
 351                 arguments.add(null);
 352                 res = fd.evaluate(null, arguments);
 353                 assertFalse(res.isOk());
 354                 assertEquals("function:integer-bag Got null argument", res.getStatus().getStatusMessage());
 355                 assertEquals("urn:oasis:names:tc:xacml:1.0:status:processing-error", res.getStatus().getStatusCode().getStatusCodeValue().stringValue());
 356
 357                 // argument of other type
 358                 arguments.clear();
 359                 arguments.add(attrString);
 360                 res = fd.evaluate(null, arguments);
 361                 assertFalse(res.isOk());
 362                 assertEquals("function:integer-bag Expected data type 'integer' saw 'string'", res.getStatus().getStatusMessage());
 363                 assertEquals("urn:oasis:names:tc:xacml:1.0:status:processing-error", res.getStatus().getStatusCode().getStatusCodeValue().stringValue());
 364
 365                 // 2 args (check response is correct)
 366                 arguments.clear();
 367                 arguments.add(attr1);
 368                 arguments.add(attr2);
 369                 res = fd.evaluate(null, arguments);
 370                 assertTrue(res.isOk());
 371                 bag = res.getBag();
 372                 assertNotNull(bag);
 373                 it = bag.getAttributeValues();
 374                 assertEquals(2, bag.size());
 375                 attrValueObject = it.next();
 376                 assertEquals(DataTypes.DT_INTEGER.getId(), attrValueObject.getDataTypeId());
 377                 assertEquals(s1, attrValueObject.getValue());
 378                 attrValueObject = it.next();
 379                 assertEquals(DataTypes.DT_INTEGER.getId(), attrValueObject.getDataTypeId());
 380                 assertEquals(s2, attrValueObject.getValue());
 381
 382                 // duplicate args (verify return)
 383                 arguments.clear();
 384                 arguments.add(attr1);
 385                 arguments.add(attr2);
 386                 arguments.add(attr1);
 387                 res = fd.evaluate(null, arguments);
 388                 assertTrue(res.isOk());
 389                 bag = res.getBag();
 390                 assertNotNull(bag);
 391                 it = bag.getAttributeValues();
 392                 assertEquals(3, bag.size());
 393                 attrValueObject = it.next();
 394                 assertEquals(DataTypes.DT_INTEGER.getId(), attrValueObject.getDataTypeId());
 395                 assertEquals(s1, attrValueObject.getValue());
 396                 attrValueObject = it.next();
 397                 assertEquals(DataTypes.DT_INTEGER.getId(), attrValueObject.getDataTypeId());
 398                 assertEquals(s2, attrValueObject.getValue());
 399                 attrValueObject = it.next();
 400                 assertEquals(DataTypes.DT_INTEGER.getId(), attrValueObject.getDataTypeId());
 401                 assertEquals(s1, attrValueObject.getValue());
 402
 403                 // lots of args
 404                 arguments.clear();
 405                 for (int i = 0; i < 1000; i++) {
 406                         arguments.add(attr1);
 407                 }
 408                 res = fd.evaluate(null, arguments);
 409                 assertTrue(res.isOk());
 410                 bag = res.getBag();
 411                 assertNotNull(bag);
 412                 it = bag.getAttributeValues();
 413                 assertEquals(1000, bag.size());
 414
 415         }
 416
 417
 418
 419
 420         @Test
 421         public void testDouble() {
 422
 423                 Double s1 = 123.45;
 424                 Double s2 = 678.901;
 425                 FunctionArgumentAttributeValue attr1 = null;
 426                 FunctionArgumentAttributeValue attr2 = null;
 427                 try {
 428                         attr1 = new FunctionArgumentAttributeValue(DataTypes.DT_DOUBLE.createAttributeValue(s1));
 429                         attr2 = new FunctionArgumentAttributeValue(DataTypes.DT_DOUBLE.createAttributeValue(s2));
 430                 } catch (Exception e) {
 431                         fail("creating attributes e="+e);
 432                 }
 433
 434                 FunctionDefinitionBag<?> fd = (FunctionDefinitionBag<?>) StdFunctions.FD_DOUBLE_BAG;
 435
 436                 // check identity and type of the thing created
 437                 assertEquals(XACML3.ID_FUNCTION_DOUBLE_BAG, fd.getId());
 438                 assertEquals(DataTypes.DT_DOUBLE.getId(), fd.getDataTypeId());
 439
 440                 // just to be safe...  If tests take too long these can probably be eliminated
 441                 assertTrue(fd.returnsBag());
 442
 443                 // bag with only one
 444                 arguments.clear();
 445                 arguments.add(attr1);
 446                 ExpressionResult res = fd.evaluate(null, arguments);
 447                 assertTrue(res.isOk());
 448                 Bag bag = res.getBag();
 449                 assertNotNull(bag);
 450                 Iterator<AttributeValue<?>> it = bag.getAttributeValues();
 451                 assertEquals(1, bag.size());
 452                 AttributeValue<?> attrValueObject = it.next();
 453                 assertEquals(DataTypes.DT_DOUBLE.getId(), attrValueObject.getDataTypeId());
 454                 assertEquals(s1, attrValueObject.getValue());
 455
 456                 // zero args => empty bag
 457                 arguments.clear();
 458                 res = fd.evaluate(null, arguments);
 459                 assertTrue(res.isOk());
 460                 bag = res.getBag();
 461                 assertNotNull(bag);
 462                 assertEquals(0, bag.size());
 463
 464
 465                 // null argument
 466                 arguments.clear();
 467                 arguments.add(null);
 468                 res = fd.evaluate(null, arguments);
 469                 assertFalse(res.isOk());
 470                 assertEquals("function:double-bag Got null argument", res.getStatus().getStatusMessage());
 471                 assertEquals("urn:oasis:names:tc:xacml:1.0:status:processing-error", res.getStatus().getStatusCode().getStatusCodeValue().stringValue());
 472
 473                 // argument of other type
 474                 arguments.clear();
 475                 arguments.add(attrInteger);
 476                 res = fd.evaluate(null, arguments);
 477                 assertFalse(res.isOk());
 478                 assertEquals("function:double-bag Expected data type 'double' saw 'integer'", res.getStatus().getStatusMessage());
 479                 assertEquals("urn:oasis:names:tc:xacml:1.0:status:processing-error", res.getStatus().getStatusCode().getStatusCodeValue().stringValue());
 480
 481                 // 2 args (check response is correct)
 482                 arguments.clear();
 483                 arguments.add(attr1);
 484                 arguments.add(attr2);
 485                 res = fd.evaluate(null, arguments);
 486                 assertTrue(res.isOk());
 487                 bag = res.getBag();
 488                 assertNotNull(bag);
 489                 it = bag.getAttributeValues();
 490                 assertEquals(2, bag.size());
 491                 attrValueObject = it.next();
 492                 assertEquals(DataTypes.DT_DOUBLE.getId(), attrValueObject.getDataTypeId());
 493                 assertEquals(s1, attrValueObject.getValue());
 494                 attrValueObject = it.next();
 495                 assertEquals(DataTypes.DT_DOUBLE.getId(), attrValueObject.getDataTypeId());
 496                 assertEquals(s2, attrValueObject.getValue());
 497
 498                 // duplicate args (verify return)
 499                 arguments.clear();
 500                 arguments.add(attr1);
 501                 arguments.add(attr2);
 502                 arguments.add(attr1);
 503                 res = fd.evaluate(null, arguments);
 504                 assertTrue(res.isOk());
 505                 bag = res.getBag();
 506                 assertNotNull(bag);
 507                 it = bag.getAttributeValues();
 508                 assertEquals(3, bag.size());
 509                 attrValueObject = it.next();
 510                 assertEquals(DataTypes.DT_DOUBLE.getId(), attrValueObject.getDataTypeId());
 511                 assertEquals(s1, attrValueObject.getValue());
 512                 attrValueObject = it.next();
 513                 assertEquals(DataTypes.DT_DOUBLE.getId(), attrValueObject.getDataTypeId());
 514                 assertEquals(s2, attrValueObject.getValue());
 515                 attrValueObject = it.next();
 516                 assertEquals(DataTypes.DT_DOUBLE.getId(), attrValueObject.getDataTypeId());
 517                 assertEquals(s1, attrValueObject.getValue());
 518
 519                 // lots of args
 520                 arguments.clear();
 521                 for (int i = 0; i < 1000; i++) {
 522                         arguments.add(attr1);
 523                 }
 524                 res = fd.evaluate(null, arguments);
 525                 assertTrue(res.isOk());
 526                 bag = res.getBag();
 527                 assertNotNull(bag);
 528                 it = bag.getAttributeValues();
 529                 assertEquals(1000, bag.size());
 530
 531         }
 532
 533
 534
 535
 536
 537         //
 538         //
 539         //  REST OF DATA TYPES OMITTED
 540         //      because they "should" all work the same
 541         //
 542         //
 543
 544
 545
 546
 547 }