1 files changed, 104 insertions, 106 deletions
diff --git a/jetty-security/src/test/java/org/eclipse/jetty/security/PropertyUserStoreTest.java b/jetty-security/src/test/java/org/eclipse/jetty/security/PropertyUserStoreTest.java
index fc1a2f3f8a..2ae011f305 100644
--- a/jetty-security/src/test/java/org/eclipse/jetty/security/PropertyUserStoreTest.java
+++ b/jetty-security/src/test/java/org/eclipse/jetty/security/PropertyUserStoreTest.java
@@ -18,178 +18,176 @@
 
 package org.eclipse.jetty.security;
 
+import static org.hamcrest.Matchers.*;
+import static org.junit.Assert.*;
+import static org.junit.Assume.*;
+
 import java.io.BufferedWriter;
 import java.io.File;
 import java.io.FileWriter;
 import java.io.Writer;
+import java.nio.file.Path;
 import java.util.ArrayList;
 import java.util.List;
+import java.util.concurrent.TimeUnit;
 import java.util.concurrent.atomic.AtomicInteger;
 
+import org.eclipse.jetty.toolchain.test.FS;
+import org.eclipse.jetty.toolchain.test.OS;
+import org.eclipse.jetty.toolchain.test.TestingDir;
 import org.eclipse.jetty.util.security.Credential;
