common/openecomp-logging-lib/openecomp-logging-core/src/test/java/org/openecomp/core/logging/aspects/MetricsAspectTest.java

   1 /*-
   2  * ============LICENSE_START=======================================================
   3  * SDC
   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.core.logging.aspects;
  22
  23 import org.openecomp.core.logging.api.Logger;
  24 import org.openecomp.core.logging.api.LoggerFactory;
  25 import org.aspectj.lang.ProceedingJoinPoint;
  26 import org.aspectj.lang.Signature;
  27 import org.aspectj.lang.reflect.SourceLocation;
  28 import org.aspectj.runtime.internal.AroundClosure;
  29 import org.easymock.EasyMock;
  30 import org.powermock.api.easymock.PowerMock;
  31 import org.powermock.core.classloader.annotations.PrepareForTest;
  32 import org.powermock.modules.testng.PowerMockTestCase;
  33 import org.testng.Assert;
  34 import org.testng.annotations.Test;
  35 import sun.reflect.generics.reflectiveObjects.NotImplementedException;
  36
  37 import java.util.ArrayList;
  38 import java.util.Collections;
  39 import java.util.List;
  40 import java.util.UUID;
  41 import java.util.concurrent.atomic.AtomicInteger;
  42 import java.util.function.Predicate;
  43
  44 /**
  45  * @author EVITALIY
  46  * @since 17/08/2016.
  47  */
  48 @PrepareForTest(LoggerFactory.class)
  49 public class MetricsAspectTest extends PowerMockTestCase {
  50
  51   private static final Object OBJ_TO_RETURN = new Object();
  52   private static final String EXPECTED_MESSAGE = "'{}' took {} milliseconds";
  53
  54   @Test
  55   public void testLogExecutionTime() throws Throwable {
  56
  57     String className = UUID.randomUUID().toString();
  58     String methodName = UUID.randomUUID().toString();
  59
  60     TestLogger logger = initLogging(className, true);
  61
  62     MetricsAspect aspect = new MetricsAspect();
  63     MockProceedingJoinPoint pjp = new MockProceedingJoinPoint(className, methodName);
  64     Object returned = aspect.logExecutionTime(pjp);
  65
  66     Assert.assertEquals(OBJ_TO_RETURN, returned);
  67     assertExecution(methodName, pjp, logger);
  68   }
  69
  70   @Test
  71   public void testMetricsDisabled() throws Throwable {
  72
  73     String className = UUID.randomUUID().toString();
  74     String methodName = UUID.randomUUID().toString();
  75
  76     TestLogger logger = initLogging(className, false);
  77
  78     MetricsAspect aspect = new MetricsAspect();
  79     MockProceedingJoinPoint pjp = new MockProceedingJoinPoint(className, methodName);
  80     Object returned = aspect.logExecutionTime(pjp);
  81
  82     Assert.assertEquals(OBJ_TO_RETURN, returned);
  83     Assert.assertEquals(1, pjp.getCount());
  84     // return any event - must be empty
  85     Assert.assertFalse(logger.contains((event) -> true));
  86   }
  87
  88   @Test(expectedExceptions = IllegalArgumentException.class)
  89   public void testThrowingError() throws Throwable {
  90
  91     String className = UUID.randomUUID().toString();
  92     String methodName = UUID.randomUUID().toString();
  93
  94     final TestLogger logger = initLogging(className, true);
  95
  96     MetricsAspect aspect = new MetricsAspect();
  97     MockProceedingJoinPoint pjp = new MockProceedingJoinPointWithException(className, methodName);
  98
  99     try {
 100       aspect.logExecutionTime(pjp);
 101     } finally {
 102       assertExecution(methodName, pjp, logger);
 103     }
 104   }
 105
 106   private TestLogger initLogging(String className, boolean enabled) {
 107     TestLogger logger = new TestLogger(enabled);
 108     PowerMock.mockStatic(LoggerFactory.class);
 109     EasyMock.expect(LoggerFactory.getLogger(className)).andReturn(logger);
 110     PowerMock.replay(LoggerFactory.class);
 111     return logger;
 112   }
 113
 114   private void assertExecution(String methodName, MockProceedingJoinPoint pjp, TestLogger logger) {
 115
 116     Assert.assertEquals(1, pjp.getCount());
 117     Assert.assertTrue(logger.contains((event) ->
 118         (event != null) && (event.length == 3) && EXPECTED_MESSAGE.equals(event[0])
 119             && methodName.equals(event[1]) && (event[2] instanceof Long)));
 120   }
 121
 122   private static class MockSignature implements Signature {
 123
 124     private final String className;
 125     private final String methodName;
 126
 127     private MockSignature(String className, String methodName) {
 128       this.className = className;
 129       this.methodName = methodName;
 130     }
 131
 132     @Override
 133     public String toShortString() {
 134       return null;
 135     }
 136
 137     @Override
 138     public String toLongString() {
 139       return null;
 140     }
 141
 142     @Override
 143     public String getName() {
 144       return methodName;
 145     }
 146
 147     @Override
 148     public int getModifiers() {
 149       return 0;
 150     }
 151
 152     @Override
 153     public Class getDeclaringType() {
 154       return null;
 155     }
 156
 157     @Override
 158     public String getDeclaringTypeName() {
 159       return className;
 160     }
 161   }
 162
 163   private static class MockProceedingJoinPoint implements ProceedingJoinPoint {
 164
 165     private AtomicInteger count = new AtomicInteger(0);
 166     private Signature signature;
 167
 168     MockProceedingJoinPoint(String className, String methodName) {
 169       this.signature = new MockSignature(className, methodName);
 170     }
 171
 172     int getCount() {
 173       return count.get();
 174     }
 175
 176     @Override
 177     public Object proceed() throws Throwable {
 178       count.incrementAndGet();
 179       return OBJ_TO_RETURN;
 180     }
 181
 182     @Override
 183     public void set$AroundClosure(AroundClosure aroundClosure) {
 184
 185     }
 186
 187     @Override
 188     public Object proceed(Object[] objects) throws Throwable {
 189       return null;
 190     }
 191
 192     @Override
 193     public String toShortString() {
 194       return null;
 195     }
 196
 197     @Override
 198     public String toLongString() {
 199       return null;
 200     }
 201
 202     @Override
 203     public Object getThis() {
 204       return null;
 205     }
 206
 207     @Override
 208     public Object getTarget() {
 209       return null;
 210     }
 211
 212     @Override
 213     public Object[] getArgs() {
 214       return new Object[0];
 215     }
 216
 217     @Override
 218     public Signature getSignature() {
 219       return this.signature;
 220     }
 221
 222     @Override
 223     public SourceLocation getSourceLocation() {
 224       return null;
 225     }
 226
 227     @Override
 228     public String getKind() {
 229       return null;
 230     }
 231
 232     @Override
 233     public StaticPart getStaticPart() {
 234       return null;
 235     }
 236   }
 237
 238   private static class MockProceedingJoinPointWithException extends MockProceedingJoinPoint {
 239
 240     MockProceedingJoinPointWithException(String className, String methodName) {
 241       super(className, methodName);
 242     }
 243
 244     @Override
 245     public Object proceed() throws Throwable {
 246       super.proceed();
 247       throw new IllegalArgumentException();
 248     }
 249   }
 250
 251   private class TestLogger implements Logger {
 252
 253     private final boolean enabled;
 254     private List<Object[]> events = Collections.synchronizedList(new ArrayList<>(10));
 255
 256     public TestLogger(boolean enabled) {
 257       this.enabled = enabled;
 258     }
 259
 260     @Override
 261     public String getName() {
 262       throw new NotImplementedException();
 263     }
 264
 265     @Override
 266     public boolean isMetricsEnabled() {
 267       return this.enabled;
 268     }
 269
 270     @Override
 271     public void metrics(String var1) {
 272       throw new NotImplementedException();
 273     }
 274
 275     @Override
 276     public void metrics(String var1, Object var2) {
 277       throw new NotImplementedException();
 278     }
 279
 280     @Override
 281     public void metrics(String var1, Object var2, Object var3) {
 282
 283       if (this.enabled) {
 284         events.add(new Object[]{var1, var2, var3});
 285       }
 286     }
 287
 288     @Override
 289     public void metrics(String var1, Object... var2) {
 290       throw new NotImplementedException();
 291     }
 292
 293     @Override
 294     public void metrics(String var1, Throwable throwable) {
 295       throw new NotImplementedException();
 296     }
 297
 298     @Override
 299     public boolean isAuditEnabled() {
 300       throw new NotImplementedException();
 301     }
 302
 303     @Override
 304     public void audit(String var1) {
 305       throw new NotImplementedException();
 306     }
 307
 308     @Override
 309     public void audit(String var1, Object var2) {
 310       throw new NotImplementedException();
 311     }
 312
 313     @Override
 314     public void audit(String var1, Object var2, Object var3) {
 315       throw new NotImplementedException();
 316     }
 317
 318     @Override
 319     public void audit(String var1, Object... var2) {
 320       throw new NotImplementedException();
 321     }
 322
 323     @Override
 324     public void audit(String var1, Throwable throwable) {
 325       throw new NotImplementedException();
 326     }
 327
 328     @Override
 329     public boolean isDebugEnabled() {
 330       throw new NotImplementedException();
 331     }
 332
 333     @Override
 334     public void debug(String var1) {
 335       throw new NotImplementedException();
 336     }
 337
 338     @Override
 339     public void debug(String var1, Object var2) {
 340       throw new NotImplementedException();
 341     }
 342
 343     @Override
 344     public void debug(String var1, Object var2, Object var3) {
 345       throw new NotImplementedException();
 346     }
 347
 348     @Override
 349     public void debug(String var1, Object... var2) {
 350       throw new NotImplementedException();
 351     }
 352
 353     @Override
 354     public void debug(String var1, Throwable throwable) {
 355       throw new NotImplementedException();
 356     }
 357
 358     @Override
 359     public boolean isInfoEnabled() {
 360       throw new NotImplementedException();
 361     }
 362
 363     @Override
 364     public void info(String var1) {
 365       throw new NotImplementedException();
 366     }
 367
 368     @Override
 369     public void info(String var1, Object var2) {
 370       throw new NotImplementedException();
 371     }
 372
 373     @Override
 374     public void info(String var1, Object var2, Object var3) {
 375       throw new NotImplementedException();
 376     }
 377
 378     @Override
 379     public void info(String var1, Object... var2) {
 380       throw new NotImplementedException();
 381     }
 382
 383     @Override
 384     public void info(String var1, Throwable throwable) {
 385       throw new NotImplementedException();
 386     }
 387
 388     @Override
 389     public boolean isWarnEnabled() {
 390       throw new NotImplementedException();
 391     }
 392
 393     @Override
 394     public void warn(String var1) {
 395       throw new NotImplementedException();
 396     }
 397
 398     @Override
 399     public void warn(String var1, Object var2) {
 400       throw new NotImplementedException();
 401     }
 402
 403     @Override
 404     public void warn(String var1, Object... var2) {
 405       throw new NotImplementedException();
 406     }
 407
 408     @Override
 409     public void warn(String var1, Object var2, Object var3) {
 410       throw new NotImplementedException();
 411     }
 412
 413     @Override
 414     public void warn(String var1, Throwable throwable) {
 415       throw new NotImplementedException();
 416     }
 417
 418     @Override
 419     public boolean isErrorEnabled() {
 420       throw new NotImplementedException();
 421     }
 422
 423     @Override
 424     public void error(String var1) {
 425       throw new NotImplementedException();
 426     }
 427
 428     @Override
 429     public void error(String var1, Object var2) {
 430       throw new NotImplementedException();
 431     }
 432
 433     @Override
 434     public void error(String var1, Object var2, Object var3) {
 435       throw new NotImplementedException();
 436     }
 437
 438     @Override
 439     public void error(String var1, Object... var2) {
 440       throw new NotImplementedException();
 441     }
 442
 443     @Override
 444     public void error(String var1, Throwable throwable) {
 445       throw new NotImplementedException();
 446     }
 447
 448     public boolean contains(Predicate<Object[]> predicate) {
 449       return events.stream().anyMatch(predicate);
 450     }
 451   }
 452 }