From 7a724b15b5a1266b8517d56008becd336db6a1c5 Mon Sep 17 00:00:00 2001 From: Luke Parker Date: Tue, 22 May 2018 17:35:18 +1000 Subject: Rename slf4j ref impl, add constants Change-Id: Ib3f24c3aa4974ac8c87fa969613192e884674f00 Issue-ID: LOG-115 Signed-off-by: Luke Parker --- .../ref/slf4j/ONAPLogAdapterOutputTest.java | 162 +++++++++ .../onap/logging/ref/slf4j/ONAPLogAdapterTest.java | 387 +++++++++++++++++++++ .../logging/ref/slf4j/ONAPLogConstantsTest.java | 133 +++++++ reference/logging-slf4j/src/test/java/testng.xml | 8 + 4 files changed, 690 insertions(+) create mode 100644 reference/logging-slf4j/src/test/java/org/onap/logging/ref/slf4j/ONAPLogAdapterOutputTest.java create mode 100644 reference/logging-slf4j/src/test/java/org/onap/logging/ref/slf4j/ONAPLogAdapterTest.java create mode 100644 reference/logging-slf4j/src/test/java/org/onap/logging/ref/slf4j/ONAPLogConstantsTest.java create mode 100644 reference/logging-slf4j/src/test/java/testng.xml (limited to 'reference/logging-slf4j/src/test/java') diff --git a/reference/logging-slf4j/src/test/java/org/onap/logging/ref/slf4j/ONAPLogAdapterOutputTest.java b/reference/logging-slf4j/src/test/java/org/onap/logging/ref/slf4j/ONAPLogAdapterOutputTest.java new file mode 100644 index 0000000..bab74bb --- /dev/null +++ b/reference/logging-slf4j/src/test/java/org/onap/logging/ref/slf4j/ONAPLogAdapterOutputTest.java @@ -0,0 +1,162 @@ +/** + * ============LICENSE_START======================================================= + * org.onap.logging + * ================================================================================ + * Copyright © 2018 Amdocs + * All rights reserved. + * ================================================================================ + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + * ============LICENSE_END========================================================= + */ + +package org.onap.logging.ref.slf4j; + +import java.io.BufferedReader; +import java.io.File; +import java.io.FileReader; +import java.nio.file.Files; +import java.util.ArrayList; +import java.util.List; +import java.util.UUID; + +import javax.xml.bind.DatatypeConverter; + +import org.slf4j.Logger; +import org.slf4j.LoggerFactory; +import org.slf4j.MDC; +import org.springframework.mock.web.MockHttpServletRequest; +import org.testng.annotations.AfterSuite; +import org.testng.annotations.BeforeSuite; +import org.testng.annotations.Test; + +import static org.hamcrest.MatcherAssert.assertThat; +import static org.hamcrest.core.Is.is; +import static org.hamcrest.core.IsNot.not; +import static org.hamcrest.core.IsNull.notNullValue; +import static org.hamcrest.core.StringContains.containsString; +import static org.hamcrest.number.OrderingComparison.greaterThan; + +/** + * Smoketest output, though the embedded configuration isn't necessarily + * canonical. + * + *

There are more comprehensive tests in the logging-slf4j-demo + * project.

+ */ +public class ONAPLogAdapterOutputTest { + + /** Temporary directory into which logfiles are written. */ + private static File sDir; + + @BeforeSuite + public static void setUp() throws Exception { + sDir = Files.createTempDirectory(ONAPLogAdapterOutputTest.class.getName()).toFile(); + System.getProperties().setProperty("SLF4J_OUTPUT_DIRECTORY", sDir.getAbsolutePath()); + LoggerFactory.getLogger(ONAPLogAdapterOutputTest.class).info("Starting."); + } + + @AfterSuite + public static void tearDown() throws Exception { + LoggerFactory.getLogger(ONAPLogAdapterOutputTest.class).info("Ending."); + Thread.sleep(1000L); + if (sDir != null) { + System.err.println("Should be deleting [" + sDir.getAbsolutePath() + "]..."); + } + } + + @Test + public void testOutput() throws Exception { + + assertThat(sDir, notNullValue()); + assertThat(sDir.isDirectory(), is(true)); + + final String uuid = UUID.randomUUID().toString(); + final String errorcode = UUID.randomUUID().toString(); + final Logger logger = LoggerFactory.getLogger(ONAPLogAdapterOutputTest.class); + + try { + MDC.put("uuid", uuid); + final ONAPLogAdapter adapter = new ONAPLogAdapter(logger); + final ONAPLogAdapter.HttpServletRequestAdapter http + = new ONAPLogAdapter.HttpServletRequestAdapter(new MockHttpServletRequest()); + adapter.entering(http); + adapter.unwrap().warn("a_warning"); + try { + throw new Exception("errorcode=" + errorcode); + } + catch (final Exception e) { + adapter.unwrap().error("an_error", e); + } + + Thread.sleep(1000L); + } + finally { + MDC.clear(); + } + + final List lines = new ArrayList<>(); + for (final File f : sDir.listFiles()) { + try (BufferedReader reader = new BufferedReader(new FileReader(f))) { + String line; + while ((line = reader.readLine()) != null) { + if (line.contains(uuid)) { + lines.add(line); + } + } + } + } + + assertThat(lines.size(), is(3)); + + assertThat(lines.get(0), containsString("ENTRY")); + final String [] line0 = lines.get(0).split("\t", -1); + assertThat(line0.length, is(9)); + DatatypeConverter.parseDateTime(line0[0]); + assertThat(line0[1].trim().length(), greaterThan(1)); + assertThat(line0[2], is("INFO")); + assertThat(line0[3], is(this.getClass().getName())); + assertThat(line0[4], containsString("uuid=" + uuid)); + assertThat(line0[5], is("")); + assertThat(line0[6], is("")); + assertThat(line0[7], is("ENTRY")); + System.err.println(lines.get(0)); + + assertThat(lines.get(1), not(containsString("ENTRY"))); + assertThat(lines.get(1), containsString("a_warning")); + final String [] line1 = lines.get(1).split("\t", -1); + assertThat(line1.length, is(9)); + DatatypeConverter.parseDateTime(line1[0]); + assertThat(line1[1].trim().length(), greaterThan(1)); + assertThat(line1[2], is("WARN")); + assertThat(line1[3], is(this.getClass().getName())); + assertThat(line1[4], containsString("uuid=" + uuid)); + assertThat(line1[5], is("a_warning")); + assertThat(line1[6], is("")); + assertThat(line1[7], is("")); + System.err.println(lines.get(1)); + + assertThat(lines.get(2), not(containsString("ENTRY"))); + assertThat(lines.get(2), containsString("an_error")); + final String [] line2 = lines.get(2).split("\t", -1); + assertThat(line2.length, is(9)); + DatatypeConverter.parseDateTime(line2[0]); + assertThat(line2[1].trim().length(), greaterThan(1)); + assertThat(line2[2], is("ERROR")); + assertThat(line2[3], is(this.getClass().getName())); + assertThat(line2[4], containsString("uuid=" + uuid)); + assertThat(line2[5], is("an_error")); + assertThat(line2[6], containsString("errorcode=" + errorcode)); + assertThat(line2[7], is("")); + System.err.println(lines.get(2)); + } +} diff --git a/reference/logging-slf4j/src/test/java/org/onap/logging/ref/slf4j/ONAPLogAdapterTest.java b/reference/logging-slf4j/src/test/java/org/onap/logging/ref/slf4j/ONAPLogAdapterTest.java new file mode 100644 index 0000000..ad22603 --- /dev/null +++ b/reference/logging-slf4j/src/test/java/org/onap/logging/ref/slf4j/ONAPLogAdapterTest.java @@ -0,0 +1,387 @@ +/** + * ============LICENSE_START======================================================= + * org.onap.logging + * ================================================================================ + * Copyright © 2018 Amdocs + * All rights reserved. + * ================================================================================ + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + * ============LICENSE_END========================================================= + */ + +package org.onap.logging.ref.slf4j; + +import java.util.HashMap; +import java.util.Map; +import java.util.UUID; + +import org.slf4j.Logger; +import org.slf4j.LoggerFactory; +import org.slf4j.MDC; +import org.slf4j.event.Level; +import org.springframework.mock.web.MockHttpServletRequest; +import org.testng.Assert; +import org.testng.annotations.AfterMethod; +import org.testng.annotations.Test; + +import static org.hamcrest.MatcherAssert.assertThat; +import static org.hamcrest.core.Is.is; +import static org.hamcrest.core.IsNot.not; +import static org.hamcrest.core.IsNull.notNullValue; +import static org.hamcrest.core.IsNull.nullValue; +import static org.hamcrest.core.IsSame.sameInstance; + +/** + * Tests for {@link ONAPLogAdapter}. + */ +public class ONAPLogAdapterTest { + + /** + * Ensure that MDCs are cleared after each testcase. + */ + @AfterMethod + public void resetMDCs() { + MDC.clear(); + } + + /** + * Test nullcheck. + */ + @Test + public void testCheckNotNull() { + + ONAPLogAdapter.checkNotNull(""); + + try { + ONAPLogAdapter.checkNotNull(null); + Assert.fail("Should throw NullPointerException"); + } + catch (final NullPointerException e) { + + } + } + + /** + * Test defaulting of nulls. + */ + @Test + public void testDefaultToEmpty() { + assertThat(ONAPLogAdapter.defaultToEmpty("123"), is("123")); + assertThat(ONAPLogAdapter.defaultToEmpty(Integer.valueOf(1984)), is("1984")); + assertThat(ONAPLogAdapter.defaultToEmpty(null), is("")); + } + + /** + * Test defaulting of nulls. + */ + @Test + public void testDefaultToUUID() { + assertThat(ONAPLogAdapter.defaultToUUID("123"), is("123")); + UUID.fromString(ONAPLogAdapter.defaultToUUID(null)); + } + + /** + * Test ENTERING. + */ + @Test + public void testEntering() { + + final Logger logger = LoggerFactory.getLogger(this.getClass()); + final ONAPLogAdapter adapter = new ONAPLogAdapter(logger); + final MockHttpServletRequest http = new MockHttpServletRequest(); + http.setRequestURI("uri123"); + http.setServerName("local123"); + http.setRemoteAddr("remote123"); + http.addHeader("X-ONAP-RequestID", "request123"); + http.addHeader("X-ONAP-InvocationID", "invocation123"); + http.addHeader("X-ONAP-PartnerName", "partner123"); + + try { + adapter.getServiceDescriptor().setServiceName("uri123"); + adapter.entering(http); + final Map mdcs = MDC.getCopyOfContextMap(); + assertThat(mdcs.get("RequestID"), is("request123")); + assertThat(mdcs.get("InvocationID"), is("invocation123")); + assertThat(mdcs.get("PartnerName"), is("partner123")); + assertThat(mdcs.get("ServiceName"), is("uri123")); + assertThat(mdcs.get("ServerFQDN"), is("local123")); + assertThat(mdcs.get("ClientIPAddress"), is("remote123")); + } + finally { + MDC.clear(); + } + } + + @Test + public void testSetServiceDescriptor() { + final ONAPLogAdapter.ServiceDescriptor override = new ONAPLogAdapter.ServiceDescriptor(); + final Logger logger = LoggerFactory.getLogger(this.getClass()); + final ONAPLogAdapter adapter = new ONAPLogAdapter(logger); + final ONAPLogAdapter.ServiceDescriptor before = adapter.getServiceDescriptor(); + adapter.setServiceDescriptor(override); + final ONAPLogAdapter.ServiceDescriptor after = adapter.getServiceDescriptor(); + assertThat(after, not(sameInstance(before))); + assertThat(after, is(override)); + } + + @Test + public void testSetResponseDescriptor() { + final ONAPLogAdapter.ResponseDescriptor override = new ONAPLogAdapter.ResponseDescriptor(); + final Logger logger = LoggerFactory.getLogger(this.getClass()); + final ONAPLogAdapter adapter = new ONAPLogAdapter(logger); + final ONAPLogAdapter.ResponseDescriptor before = adapter.getResponseDescriptor(); + adapter.setResponseDescriptor(override); + final ONAPLogAdapter.ResponseDescriptor after = adapter.getResponseDescriptor(); + assertThat(after, not(sameInstance(before))); + assertThat(after, is(override)); + } + + @Test + public void testUnwrap() { + final Logger logger = LoggerFactory.getLogger(this.getClass()); + final ONAPLogAdapter adapter = new ONAPLogAdapter(logger); + assertThat(adapter.unwrap(), is(logger)); + } + + /** + * Test EXITING. + */ + @Test + public void testExiting() { + + final Logger logger = LoggerFactory.getLogger(this.getClass()); + final ONAPLogAdapter adapter = new ONAPLogAdapter(logger); + + try { + MDC.put("somekey", "somevalue"); + assertThat(MDC.get("somekey"), is("somevalue")); + adapter.exiting(); + assertThat(MDC.get("somekey"), nullValue()); + } + finally { + MDC.clear(); + } + } + + /** + * Test INVOKE. + */ + @Test + public void testInvokeSyncAsyncNull() { + + final Logger logger = LoggerFactory.getLogger(this.getClass()); + final ONAPLogAdapter adapter = new ONAPLogAdapter(logger); + + final UUID syncUUID = adapter.invoke(ONAPLogConstants.InvocationMode.SYNCHRONOUS); + assertThat(syncUUID, notNullValue()); + + final UUID asyncUUID = adapter.invoke(ONAPLogConstants.InvocationMode.SYNCHRONOUS); + assertThat(asyncUUID, notNullValue()); + + final UUID agnosticUUID = adapter.invoke((ONAPLogConstants.InvocationMode)null); + assertThat(agnosticUUID, notNullValue()); + + } + + /** + * Test INVOKE, with RequestAdapter. + */ + @Test + public void testInvokeWithAdapter() throws Exception { + + final Logger logger = LoggerFactory.getLogger(this.getClass()); + final ONAPLogAdapter adapter = new ONAPLogAdapter(logger); + + final Map headers = new HashMap<>(); + final ONAPLogAdapter.RequestBuilder builder = new ONAPLogAdapter.RequestBuilder() { + @Override + public ONAPLogAdapter.RequestBuilder setHeader(final String name, final String value) { + headers.put(name, value); + return this; + } + }; + + try { + final UUID uuid = adapter.invoke(builder, ONAPLogConstants.InvocationMode.SYNCHRONOUS); + assertThat(uuid, notNullValue()); + assertThat(headers.get(ONAPLogConstants.Headers.INVOCATION_ID), is(uuid.toString())); + assertThat(headers.containsKey(ONAPLogConstants.Headers.PARTNER_NAME), is(true)); + assertThat(headers.containsKey(ONAPLogConstants.Headers.REQUEST_ID), is(true)); + } + finally { + MDC.clear(); + } + } + + /** + * Test INVOKE, with RequestAdapter. + */ + @Test + public void testInvokeWithAdapterAndNull() throws Exception { + + final Logger logger = LoggerFactory.getLogger(this.getClass()); + final ONAPLogAdapter adapter = new ONAPLogAdapter(logger); + + final Map headers = new HashMap<>(); + final ONAPLogAdapter.RequestBuilder builder = new ONAPLogAdapter.RequestBuilder() { + @Override + public ONAPLogAdapter.RequestBuilder setHeader(final String name, final String value) { + headers.put(name, value); + return this; + } + }; + + try { + final UUID uuid = adapter.invoke(builder); + assertThat(uuid, notNullValue()); + assertThat(headers.get(ONAPLogConstants.Headers.INVOCATION_ID), is(uuid.toString())); + assertThat(headers.containsKey(ONAPLogConstants.Headers.PARTNER_NAME), is(true)); + assertThat(headers.containsKey(ONAPLogConstants.Headers.REQUEST_ID), is(true)); + } + finally { + MDC.clear(); + } + } + + @Test + public void testHttpServletRequestAdapter() { + + final UUID uuid = UUID.randomUUID(); + final MockHttpServletRequest request = new MockHttpServletRequest(); + request.addHeader("uuid", uuid.toString()); + request.setRequestURI("/ctx0"); + request.setServerName("srv0"); + + final ONAPLogAdapter.HttpServletRequestAdapter adapter + = new ONAPLogAdapter.HttpServletRequestAdapter(request); + assertThat(adapter.getHeader("uuid"), is(uuid.toString())); + assertThat(adapter.getRequestURI(), is("/ctx0")); + assertThat(adapter.getServerAddress(), is("srv0")); + } + + @Test + public void testServiceDescriptor() { + final String uuid = UUID.randomUUID().toString(); + + final ONAPLogAdapter.ServiceDescriptor adapter + = new ONAPLogAdapter.ServiceDescriptor(); + adapter.setServiceUUID(uuid); + adapter.setServiceName("name0"); + + assertThat(MDC.get(ONAPLogConstants.MDCs.SERVICE_NAME), nullValue()); + assertThat(MDC.get(ONAPLogConstants.MDCs.INSTANCE_UUID), nullValue()); + + adapter.setMDCs(); + + assertThat(MDC.get(ONAPLogConstants.MDCs.SERVICE_NAME), is("name0")); + assertThat(MDC.get(ONAPLogConstants.MDCs.INSTANCE_UUID), is(uuid)); + } + + @Test + public void testResponseDescriptor() { + final String uuid = UUID.randomUUID().toString(); + + final ONAPLogAdapter.ResponseDescriptor adapter + = new ONAPLogAdapter.ResponseDescriptor(); + adapter.setResponseCode("code0"); + adapter.setResponseDescription("desc0"); + adapter.setResponseSeverity(Level.INFO); + adapter.setResponseStatus(ONAPLogConstants.ResponseStatus.COMPLETED); + + assertThat(MDC.get(ONAPLogConstants.MDCs.RESPONSE_CODE), nullValue()); + assertThat(MDC.get(ONAPLogConstants.MDCs.RESPONSE_DESCRIPTION), nullValue()); + assertThat(MDC.get(ONAPLogConstants.MDCs.RESPONSE_SEVERITY), nullValue()); + assertThat(MDC.get(ONAPLogConstants.MDCs.RESPONSE_STATUS_CODE), nullValue()); + + adapter.setMDCs(); + + assertThat(MDC.get(ONAPLogConstants.MDCs.RESPONSE_CODE), is("code0")); + assertThat(MDC.get(ONAPLogConstants.MDCs.RESPONSE_DESCRIPTION), is("desc0")); + assertThat(MDC.get(ONAPLogConstants.MDCs.RESPONSE_SEVERITY), is("INFO")); + assertThat(MDC.get(ONAPLogConstants.MDCs.RESPONSE_STATUS_CODE), is("COMPLETED")); + } + + /** + * Exercise the contract, for a caller that's happy to have their + * service name automatically derived. (This validates nothing + * and achieves nothing; it's just to provide an example of minimal usage). + */ + @Test + public void testContract() { + + // Note no wrapper around HttpServletRequest, which will work for + // most invocations (since they come via HTTP), but otherwise + // can implement your own RequestAdapter. + + final Logger logger = LoggerFactory.getLogger(this.getClass()); + final ONAPLogAdapter adapter = new ONAPLogAdapter(logger); + final MockHttpServletRequest http = new MockHttpServletRequest(); + + // Immediately log ENTERING marker, with global MDCs. + + adapter.entering(http); + try { + + // Generate (and log) an invocationID, then use it to + // invoke another component. + + final RESTClient client = new RESTClient(); // implements ONAPLogAdapter.RequestBuilder. + adapter.invoke(client, ONAPLogConstants.InvocationMode.SYNCHRONOUS); + final RESTRequest request = null; // TODO: build real request. + final RESTResponse response = client.execute(request); // TODO: handle real response. + + // Set response details prior to #exiting. + // (Obviously there'd be errorhandling, etc. IRL). + + adapter.getResponseDescriptor() + .setResponseCode((String)null) + .setResponseSeverity(Level.INFO) + .setResponseStatus(ONAPLogConstants.ResponseStatus.COMPLETED); + } + finally { + + // Return, logging EXIT marker, with response MDCs. + + adapter.exiting(); + } + } + + /** + * Dummy class, for example code. + */ + static class RESTClient implements ONAPLogAdapter.RequestBuilder { + + @Override + public RESTClient setHeader(final String name, final String value) { + return null; + } + + RESTResponse execute(RESTRequest request) { + return null; + } + } + + /** + * Dummy class, for example code. + */ + static class RESTRequest { + + } + + /** + * Dummy class, for example code. + */ + static class RESTResponse { + + } +} diff --git a/reference/logging-slf4j/src/test/java/org/onap/logging/ref/slf4j/ONAPLogConstantsTest.java b/reference/logging-slf4j/src/test/java/org/onap/logging/ref/slf4j/ONAPLogConstantsTest.java new file mode 100644 index 0000000..f6642f9 --- /dev/null +++ b/reference/logging-slf4j/src/test/java/org/onap/logging/ref/slf4j/ONAPLogConstantsTest.java @@ -0,0 +1,133 @@ +/** + * ============LICENSE_START======================================================= + * org.onap.logging + * ================================================================================ + * Copyright © 2018 Amdocs + * All rights reserved. + * ================================================================================ + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + * ============LICENSE_END========================================================= + */ + +package org.onap.logging.ref.slf4j; + +import java.lang.reflect.Constructor; +import java.lang.reflect.InvocationTargetException; + +import org.testng.Assert; +import org.testng.annotations.Test; + +import static org.hamcrest.MatcherAssert.assertThat; +import static org.hamcrest.core.Is.is; +import static org.hamcrest.core.IsInstanceOf.instanceOf; + +/** + * Tests for {@link ONAPLogConstants}. + */ +public class ONAPLogConstantsTest { + + @Test + public void testConstructors() throws Exception { + assertInaccessibleConstructor(ONAPLogConstants.class); + assertInaccessibleConstructor(ONAPLogConstants.MDCs.class); + assertInaccessibleConstructor(ONAPLogConstants.Markers.class); + assertInaccessibleConstructor(ONAPLogConstants.Headers.class); + } + + @Test + public void testConstructorUnsupported() throws Exception { + try { + Constructor c = ONAPLogConstants.class.getDeclaredConstructors()[0]; + c.setAccessible(true); + c.newInstance(); + Assert.fail("Should fail for hidden constructor."); + } + catch (final InvocationTargetException e) { + assertThat(e.getCause(), instanceOf(UnsupportedOperationException.class)); + } + } + + @Test + public void testHeaders() { + assertThat(ONAPLogConstants.Headers.REQUEST_ID, is("X-ONAP-RequestID")); + assertThat(ONAPLogConstants.Headers.INVOCATION_ID, is("X-ONAP-InvocationID")); + assertThat(ONAPLogConstants.Headers.PARTNER_NAME, is("X-ONAP-PartnerName")); + } + + @Test + public void testMarkers() { + assertThat(ONAPLogConstants.Markers.ENTRY.toString(), is("ENTRY")); + assertThat(ONAPLogConstants.Markers.EXIT.toString(), is("EXIT")); + assertThat(ONAPLogConstants.Markers.INVOKE.toString(), is("INVOKE")); + assertThat(ONAPLogConstants.Markers.INVOKE_ASYNCHRONOUS.toString(), is("INVOKE [ ASYNCHRONOUS ]")); + assertThat(ONAPLogConstants.Markers.INVOKE_SYNCHRONOUS.toString(), is("INVOKE [ SYNCHRONOUS ]")); + } + + @Test + public void testInvocationMode() { + assertThat(ONAPLogConstants.InvocationMode.SYNCHRONOUS.getMarker(), + is(ONAPLogConstants.Markers.INVOKE_SYNCHRONOUS)); + assertThat(ONAPLogConstants.InvocationMode.ASYNCHRONOUS.getMarker(), + is(ONAPLogConstants.Markers.INVOKE_ASYNCHRONOUS)); + } + + @Test + public void testInvocationModeToString() { + assertThat(ONAPLogConstants.InvocationMode.SYNCHRONOUS.toString(), + is("SYNCHRONOUS")); + } + + @Test + public void testResponseStatus() { + assertThat(ONAPLogConstants.ResponseStatus.COMPLETED.toString(), is("COMPLETED")); + assertThat(ONAPLogConstants.ResponseStatus.ERROR.toString(), is("ERROR")); + } + + @Test + public void testMDCs() { + + assertThat(ONAPLogConstants.MDCs.CLIENT_IP_ADDRESS.toString(), is("ClientIPAddress")); + assertThat(ONAPLogConstants.MDCs.SERVER_FQDN.toString(), is("ServerFQDN")); + + assertThat(ONAPLogConstants.MDCs.ENTRY_TIMESTAMP.toString(), is("EntryTimestamp")); + assertThat(ONAPLogConstants.MDCs.INVOKE_TIMESTAMP.toString(), is("InvokeTimestamp")); + + assertThat(ONAPLogConstants.MDCs.REQUEST_ID.toString(), is("RequestID")); + assertThat(ONAPLogConstants.MDCs.INVOCATION_ID.toString(), is("InvocationID")); + assertThat(ONAPLogConstants.MDCs.PARTNER_NAME.toString(), is("PartnerName")); + assertThat(ONAPLogConstants.MDCs.INSTANCE_UUID.toString(), is("InstanceUUID")); + assertThat(ONAPLogConstants.MDCs.SERVICE_NAME.toString(), is("ServiceName")); + assertThat(ONAPLogConstants.MDCs.TARGET_SERVICE_NAME.toString(), is("TargetServiceName")); + + } + + static void assertInaccessibleConstructor(final Class c) throws Exception { + try { + c.getDeclaredConstructors()[0].newInstance(); + Assert.fail("Should fail for hidden constructor."); + } + catch (final IllegalAccessException e) { + + } + + try { + final Constructor constructor = c.getDeclaredConstructors()[0]; + constructor.setAccessible(true); + constructor.newInstance(); + Assert.fail("Should fail even when invoked."); + } + catch (final InvocationTargetException e) { + assertThat(e.getCause(), instanceOf(UnsupportedOperationException.class)); + } + } +} diff --git a/reference/logging-slf4j/src/test/java/testng.xml b/reference/logging-slf4j/src/test/java/testng.xml new file mode 100644 index 0000000..7b31c26 --- /dev/null +++ b/reference/logging-slf4j/src/test/java/testng.xml @@ -0,0 +1,8 @@ + + + + + + + + \ No newline at end of file -- cgit 1.2.3-korg