-import org.junit.After;
-import org.junit.Assert;
-import org.junit.Before;
+import org.hamcrest.Matcher;
+import org.junit.Rule;
 import org.junit.Test;
 
 public class PropertyUserStoreTest
 {
-    String testFileDir = "target" + File.separator + "property-user-store-test";
-    String testFile = testFileDir + File.separator + "users.txt";
-
-    @Before
-    public void before() throws Exception
+    private final class UserCount implements PropertyUserStore.UserListener
     {
-        File file = new File(testFileDir);
-        file.mkdirs();
+        private final AtomicInteger userCount = new AtomicInteger();
+        private final List<String> users = new ArrayList<String>();
 
-        writeInitialUsers(testFile);
-    }
+        private UserCount()
+        {
+        }
 
-    @After
-    public void after() throws Exception
-    {
-        File file = new File(testFile);
+        public void update(String username, Credential credential, String[] roleArray)
+        {
+            if (!users.contains(username))
+            {
+                users.add(username);
+                userCount.getAndIncrement();
+            }
+        }
 
-        file.delete();
+        public void remove(String username)
+        {
+            users.remove(username);
+            userCount.getAndDecrement();
+        }
+
+        public void awaitCount(int expectedCount) throws InterruptedException
+        {
+            long timeout = System.currentTimeMillis() + TimeUnit.SECONDS.toMillis(10);
+            
+            while (userCount.get() != expectedCount && (System.currentTimeMillis() < timeout))
+            {
+                TimeUnit.MILLISECONDS.sleep(100);
+            }
+            
+            assertThatCount(is(expectedCount));
+        }
+
+        public void assertThatCount(Matcher<Integer> matcher)
+        {
+            assertThat("User count",userCount.get(),matcher);
+        }
+
+        public void assertThatUsers(Matcher<Iterable<? super String>> matcher)
+        {
+            assertThat("Users list",users,matcher);
+        }
     }
 
-    private void writeInitialUsers(String testFile) throws Exception
+    @Rule
+    public TestingDir testdir = new TestingDir();
+
+    private File initUsersText() throws Exception
     {
-        try (Writer writer = new BufferedWriter(new FileWriter(testFile)))
+        Path dir = testdir.getDir().toPath().toRealPath();
+        FS.ensureDirExists(dir.toFile());
+        File users = dir.resolve("users.txt").toFile();
+        
+        try (Writer writer = new BufferedWriter(new FileWriter(users)))
         {
             writer.append("tom: tom, roleA\n");
             writer.append("dick: dick, roleB\n");
             writer.append("harry: harry, roleA, roleB\n");
         }
+        
+        return users;
     }
 
-    private void writeAdditionalUser(String testFile) throws Exception
+    private void addAdditionalUser(File usersFile, String userRef) throws Exception
     {
         Thread.sleep(1001);
-        try (Writer writer = new BufferedWriter(new FileWriter(testFile,true)))
+        try (Writer writer = new BufferedWriter(new FileWriter(usersFile,true)))
         {
-            writer.append("skip: skip, roleA\n");
+            writer.append(userRef);
         }
     }
 
     @Test
     public void testPropertyUserStoreLoad() throws Exception
     {
-        final AtomicInteger userCount = new AtomicInteger();
+        final UserCount userCount = new UserCount();
+        final File usersFile = initUsersText();
 
         PropertyUserStore store = new PropertyUserStore();
+        store.setConfigPath(usersFile);
 
-        store.setConfig(testFile);
-
-        store.registerUserListener(new PropertyUserStore.UserListener()
-        {
-
-            public void update(String username, Credential credential, String[] roleArray)
-            {
-                userCount.getAndIncrement();
-            }
-
-            public void remove(String username)
-            {
-
-            }
-        });
+        store.registerUserListener(userCount);
 
         store.start();
 
-        Assert.assertNotNull("Failed to retrieve UserIdentity directly from PropertyUserStore", store.getUserIdentity("tom"));
-        Assert.assertNotNull("Failed to retrieve UserIdentity directly from PropertyUserStore", store.getUserIdentity("dick"));
-        Assert.assertNotNull("Failed to retrieve UserIdentity directly from PropertyUserStore", store.getUserIdentity("harry"));
-        Assert.assertEquals(3,userCount.get());
+        assertThat("Failed to retrieve UserIdentity directly from PropertyUserStore", store.getUserIdentity("tom"), notNullValue());
+        assertThat("Failed to retrieve UserIdentity directly from PropertyUserStore", store.getUserIdentity("dick"), notNullValue());
+        assertThat("Failed to retrieve UserIdentity directly from PropertyUserStore", store.getUserIdentity("harry"), notNullValue());
+        userCount.assertThatCount(is(3));
+        userCount.awaitCount(3);
     }
 
     @Test
     public void testPropertyUserStoreLoadUpdateUser() throws Exception
     {
-
-        final AtomicInteger userCount = new AtomicInteger();
-
-        final List<String> users = new ArrayList<String>();
+        assumeThat("Skipping on OSX", OS.IS_OSX, is(false));
+        final UserCount userCount = new UserCount();
+        final File usersFile = initUsersText();
 
         PropertyUserStore store = new PropertyUserStore();
-        store.setRefreshInterval(1);
-        store.setConfig(testFile);
-
-        store.registerUserListener(new PropertyUserStore.UserListener()
-        {
-            public void update(String username, Credential credential, String[] roleArray)
-            {
-                if (!users.contains(username))
-                {
-                    users.add(username);
-                    userCount.getAndIncrement();
-                }
-            }
-
-            public void remove(String username)
-            {
+        store.setHotReload(true);
+        store.setConfigPath(usersFile);
 
-            }
-        });
+        store.registerUserListener(userCount);
 
         store.start();
-        Assert.assertEquals(3,userCount.get());
-
-        writeAdditionalUser(testFile);
+        
+        userCount.assertThatCount(is(3));
 
-        long start = System.currentTimeMillis();
-        while (userCount.get() < 4 && (System.currentTimeMillis() - start) < 10000)
-        {
-            Thread.sleep(10);
-        }
+        addAdditionalUser(usersFile,"skip: skip, roleA\n");
 
-        Assert.assertNotNull("Failed to retrieve UserIdentity from PropertyUserStore directly", store.getUserIdentity("skip"));
-        Assert.assertEquals(4,userCount.get());
+        userCount.awaitCount(4);
 
-        Assert.assertTrue(users.contains("skip"));
+        assertThat("Failed to retrieve UserIdentity from PropertyUserStore directly", store.getUserIdentity("skip"), notNullValue());
+        
+        userCount.assertThatCount(is(4));
+        userCount.assertThatUsers(hasItem("skip"));
     }
 
     @Test
     public void testPropertyUserStoreLoadRemoveUser() throws Exception
     {
-        writeAdditionalUser(testFile);
-
-        final AtomicInteger userCount = new AtomicInteger();
-
-        final List<String> users = new ArrayList<String>();
+        assumeThat("Skipping on OSX", OS.IS_OSX, is(false));
+        final UserCount userCount = new UserCount();
+        // initial user file (3) users
+        final File usersFile = initUsersText();
+        
+        // adding 4th user
+        addAdditionalUser(usersFile,"skip: skip, roleA\n");
 
         PropertyUserStore store = new PropertyUserStore();
-        store.setRefreshInterval(2);
-        store.setConfig(testFile);
-
-        store.registerUserListener(new PropertyUserStore.UserListener()
-        {
+        store.setHotReload(true);
+        store.setConfigPath(usersFile);
 
-            public void update(String username, Credential credential, String[] roleArray)
-            {
-                if (!users.contains(username))
-                {
-                    users.add(username);
-                    userCount.getAndIncrement();
-                }
-            }
-
-            public void remove(String username)
-            {
-                users.remove(username);
-                userCount.getAndDecrement();
-            }
-        });
+        store.registerUserListener(userCount);
 
         store.start();
 
-        Assert.assertEquals(4,userCount.get());
+        userCount.assertThatCount(is(4));
 
-        Thread.sleep(2000);
-        writeInitialUsers(testFile);
-        Thread.sleep(3000);
-        Assert.assertEquals(3,userCount.get());
+        // rewrite file with original 3 users
+        initUsersText();
+        
+        userCount.awaitCount(3);
     }
-
 }