src/test/java/org/apache/sling/servlets/post/impl/RequestPropertyTest.java

/*
 * Licensed to the Apache Software Foundation (ASF) under one or more
 * contributor license agreements. See the NOTICE file distributed with this
 * work for additional information regarding copyright ownership. The ASF
 * licenses this file to You 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 org.apache.sling.servlets.post.impl;

import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertFalse;
import static org.junit.Assert.assertNull;
import static org.junit.Assert.assertTrue;

import java.util.ArrayList;
import java.util.List;
import java.util.Map;
import java.util.Set;
import java.util.Vector;

import junitx.util.PrivateAccessor;

import org.apache.sling.api.SlingHttpServletRequest;
import org.apache.sling.api.request.RequestParameter;
import org.apache.sling.api.request.RequestParameterMap;
import org.apache.sling.servlets.post.HtmlResponse;
import org.apache.sling.servlets.post.PostResponse;
import org.apache.sling.servlets.post.impl.helper.RequestProperty;
import org.apache.sling.servlets.post.impl.operations.ModifyOperation;
import org.jmock.Expectations;
import org.jmock.Mockery;
import org.jmock.integration.junit4.JMock;
import org.jmock.integration.junit4.JUnit4Mockery;
import org.junit.Test;
import org.junit.runner.RunWith;

/**
 * This is primary a series of tests of the hasValues(), providesValues(), and getStringValues() methods of
 * RequestProperty. It uses the collectContent() method of ModifyOperation to make the test cases more readable.
 */
@RunWith(JMock.class)
public class RequestPropertyTest {

    private Mockery context = new JUnit4Mockery();

    @Test
    public void testSingleValue() throws Throwable {
        Map<String, RequestProperty> props = collectContent(p("./param", "true"));

        assertEquals(1, props.size());
        assertTrue(props.get("/test/path/param").hasValues());
        assertTrue(props.get("/test/path/param").providesValue());
        assertEquals(1, props.get("/test/path/param").getStringValues().length);
        assertEquals("true", props.get("/test/path/param").getStringValues()[0]);
    }

    @Test
    public void testSingleValueWithBlank() throws Throwable {
        Map<String, RequestProperty> props = collectContent(p("./param", ""));

        assertEquals(1, props.size());
        RequestProperty prop = props.get("/test/path/param");
        assertTrue(prop.hasValues());
        assertFalse(prop.providesValue());
        assertEquals(1, prop.getStringValues().length);
        assertEquals("", prop.getStringValues()[0]);
    }

    @Test
    public void testNullSingleValueWithDefaultToIgnore() throws Throwable {
        Map<String, RequestProperty> props = collectContent(p("./param@DefaultValue", ":ignore"));

        assertEquals(1, props.size());
        RequestProperty prop = props.get("/test/path/param");
        assertFalse(prop.hasValues());
    }

    @Test
    public void testSingleValueWithDefaultToIgnore() throws Throwable {
        Map<String, RequestProperty> props = collectContent(p("./param", ""), p("./param@DefaultValue", ":ignore"));

        assertEquals(1, props.size());
        RequestProperty prop = props.get("/test/path/param");
        assertTrue(prop.hasValues());
        assertFalse(prop.providesValue());
        assertEquals(0, prop.getStringValues().length);
    }

    @Test
    public void testSingleValueWithDefaultToNull() throws Throwable {
        Map<String, RequestProperty> props = collectContent(p("./param", ""), p("./param@DefaultValue", ":null"));

        assertEquals(1, props.size());
        RequestProperty prop = props.get("/test/path/param");
        assertTrue(prop.hasValues());
        assertTrue(prop.providesValue());
        assertNull(prop.getStringValues());
    }

    @Test
    public void testSingleValueIgnoringBlanks() throws Throwable {
        Map<String, RequestProperty> props = collectContent(p("./param", ""), p("./param@IgnoreBlanks", "true"));

        assertEquals(1, props.size());
        RequestProperty prop = props.get("/test/path/param");
        assertFalse(prop.hasValues());
    }

    @Test
    public void testMultiValue() throws Throwable {
        Map<String, RequestProperty> props = collectContent(p("./param", "true", "false"));

        assertEquals(1, props.size());
        RequestProperty prop = props.get("/test/path/param");
        assertTrue(prop.hasValues());
        assertTrue(prop.providesValue());
        assertEquals(2, prop.getStringValues().length);
        assertEquals("true", prop.getStringValues()[0]);
        assertEquals("false", prop.getStringValues()[1]);
    }

    @Test
    public void testMultiValueWithBlank() throws Throwable {
        Map<String, RequestProperty> props = collectContent(p("./param", "true", ""));

        assertEquals(1, props.size());
        RequestProperty prop = props.get("/test/path/param");
        assertTrue(prop.hasValues());
        assertTrue(prop.providesValue());
        assertEquals(2, prop.getStringValues().length);
        assertEquals("true", prop.getStringValues()[0]);
        assertEquals("", prop.getStringValues()[1]);
    }

