X-Git-Url: http://wamblee.org/gitweb/?a=blobdiff_plain;f=impl%2Fsrc%2Ftest%2Fjava%2Forg%2Fwamblee%2Fxmlrouter%2Fimpl%2FSingleRouterConfigTest.java;h=7a71a6c2e8bda9924698ea03f982d5aa471695f4;hb=3b2c669b25bfcb5a3c3f06ff9180d85143bebb2a;hp=c6f9920865f4165a3f7dcf7d17e62abebe38d9c2;hpb=19413a6699295b4bbebc1b3bdb9838fd4370e581;p=xmlrouter

diff --git a/impl/src/test/java/org/wamblee/xmlrouter/impl/SingleRouterConfigTest.java b/impl/src/test/java/org/wamblee/xmlrouter/impl/SingleRouterConfigTest.java
index c6f9920..7a71a6c 100644
--- a/impl/src/test/java/org/wamblee/xmlrouter/impl/SingleRouterConfigTest.java
+++ b/impl/src/test/java/org/wamblee/xmlrouter/impl/SingleRouterConfigTest.java
@@ -18,8 +18,6 @@ package org.wamblee.xmlrouter.impl;
 import static junit.framework.Assert.*;
 import static org.mockito.Mockito.*;
 
-import java.util.concurrent.atomic.AtomicLong;
-
 import org.junit.Before;
 import org.junit.Test;
 import org.wamblee.xmlrouter.common.Id;
