[so/libs.git] /

/*-
 * ============LICENSE_START=======================================================
 * ONAP - SO
 * ================================================================================
 * Copyright (C) 2018 AT&T Intellectual Property. 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 com.woorea.openstack.connector;

import static org.junit.Assert.assertTrue;
import static org.mockito.Matchers.any;
import static org.mockito.Mockito.doCallRealMethod;
import static org.mockito.Mockito.mock;
import static org.mockito.Mockito.when;

import java.io.ByteArrayInputStream;
import java.io.IOException;
import java.io.OutputStream;
import java.lang.reflect.Method;
import java.net.URI;
import java.util.Arrays;
import java.util.HashMap;
import java.util.List;
import java.util.logging.ConsoleHandler;
import java.util.logging.Level;
import java.util.logging.LogRecord;
import java.util.logging.Logger;
import java.util.logging.SimpleFormatter;

import javax.ws.rs.core.MultivaluedMap;

import org.junit.Before;
import org.junit.BeforeClass;
import org.junit.Test;
import org.mockito.invocation.InvocationOnMock;
import org.mockito.stubbing.Answer;

import com.sun.jersey.api.client.ClientHandler;
import com.sun.jersey.api.client.ClientRequest;
import com.sun.jersey.api.client.ClientRequestAdapter;
import com.sun.jersey.api.client.ClientResponse;
import com.sun.jersey.api.client.filter.ClientFilter;

public class JerseyLoggingFilterTest {

        private static Logger logger;
        private static LogFormatter logFormatter;
        
        @BeforeClass
        public static void setUpClass() throws Exception {
                logger = Logger.getLogger(JerseyLoggingFilterTest.class.getSimpleName());
                logger.setLevel(Level.ALL);
                logger.setUseParentHandlers(false);

                ConsoleHandler handler = new ConsoleHandler();
                logFormatter = new LogFormatter();
                handler.setFormatter(logFormatter);
                handler.setLevel(Level.ALL);
                logger.addHandler(handler);
        }

        @Before
        public void setUpTest() {
                logFormatter.clearLog();
        }
        
        /**
         * Tests a scenario with no request content (GET).
         * @throws Exception for unexpected errors
         */
        @Test
        public void testGET() throws Exception {
                String responseContent = "<response>Hello, I am Eliza.</response>";
                execute("GET", "http://www.onap.org/eliza", null, responseContent);
        }
        
        /**
         * Tests a scenario with request content (POST).
         * @throws Exception for unexpected errors
         */
        @Test
        public void testPOST() throws Exception {
                String requestContent = "<request>I feel sad.</request>";
                String responseContent = "<response>Do you often feel sad?</response>";
                execute("POST", "http://www.onap.org/eliza", requestContent, responseContent);
        }

        /**
         * Runs a single test.
         * @param httpMethod any HTTP method (POST, GET, ...)
         * @param url any URL
         * @param requestContent mock request content, possibly null
         * @param responseContent mock response content, never null
         * @throws Exception for unexpected errors
         */
        private void execute(String httpMethod, String url, String requestContent, String responseContent)
                        throws Exception {
                JerseyLoggingFilter loggingFilter = new JerseyLoggingFilter(logger);

                // Mock multi-valued and single valued request headers

                HashMap<String, List<Object>> requestHeaderMap = new HashMap<>();
                requestHeaderMap.put("Accept", Arrays.asList(new Object[]{"application/xml","application/json"}));

                if (requestContent != null) {
                        requestHeaderMap.put("Content-Type", Arrays.asList(new Object[]{"application/xml"}));
                        requestHeaderMap.put("Content-Length", Arrays.asList(new Object[]{String.valueOf(requestContent.length())}));
                }

                @SuppressWarnings("unchecked")
                MultivaluedMap<String, Object> requestHeaders = mock(MultivaluedMap.class);
                when(requestHeaders.entrySet()).thenReturn(requestHeaderMap.entrySet());

                // Mock the request object

                ClientRequest request = mock(TestClientRequest.class);
                when(request.getURI()).thenReturn(new URI(url));
                when(request.getMethod()).thenReturn(httpMethod);
                when(request.getHeaders()).thenReturn(requestHeaders);

                if (requestContent != null) {
                        when(request.getEntity()).thenReturn(requestContent.getBytes("UTF-8"));
                }

                doCallRealMethod().when(request).setAdapter(any(ClientRequestAdapter.class));
                when(request.getAdapter()).thenCallRealMethod();
                request.setAdapter(new DefaultClientRequestAdapter());

                // Mock multi-valued and single valued response headers

                HashMap<String, List<String>> responseHeaderMap = new HashMap<>();
                responseHeaderMap.put("Cache-Control", Arrays.asList(new String[]{"no-cache","no-store"}));
                responseHeaderMap.put("Content-Type", Arrays.asList(new String[]{"application/xml"}));
                responseHeaderMap.put("Content-Length", Arrays.asList(new String[]{String.valueOf(responseContent.length())}));
                @SuppressWarnings("unchecked")
                MultivaluedMap<String, String> responseHeaders = mock(MultivaluedMap.class);
                when(responseHeaders.entrySet()).thenReturn(responseHeaderMap.entrySet());

                // Mock the response object

                ClientResponse response = mock(ClientResponse.class);
                when(response.getStatus()).thenReturn(200);
                when(response.getHeaders()).thenReturn(responseHeaders);
                when(response.getEntityInputStream()).thenReturn(
                                new ByteArrayInputStream(responseContent.getBytes("UTF-8")));

                // Mock a handler that returns the response object and set
                // it to be the next filter after the logging filter.

                ClientFilter handler = mock(ClientFilter.class);
                when(handler.handle(request)).then(produceResponse(response));
                Method setNext = ClientFilter.class.getDeclaredMethod("setNext", new Class<?>[]{ClientHandler.class});
                setNext.setAccessible(true);
                setNext.invoke(loggingFilter, new Object[]{handler});

                // Run the request into the logging filter

                loggingFilter.handle(request);

                // Validate resulting the log content

                String log = logFormatter.getLog();

                assertContains(log, "* Client out-bound request");
                assertContains(log, "> " + httpMethod + " " + url);

                for (String header : requestHeaderMap.keySet()) {
                        assertContains(log, "> " + header + ": ");
                }

                if (requestContent != null) {
                        assertContains(log, requestContent);
                }

                assertContains(log, "* Client in-bound response");
                assertContains(log, "< 200");

                for (String header : responseHeaderMap.keySet()) {
                        assertContains(log, "< " + header + ": ");
                }

                assertContains(log, responseContent);
        }
        
        private void assertContains(String log, String expect) {
                assertTrue("Log does not contain '" + expect + "'", log.contains(expect));
        }

        private class DefaultClientRequestAdapter implements ClientRequestAdapter {
                @Override
                public OutputStream adapt(ClientRequest request, OutputStream out) throws IOException {
                        return out;
                }
        }

        private abstract class TestClientRequest extends ClientRequest {
                private ClientRequestAdapter adapter;

                @Override
                public ClientRequestAdapter getAdapter() {
                        return adapter;
                }

                @Override
                public void setAdapter(ClientRequestAdapter adapter) {
                        this.adapter = adapter;
                }
        }
        
        private Answer<ClientResponse> produceResponse(final ClientResponse response) { 
                return new Answer<ClientResponse>() {
                        public ClientResponse answer(InvocationOnMock invocation) throws IOException {
                                ClientRequest request = (ClientRequest) invocation.getArguments()[0];
                                byte[] entity = (byte[]) request.getEntity();

                                if (entity != null) {
                                        ClientRequestAdapter adapter = request.getAdapter();
        
                                        OutputStream nullOutputStream = new OutputStream() {
                                                @Override
                                                public void write(int b) {
                                                        // Discard
                                                }
                                        };

                                        OutputStream outputStream = adapter.adapt(request, nullOutputStream);
                                        outputStream.write(entity);
                                        outputStream.close();
                                }

                                return response;
                        }
                };
        }

        private static class LogFormatter extends SimpleFormatter {
                StringBuilder buffer = new StringBuilder();

                public synchronized String getLog() {
                        return buffer.toString();
                }

                public synchronized void clearLog() {
                        buffer.setLength(0);
                }

                @Override
                public synchronized String format(LogRecord record) {
                        String logData = super.format(record);
                        buffer.append(logData);
                        return logData;
                }
        }
}