    @Test
    public void testMultiValueWithBlanks() throws Throwable {
        Map<String, RequestProperty> props = collectContent(p("./param", "true", "", ""));

        assertEquals(1, props.size());
        RequestProperty prop = props.get("/test/path/param");
        assertTrue(prop.hasValues());
        assertTrue(prop.providesValue());
        assertEquals(3, prop.getStringValues().length);
        assertEquals("true", prop.getStringValues()[0]);
        assertEquals("", prop.getStringValues()[1]);
        assertEquals("", prop.getStringValues()[2]);
    }

    @Test
    public void testMultiValueWithAllBlanks() throws Throwable {
        Map<String, RequestProperty> props = collectContent(p("./param", "", "", ""));

        assertEquals(1, props.size());
        RequestProperty prop = props.get("/test/path/param");
        assertTrue(prop.hasValues());
        assertFalse(prop.providesValue());
        assertEquals(3, prop.getStringValues().length);
        assertEquals("", prop.getStringValues()[0]);
        assertEquals("", prop.getStringValues()[1]);
        assertEquals("", prop.getStringValues()[2]);
    }

    @Test
    public void testMultiValueWithBlankIgnoringBlanks() throws Throwable {
        Map<String, RequestProperty> props = collectContent(p("./param", "true", ""));

        assertEquals(1, props.size());
        RequestProperty prop = props.get("/test/path/param");
        assertTrue(prop.hasValues());
        assertTrue(prop.providesValue());
        assertEquals(2, prop.getStringValues().length);
        assertEquals("true", prop.getStringValues()[0]);
        assertEquals("", prop.getStringValues()[1]);
    }

    @Test
    public void testMultiValueWithBlanksIgnoringBlanks() throws Throwable {
        Map<String, RequestProperty> props = collectContent(p("./param", "true", "", ""), p("./param@IgnoreBlanks", "true"));

        assertEquals(1, props.size());
        RequestProperty prop = props.get("/test/path/param");
        assertTrue(prop.hasValues());
        assertTrue(prop.providesValue());
        assertEquals(1, prop.getStringValues().length);
        assertEquals("true", prop.getStringValues()[0]);
    }

    @Test
    public void testMultiValueWithAllBlanksIgnoringBlanks() throws Throwable {
        Map<String, RequestProperty> props = collectContent(p("./param", "", "", ""), p("./param@IgnoreBlanks", "true"));

        assertEquals(1, props.size());
        RequestProperty prop = props.get("/test/path/param");
        assertFalse(prop.hasValues());
    }

    private static final Class[] COLLECT_CLASSES = new Class[] { SlingHttpServletRequest.class, PostResponse.class };

    private class Param {
        String key;
        String[] value;
    }

    private Param p(String key, String... value) {
        Param kv = new Param();
        kv.key = key;
        kv.value = value;
        return kv;
    }

    @SuppressWarnings("unchecked")
    private Map<String, RequestProperty> collectContent(Param... kvs) throws Throwable {
        final List<Map.Entry<String, RequestParameter>> params = new ArrayList<Map.Entry<String, RequestParameter>>();
        for (int i = 0; i < kvs.length; i++) {
            final Param kv = kvs[i];
            final RequestParameter[] param = new RequestParameter[kv.value.length];
            for (int j = 0; j < kv.value.length; j++) {
                final String strValue = kv.value[j];
                final RequestParameter aparam = context.mock(RequestParameter.class, "requestParameter" + i + "#" + j);
                context.checking(new Expectations() {
                    {
                        allowing(aparam).getString();
                        will(returnValue(strValue));
                    }
                });
                param[j] = aparam;
            }
            final Map.Entry<String, RequestParameter> entry = context.mock(Map.Entry.class, "entry" + i);
            context.checking(new Expectations() {
                {
                    allowing(entry).getKey();
                    will(returnValue(kv.key));
                    allowing(entry).getValue();
                    will(returnValue(param));

                }
            });
            params.add(entry);
        }

        final Set set = context.mock(Set.class);
        context.checking(new Expectations() {
            {
                one(set).iterator();
                will(returnValue(params.iterator()));
            }
        });

        final RequestParameterMap map = context.mock(RequestParameterMap.class);
        context.checking(new Expectations() {
            {
                one(map).entrySet();
                will(returnValue(set));

            }
        });

        final SlingHttpServletRequest request = context.mock(SlingHttpServletRequest.class);
        context.checking(new Expectations() {
            {
                Vector names = new Vector();
                names.add("./param");

                one(request).getParameterNames();
                will(returnValue(names.elements()));
                one(request).getRequestParameterMap();
                will(returnValue(map));

            }
        });
        final HtmlResponse response = new HtmlResponse();
        response.setPath("/test/path");

        Map<String, RequestProperty> props = (Map<String, RequestProperty>) PrivateAccessor.invoke(
            new ModifyOperation(), "collectContent", COLLECT_CLASSES,
            new Object[] { request, response });
        return props;
    }
}