@@ -29,72 +27,129 @@ import org.wamblee.xmlrouter.config.Transformation;
 
 public class SingleRouterConfigTest {
 
-    private AtomicLong sequence;
-    private ExtendedRouterConfig config;
+    private SingleRouterConfig config;
 
     @Before
     public void setUp() {
-        sequence = new AtomicLong(1L);
-        config = new SingleRouterConfig(sequence);
+        config = new SingleRouterConfig("routerconfig");
+        assertEquals("routerconfig", config.getId().getId());
     }
 
     @Test
     public void testDocumentType() {
         DocumentType type1 = mock(DocumentType.class);
+        when(type1.getId()).thenReturn(new Id<DocumentType>("type1"));
         DocumentType type2 = mock(DocumentType.class);
+        when(type2.getId()).thenReturn(new Id<DocumentType>("type2"));
 
-        assertFalse(config.isDirty());
-        Id<DocumentType> id1 = config.documentTypeConfig().add(type1);
-        assertTrue(config.isDirty());
-
-        config.resetDirty();
-        assertFalse(config.isDirty());
-        Id<DocumentType> id2 = config.documentTypeConfig().add(type2);
-        assertFalse(id1.equals(id2));
-        assertTrue(config.isDirty());
-
-        assertEquals(2, config.documentTypeConfig().map().size());
-        assertTrue(config.documentTypeConfig().map().get(id1) instanceof RobustDocumentType);
+        config.documentTypeConfig().add(type1);
+        config.documentTypeConfig().add(type2);
 
+        assertEquals(2, config.documentTypeConfig().values().size());
+        Object firstValue = config.documentTypeConfig().values().iterator()
+            .next();
+        assertTrue(firstValue instanceof RobustDocumentType);
     }
 
     @Test
     public void testTransformation() {
         Transformation transformation1 = mock(Transformation.class);
+        when(transformation1.getId()).thenReturn(new Id<Transformation>("t1"));
         Transformation transformation2 = mock(Transformation.class);
+        when(transformation2.getId()).thenReturn(new Id<Transformation>("t2"));
 
-        assertFalse(config.isDirty());
-        Id<Transformation> id1 = config.transformationConfig().add(
-            transformation1);
-        assertTrue(config.isDirty());
+        config.transformationConfig().add(transformation1);
 
-        config.resetDirty();
-        assertFalse(config.isDirty());
-        Id<Transformation> id2 = config.transformationConfig().add(
-            transformation2);
-        assertFalse(id1.equals(id2));
-        assertTrue(config.isDirty());
+        config.transformationConfig().add(transformation2);
 
-        assertEquals(2, config.transformationConfig().map().size());
-        assertTrue(config.transformationConfig().map().get(id1) instanceof RobustTransformation);
+        assertEquals(2, config.transformationConfig().values().size());
+        Object firstValue = config.transformationConfig().values().iterator()
+            .next();
+        assertTrue(firstValue instanceof RobustTransformation);
     }
 
     @Test
     public void testFilter() {
         Filter filter1 = mock(Filter.class);
+        when(filter1.getId()).thenReturn(new Id<Filter>("f1"));
+        Filter filter2 = mock(Filter.class);
+        when(filter2.getId()).thenReturn(new Id<Filter>("f2"));
+
+        config.filterConfig().add(filter1);
+
+        config.filterConfig().add(filter2);
+
+        assertEquals(2, config.filterConfig().values().size());
+        Object firstValue = config.filterConfig().values().iterator().next();
+        assertTrue(firstValue instanceof RobustFilter);
+    }
+
+    @Test
+    public void testEqualityEmptyConfig() {
+        RouterConfig config1 = new SingleRouterConfig("routerconfig");
+        RouterConfig config2 = new SingleRouterConfig("routerconfig");
+        assertEquals(config1, config2);
+    }
+
+    @Test
+    public void testEqualsNonEmpty() {
+        RouterConfig config1 = new SingleRouterConfig("routerconfig");
+
+        assertFalse(config1.equals(null));
+        assertFalse(config.equals("hello"));
+
+        RouterConfig config2 = new SingleRouterConfig("routerconfig");
+        DocumentType type1 = mock(DocumentType.class);
+        when(type1.getId()).thenReturn(new Id<DocumentType>("type1"));
+        DocumentType type2 = mock(DocumentType.class);
+        when(type2.getId()).thenReturn(new Id<DocumentType>("type1"));
+        Filter filter1 = mock(Filter.class);
+        when(filter1.getId()).thenReturn(new Id<Filter>("f1"));
         Filter filter2 = mock(Filter.class);
+        when(filter2.getId()).thenReturn(new Id<Filter>("f1"));
+        Transformation transformation1 = mock(Transformation.class);
+        when(transformation1.getId()).thenReturn(new Id<Transformation>("t1"));
+        Transformation transformation2 = mock(Transformation.class);
+        when(transformation2.getId()).thenReturn(new Id<Transformation>("t1"));
 
-        assertFalse(config.isDirty());
-        Id<Filter> id1 = config.filterConfig().add(filter1);
-        assertTrue(config.isDirty());
+        config1.documentTypeConfig().add(type1);
+        assertFalse(config1.equals(config2));
 
-        config.resetDirty();
-        assertFalse(config.isDirty());
-        Id<Filter> id2 = config.filterConfig().add(filter2);
-        assertFalse(id1.equals(id2));
-        assertTrue(config.isDirty());
+        config2.documentTypeConfig().add(type2);
+        assertEquals(config1, config2);
+        assertEquals(config1.hashCode(), config2.hashCode());
 
-        assertEquals(2, config.filterConfig().map().size());
-        assertTrue(config.filterConfig().map().get(id1) instanceof RobustFilter);
+        config1.transformationConfig().add(transformation1);
+        config2.transformationConfig().add(transformation2);
+
+        assertEquals(config1, config2);
+        assertEquals(config1.hashCode(), config2.hashCode());
+
+        config1.filterConfig().add(filter1);
+        config2.filterConfig().add(filter2);
+
+        assertEquals(config1, config2);
+        assertEquals(config1.hashCode(), config2.hashCode());
+    }
+
+    @Test
+    public void testCopy() {
+        testDocumentType();
+        testFilter();
+        testTransformation();
+
+        SingleRouterConfig copy = new SingleRouterConfig(config);
+        assertEquals(config.getId(), copy.getId());
+        assertEquals(config, copy);
+
+        // verify the copy is not shallow.
+
+        config.documentTypeConfig().remove(new Id<DocumentType>("type1"));
+        config.transformationConfig().remove(new Id<Transformation>("t1"));
+        config.filterConfig().remove(new Id<Filter>("f1"));
+        assertEquals(1, config.documentTypeConfig().values().size());
+        assertEquals(1, config.transformationConfig().values().size());
+        assertEquals(1, config.filterConfig().values().size());
+        assertFalse(config.equals(copy));
     }
 }