ControllerOperationCollectionAspectTest.java

/**
 * Copyright (c) 2009-2011 VMware, Inc. 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.
 */

package com.springsource.insight.plugin.springweb.controller;

import java.util.Collections;
import java.util.Map;

import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;

import org.junit.Test;
import org.springframework.stereotype.Controller;
import org.springframework.ui.ExtendedModelMap;
import org.springframework.ui.Model;
import org.springframework.ui.ModelMap;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.servlet.ModelAndView;
import org.springframework.web.servlet.View;

import com.springsource.insight.intercept.operation.Operation;
import com.springsource.insight.intercept.operation.OperationMap;

public class ControllerOperationCollectionAspectTest extends AbstractControllerOperationCollectionAspectTestSupport {
    public ControllerOperationCollectionAspectTest() {
        super(false);
    }

    @Test
    public void testControllerMonitored() {
        ExampleController testController = new ExampleController();
        testController.example();

        Operation op = assertControllerOperation();
        assertNullValue(ControllerOperationCollector.RETURN_VALUE_MODEL_MAP, op.get(ControllerOperationCollector.RETURN_VALUE_MODEL_MAP, OperationMap.class));
        assertNullValue(ControllerOperationCollectionAspect.MODEL_ARGUMENT_NAME, op.get(ControllerOperationCollectionAspect.MODEL_ARGUMENT_NAME, OperationMap.class));
    }

    @Test
    public void testReturnModelValue() {
        ExampleController controller = createTestExampleController("testReturnModelValue");
        controller.returnModelValue();
        assertEncodeReturnModelValues(controller);
    }

    @Test
    public void testReturnModelMapValue() {
        ExampleController controller = createTestExampleController("testReturnModelMapValue");
        controller.returnModelMapValue();
        assertEncodeReturnModelValues(controller);
    }

    @Test
    public void testReturnModelAndViewValue() {
        ExampleController controller = createTestExampleController("testReturnModelAndViewValue");
        controller.returnModelAndViewValue();

        Operation op = assertEncodeReturnModelValues(controller);
        assertControllerView(op, controller);
    }

    @Test
    public void testReturnMapValue() {
        ExampleController controller = createTestExampleController("testReturnMapValue");
        controller.returnMapValue();
        assertEncodeReturnModelValues(controller);
    }

    @Test
    public void testWithModelArgument() {
        ExampleController controller = createTestExampleController("testWithModelArgument");
        Map<String, ?> argModel = createTestArgumentModelMap("testWithModelArgument");
        controller.withModelArgument(new ExtendedModelMap().addAllAttributes(argModel));
        assertEncodeModelArgValues(argModel);
    }

    @Test
    public void testWithModelMapArgument() {
        ExampleController controller = createTestExampleController("testWithModelMapArgument");
        Map<String, ?> argModel = createTestArgumentModelMap("testWithModelMapArgument");
        controller.withModelMapArgument(new ModelMap().addAllAttributes(argModel));
        assertEncodeModelArgValues(argModel);
    }

    @Test
    public void testWithSimpleMapArgument() {
        ExampleController controller = createTestExampleController("testWithSimpleMapArgument");
        Map<String, ?> argModel = createTestArgumentModelMap("testWithSimpleMapArgument");
        controller.withSimpleMapArgument(argModel);
        assertEncodeModelArgValues(argModel);
    }

    @Test
    public void testReturnModelAndViewValueWithModelArgument() {
        ExampleController controller = createTestExampleController("testReturnModelAndViewValue");
        Map<String, ?> argModel = createTestArgumentModelMap("testReturnModelAndViewValue");
        controller.returnModelAndViewValueWithModelArgument(new ExtendedModelMap().addAllAttributes(argModel));

        Operation op = assertEncodeReturnModelValues(controller);
        assertEncodeModelArgValues(op, argModel);
        assertControllerView(op, controller);
    }

    @Test
    public void testReturnView() {
        ExampleController controller = createTestExampleController("testReturnView");
        View view = controller.returnView();
        assertControllerView(view.getClass().getSimpleName());
    }

