/**
* Licensed to Apereo under one or more contributor license agreements. See the NOTICE file
* distributed with this work for additional information regarding copyright ownership. Apereo
* 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 the
* following location:
*
* <p>http://www.apache.org/licenses/LICENSE-2.0
*
* <p>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.apereo.portal.portlet.container.services;
import static junit.framework.Assert.assertEquals;
import static junit.framework.Assert.assertFalse;
import static junit.framework.Assert.assertNotNull;
import static junit.framework.Assert.assertNull;
import static junit.framework.Assert.assertTrue;
import static org.junit.Assert.assertArrayEquals;
import com.google.common.collect.ImmutableList;
import com.google.common.collect.ImmutableMap;
import com.google.common.collect.ImmutableSet;
import java.io.IOException;
import java.util.Collections;
import java.util.Enumeration;
import java.util.HashSet;
import java.util.LinkedHashMap;
import java.util.Map;
import javax.portlet.ReadOnlyException;
import javax.portlet.ValidatorException;
import org.apache.commons.collections.EnumerationUtils;
import org.apereo.portal.portlet.dao.jpa.PortletPreferenceImpl;
import org.apereo.portal.portlet.om.IPortletPreference;
import org.apereo.portal.url.ParameterMap;
import org.junit.Before;
import org.junit.Test;
public class AbstractPortletPreferencesImplTest {
private Map<String, IPortletPreference> targetPrefs =
new LinkedHashMap<String, IPortletPreference>();
private Map<String, IPortletPreference> basePrefs =
new LinkedHashMap<String, IPortletPreference>();
private Map<String, IPortletPreference> storedPrefs = Collections.emptyMap();
private boolean modified = true;
private AbstractPortletPreferencesImpl<Object> portletPreferences;
@Before
public void setup() {
targetPrefs = new LinkedHashMap<String, IPortletPreference>();
basePrefs = new LinkedHashMap<String, IPortletPreference>();
storedPrefs = Collections.emptyMap();
modified = true;
portletPreferences =
new AbstractPortletPreferencesImpl<Object>(false) {
@Override
protected Object getLogDescription() {
return "TEST";
}
@Override
protected void loadTargetPortletPreferences(
Object initContext,
Map<String, IPortletPreference> targetPortletPreferences) {
targetPortletPreferences.putAll(targetPrefs);
}
@Override
protected void loadBasePortletPreferences(
Object initContext,
Map<String, IPortletPreference> basePortletPreferences) {
basePortletPreferences.putAll(basePrefs);
}
@Override
protected boolean storeInternal() throws IOException, ValidatorException {
final Map<String, IPortletPreference> targetPortletPreferences =
this.getTargetPortletPreferences();
storedPrefs = ImmutableMap.copyOf(targetPortletPreferences);
return modified;
}
};
}
protected void addPref(
Map<String, IPortletPreference> prefs, String name, boolean readOnly, String[] values) {
final PortletPreferenceImpl preference = new PortletPreferenceImpl(name, readOnly);
preference.setValues(values);
prefs.put(name, preference);
}
@Test(expected = IllegalArgumentException.class)
public void testIsReadOnlyNullKey() throws ReadOnlyException, ValidatorException, IOException {
portletPreferences.isReadOnly((String) null);
}
@Test
public void testIsReadOnly() throws ReadOnlyException, ValidatorException, IOException {
addPref(basePrefs, "key1", true, new String[] {"default"});
addPref(basePrefs, "key2", false, new String[] {"default"});
boolean readOnly = portletPreferences.isReadOnly("key1");
assertTrue(readOnly);
readOnly = portletPreferences.isReadOnly("key2");
assertFalse(readOnly);
readOnly = portletPreferences.isReadOnly("key3");
assertFalse(readOnly);
}
@Test(expected = IllegalArgumentException.class)
public void testNullGetValueKey() throws ReadOnlyException {
portletPreferences.getValue(null, null);
}
@Test(expected = IllegalArgumentException.class)
public void testNullGetValuesKey() throws ReadOnlyException {
portletPreferences.getValues(null, null);
}
@Test
public void testGetValue() throws ReadOnlyException, ValidatorException, IOException {
addPref(basePrefs, "key1", false, null);
addPref(basePrefs, "key2", false, new String[] {});
addPref(basePrefs, "key3", false, new String[] {null});
addPref(basePrefs, "key4", false, new String[] {"value1", "value2"});
String value = portletPreferences.getValue("key0", "FOOBAR");
assertEquals("FOOBAR", value);
// Next 3 asserts check whether null values are treated like non-existent values as specified in
// PortletPreferences#getValue(String, String)
value = portletPreferences.getValue("key1", "FOOBAR");
assertEquals("FOOBAR", value);
value = portletPreferences.getValue("key2", "FOOBAR");
assertEquals("FOOBAR", value);
value = portletPreferences.getValue("key3", "FOOBAR");
assertNull(value);
value = portletPreferences.getValue("key4", "FOOBAR");
assertEquals("value1", value);
value = portletPreferences.getValue("key1", null);
assertNull(value);
value = portletPreferences.getValue("key2", null);
assertNull(value);
value = portletPreferences.getValue("key3", null);
assertNull(value);
}
@Test
public void testGetValues() throws ReadOnlyException, ValidatorException, IOException {
addPref(basePrefs, "key1", false, null);
addPref(basePrefs, "key2", false, new String[] {});
addPref(basePrefs, "key3", false, new String[] {null});
addPref(basePrefs, "key4", false, new String[] {"value1", "value2"});
String[] values = portletPreferences.getValues("key0", new String[] {"FOOBAR"});
assertArrayEquals(new String[] {"FOOBAR"}, values);
values = portletPreferences.getValues("key1", new String[] {"FOOBAR"});
assertNull(values);
values = portletPreferences.getValues("key2", new String[] {"FOOBAR"});
assertArrayEquals(new String[] {}, values);
values = portletPreferences.getValues("key3", new String[] {"FOOBAR"});
assertArrayEquals(new String[] {null}, values);
values = portletPreferences.getValues("key4", new String[] {"FOOBAR"});
assertArrayEquals(new String[] {"value1", "value2"}, values);
}
@Test(expected = IllegalArgumentException.class)
public void testNullSetValueKey() throws ReadOnlyException {
portletPreferences.setValue(null, null);
}
@Test(expected = IllegalArgumentException.class)
public void testNullSetValuesKey() throws ReadOnlyException {
portletPreferences.setValues(null, null);
}
@Test
public void testNullSetValueValue() throws ReadOnlyException, ValidatorException, IOException {
portletPreferences.setValue("key", null);
portletPreferences.store();
assertEquals(1, this.storedPrefs.size());
final IPortletPreference pref = this.storedPrefs.get("key");
assertNotNull(pref);
assertEquals("key", pref.getName());
assertArrayEquals(new String[] {null}, pref.getValues());
assertFalse(pref.isReadOnly());
}
@Test
public void testNullSetValueValues() throws ReadOnlyException, ValidatorException, IOException {
portletPreferences.setValues("key", null);
portletPreferences.store();
assertEquals(1, this.storedPrefs.size());
final IPortletPreference pref = this.storedPrefs.get("key");
assertNotNull(pref);
assertEquals("key", pref.getName());
assertNull(pref.getValues());
assertFalse(pref.isReadOnly());
}
@Test
public void testNullEntryInValues() throws ReadOnlyException, ValidatorException, IOException {
portletPreferences.setValues("key", new String[] {null});
portletPreferences.store();
assertEquals(1, this.storedPrefs.size());
final IPortletPreference pref = this.storedPrefs.get("key");
assertNotNull(pref);
assertEquals("key", pref.getName());
assertArrayEquals(new String[] {null}, pref.getValues());
assertFalse(pref.isReadOnly());
}
@Test(expected = ReadOnlyException.class)
public void testSetReadOnlyValue() throws ReadOnlyException, ValidatorException, IOException {
addPref(basePrefs, "key", true, new String[] {"default"});
//Set a modified value
portletPreferences.setValue("key", "modified");
}
@Test(expected = ReadOnlyException.class)
public void testSetReadOnlyValues() throws ReadOnlyException, ValidatorException, IOException {
addPref(basePrefs, "key", true, new String[] {"default"});
//Set a modified value
portletPreferences.setValues("key", new String[] {"modified"});
}
@Test
public void testSetMatchesBase() throws ReadOnlyException, ValidatorException, IOException {
addPref(basePrefs, "key", false, new String[] {"default"});
//Set a modified value
portletPreferences.setValues("key", new String[] {"modified"});
//Initial store, check that correct stored map is created
portletPreferences.store();
//Actually "store" the stored prefs
this.targetPrefs = new LinkedHashMap<String, IPortletPreference>(this.storedPrefs);
assertEquals(1, this.storedPrefs.size());
IPortletPreference pref = this.storedPrefs.get("key");
assertNotNull(pref);
assertEquals("key", pref.getName());
assertArrayEquals(new String[] {"modified"}, pref.getValues());
assertFalse(pref.isReadOnly());
//Set the default value
portletPreferences.setValues("key", new String[] {"default"});
//Store again, should have nothing stored after this
portletPreferences.store();
assertEquals(0, this.storedPrefs.size());
}
@Test
public void testSetUpdateExisting() throws ReadOnlyException, ValidatorException, IOException {
addPref(basePrefs, "key", false, new String[] {"default"});
//Set a modified value
portletPreferences.setValues("key", new String[] {"modified"});
//Initial store, check that correct stored map is created
portletPreferences.store();
//Actually "store" the stored prefs
this.targetPrefs = new LinkedHashMap<String, IPortletPreference>(this.storedPrefs);
assertEquals(1, this.storedPrefs.size());
IPortletPreference pref = this.storedPrefs.get("key");
assertNotNull(pref);
assertEquals("key", pref.getName());
assertArrayEquals(new String[] {"modified"}, pref.getValues());
assertFalse(pref.isReadOnly());
//Set a modified value
portletPreferences.setValues("key", null);
//Initial store, check that correct stored map is created
portletPreferences.store();
//Actually "store" the stored prefs
this.targetPrefs = new LinkedHashMap<String, IPortletPreference>(this.storedPrefs);
assertEquals(1, this.storedPrefs.size());
pref = this.storedPrefs.get("key");
assertNotNull(pref);
assertEquals("key", pref.getName());
assertArrayEquals(null, pref.getValues());
assertFalse(pref.isReadOnly());
}
@Test
public void testGetNames() throws ReadOnlyException, ValidatorException, IOException {
addPref(basePrefs, "key", false, new String[] {"default"});
addPref(basePrefs, "key1", false, new String[] {"default"});
Enumeration<String> names = portletPreferences.getNames();
assertEquals(
ImmutableSet.of("key", "key1"),
new HashSet<String>(EnumerationUtils.toList(names)));
//Set a modified value
portletPreferences.setValues("key", new String[] {"modified"});
portletPreferences.setValues("key3", new String[] {"modified"});
names = portletPreferences.getNames();
assertEquals(
ImmutableSet.of("key", "key1", "key3"),
new HashSet<String>(EnumerationUtils.toList(names)));
//Initial store, check that correct stored map is created
portletPreferences.store();
//Actually "store" the stored prefs
this.targetPrefs = new LinkedHashMap<String, IPortletPreference>(this.storedPrefs);
names = portletPreferences.getNames();
assertEquals(
ImmutableSet.of("key", "key1", "key3"),
new HashSet<String>(EnumerationUtils.toList(names)));
portletPreferences.reset("key3");
names = portletPreferences.getNames();
assertEquals(
ImmutableSet.of("key", "key1"),
new HashSet<String>(EnumerationUtils.toList(names)));
//Initial store, check that correct stored map is created
portletPreferences.store();
//Actually "store" the stored prefs
this.targetPrefs = new LinkedHashMap<String, IPortletPreference>(this.storedPrefs);
names = portletPreferences.getNames();
assertEquals(
ImmutableSet.of("key", "key1"),
new HashSet<String>(EnumerationUtils.toList(names)));
}
@Test
public void testGetMap() throws ReadOnlyException, ValidatorException, IOException {
addPref(basePrefs, "key", false, new String[] {"default"});
addPref(basePrefs, "key1", false, new String[] {"default"});
Map<String, String[]> map = portletPreferences.getMap();
assertEquals(
ImmutableMap.of(
"key", ImmutableList.of("default"), "key1", ImmutableList.of("default")),
ParameterMap.convertArrayMap(map));
//Set a modified value
portletPreferences.setValues("key", new String[] {"modified"});
portletPreferences.setValues("key3", new String[] {"modified"});
map = portletPreferences.getMap();
assertEquals(
ImmutableMap.of(
"key",
ImmutableList.of("modified"),
"key1",
ImmutableList.of("default"),
"key3",
ImmutableList.of("modified")),
ParameterMap.convertArrayMap(map));
//Initial store, check that correct stored map is created
portletPreferences.store();
//Actually "store" the stored prefs
this.targetPrefs = new LinkedHashMap<String, IPortletPreference>(this.storedPrefs);
map = portletPreferences.getMap();
assertEquals(
ImmutableMap.of(
"key",
ImmutableList.of("modified"),
"key1",
ImmutableList.of("default"),
"key3",
ImmutableList.of("modified")),
ParameterMap.convertArrayMap(map));
portletPreferences.reset("key3");
map = portletPreferences.getMap();
assertEquals(
ImmutableMap.of(
"key", ImmutableList.of("modified"), "key1", ImmutableList.of("default")),
ParameterMap.convertArrayMap(map));
//Initial store, check that correct stored map is created
portletPreferences.store();
//Actually "store" the stored prefs
this.targetPrefs = new LinkedHashMap<String, IPortletPreference>(this.storedPrefs);
map = portletPreferences.getMap();
assertEquals(
ImmutableMap.of(
"key", ImmutableList.of("modified"), "key1", ImmutableList.of("default")),
ParameterMap.convertArrayMap(map));
}
@Test(expected = ReadOnlyException.class)
public void testResetReadOnly() throws ReadOnlyException, ValidatorException, IOException {
addPref(basePrefs, "key", true, new String[] {"default"});
portletPreferences.reset("key");
}
@Test
public void testResetToBase() throws ReadOnlyException, ValidatorException, IOException {
addPref(basePrefs, "key", false, new String[] {"default"});
//Set a modified value
portletPreferences.setValues("key", new String[] {"modified"});
//Initial store, check that correct stored map is created
portletPreferences.store();
//Actually "store" the stored prefs
this.targetPrefs = new LinkedHashMap<String, IPortletPreference>(this.storedPrefs);
assertEquals(1, this.storedPrefs.size());
IPortletPreference pref = this.storedPrefs.get("key");
assertNotNull(pref);
assertEquals("key", pref.getName());
assertArrayEquals(new String[] {"modified"}, pref.getValues());
assertFalse(pref.isReadOnly());
//Get the current value
String[] values = portletPreferences.getValues("key", null);
assertArrayEquals(new String[] {"modified"}, values);
//Reset it
portletPreferences.reset("key");
//Get the default value
values = portletPreferences.getValues("key", null);
assertArrayEquals(new String[] {"default"}, values);
//Do another store to verify nothing gets stored
portletPreferences.store();
//Actually "store" the stored prefs
this.targetPrefs = new LinkedHashMap<String, IPortletPreference>(this.storedPrefs);
assertEquals(0, this.storedPrefs.size());
}
}