QPID-5138: Introduce preferences provider interface and its implementation storing preferences on file system

git-svn-id: https://svn.apache.org/repos/asf/qpid/trunk@1523217 13f79535-47bb-0310-9956-ffa450edef68

1 files changed, 246 insertions, 0 deletions

diff --git a/qpid/java/broker/src/test/java/org/apache/qpid/server/model/adapter/FileSystemPreferencesProviderTest.java b/qpid/java/broker/src/test/java/org/apache/qpid/server/model/adapter/FileSystemPreferencesProviderTest.java
new file mode 100644
index 0000000000..bb64241ff0
--- /dev/null
+++ b/qpid/java/broker/src/test/java/org/apache/qpid/server/model/adapter/FileSystemPreferencesProviderTest.java
@@ -0,0 +1,246 @@
+package org.apache.qpid.server.model.adapter;
+
+import static org.mockito.Mockito.mock;
+import static org.mockito.Mockito.when;
+
+import java.io.File;
+import java.util.Arrays;
+import java.util.HashMap;
+import java.util.HashSet;
+import java.util.Map;
+import java.util.Set;
+import java.util.UUID;
+
+import org.apache.qpid.server.configuration.updater.TaskExecutor;
+import org.apache.qpid.server.model.AuthenticationProvider;
+import org.apache.qpid.server.model.Broker;
+import org.apache.qpid.server.model.State;
+import org.apache.qpid.server.util.BrokerTestHelper;
+import org.apache.qpid.test.utils.QpidTestCase;
+import org.apache.qpid.test.utils.TestFileUtils;
+
+public class FileSystemPreferencesProviderTest extends QpidTestCase
+{
+    private static final String TEST_PREFERENCES = "{\"user1\":{\"pref1\":\"pref1User1Value\", \"pref2\": true, \"pref3\": 1.0, \"pref4\": 2},"
+            + "\"user2\":{\"pref1\":\"pref1User2Value\", \"pref2\": false, \"pref3\": 2.0, \"pref4\": 3}}";
+    private FileSystemPreferencesProvider _preferencesProvider;
+    private AuthenticationProvider _authenticationProvider;
+    private Broker _broker;
+    private String _user1, _user2;
+    private File _preferencesFile;
+
+    protected void setUp() throws Exception
+    {
+        super.setUp();
+        BrokerTestHelper.setUp();
+        _authenticationProvider = mock(AuthenticationProvider.class);
+        _user1 = "user1";
+        _user2 = "user2";
+        _preferencesFile = TestFileUtils.createTempFile(this, ".prefs.json", TEST_PREFERENCES);
+
+        _broker = BrokerTestHelper.createBrokerMock();
+        TaskExecutor taslExecutor = mock(TaskExecutor.class);
+        when(taslExecutor.isTaskExecutorThread()).thenReturn(true);
+        when(_broker.getTaskExecutor()).thenReturn(taslExecutor);
+        when(_authenticationProvider.getParent(Broker.class)).thenReturn(_broker);
+    }
+
+    protected void tearDown() throws Exception
+    {
+        try
+        {
+            BrokerTestHelper.tearDown();
+            _preferencesFile.delete();
+        }
+        finally
+        {
+            super.tearDown();
+        }
+    }
+
+    public void testConstructionWithExistingFile()
+    {
+        _preferencesProvider = createPreferencesProvider();
+        assertEquals(State.INITIALISING, _preferencesProvider.getActualState());
+    }
+
+    public void testConstructionWithNonExistingFile()
+    {
+        File nonExistingFile = new File(TMP_FOLDER, "preferences-" + UUID.randomUUID() + ".json");
+        assertFalse("Preferences file exists", nonExistingFile.exists());
+        try
+        {
+            Map<String, Object> attributes = new HashMap<String, Object>();
+            attributes.put(FileSystemPreferencesProvider.PATH, nonExistingFile.getAbsolutePath());
+            _preferencesProvider = new FileSystemPreferencesProvider(UUID.randomUUID(), attributes, _authenticationProvider, _broker.getTaskExecutor());
+            _preferencesProvider.createStoreIfNotExist();
+            assertEquals(State.INITIALISING, _preferencesProvider.getActualState());
+            assertTrue("Preferences file was not created", nonExistingFile.exists());
+        }
+        finally
+        {
+            nonExistingFile.delete();
+        }
+    }
+
+    public void testConstructionWithEmptyFile() throws Exception
+    {
+        File emptyPrefsFile = new File(TMP_FOLDER, "preferences-" + UUID.randomUUID() + ".json");
+        emptyPrefsFile.createNewFile();
+        assertTrue("Preferences file does notexists", emptyPrefsFile.exists());
+        try
+        {
+            Map<String, Object> attributes = new HashMap<String, Object>();
+            attributes.put(FileSystemPreferencesProvider.PATH, emptyPrefsFile.getAbsolutePath());
+            _preferencesProvider = new FileSystemPreferencesProvider(UUID.randomUUID(), attributes, _authenticationProvider, _broker.getTaskExecutor());
+            assertEquals(State.INITIALISING, _preferencesProvider.getActualState());
+        }
+        finally
+        {
+            emptyPrefsFile.delete();
+        }
+    }
+
+    public void testActivate()
+    {
+        _preferencesProvider = createPreferencesProvider();
+        _preferencesProvider.setDesiredState(State.INITIALISING, State.ACTIVE);
+
+        assertEquals("Unexpexpected state", State.ACTIVE, _preferencesProvider.getActualState());
+    }
+
+    public void testChangeAttributes()
+    {
+        _preferencesProvider = createPreferencesProvider();
+        _preferencesProvider.setDesiredState(State.INITIALISING, State.ACTIVE);
+
+        File newPrefsFile = TestFileUtils.createTempFile(this, ".prefs.json",  "{\"user3\":{\"pref1\":\"pref1User3Value\", \"pref3\": 2.0}}");
+        try
+        {
+            Map<String, Object> attributes = new HashMap<String, Object>();
+            attributes.put(FileSystemPreferencesProvider.PATH, newPrefsFile.getAbsolutePath());
+            _preferencesProvider.changeAttributes(attributes);
+            assertEquals("Unexpected path", newPrefsFile.getAbsolutePath(),
+                    _preferencesProvider.getAttribute(FileSystemPreferencesProvider.PATH));
+
+            Map<String, Object> preferences1 = _preferencesProvider.getPreferences(_user1);
+            assertTrue("Unexpected preferences for user1", preferences1.isEmpty());
+
+            String user3 = "user3";
+            Map<String, Object> preferences3 = _preferencesProvider.getPreferences(user3);
+            assertFalse("No preference found for user3", preferences3.isEmpty());
+            assertEquals("Unexpected preference 1 for user 3", "pref1User3Value", preferences3.get("pref1"));
+            assertEquals("Unexpected preference 3 for user 3", 2.0, ((Number) preferences3.get("pref3")).floatValue(), 0.01);
+        }
+        finally
+        {
+            newPrefsFile.delete();
+        }
+    }
+
+    public void testGetPreferences()
+    {
+        _preferencesProvider = createPreferencesProvider();
+        _preferencesProvider.setDesiredState(State.INITIALISING, State.ACTIVE);
+
+        Map<String, Object> preferences1 = _preferencesProvider.getPreferences(_user1);
+        assertUser1Preferences(preferences1);
+
+        Map<String, Object> preferences2 = _preferencesProvider.getPreferences(_user2);
+        assertUser2Preferences(preferences2);
+
+        String user3 = "user3";
+        Map<String, Object> preferences3 = _preferencesProvider.getPreferences(user3);
+        assertTrue("No preference found for user3", preferences3.isEmpty());
+    }
+
+    public void testSetPrefernces()
+    {
+        _preferencesProvider = createPreferencesProvider();
+        _preferencesProvider.setDesiredState(State.INITIALISING, State.ACTIVE);
+
+        Map<String, Object> newPreferences = new HashMap<String, Object>();
+        newPreferences.put("pref2", false);
+        newPreferences.put("pref4", 8);
+        Map<String, Object> pref5 = new HashMap<String, Object>();
+        pref5.put("test1", "test1Value");
+        pref5.put("test2", 5);
+        newPreferences.put("pref5", pref5);
+
+        _preferencesProvider.setPreferences(_user1, newPreferences);
+
+        FileSystemPreferencesProvider newProvider = createPreferencesProvider();
+        Map<String, Object> preferences1 = newProvider.getPreferences(_user1);
+        assertNotNull("Preferences should not be null for user 1", preferences1);
+        assertEquals("Unexpected preference 1 for user 1", "pref1User1Value", preferences1.get("pref1"));
+        assertEquals("Unexpected preference 2 for user 1", false, preferences1.get("pref2"));
+        assertEquals("Unexpected preference 3 for user 1", 1.0, ((Number) preferences1.get("pref3")).floatValue(), 0.01);
+        assertEquals("Unexpected preference 4 for user 1", 8, preferences1.get("pref4"));
+        assertNotNull("Unexpected preference 5 for user 1", preferences1.get("pref5"));
+        assertEquals("Unexpected preference 5 for user 1", pref5, preferences1.get("pref5"));
+
+        Map<String, Object> preferences2 = newProvider.getPreferences(_user2);
+        assertUser2Preferences(preferences2);
+
+        String user3 = "user3";
+        Map<String, Object> preferences3 = newProvider.getPreferences(user3);
+        assertTrue("No preference found for user3", preferences3.isEmpty());
+    }
+
+    public void testDeletePrefernces()
+    {
+        _preferencesProvider = createPreferencesProvider();
+        _preferencesProvider.setDesiredState(State.INITIALISING, State.ACTIVE);
+
+        _preferencesProvider.deletePreferences(_user1);
+
+        FileSystemPreferencesProvider newProvider = createPreferencesProvider();
+        Map<String, Object> preferences1 = newProvider.getPreferences(_user1);
+        assertTrue("Preferences should not be set for user 1", preferences1.isEmpty());
+
+        Map<String, Object> preferences2 = newProvider.getPreferences(_user2);
+        assertUser2Preferences(preferences2);
+
+        String user3 = "user3";
+        Map<String, Object> preferences3 = newProvider.getPreferences(user3);
+        assertTrue("No preference found for user3", preferences3.isEmpty());
+    }
+
+    public void testListUserNames()
+    {
+        _preferencesProvider = createPreferencesProvider();
+        _preferencesProvider.setDesiredState(State.INITIALISING, State.ACTIVE);
+
+        Set<String> userNames = _preferencesProvider.listUserIDs();
+
+        assertEquals("Unexpected user names", new HashSet<String>(Arrays.asList("user1", "user2")), userNames);
+    }
+
+    private FileSystemPreferencesProvider createPreferencesProvider()
+    {
+        Map<String, Object> attributes = new HashMap<String, Object>();
+        attributes.put(FileSystemPreferencesProvider.PATH, _preferencesFile.getAbsolutePath());
+        attributes.put(FileSystemPreferencesProvider.NAME, "test");
+        return _preferencesProvider = new FileSystemPreferencesProvider(UUID.randomUUID(), attributes, _authenticationProvider, _broker.getTaskExecutor());
+    }
+
+    private void assertUser1Preferences(Map<String, Object> preferences1)
+    {
+        assertNotNull("Preferences should not be null for user 1", preferences1);
+        assertEquals("Unexpected preference 1 for user 1", "pref1User1Value", preferences1.get("pref1"));
+        assertEquals("Unexpected preference 2 for user 1", true, preferences1.get("pref2"));
+        assertEquals("Unexpected preference 3 for user 1", 1.0, ((Number) preferences1.get("pref3")).floatValue(), 0.01);
+        assertEquals("Unexpected preference 4 for user 1", 2, preferences1.get("pref4"));
+        assertNull("Unexpected preference 5 for user 1", preferences1.get("pref5"));
+    }
+
+    private void assertUser2Preferences(Map<String, Object> preferences2)
+    {
+        assertNotNull("Preferences should not be null for user 2", preferences2);
+        assertEquals("Unexpected preference 1 for user 2", "pref1User2Value", preferences2.get("pref1"));
+        assertEquals("Unexpected preference 2 for user 2", false, preferences2.get("pref2"));
+        assertEquals("Unexpected preference 2 for user 2", 2.0, ((Number) preferences2.get("pref3")).floatValue(), 0.01);
+        assertEquals("Unexpected preference 3 for user 2", 3, preferences2.get("pref4"));
+        assertNull("Unexpected preference 5 for user 2", preferences2.get("pref5"));
+    }
+}