    @Test
    public void testReturnViewName() {
        ExampleController controller = createTestExampleController("testReturnViewName");
        assertControllerView(controller.returnViewName());
    }

    private ExampleController createTestExampleController(final String testName) {
        return new ExampleController(createTestReturnModelMap(testName), testName);
    }

    private Map<String, Object> createTestArgumentModelMap(final String testName) {
        return createTestModelMap(testName + "[" + ControllerOperationCollectionAspect.MODEL_ARGUMENT_NAME + "]");
    }

    private Map<String, Object> createTestReturnModelMap(final String testName) {
        return createTestModelMap(testName + "[" + ControllerOperationCollector.RETURN_VALUE_MODEL_MAP + "]");
    }

    private static String assertControllerView(Operation op, ExampleController controller) {
        return assertControllerView(op, controller.returnView);
    }

    private Operation assertEncodeModelArgValues(Map<String, ?> argModel) {
        Operation op = getLastEntered();
        assertNotNull("No operation entered", op);
        assertEncodeModelArgValues(op, argModel);
        return op;
    }

    private OperationMap assertEncodeModelArgValues(Operation op, Map<String, ?> argModel) {
        return assertEncodeModelValues(op, ControllerOperationCollectionAspect.MODEL_ARGUMENT_NAME, argModel);
    }

    @Override
    public ControllerOperationCollectionAspect getAspect() {
        return ControllerOperationCollectionAspect.aspectOf();
    }

    @Controller
    static class ExampleController extends TestSupportController {
        ExampleController() {
            this(Collections.<String, Object>emptyMap());
        }

        ExampleController(Map<String, ?> outgoingModel) {
            this(outgoingModel, "");
        }

        ExampleController(Map<String, ?> outgoingModel, String outgoingView) {
            super(outgoingModel, outgoingView);
        }

        @RequestMapping(value = "/example")
        public void example() {
            // do nothing
        }

        @RequestMapping(value = "/returnModel")
        public Model returnModelValue() {
            return new ExtendedModelMap().addAllAttributes(returnModel);
        }

        @RequestMapping(value = "/returnModelMapValue")
        public ModelMap returnModelMapValue() {
            return new ModelMap().addAllAttributes(returnModel);
        }

        @RequestMapping(value = "/returnModelAndViewValue")
        public ModelAndView returnModelAndViewValue() {
            return new ModelAndView(returnView, returnModel);
        }

        @RequestMapping(value = "/returnModelAndViewValueWithModelArgument")
        public ModelAndView returnModelAndViewValueWithModelArgument(Model model) {
            assertNotNull("Missing model value", model);
            return new ModelAndView(returnView, returnModel);
        }

        @RequestMapping(value = "/returnMapValue")
        public Map<String, ?> returnMapValue() {
            return returnModel;
        }

        @RequestMapping(value = "/withModelArgument")
        public void withModelArgument(Model model) {
            assertNotNull("Missing model value", model);
        }

        @RequestMapping(value = "/withModelMapArgument")
        public void withModelMapArgument(ModelMap model) {
            assertNotNull("Missing model value", model);
        }

        @RequestMapping(value = "/withSimpleMapArgument")
        public void withSimpleMapArgument(Map<String, ?> model) {
            assertNotNull("Missing model value", model);
        }

        @RequestMapping(value = "/returnView")
        public View returnView() {
            return new ExampleView("java/x-class");
        }

        @RequestMapping(value = "/returnViewName")
        public String returnViewName() {
            return returnView;
        }
    }

    static class ExampleView implements View {
        final String contentType;

        ExampleView() {
            this("");
        }

        ExampleView(String ct) {
            contentType = ct;
        }

        public String getContentType() {
            return contentType;
        }

        public void render(Map<String, ?> model, HttpServletRequest request, HttpServletResponse response) throws Exception {
            assertNotNull("No model", model);
            assertNotNull("No request", request);
            assertNotNull("No response", response);
        }
    }
}