feature[ats_M5LLE]: OrcsTransaction implementation

29 files changed, 2419 insertions, 308 deletions

diff --git a/plugins/org.eclipse.osee.orcs.core.test/src/org/eclipse/osee/orcs/core/internal/InternalTestSuite.java b/plugins/org.eclipse.osee.orcs.core.test/src/org/eclipse/osee/orcs/core/internal/InternalTestSuite.java
index f436c20a35e..18ee8b9dd12 100644
--- a/plugins/org.eclipse.osee.orcs.core.test/src/org/eclipse/osee/orcs/core/internal/InternalTestSuite.java
+++ b/plugins/org.eclipse.osee.orcs.core.test/src/org/eclipse/osee/orcs/core/internal/InternalTestSuite.java
@@ -13,6 +13,7 @@ package org.eclipse.osee.orcs.core.internal;
 import org.eclipse.osee.orcs.core.internal.artifact.ArtifactTestSuite;
 import org.eclipse.osee.orcs.core.internal.attribute.AttributeTestSuite;
 import org.eclipse.osee.orcs.core.internal.branch.BranchTestSuite;
+import org.eclipse.osee.orcs.core.internal.proxy.ProxyTestSuite;
 import org.eclipse.osee.orcs.core.internal.relation.RelationTestSuite;
 import org.eclipse.osee.orcs.core.internal.search.QueryTestSuite;
 import org.junit.runner.RunWith;
@@ -26,8 +27,9 @@ import org.junit.runners.Suite;
    ArtifactTestSuite.class,
    AttributeTestSuite.class,
    BranchTestSuite.class,
-   RelationTestSuite.class,
-   QueryTestSuite.class})
+   ProxyTestSuite.class,
+   QueryTestSuite.class,
+   RelationTestSuite.class})
 public class InternalTestSuite {
    // Test Suite
 }
diff --git a/plugins/org.eclipse.osee.orcs.core.test/src/org/eclipse/osee/orcs/core/internal/artifact/ArtifactFactoryTest.java b/plugins/org.eclipse.osee.orcs.core.test/src/org/eclipse/osee/orcs/core/internal/artifact/ArtifactFactoryTest.java
index 5db6a0f505c..b1f7834b057 100644
--- a/plugins/org.eclipse.osee.orcs.core.test/src/org/eclipse/osee/orcs/core/internal/artifact/ArtifactFactoryTest.java
+++ b/plugins/org.eclipse.osee.orcs.core.test/src/org/eclipse/osee/orcs/core/internal/artifact/ArtifactFactoryTest.java
@@ -10,12 +10,18 @@
  *******************************************************************************/
 package org.eclipse.osee.orcs.core.internal.artifact;
 
-import static org.junit.Assert.*;
-import static org.mockito.Matchers.*;
-import static org.mockito.Mockito.*;
-import java.util.Collection;
+import static org.junit.Assert.assertEquals;
+import static org.mockito.Matchers.eq;
+import static org.mockito.Mockito.mock;
+import static org.mockito.Mockito.times;
+import static org.mockito.Mockito.verify;
+import static org.mockito.Mockito.when;
+import java.util.ArrayList;
+import java.util.Collections;
 import java.util.List;
 import org.eclipse.osee.framework.core.data.IAttributeType;
+import org.eclipse.osee.framework.core.enums.CoreAttributeTypes;
+import org.eclipse.osee.framework.core.exception.OseeArgumentException;
 import org.eclipse.osee.framework.core.exception.OseeCoreException;
 import org.eclipse.osee.framework.core.model.Branch;
 import org.eclipse.osee.framework.core.model.cache.ArtifactTypeCache;
@@ -24,97 +30,215 @@ import org.eclipse.osee.framework.core.model.type.ArtifactType;
 import org.eclipse.osee.framework.jdk.core.util.GUID;
 import org.eclipse.osee.orcs.core.ds.ArtifactData;
 import org.eclipse.osee.orcs.core.ds.ArtifactDataFactory;
-import org.eclipse.osee.orcs.core.ds.ArtifactTransactionData;
 import org.eclipse.osee.orcs.core.ds.AttributeData;
 import org.eclipse.osee.orcs.core.ds.VersionData;
+import org.eclipse.osee.orcs.core.internal.attribute.Attribute;
 import org.eclipse.osee.orcs.core.internal.attribute.AttributeFactory;
+import org.eclipse.osee.orcs.core.internal.relation.RelationContainer;
 import org.eclipse.osee.orcs.core.internal.relation.RelationFactory;
-import org.eclipse.osee.orcs.data.ArtifactReadable;
+import org.junit.Assert;
 import org.junit.Before;
-import org.junit.Ignore;
+import org.junit.Rule;
 import org.junit.Test;
+import org.junit.rules.ExpectedException;
+import org.mockito.ArgumentCaptor;
 import org.mockito.Mock;
 import org.mockito.MockitoAnnotations;
+import org.mockito.invocation.InvocationOnMock;
+import org.mockito.stubbing.Answer;
 
+/**
+ * Test Case for {@link ArtifactFactory}
+ * 
+ * @author John Misinco
+ */
 public class ArtifactFactoryTest {
 
+   @Rule
+   public ExpectedException thrown = ExpectedException.none();
+
    // @formatter:off
    @Mock private Branch branch;
    @Mock private ArtifactType artifactType;
    @Mock private ArtifactData artifactData;
    @Mock private RelationContainer relationContainer;
+   @Mock private VersionData artifactVersion;
+   
+   @Mock private ArtifactDataFactory dataFactory;
+   @Mock private AttributeFactory attributeFactory;
+   @Mock private RelationFactory relationFactory;
+   @Mock private ArtifactTypeCache artifactTypeCache;
+   @Mock private BranchCache branchCache;
+   
+   @Mock private Attribute<Object> attribute;
+   @Mock private AttributeData attributeData;
+   @Mock private ArtifactImpl source;
+   
+   @Mock private ArtifactData otherArtifactData;
    // @formatter:on
 
-   private final String guid = GUID.create();
-
+   private String guid;
    private ArtifactFactory artifactFactory;
+   private List<IAttributeType> types;
 
    @Before
    public void init() throws OseeCoreException {
       MockitoAnnotations.initMocks(this);
-      AttributeFactory attributeFactory = mock(AttributeFactory.class);
-      RelationFactory relationFactory = mock(RelationFactory.class);
-      ArtifactTypeCache artifactTypeCache = mock(ArtifactTypeCache.class);
-      BranchCache branchCache = mock(BranchCache.class);
-      ArtifactDataFactory factory = mock(ArtifactDataFactory.class);
-      artifactFactory = new ArtifactFactory(factory, attributeFactory, relationFactory, artifactTypeCache, branchCache);
-      when(artifactTypeCache.getByGuid(anyLong())).thenReturn(artifactType);
-      when(branchCache.getById(anyInt())).thenReturn(branch);
-      VersionData version = mock(VersionData.class);
-      when(artifactData.getVersion()).thenReturn(version);
-      when(relationFactory.createRelationContainer(anyInt())).thenReturn(relationContainer);
-      when(factory.create(branch, artifactType, guid)).thenReturn(artifactData);
-      when(factory.copy(branch, artifactData)).thenReturn(artifactData);
+
+      artifactFactory =
+         new ArtifactFactory(dataFactory, attributeFactory, relationFactory, artifactTypeCache, branchCache);
+
+      guid = GUID.create();
+
+      types = new ArrayList<IAttributeType>();
+      types.add(CoreAttributeTypes.RelationOrder);
+      types.add(CoreAttributeTypes.City);
+      types.add(CoreAttributeTypes.Annotation);
+
+      when(artifactData.getLocalId()).thenReturn(45);
       when(artifactData.getGuid()).thenReturn(guid);
+      when(artifactData.getTypeUuid()).thenReturn(65L);
+      when(artifactData.getVersion()).thenReturn(artifactVersion);
+      when(artifactVersion.getBranchId()).thenReturn(23);
+
+      when(otherArtifactData.getLocalId()).thenReturn(45);
+      when(otherArtifactData.getGuid()).thenReturn(guid);
+      when(otherArtifactData.getTypeUuid()).thenReturn(65L);
+      when(otherArtifactData.getVersion()).thenReturn(artifactVersion);
+
+      when(relationFactory.createRelationContainer(45)).thenReturn(relationContainer);
+      when(artifactTypeCache.getByGuid(65L)).thenReturn(artifactType);
+      when(branchCache.getById(23)).thenReturn(branch);
    }
 
    @Test
-   public void testCreateWriteableArtifact() throws OseeCoreException {
-      ArtifactReadable artifact = artifactFactory.createWriteableArtifact(artifactData);
-      assertEquals(artifactType, artifact.getArtifactType());
-      assertEquals(guid, artifact.getGuid());
+   public void testCreateArtifactFromBranchTypeAndGuid() throws OseeCoreException {
+      when(dataFactory.create(branch, artifactType, guid)).thenReturn(artifactData);
+
+      ArtifactImpl artifact = artifactFactory.createArtifact(branch, artifactType, guid);
 
-      artifact = artifactFactory.createWriteableArtifact(branch, artifactType, guid);
+      verify(dataFactory).create(branch, artifactType, guid);
       assertEquals(artifactType, artifact.getArtifactType());
       assertEquals(guid, artifact.getGuid());
    }
 
    @Test
-   public void testCreateReadableArtifact() throws OseeCoreException {
-      ArtifactReadable artifact = artifactFactory.createReadableArtifact(artifactData);
+   public void testCreateArtifactFromArtifactData() throws OseeCoreException {
+      when(relationFactory.createRelationContainer(45)).thenReturn(relationContainer);
+      when(artifactTypeCache.getByGuid(65L)).thenReturn(artifactType);
+      when(branchCache.getById(23)).thenReturn(branch);
+
+      ArtifactImpl artifact = artifactFactory.createArtifact(artifactData);
+
       assertEquals(artifactType, artifact.getArtifactType());
       assertEquals(guid, artifact.getGuid());
    }
 
    @Test
-   @Ignore
    public void testCopyArtifact() throws OseeCoreException {
-      WritableArtifactProxy source = mock(WritableArtifactProxy.class);
-      Collection<? extends IAttributeType> types = mock(Collection.class);
-      ArtifactImpl impl = mock(ArtifactImpl.class);
-      when(source.getProxiedObject()).thenReturn(impl);
-      when(impl.getOrcsData()).thenReturn(artifactData);
-      artifactFactory.copyArtifact(source, types, branch);
+      when(source.getOrcsData()).thenReturn(artifactData);
+      when(dataFactory.copy(branch, artifactData)).thenReturn(otherArtifactData);
+
+      when(source.getAttributes(CoreAttributeTypes.Annotation)).thenAnswer(new ReturnAttribute(attribute));
+      when(attribute.getOrcsData()).thenReturn(attributeData);
+      when(artifactType.isValidAttributeType(CoreAttributeTypes.Annotation, branch)).thenReturn(true);
+
+      ArgumentCaptor<ArtifactImpl> implCapture = ArgumentCaptor.forClass(ArtifactImpl.class);
+
+      ArtifactImpl actual = artifactFactory.copyArtifact(source, types, branch);
+
+      verify(source, times(0)).getAttributes(CoreAttributeTypes.RelationOrder);
+      verify(source, times(0)).getAttributes(CoreAttributeTypes.City);
+      verify(source, times(1)).getAttributes(CoreAttributeTypes.Annotation);
+      verify(attributeFactory).copyAttribute(eq(attributeData), eq(branch), implCapture.capture());
+      Assert.assertTrue(implCapture.getValue().isLoaded());
+      Assert.assertTrue(actual == implCapture.getValue());
+   }
+
+   @Test
+   public void testIntroduceArtifactBranchException() throws OseeCoreException {
+      when(source.getBranch()).thenReturn(branch);
+
+      thrown.expect(OseeArgumentException.class);
+      thrown.expectMessage("Source artifact is on the same branch as [" + branch + "]");
+      artifactFactory.introduceArtifact(source, branch);
+   }
+
+   @Test
+   public void testIntroduceArtifact() throws OseeCoreException {
+      Branch otherBranch = mock(Branch.class);
+
+      when(source.getBranch()).thenReturn(otherBranch);
+      when(source.getOrcsData()).thenReturn(artifactData);
+
+      when(dataFactory.introduce(branch, artifactData)).thenReturn(otherArtifactData);
+
+      when(source.getExistingAttributeTypes()).thenAnswer(new ReturnExistingTypes(types));
+      when(source.getAttributes(CoreAttributeTypes.Annotation)).thenAnswer(new ReturnAttribute(attribute));
+      when(attribute.getOrcsData()).thenReturn(attributeData);
+      when(artifactType.isValidAttributeType(CoreAttributeTypes.Annotation, branch)).thenReturn(true);
+
+      ArgumentCaptor<ArtifactImpl> implCapture = ArgumentCaptor.forClass(ArtifactImpl.class);
+
+      ArtifactImpl actual = artifactFactory.introduceArtifact(source, branch);
+
+      verify(source, times(0)).getAttributes(CoreAttributeTypes.RelationOrder);
+      verify(source, times(0)).getAttributes(CoreAttributeTypes.City);
+      verify(source, times(1)).getAttributes(CoreAttributeTypes.Annotation);
+
+      verify(attributeFactory).introduceAttribute(eq(attributeData), eq(branch), implCapture.capture());
+
+      Assert.assertTrue(implCapture.getValue().isLoaded());
+      Assert.assertTrue(actual == implCapture.getValue());
    }
 
    @Test
-   public void testSetBackingData() throws OseeCoreException {
-      WritableArtifactProxy writeable = mock(WritableArtifactProxy.class);
-      ArtifactImpl original = mock(ArtifactImpl.class);
-      ArtifactImpl proxied = mock(ArtifactImpl.class);
-      List<AttributeData> attrData = mock(List.class);
-      ArtifactTransactionData data = mock(ArtifactTransactionData.class);
-
-      when(writeable.getOriginal()).thenReturn(original);
-      when(writeable.getProxiedObject()).thenReturn(proxied);
-      when(data.getArtifactData()).thenReturn(artifactData);
-      when(data.getAttributeData()).thenReturn(attrData);
-
-      artifactFactory.setBackingData(writeable, data);
-
-      verify(original).setOrcsData(artifactData);
-      verify(original).setBackingData(attrData);
-      verify(proxied).setOrcsData(artifactData);
-      verify(proxied).setBackingData(attrData);
+   public void testClone() throws OseeCoreException {
+      when(source.getOrcsData()).thenReturn(artifactData);
+      when(dataFactory.copy(branch, artifactData)).thenReturn(otherArtifactData);
+
+      when(source.getExistingAttributeTypes()).thenAnswer(new ReturnExistingTypes(types));
+      when(source.getAttributes(CoreAttributeTypes.Annotation)).thenAnswer(new ReturnAttribute(attribute));
+      when(attribute.getOrcsData()).thenReturn(attributeData);
+      when(artifactType.isValidAttributeType(CoreAttributeTypes.Annotation, branch)).thenReturn(true);
+
+      ArgumentCaptor<ArtifactImpl> implCapture = ArgumentCaptor.forClass(ArtifactImpl.class);
+
+      ArtifactImpl actual = artifactFactory.copyArtifact(source, types, branch);
+
+      verify(source, times(0)).getAttributes(CoreAttributeTypes.RelationOrder);
+      verify(source, times(0)).getAttributes(CoreAttributeTypes.City);
+      verify(source, times(1)).getAttributes(CoreAttributeTypes.Annotation);
+      verify(attributeFactory).copyAttribute(eq(attributeData), eq(branch), implCapture.capture());
+      Assert.assertTrue(implCapture.getValue().isLoaded());
+      Assert.assertTrue(actual == implCapture.getValue());
    }
+
+   private static final class ReturnAttribute implements Answer<List<Attribute<Object>>> {
+
+      private final Attribute<Object> attribute;
+
+      public ReturnAttribute(Attribute<Object> attribute) {
+         this.attribute = attribute;
+      }
+
+      @Override
+      public List<Attribute<Object>> answer(InvocationOnMock invocation) throws Throwable {
+         return Collections.singletonList(attribute);
+      }
+   };
+
+   private static final class ReturnExistingTypes implements Answer<List<IAttributeType>> {
+
+      private final List<IAttributeType> types;
+
+      public ReturnExistingTypes(List<IAttributeType> types) {
+         this.types = types;
+      }
+
+      @Override
+      public List<IAttributeType> answer(InvocationOnMock invocation) throws Throwable {
+         return types;
+      }
+   };
 }
diff --git a/plugins/org.eclipse.osee.orcs.core.test/src/org/eclipse/osee/orcs/core/internal/attribute/AttributeCollectionTest.java b/plugins/org.eclipse.osee.orcs.core.test/src/org/eclipse/osee/orcs/core/internal/attribute/AttributeCollectionTest.java
index dfcde694c83..c33e13b1282 100644
--- a/plugins/org.eclipse.osee.orcs.core.test/src/org/eclipse/osee/orcs/core/internal/attribute/AttributeCollectionTest.java
+++ b/plugins/org.eclipse.osee.orcs.core.test/src/org/eclipse/osee/orcs/core/internal/attribute/AttributeCollectionTest.java
@@ -10,20 +10,37 @@
  *******************************************************************************/
 package org.eclipse.osee.orcs.core.internal.attribute;
 
-import static org.junit.Assert.*;
-import static org.mockito.Mockito.*;
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertFalse;
+import static org.junit.Assert.assertTrue;
+import static org.mockito.Mockito.mock;
+import static org.mockito.Mockito.when;
+import java.util.Collection;
+import java.util.List;
+import junit.framework.Assert;
+import org.eclipse.osee.framework.core.data.ResultSet;
 import org.eclipse.osee.framework.core.enums.CoreAttributeTypes;
 import org.eclipse.osee.framework.core.enums.DeletionFlag;
 import org.eclipse.osee.framework.core.exception.OseeCoreException;
+import org.eclipse.osee.framework.core.model.type.AttributeType;
 import org.junit.Before;
 import org.junit.Test;
 import org.mockito.Mock;
 import org.mockito.MockitoAnnotations;
 
+/**
+ * Test Case for {@link AttributeCollection}
+ * 
+ * @author Roberto E. Escobar
+ */
+@SuppressWarnings("rawtypes")
 public class AttributeCollectionTest {
 
    // @formatter:off
    @Mock private AttributeExceptionFactory exceptionFactory;
+   @Mock Attribute dirtyAttr;
+   @Mock Attribute cleanAttr;
+   @Mock Attribute deletedAttr;
    // @formatter:on
 
    private AttributeCollection attributeCollection;
@@ -32,22 +49,148 @@ public class AttributeCollectionTest {
    public void init() {
       MockitoAnnotations.initMocks(this);
       attributeCollection = new AttributeCollection(exceptionFactory);
+
+      attributeCollection.addAttribute(CoreAttributeTypes.Country, dirtyAttr);
+      attributeCollection.addAttribute(CoreAttributeTypes.Active, cleanAttr);
+      attributeCollection.addAttribute(CoreAttributeTypes.Annotation, deletedAttr);
+
+      when(dirtyAttr.isDirty()).thenReturn(true);
+      when(deletedAttr.isDeleted()).thenReturn(true);
    }
 
    @Test
-   @SuppressWarnings("unchecked")
-   public void testGetAttributesDirty() {
-      Attribute<String> dirtyAttr = mock(Attribute.class);
-      Attribute<String> cleanAttr = mock(Attribute.class);
-      when(dirtyAttr.isDirty()).thenReturn(true);
-      attributeCollection.addAttribute(CoreAttributeTypes.Country, dirtyAttr);
-      attributeCollection.addAttribute(CoreAttributeTypes.Country, cleanAttr);
-      assertEquals(1, attributeCollection.getAttributesDirty().size());
-      assertEquals(dirtyAttr, attributeCollection.getAttributesDirty().iterator().next());
+   public void testGetAttributesDirty() throws OseeCoreException {
+      assertEquals(1, attributeCollection.getAttributeListDirties().size());
+      assertEquals(dirtyAttr, attributeCollection.getAttributeListDirties().iterator().next());
+   }
+
+   @Test
+   public void testHasAttributesDirty() {
+      boolean actual1 = attributeCollection.hasAttributesDirty();
+      assertTrue(actual1);
+
+      attributeCollection.removeAttribute(CoreAttributeTypes.Country, dirtyAttr);
+
+      boolean actual2 = attributeCollection.hasAttributesDirty();
+      assertFalse(actual2);
+   }
+
+   @Test
+   public void testGetAllAttributes() {
+      List<Attribute<?>> attributes = attributeCollection.getAllAttributes();
+      assertEquals(3, attributes.size());
+
+      assertTrue(attributes.contains(dirtyAttr));
+      assertTrue(attributes.contains(cleanAttr));
+      assertTrue(attributes.contains(deletedAttr));
+   }
+
+   @Test
+   public void testGetExistingTypes() throws OseeCoreException {
+      AttributeType typeA = mock(AttributeType.class);
+      AttributeType typeB = mock(AttributeType.class);
+      AttributeType typeC = mock(AttributeType.class);
+
+      when(dirtyAttr.getAttributeType()).thenReturn(typeA);
+      when(dirtyAttr.isDeleted()).thenReturn(true);
+
+      when(cleanAttr.getAttributeType()).thenReturn(typeB);
+      when(cleanAttr.isDeleted()).thenReturn(true);
+
+      when(deletedAttr.getAttributeType()).thenReturn(typeC);
+      when(deletedAttr.isDeleted()).thenReturn(false);
+
+      Collection<AttributeType> types = attributeCollection.getExistingTypes(DeletionFlag.INCLUDE_DELETED);
+
+      assertEquals(3, types.size());
+
+      assertTrue(types.contains(typeA));
+      assertTrue(types.contains(typeB));
+      assertTrue(types.contains(typeC));
+
+      Collection<AttributeType> types2 = attributeCollection.getExistingTypes(DeletionFlag.EXCLUDE_DELETED);
+      assertEquals(1, types2.size());
+
+      assertFalse(types2.contains(typeA));
+      assertFalse(types2.contains(typeB));
+      assertTrue(types2.contains(typeC));
+   }
+
+   @Test
+   public void testGetListDeletionFlag() throws OseeCoreException {
+      List<Attribute<Object>> list1 = attributeCollection.getAttributeList(DeletionFlag.INCLUDE_DELETED);
+
+      assertEquals(3, list1.size());
+      assertTrue(list1.contains(dirtyAttr));
+      assertTrue(list1.contains(cleanAttr));
+      assertTrue(list1.contains(deletedAttr));
+
+      List<Attribute<Object>> list2 = attributeCollection.getAttributeList(DeletionFlag.EXCLUDE_DELETED);
+      assertEquals(2, list2.size());
+
+      assertTrue(list2.contains(dirtyAttr));
+      assertTrue(list2.contains(cleanAttr));
+      assertFalse(list2.contains(deletedAttr));
+   }
+
+   @Test
+   public void testGetSetDeletionFlag() throws OseeCoreException {
+      ResultSet<Attribute<Object>> set1 = attributeCollection.getAttributeSet(DeletionFlag.INCLUDE_DELETED);
+
+      assertEquals(3, set1.getList().size());
+      assertTrue(set1.getList().contains(dirtyAttr));
+      assertTrue(set1.getList().contains(cleanAttr));
+      assertTrue(set1.getList().contains(deletedAttr));
+
+      ResultSet<Attribute<Object>> set2 = attributeCollection.getAttributeSet(DeletionFlag.EXCLUDE_DELETED);
+      assertEquals(2, set2.getList().size());
+
+      assertTrue(set2.getList().contains(dirtyAttr));
+      assertTrue(set2.getList().contains(cleanAttr));
+      assertFalse(set2.getList().contains(deletedAttr));
+   }
+
+   @Test
+   public void testGetListTypeAndDelete() throws OseeCoreException {
+      List<Attribute<Object>> list1 =
+         attributeCollection.getAttributeList(CoreAttributeTypes.Annotation, DeletionFlag.INCLUDE_DELETED);
+      assertEquals(1, list1.size());
+      assertTrue(list1.contains(deletedAttr));
+
+      List<Attribute<Object>> list2 =
+         attributeCollection.getAttributeList(CoreAttributeTypes.Annotation, DeletionFlag.EXCLUDE_DELETED);
+      assertEquals(0, list2.size());
+   }
+
+   @Test
+   public void testGetSetTypeAndDelete() throws OseeCoreException {
+      ResultSet<Attribute<Object>> set1 =
+         attributeCollection.getAttributeSet(CoreAttributeTypes.Annotation, DeletionFlag.INCLUDE_DELETED);
+
+      assertEquals(1, set1.getList().size());
+      assertTrue(set1.getList().contains(deletedAttr));
+
+      ResultSet<Attribute<Object>> set2 =
+         attributeCollection.getAttributeSet(CoreAttributeTypes.Annotation, DeletionFlag.EXCLUDE_DELETED);
+      assertEquals(0, set2.getList().size());
    }
 
    @Test
    public void testGetAttributeSetFromString() throws OseeCoreException {
-      attributeCollection.getAttributeSetFromString(CoreAttributeTypes.Country, DeletionFlag.EXCLUDE_DELETED, "test");
+      when(cleanAttr.getValue()).thenReturn(true);
+
+      ResultSet<Attribute<Object>> set =
+         attributeCollection.getAttributeSetFromString(CoreAttributeTypes.Active, DeletionFlag.EXCLUDE_DELETED, "true");
+      Assert.assertEquals(cleanAttr, set.getExactlyOne());
+   }
+
+   @Test
+   public void testGetAttributeSetFromValue() throws OseeCoreException {
+      when(cleanAttr.getValue()).thenReturn(true);
+
+      ResultSet<Attribute<Boolean>> set =
+         attributeCollection.getAttributeSetFromValue(CoreAttributeTypes.Active, DeletionFlag.EXCLUDE_DELETED, true);
+      Assert.assertEquals(cleanAttr, set.getExactlyOne());
    }
+
 }
diff --git a/plugins/org.eclipse.osee.orcs.core.test/src/org/eclipse/osee/orcs/core/internal/attribute/AttributeDeletedFilterTest.java b/plugins/org.eclipse.osee.orcs.core.test/src/org/eclipse/osee/orcs/core/internal/attribute/AttributeDeletedFilterTest.java
new file mode 100644
index 00000000000..9fe2e650a80
--- /dev/null
+++ b/plugins/org.eclipse.osee.orcs.core.test/src/org/eclipse/osee/orcs/core/internal/attribute/AttributeDeletedFilterTest.java
@@ -0,0 +1,59 @@
+/*******************************************************************************
+ * Copyright (c) 2012 Boeing.
+ * All rights reserved. This program and the accompanying materials
+ * are made available under the terms of the Eclipse Public License v1.0
+ * which accompanies this distribution, and is available at
+ * http://www.eclipse.org/legal/epl-v10.html
+ *
+ * Contributors:
+ *     Boeing - initial API and implementation
+ *******************************************************************************/
+package org.eclipse.osee.orcs.core.internal.attribute;
+
+import static org.mockito.Mockito.when;
+import org.eclipse.osee.framework.core.enums.DeletionFlag;
+import org.eclipse.osee.framework.core.exception.OseeCoreException;
+import org.junit.Assert;
+import org.junit.Before;
+import org.junit.Test;
+import org.mockito.Mock;
+import org.mockito.MockitoAnnotations;
+
+/**
+ * Test Case for {@link AttributeDeletedFilter}
+ * 
+ * @author Roberto E. Escobar
+ */
+@SuppressWarnings("rawtypes")
+public class AttributeDeletedFilterTest {
+
+   // @formatter:off
+   @Mock private Attribute deletedAttr;
+   @Mock private Attribute attribute;
+   // @formatter:on
+
+   @Before
+   public void init() {
+      MockitoAnnotations.initMocks(this);
+
+      when(deletedAttr.isDeleted()).thenReturn(true);
+      when(attribute.isDeleted()).thenReturn(false);
+   }
+
+   @Test
+   public void testIncludeDeleted() throws OseeCoreException {
+      Assert.assertTrue(filter(DeletionFlag.INCLUDE_DELETED).accept(deletedAttr));
+      Assert.assertTrue(filter(DeletionFlag.INCLUDE_DELETED).accept(attribute));
+   }
+
+   @Test
+   public void testExcludeDeleted() throws OseeCoreException {
+      Assert.assertFalse(filter(DeletionFlag.EXCLUDE_DELETED).accept(deletedAttr));
+      Assert.assertTrue(filter(DeletionFlag.EXCLUDE_DELETED).accept(attribute));
+   }
+
+   private AttributeFilter filter(DeletionFlag flag) {
+      return new AttributeDeletedFilter(flag);
+   }
+
+}
diff --git a/plugins/org.eclipse.osee.orcs.core.test/src/org/eclipse/osee/orcs/core/internal/attribute/AttributeDirtyFilterTest.java b/plugins/org.eclipse.osee.orcs.core.test/src/org/eclipse/osee/orcs/core/internal/attribute/AttributeDirtyFilterTest.java
new file mode 100644
index 00000000000..ca450778a43
--- /dev/null
+++ b/plugins/org.eclipse.osee.orcs.core.test/src/org/eclipse/osee/orcs/core/internal/attribute/AttributeDirtyFilterTest.java
@@ -0,0 +1,59 @@
+/*******************************************************************************
+ * Copyright (c) 2012 Boeing.
+ * All rights reserved. This program and the accompanying materials
+ * are made available under the terms of the Eclipse Public License v1.0
+ * which accompanies this distribution, and is available at
+ * http://www.eclipse.org/legal/epl-v10.html
+ *
+ * Contributors:
+ *     Boeing - initial API and implementation
+ *******************************************************************************/
+package org.eclipse.osee.orcs.core.internal.attribute;
+
+import static org.mockito.Mockito.when;
+import org.eclipse.osee.framework.core.exception.OseeCoreException;
+import org.eclipse.osee.orcs.core.internal.attribute.AttributeDirtyFilter.DirtyFlag;
+import org.junit.Assert;
+import org.junit.Before;
+import org.junit.Test;
+import org.mockito.Mock;
+import org.mockito.MockitoAnnotations;
+
+/**
+ * Test Case for {@link AttributeDirtyFilter}
+ * 
+ * @author Roberto E. Escobar
+ */
+@SuppressWarnings("rawtypes")
+public class AttributeDirtyFilterTest {
+
+   // @formatter:off
+   @Mock private Attribute dirtyAttr;
+   @Mock private Attribute noneDirtyAttr;
+   // @formatter:on
+
+   @Before
+   public void init() {
+      MockitoAnnotations.initMocks(this);
+
+      when(dirtyAttr.isDirty()).thenReturn(true);
+      when(noneDirtyAttr.isDirty()).thenReturn(false);
+   }
+
+   @Test
+   public void testAcceptDirties() throws OseeCoreException {
+      Assert.assertFalse(filter(DirtyFlag.DIRTY).accept(noneDirtyAttr));
+      Assert.assertTrue(filter(DirtyFlag.DIRTY).accept(dirtyAttr));
+   }
+
+   @Test
+   public void testAcceptNoneDirties() throws OseeCoreException {
+      Assert.assertTrue(filter(DirtyFlag.NON_DIRTY).accept(noneDirtyAttr));
+      Assert.assertFalse(filter(DirtyFlag.NON_DIRTY).accept(dirtyAttr));
+   }
+
+   private AttributeFilter filter(DirtyFlag flag) {
+      return new AttributeDirtyFilter(flag);
+   }
+
+}
diff --git a/plugins/org.eclipse.osee.orcs.core.test/src/org/eclipse/osee/orcs/core/internal/attribute/AttributeFactoryTest.java b/plugins/org.eclipse.osee.orcs.core.test/src/org/eclipse/osee/orcs/core/internal/attribute/AttributeFactoryTest.java
index 07bd6997943..71659bde77c 100644
--- a/plugins/org.eclipse.osee.orcs.core.test/src/org/eclipse/osee/orcs/core/internal/attribute/AttributeFactoryTest.java
+++ b/plugins/org.eclipse.osee.orcs.core.test/src/org/eclipse/osee/orcs/core/internal/attribute/AttributeFactoryTest.java
@@ -10,19 +10,33 @@
  *******************************************************************************/
 package org.eclipse.osee.orcs.core.internal.attribute;
 
-import static org.mockito.Matchers.*;
-import static org.mockito.Mockito.*;
+import static org.mockito.Matchers.eq;
+import static org.mockito.Mockito.mock;
+import static org.mockito.Mockito.times;
+import static org.mockito.Mockito.verify;
+import static org.mockito.Mockito.when;
+import java.lang.ref.WeakReference;
+import junit.framework.Assert;
+import org.eclipse.osee.framework.core.data.IAttributeType;
+import org.eclipse.osee.framework.core.data.IOseeBranch;
+import org.eclipse.osee.framework.core.enums.CoreAttributeTypes;
 import org.eclipse.osee.framework.core.enums.CoreBranches;
+import org.eclipse.osee.framework.core.exception.OseeArgumentException;
 import org.eclipse.osee.framework.core.exception.OseeCoreException;
 import org.eclipse.osee.framework.core.model.cache.AttributeTypeCache;
 import org.eclipse.osee.framework.core.model.type.AttributeType;
-import org.eclipse.osee.logger.Log;
+import org.eclipse.osee.orcs.core.ds.ArtifactData;
 import org.eclipse.osee.orcs.core.ds.AttributeData;
 import org.eclipse.osee.orcs.core.ds.AttributeDataFactory;
 import org.eclipse.osee.orcs.core.ds.DataProxy;
+import org.eclipse.osee.orcs.core.ds.ResourceNameResolver;
 import org.eclipse.osee.orcs.core.ds.VersionData;
+import org.eclipse.osee.orcs.core.internal.artifact.AttributeManager;
 import org.junit.Before;
+import org.junit.Rule;
 import org.junit.Test;
+import org.junit.rules.ExpectedException;
+import org.mockito.ArgumentCaptor;
 import org.mockito.Mock;
 import org.mockito.MockitoAnnotations;
 
@@ -33,66 +47,172 @@ import org.mockito.MockitoAnnotations;
  */
 public class AttributeFactoryTest {
 
-   @Mock
-   private Log logger;
-   @Mock
-   private AttributeTypeCache cache;
-   @Mock
-   private AttributeType attrType;
-   @Mock
-   private AttributeClassResolver resolver;
-   @Mock
-   private AttributeDataFactory dataFactory;
-   //   @Mock
-   //   private AttributeContainer container;
-   @Mock
-   private AttributeData data;
-   @Mock
-   private DataProxy proxy;
-   @Mock
-   private Attribute<Object> attr;
+   @Rule
+   public ExpectedException thrown = ExpectedException.none();
+
+   // @formatter:off
+   @Mock private AttributeClassResolver classResolver;
+   @Mock private AttributeTypeCache cache;
+   @Mock private AttributeDataFactory dataFactory;
+   
+   @Mock private AttributeData attributeData;
+   @Mock private VersionData attrVersionData;
+   
+   @Mock private AttributeType attributeType;
+   @Mock private Attribute<Object> attribute;
+
+   @Mock private AttributeManager container;
+   @Mock private DataProxy proxy;
+   // @formatter:on
 
    private AttributeFactory factory;
+   private long expectedGuid;
+   private final IOseeBranch branch = CoreBranches.COMMON;
 
    @Before
-   public void initMocks() throws OseeCoreException {
+   public void init() throws OseeCoreException {
       MockitoAnnotations.initMocks(this);
-      when(cache.getByGuid(anyLong())).thenReturn(attrType);
-      when(resolver.createAttribute(any(AttributeType.class))).thenReturn(attr);
-      when(data.getDataProxy()).thenReturn(proxy);
-      factory = new AttributeFactory(logger, resolver, cache, dataFactory);
+
+      factory = new AttributeFactory(classResolver, cache, dataFactory);
+
+      expectedGuid = CoreAttributeTypes.Name.getGuid();
+
+      when(attributeData.getTypeUuid()).thenReturn(expectedGuid);
+      when(cache.getByGuid(expectedGuid)).thenReturn(attributeType);
+      when(classResolver.createAttribute(attributeType)).thenReturn(attribute);
+      when(attributeData.getDataProxy()).thenReturn(proxy);
+   }
+
+   @Test
+   public void testCreateAttributeNullType() throws OseeCoreException {
+      when(cache.getByGuid(expectedGuid)).thenReturn(null);
+
+      thrown.expect(OseeArgumentException.class);
+      thrown.expectMessage("attributeType cannot be null - Cannot find attribute type with uuid[" + expectedGuid + "]");
+      factory.createAttribute(container, attributeData);
    }
 
+   @SuppressWarnings({"unchecked", "rawtypes"})
    @Test
    public void testCreateAttribute() throws OseeCoreException {
-      //      factory.createAttribute(container, data);
-      //      verify(container).add(attrType, attr);
+      ArgumentCaptor<ResourceNameResolver> resolverCapture = ArgumentCaptor.forClass(ResourceNameResolver.class);
+      ArgumentCaptor<WeakReference> refCapture = ArgumentCaptor.forClass(WeakReference.class);
+
+      Attribute<Object> actual = factory.createAttribute(container, attributeData);
+
+      Assert.assertTrue(attribute == actual);
+
+      verify(proxy).setResolver(resolverCapture.capture());
+      verify(attribute).internalInitialize(refCapture.capture(), eq(attributeData), eq(attributeType), eq(false),
+         eq(false));
+      verify(container).add(attributeType, attribute);
+      Assert.assertEquals(container, refCapture.getValue().get());
+
    }
 
+   @SuppressWarnings({"unchecked", "rawtypes"})
+   @Test
+   public void testCreateAttributeFromArtifactDataAndType() throws OseeCoreException {
+      ArtifactData artifactData = mock(ArtifactData.class);
+      VersionData artVersionData = mock(VersionData.class);
+
+      when(dataFactory.create(artifactData, attributeType)).thenReturn(attributeData);
+      when(attributeData.getVersion()).thenReturn(attrVersionData);
+      when(artifactData.getVersion()).thenReturn(artVersionData);
+      when(artVersionData.getBranchId()).thenReturn(45);
+
+      ArgumentCaptor<ResourceNameResolver> resolverCapture = ArgumentCaptor.forClass(ResourceNameResolver.class);
+      ArgumentCaptor<WeakReference> refCapture = ArgumentCaptor.forClass(WeakReference.class);
+
+      Attribute<Object> actual = factory.createAttribute(container, artifactData, attributeType);
+
+      verify(dataFactory).create(artifactData, attributeType);
+      verify(attrVersionData).setBranchId(45);
+      Assert.assertTrue(attribute == actual);
+
+      verify(proxy).setResolver(resolverCapture.capture());
+      verify(attribute).internalInitialize(refCapture.capture(), eq(attributeData), eq(attributeType), eq(false),
+         eq(false));
+      verify(container).add(attributeType, attribute);
+      Assert.assertEquals(container, refCapture.getValue().get());
+
+   }
+
+   @SuppressWarnings({"unchecked", "rawtypes"})
    @Test
    public void testCopyAttribute() throws OseeCoreException {
-      when(attr.getOrcsData()).thenReturn(data);
-      AttributeData copyAttrData = mock(AttributeData.class);
-      when(copyAttrData.getDataProxy()).thenReturn(proxy);
-      when(dataFactory.copy(CoreBranches.COMMON, data)).thenReturn(copyAttrData);
-      //      Attribute<?> copy = factory.copyAttribute(attr, CoreBranches.COMMON, container);
-
-      //      verify(container).add(attrType, copy);
-      verify(dataFactory).copy(CoreBranches.COMMON, data);
+      AttributeData copiedAttributeData = mock(AttributeData.class);
+
+      when(dataFactory.copy(branch, attributeData)).thenReturn(copiedAttributeData);
+      when(copiedAttributeData.getTypeUuid()).thenReturn(expectedGuid);
+      when(copiedAttributeData.getDataProxy()).thenReturn(proxy);
+
+      ArgumentCaptor<ResourceNameResolver> resolverCapture = ArgumentCaptor.forClass(ResourceNameResolver.class);
+      ArgumentCaptor<WeakReference> refCapture = ArgumentCaptor.forClass(WeakReference.class);
+
+      Attribute<Object> actual = factory.copyAttribute(attributeData, branch, container);
+
+      Assert.assertTrue(attribute == actual);
+
+      verify(dataFactory).copy(branch, attributeData);
+
+      verify(proxy).setResolver(resolverCapture.capture());
+      verify(attribute).internalInitialize(refCapture.capture(), eq(copiedAttributeData), eq(attributeType), eq(false),
+         eq(false));
+      verify(container).add(attributeType, attribute);
+      Assert.assertEquals(container, refCapture.getValue().get());
+   }
+
+   @Test
+   public void testIntroduceAttributeNotInStorage() throws OseeCoreException {
+      when(attributeData.getVersion()).thenReturn(attrVersionData);
+      when(attrVersionData.isInStorage()).thenReturn(false);
+
+      boolean actual = factory.introduceAttribute(attributeData, branch, container);
+      Assert.assertFalse(actual);
    }
 
+   @SuppressWarnings({"rawtypes", "unchecked"})
    @Test
    public void testIntroduceAttribute() throws OseeCoreException {
-      VersionData version = mock(VersionData.class);
-      AttributeData newAttrData = mock(AttributeData.class);
-      when(newAttrData.getDataProxy()).thenReturn(proxy);
-      when(attr.getOrcsData()).thenReturn(data);
-      when(data.getVersion()).thenReturn(version);
-      when(version.isInStorage()).thenReturn(true);
-      when(dataFactory.introduce(CoreBranches.COMMON, data)).thenReturn(newAttrData);
-      //      factory.introduceAttribute(attr, CoreBranches.COMMON, container);
-
-      verify(dataFactory).introduce(CoreBranches.COMMON, data);
-      //      verify(container).add(attrType, attr);
+      AttributeData introducedAttributeData = mock(AttributeData.class);
+
+      when(attributeData.getVersion()).thenReturn(attrVersionData);
+      when(attrVersionData.isInStorage()).thenReturn(true);
+
+      when(dataFactory.introduce(branch, attributeData)).thenReturn(introducedAttributeData);
+      when(introducedAttributeData.getTypeUuid()).thenReturn(expectedGuid);
+      when(introducedAttributeData.getDataProxy()).thenReturn(proxy);
+
+      ArgumentCaptor<ResourceNameResolver> resolverCapture = ArgumentCaptor.forClass(ResourceNameResolver.class);
+      ArgumentCaptor<WeakReference> refCapture = ArgumentCaptor.forClass(WeakReference.class);
+
+      boolean actual = factory.introduceAttribute(attributeData, branch, container);
+      Assert.assertTrue(actual);
+
+      verify(dataFactory).introduce(branch, attributeData);
+
+      verify(proxy).setResolver(resolverCapture.capture());
+      verify(attribute).internalInitialize(refCapture.capture(), eq(introducedAttributeData), eq(attributeType),
+         eq(false), eq(false));
+      verify(container).add(attributeType, attribute);
+      Assert.assertEquals(container, refCapture.getValue().get());
+   }
+
+   @Test
+   public void testGetAttributeType() throws OseeCoreException {
+      IAttributeType token = mock(IAttributeType.class);
+
+      when(cache.get(token)).thenReturn(attributeType);
+
+      AttributeType actual = factory.getAttribeType(attributeType);
+
+      Assert.assertTrue(actual == attributeType);
+      verify(cache, times(0)).get(attributeType);
+
+      AttributeType actual1 = factory.getAttribeType(token);
+
+      Assert.assertTrue(actual1 == attributeType);
+      verify(cache).get(token);
    }
 }
diff --git a/plugins/org.eclipse.osee.orcs.core.test/src/org/eclipse/osee/orcs/core/internal/attribute/AttributeFilterTest.java b/plugins/org.eclipse.osee.orcs.core.test/src/org/eclipse/osee/orcs/core/internal/attribute/AttributeFilterTest.java
new file mode 100644
index 00000000000..72b96b280bd
--- /dev/null
+++ b/plugins/org.eclipse.osee.orcs.core.test/src/org/eclipse/osee/orcs/core/internal/attribute/AttributeFilterTest.java
@@ -0,0 +1,93 @@
+/*******************************************************************************
+ * Copyright (c) 2012 Boeing.
+ * All rights reserved. This program and the accompanying materials
+ * are made available under the terms of the Eclipse Public License v1.0
+ * which accompanies this distribution, and is available at
+ * http://www.eclipse.org/legal/epl-v10.html
+ *
+ * Contributors:
+ *     Boeing - initial API and implementation
+ *******************************************************************************/
+package org.eclipse.osee.orcs.core.internal.attribute;
+
+import static org.mockito.Mockito.when;
+import org.eclipse.osee.framework.core.exception.OseeCoreException;
+import org.junit.Assert;
+import org.junit.Before;
+import org.junit.Test;
+import org.mockito.Mock;
+import org.mockito.Mockito;
+import org.mockito.MockitoAnnotations;
+
+/**
+ * Test Case for {@link AttributeDeletedFilter}
+ * 
+ * @author Roberto E. Escobar
+ */
+public class AttributeFilterTest {
+
+   // @formatter:off
+   @SuppressWarnings("rawtypes")
+   @Mock private Attribute attribute;
+   // @formatter:on
+
+   private AttributeFilter filter1;
+   private AttributeFilter filter2;
+
+   @Before
+   public void init() {
+      MockitoAnnotations.initMocks(this);
+      filter1 = Mockito.spy(new FilterMock());
+      filter2 = Mockito.spy(new FilterMock());
+   }
+
+   @Test
+   public void testAnd() throws OseeCoreException {
+      AttributeFilter andFilter = filter1.and(filter2);
+
+      when(filter1.accept(attribute)).thenReturn(true);
+      when(filter2.accept(attribute)).thenReturn(true);
+      Assert.assertTrue(andFilter.accept(attribute));
+
+      when(filter1.accept(attribute)).thenReturn(false);
+      when(filter2.accept(attribute)).thenReturn(true);
+      Assert.assertFalse(andFilter.accept(attribute));
+
+      when(filter1.accept(attribute)).thenReturn(true);
+      when(filter2.accept(attribute)).thenReturn(false);
+      Assert.assertFalse(andFilter.accept(attribute));
+
+      when(filter1.accept(attribute)).thenReturn(false);
+      when(filter2.accept(attribute)).thenReturn(false);
+      Assert.assertFalse(andFilter.accept(attribute));
+   }
+
+   @Test
+   public void testOr() throws OseeCoreException {
+      AttributeFilter orFilter = filter1.or(filter2);
+
+      when(filter1.accept(attribute)).thenReturn(true);
+      when(filter2.accept(attribute)).thenReturn(true);
+      Assert.assertTrue(orFilter.accept(attribute));
+
+      when(filter1.accept(attribute)).thenReturn(false);
+      when(filter2.accept(attribute)).thenReturn(true);
+      Assert.assertTrue(orFilter.accept(attribute));
+
+      when(filter1.accept(attribute)).thenReturn(true);
+      when(filter2.accept(attribute)).thenReturn(false);
+      Assert.assertTrue(orFilter.accept(attribute));
+
+      when(filter1.accept(attribute)).thenReturn(false);
+      when(filter2.accept(attribute)).thenReturn(false);
+      Assert.assertFalse(orFilter.accept(attribute));
+   }
+
+   private class FilterMock extends AttributeFilter {
+      @Override
+      public boolean accept(Attribute<?> attribute) {
+         return false;
+      }
+   };
+
+}
diff --git a/plugins/org.eclipse.osee.orcs.core.test/src/org/eclipse/osee/orcs/core/internal/attribute/AttributeFromStringFilterTest.java b/plugins/org.eclipse.osee.orcs.core.test/src/org/eclipse/osee/orcs/core/internal/attribute/AttributeFromStringFilterTest.java
new file mode 100644
index 00000000000..f3c237ef2b4
--- /dev/null
+++ b/plugins/org.eclipse.osee.orcs.core.test/src/org/eclipse/osee/orcs/core/internal/attribute/AttributeFromStringFilterTest.java
@@ -0,0 +1,74 @@
+/*******************************************************************************
+ * Copyright (c) 2012 Boeing.
+ * All rights reserved. This program and the accompanying materials
+ * are made available under the terms of the Eclipse Public License v1.0
+ * which accompanies this distribution, and is available at
+ * http://www.eclipse.org/legal/epl-v10.html
+ *
+ * Contributors:
+ *     Boeing - initial API and implementation
+ *******************************************************************************/
+package org.eclipse.osee.orcs.core.internal.attribute;
+
+import static org.mockito.Mockito.when;
+import java.util.Date;
+import org.eclipse.osee.framework.core.exception.OseeCoreException;
+import org.junit.Assert;
+import org.junit.Before;
+import org.junit.Test;
+import org.mockito.Mock;
+import org.mockito.MockitoAnnotations;
+
+/**
+ * Test Case for {@link AttributeFromStringFilter}
+ * 
+ * @author Roberto E. Escobar
+ */
+@SuppressWarnings("rawtypes")
+public class AttributeFromStringFilterTest {
+
+   // @formatter:off
+   @Mock private Attribute attribute1;
+   @Mock private Attribute attribute2;
+   @Mock private Attribute attribute3;
+   // @formatter:on
+
+   private Date date;
+
+   @Before
+   public void init() throws OseeCoreException {
+      MockitoAnnotations.initMocks(this);
+
+      date = new Date();
+
+      when(attribute1.getValue()).thenReturn(45789L);
+      when(attribute2.getValue()).thenReturn(true);
+      when(attribute3.getValue()).thenReturn(date);
+   }
+
+   @Test
+   public void testAccept() throws OseeCoreException {
+      Assert.assertTrue(filter("45789").accept(attribute1));
+      Assert.assertTrue(filter("true").accept(attribute2));
+      Assert.assertTrue(filter(date.toString()).accept(attribute3));
+   }
+
+   @Test
+   public void testNotAccept() throws OseeCoreException {
+      Assert.assertFalse(filter("Helo").accept(attribute1));
+      Assert.assertFalse(filter("Hello").accept(attribute2));
+
+      Date date2 = new Date(123123111231L);
+
+      Assert.assertFalse(filter(date2.toString()).accept(attribute3));
+
+      Assert.assertFalse(filter("true").accept(attribute1));
+      Assert.assertFalse(filter("false").accept(attribute1));
+      Assert.assertFalse(filter("false").accept(attribute2));
+   }
+
+   private <T> AttributeFilter filter(String value) {
+      return new AttributeFromStringFilter(value);
+   }
+
+}
diff --git a/plugins/org.eclipse.osee.orcs.core.test/src/org/eclipse/osee/orcs/core/internal/attribute/AttributeResultSetTest.java b/plugins/org.eclipse.osee.orcs.core.test/src/org/eclipse/osee/orcs/core/internal/attribute/AttributeResultSetTest.java
new file mode 100644
index 00000000000..95dd6ecbce5
--- /dev/null
+++ b/plugins/org.eclipse.osee.orcs.core.test/src/org/eclipse/osee/orcs/core/internal/attribute/AttributeResultSetTest.java
@@ -0,0 +1,127 @@
+/*******************************************************************************
+ * Copyright (c) 2012 Boeing.
+ * All rights reserved. This program and the accompanying materials
+ * are made available under the terms of the Eclipse Public License v1.0
+ * which accompanies this distribution, and is available at
+ * http://www.eclipse.org/legal/epl-v10.html
+ *
+ * Contributors:
+ *     Boeing - initial API and implementation
+ *******************************************************************************/
+package org.eclipse.osee.orcs.core.internal.attribute;
+
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertNull;
+import static org.mockito.Mockito.spy;
+import static org.mockito.Mockito.verify;
+import java.util.ArrayList;
+import java.util.List;
+import org.eclipse.osee.framework.core.data.IAttributeType;
+import org.eclipse.osee.framework.core.enums.CoreAttributeTypes;
+import org.eclipse.osee.framework.core.exception.ItemDoesNotExist;
+import org.eclipse.osee.framework.core.exception.MultipleItemsExist;
+import org.eclipse.osee.framework.core.exception.OseeCoreException;
+import org.junit.Before;
+import org.junit.Rule;
+import org.junit.Test;
+import org.junit.rules.ExpectedException;
+import org.mockito.Mock;
+import org.mockito.MockitoAnnotations;
+
+/**
+ * Test Case for {@link AttributeResultSet }
+ * 
+ * @author Roberto E. Escobar
+ */
+public class AttributeResultSetTest {
+
+   @Rule
+   public ExpectedException thrown = ExpectedException.none();
+
+   // @formatter:off
+   @Mock private AttributeExceptionFactory factory;
+   @Mock private Attribute<String> attribute1;
+   @Mock private Attribute<String> attribute2;
+   // @formatter:on
+
+   private AttributeResultSet<String> rSetWithType;
+   private AttributeResultSet<String> rSetNoType;
+
+   private final IAttributeType type = CoreAttributeTypes.Annotation;
+   private List<Attribute<String>> list;
+
+   @Before
+   public void init() {
+      MockitoAnnotations.initMocks(this);
+
+      list = new ArrayList<Attribute<String>>();
+      rSetNoType = new AttributeResultSet<String>(null, list);
+      rSetWithType = new AttributeResultSet<String>(factory, type, list);
+   }
+
+   @Test
+   public void testGetList() {
+      assertEquals(list, rSetNoType.getList());
+   }
+
+   @Test
+   public void testIterator() {
+      List<Attribute<String>> spy = spy(list);
+      rSetNoType = new AttributeResultSet<String>(factory, spy);
+      rSetNoType.iterator();
+
+      verify(spy).iterator();
+   }
+
+   @Test
+   public void testGetIterable() {
+      assertEquals(list, rSetNoType.getIterable(-1));
+   }
+
+   @Test
+   public void testExactlyOne() throws OseeCoreException {
+      thrown.expect(ItemDoesNotExist.class);
+      rSetNoType.getExactlyOne();
+
+      rSetWithType.getExactlyOne();
+      verify(factory).createDoesNotExistException(type);
+
+      list.add(attribute1);
+      assertEquals(attribute1, rSetNoType.getExactlyOne());
+
+      list.add(attribute2);
+
+      thrown.expect(MultipleItemsExist.class);
+      rSetNoType.getExactlyOne();
+
+      rSetWithType.getExactlyOne();
+      verify(factory).createManyExistException(type, 2);
+   }
+
+   @Test
+   public void testGetOneOrNull() {
+      assertNull(rSetNoType.getOneOrNull());
+
+      list.add(attribute1);
+      assertEquals(attribute1, rSetNoType.getOneOrNull());
+
+      list.add(attribute2);
+      assertEquals(attribute1, rSetNoType.getOneOrNull());
+   }
+
+   @Test
+   public void testGetAtMostOneOrNull() throws OseeCoreException {
+      assertNull(rSetNoType.getAtMostOneOrNull());
+
+      list.add(attribute1);
+      assertEquals(attribute1, rSetNoType.getAtMostOneOrNull());
+
+      list.add(attribute2);
+
+      thrown.expect(MultipleItemsExist.class);
+      rSetNoType.getAtMostOneOrNull();
+
+      rSetWithType.getAtMostOneOrNull();
+      verify(factory).createManyExistException(type, 2);
+   }
+}
diff --git a/plugins/org.eclipse.osee.orcs.core.test/src/org/eclipse/osee/orcs/core/internal/attribute/AttributeRowMapperTest.java b/plugins/org.eclipse.osee.orcs.core.test/src/org/eclipse/osee/orcs/core/internal/attribute/AttributeRowMapperTest.java
index d0563b5414e..7ec327e8ecf 100644
--- a/plugins/org.eclipse.osee.orcs.core.test/src/org/eclipse/osee/orcs/core/internal/attribute/AttributeRowMapperTest.java
+++ b/plugins/org.eclipse.osee.orcs.core.test/src/org/eclipse/osee/orcs/core/internal/attribute/AttributeRowMapperTest.java
@@ -10,9 +10,20 @@
  *******************************************************************************/
 package org.eclipse.osee.orcs.core.internal.attribute;
 
+import static org.mockito.Mockito.times;
+import static org.mockito.Mockito.verify;
+import static org.mockito.Mockito.when;
+import java.util.Map;
 import org.eclipse.osee.framework.core.exception.OseeCoreException;
-import org.junit.Ignore;
+import org.eclipse.osee.logger.Log;
+import org.eclipse.osee.orcs.core.ds.AttributeData;
+import org.eclipse.osee.orcs.core.internal.artifact.AttributeManager;
+import org.junit.Before;
 import org.junit.Test;
+import org.mockito.Mock;
+import org.mockito.MockitoAnnotations;
+import org.mockito.invocation.InvocationOnMock;
+import org.mockito.stubbing.Answer;
 
 /**
  * Test Case for {@link AttributeRowMapper}
@@ -21,14 +32,50 @@ import org.junit.Test;
  */
 public class AttributeRowMapperTest {
 
+   // @formatter:off
+   @Mock private Log logger;
+   @Mock private AttributeFactory factory;
+   @Mock private Map<Integer, ? extends AttributeManager> attributeContainers;
+   @Mock private AttributeData data;
+   @Mock private AttributeManager manager;
+   // @formatter:on
+
+   private AttributeRowMapper mapper;
+
+   @Before
+   public void init() {
+      MockitoAnnotations.initMocks(this);
+
+      mapper = new AttributeRowMapper(logger, factory, attributeContainers);
+   }
+
    @Test
-   @Ignore
-   public void test() throws OseeCoreException {
-      //      Log logger = new MockLog();
-      //      AttributeFactory factory = null;
-      //      AttributeData row = new AttributeData();
-      //      Map<Integer, ? extends AttributeContainer> attributeContainers = new HashMap<Integer, AttributeContainer>();
-      //      AttributeRowMapper mapper = new AttributeRowMapper(logger, factory, attributeContainers);
-      //      mapper.onData(row);
+   public void testOnDataValid() throws OseeCoreException {
+      when(data.getArtifactId()).thenReturn(45);
+      when(attributeContainers.get(45)).thenAnswer(new Answer<AttributeManager>() {
+
+         @Override
+         public AttributeManager answer(InvocationOnMock invocation) throws Throwable {
+            return manager;
+         }
+      });
+
+      mapper.onData(data);
+
+      verify(attributeContainers).get(45);
+      verify(factory).createAttribute(manager, data);
+      verify(logger, times(0)).warn("");
+   }
+
+   @Test
+   public void testOnDataNotFound() throws OseeCoreException {
+      when(data.getArtifactId()).thenReturn(45);
+      when(attributeContainers.get(45)).thenReturn(null);
+
+      mapper.onData(data);
+
+      verify(attributeContainers).get(45);
+      verify(factory, times(0)).createAttribute(manager, data);
+      verify(logger).warn("Orphaned attribute detected - [%s]", data);
    }
 }
diff --git a/plugins/org.eclipse.osee.orcs.core.test/src/org/eclipse/osee/orcs/core/internal/attribute/AttributeTestSuite.java b/plugins/org.eclipse.osee.orcs.core.test/src/org/eclipse/osee/orcs/core/internal/attribute/AttributeTestSuite.java
index 6cc5d2305b6..bef093f4049 100644
--- a/plugins/org.eclipse.osee.orcs.core.test/src/org/eclipse/osee/orcs/core/internal/attribute/AttributeTestSuite.java
+++ b/plugins/org.eclipse.osee.orcs.core.test/src/org/eclipse/osee/orcs/core/internal/attribute/AttributeTestSuite.java
@@ -19,9 +19,15 @@ import org.junit.runners.Suite;
 @RunWith(Suite.class)
 @Suite.SuiteClasses({
    AttributeClassResolverTest.class,
+   AttributeCollectionTest.class,
+   AttributeDeletedFilterTest.class,
+   AttributeDirtyFilterTest.class,
    AttributeFactoryTest.class,
-   AttributeFactoryTest.class,
-   AttributeCollectionTest.class})
+   AttributeFilterTest.class,
+   AttributeFromStringFilterTest.class,
+   AttributeResultSetTest.class,
+   AttributeRowMapperTest.class,
+   AttributeValueFilterTest.class})
 public class AttributeTestSuite {
    // Test Suite
 }
diff --git a/plugins/org.eclipse.osee.orcs.core.test/src/org/eclipse/osee/orcs/core/internal/attribute/AttributeValueFilterTest.java b/plugins/org.eclipse.osee.orcs.core.test/src/org/eclipse/osee/orcs/core/internal/attribute/AttributeValueFilterTest.java
new file mode 100644
index 00000000000..aa2c64ccd63
--- /dev/null
+++ b/plugins/org.eclipse.osee.orcs.core.test/src/org/eclipse/osee/orcs/core/internal/attribute/AttributeValueFilterTest.java
@@ -0,0 +1,62 @@
+/*******************************************************************************
+ * Copyright (c) 2012 Boeing.
+ * All rights reserved. This program and the accompanying materials
+ * are made available under the terms of the Eclipse Public License v1.0
+ * which accompanies this distribution, and is available at
+ * http://www.eclipse.org/legal/epl-v10.html
+ *
+ * Contributors:
+ *     Boeing - initial API and implementation
+ *******************************************************************************/
+package org.eclipse.osee.orcs.core.internal.attribute;
+
+import static org.mockito.Mockito.when;
+import org.eclipse.osee.framework.core.exception.OseeCoreException;
+import org.junit.Assert;
+import org.junit.Before;
+import org.junit.Test;
+import org.mockito.Mock;
+import org.mockito.MockitoAnnotations;
+
+/**
+ * Test Case for {@link AttributeValueFilter}
+ * 
+ * @author Roberto E. Escobar
+ */
+@SuppressWarnings("rawtypes")
+public class AttributeValueFilterTest {
+
+   // @formatter:off
+   @Mock private Attribute attribute1;
+   @Mock private Attribute attribute2;
+   // @formatter:on
+
+   @Before
+   public void init() throws OseeCoreException {
+      MockitoAnnotations.initMocks(this);
+
+      when(attribute1.getValue()).thenReturn("Hello");
+      when(attribute2.getValue()).thenReturn(true);
+   }
+
+   @Test
+   public void testAccept() throws OseeCoreException {
+      Assert.assertTrue(filter("Hello").accept(attribute1));
+      Assert.assertTrue(filter(true).accept(attribute2));
+   }
+
+   @Test
+   public void testNotAccept() throws OseeCoreException {
+      Assert.assertFalse(filter("Helo").accept(attribute1));
+      Assert.assertFalse(filter("Hello").accept(attribute2));
+
+      Assert.assertFalse(filter(true).accept(attribute1));
+      Assert.assertFalse(filter(false).accept(attribute1));
+      Assert.assertFalse(filter(false).accept(attribute2));
+   }
+
+   private <T> AttributeFilter filter(T value) {
+      return new AttributeValueFilter<T>(value);
+   }
+
+}
diff --git a/plugins/org.eclipse.osee.orcs.core.test/src/org/eclipse/osee/orcs/core/internal/branch/provider/BranchProviderTestSuite.java b/plugins/org.eclipse.osee.orcs.core.test/src/org/eclipse/osee/orcs/core/internal/branch/provider/BranchProviderTestSuite.java
index d3a8e65e7b8..bbf6ec34b3a 100644
--- a/plugins/org.eclipse.osee.orcs.core.test/src/org/eclipse/osee/orcs/core/internal/branch/provider/BranchProviderTestSuite.java
+++ b/plugins/org.eclipse.osee.orcs.core.test/src/org/eclipse/osee/orcs/core/internal/branch/provider/BranchProviderTestSuite.java
@@ -14,7 +14,7 @@ import org.junit.runner.RunWith;
 import org.junit.runners.Suite;
 
 @RunWith(Suite.class)
-@Suite.SuiteClasses({PurgeBranchTest.class, DeletedBranchProviderTest.class, MultiBranchProviderTest.class})
+@Suite.SuiteClasses({DeletedBranchProviderTest.class, MultiBranchProviderTest.class})
 /**
  * @author John R. Misinco
  */
diff --git a/plugins/org.eclipse.osee.orcs.core.test/src/org/eclipse/osee/orcs/core/internal/branch/provider/PurgeBranchTest.java b/plugins/org.eclipse.osee.orcs.core.test/src/org/eclipse/osee/orcs/core/internal/branch/provider/PurgeBranchTest.java
deleted file mode 100644
index babe113d077..00000000000
--- a/plugins/org.eclipse.osee.orcs.core.test/src/org/eclipse/osee/orcs/core/internal/branch/provider/PurgeBranchTest.java
+++ /dev/null
@@ -1,140 +0,0 @@
-/*******************************************************************************
- * Copyright (c) 2011 Boeing.
- * All rights reserved. This program and the accompanying materials
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- *
- * Contributors:
- *     Boeing - initial API and implementation
- *******************************************************************************/
-package org.eclipse.osee.orcs.core.internal.branch.provider;
-
-import org.junit.Ignore;
-import org.junit.Test;
-
-/**
- * @author John R. Misinco
- */
-public final class PurgeBranchTest {
-
-   @Ignore
-   @Test
-   public void testPurgeBranch() throws Exception {
-      //
-      //      runTest(false, false, false, true);
-   }
-   //
-   //   @Test
-   //   public void testBranchOperationException__nullFactory() throws Exception {
-   //      runTest(true, false, false, false);
-   //   }
-   //
-   //   @Test
-   //   public void testBranchOperationException__nullProvider() throws Exception {
-   //      runTest(false, true, false, false);
-   //   }
-   //
-   //   @Test
-   //   public void testBranchOperationException__nullLogger() throws Exception {
-   //      runTest(false, false, true, false);
-   //   }
-   //
-   //   @Test
-   //   public void testBranchOperationException__allNull() throws Exception {
-   //      runTest(true, true, true, false);
-   //   }
-   //
-   //   private void runTest(boolean nullFactory, boolean nullProvider, boolean nullLogger, boolean expectedResult) throws Exception {
-   //      MockBranchProvider mbp = new MockBranchProvider();
-   //
-   //      if (nullProvider) {
-   //         mbp = null;
-   //      }
-   //
-   //      Collection<Branch> branches = mbp.getBranches();
-   //      Branch rootBranch = MockBranchProvider.getRootBranch(branches);
-   //      BranchCache branchCache = createBranchCache();
-   //      branchCache.cache(rootBranch);
-   //
-   //      IOseeBranch toPurge = TokenFactory.createBranch(rootBranch.getGuid(), rootBranch.getName());
-   //      MockBranchDataStore branchStore = new MockBranchDataStore();
-   //
-   //      Callable<List<Branch>> callable =
-   //         new PurgeBranchCallable(new MockLog(), new MockSessionContext(), branchStore, branchCache, toPurge, false);
-   //      List<Branch> purged = callable.call();
-   //
-   //      Assert.assertEquals(10, branchStore.getPurgeCount());
-   //      Assert.assertTrue(verifyCallOrder(purged));
-   //   }
-   //
-   //   private static boolean verifyCallOrder(List<Branch> callOrder) throws OseeCoreException {
-   //      boolean result = true;
-   //      for (Branch cur : callOrder) {
-   //         int idxCur = callOrder.indexOf(cur);
-   //         Branch parent = cur.getParentBranch();
-   //         if (parent != null) {
-   //            int idxParent = callOrder.indexOf(parent);
-   //            if (idxCur > idxParent) {
-   //               result = false;
-   //               break;
-   //            }
-   //         }
-   //      }
-   //      return result;
-   //   }
-   //
-   //   private static BranchCache createBranchCache() {
-   //      return new BranchCache(new IOseeDataAccessor<String, Branch>() {
-   //
-   //         @Override
-   //         public void load(IOseeCache<String, Branch> cache) {
-   //            //
-   //         }
-   //
-   //         @Override
-   //         public void store(Collection<Branch> types) {
-   //            //
-   //         }
-   //      });
-   //   }
-   //
-   //   private final class MockBranchDataStore implements BranchDataStore {
-   //
-   //      private int purgeCount = 0;
-   //
-   //      @Override
-   //      public Callable<Branch> createBranch(String sessionId, CreateBranchData newBranchData) {
-   //         return null;
-   //      }
-   //
-   //      @Override
-   //      public Callable<Branch> purgeBranch(String sessionId, final Branch branch) {
-   //         purgeCount++;
-   //         return new Callable<Branch>() {
-   //
-   //            @Override
-   //            public Branch call() throws Exception {
-   //               return branch;
-   //            }
-   //
-   //         };
-   //      }
-   //
-   //      @Override
-   //      public Callable<TransactionRecord> commitBranch(String sessionId, Branch source, Branch destination) {
-   //         return null;
-   //      }
-   //
-   //      @Override
-   //      public Callable<?> compareBranch(String sessionId, TransactionRecord sourceTx, TransactionRecord destinationTx) {
-   //         return null;
-   //      }
-   //
-   //      public int getPurgeCount() {
-   //         return purgeCount;
-   //      }
-   //
-   //   }
-
-}
diff --git a/plugins/org.eclipse.osee.orcs.core.test/src/org/eclipse/osee/orcs/core/internal/proxy/ArtifactProxyFactoryTest.java b/plugins/org.eclipse.osee.orcs.core.test/src/org/eclipse/osee/orcs/core/internal/proxy/ArtifactProxyFactoryTest.java
new file mode 100644
index 00000000000..a3c253d2338
--- /dev/null
+++ b/plugins/org.eclipse.osee.orcs.core.test/src/org/eclipse/osee/orcs/core/internal/proxy/ArtifactProxyFactoryTest.java
@@ -0,0 +1,190 @@
+/*******************************************************************************
+ * Copyright (c) 2012 Boeing.
+ * All rights reserved. This program and the accompanying materials
+ * are made available under the terms of the Eclipse Public License v1.0
+ * which accompanies this distribution, and is available at
+ * http://www.eclipse.org/legal/epl-v10.html
+ *
+ * Contributors:
+ *     Boeing - initial API and implementation
+ *******************************************************************************/
+package org.eclipse.osee.orcs.core.internal.proxy;
+
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertFalse;
+import static org.junit.Assert.assertNotNull;
+import static org.junit.Assert.assertTrue;
+import static org.mockito.Mockito.verify;
+import static org.mockito.Mockito.when;
+import java.util.Collection;
+import java.util.regex.Matcher;
+import java.util.regex.Pattern;
+import org.eclipse.osee.framework.core.data.IArtifactType;
+import org.eclipse.osee.framework.core.data.IAttributeType;
+import org.eclipse.osee.framework.core.data.IOseeBranch;
+import org.eclipse.osee.framework.core.enums.CoreArtifactTypes;
+import org.eclipse.osee.framework.core.enums.CoreBranches;
+import org.eclipse.osee.framework.core.exception.OseeArgumentException;
+import org.eclipse.osee.framework.core.exception.OseeCoreException;
+import org.eclipse.osee.framework.jdk.core.util.GUID;
+import org.eclipse.osee.orcs.core.internal.artifact.ArtifactFactory;
+import org.eclipse.osee.orcs.core.internal.artifact.ArtifactImpl;
+import org.eclipse.osee.orcs.data.ArtifactReadable;
+import org.eclipse.osee.orcs.data.ArtifactWriteable;
+import org.hamcrest.BaseMatcher;
+import org.hamcrest.Description;
+import org.junit.Before;
+import org.junit.Rule;
+import org.junit.Test;
+import org.junit.rules.ExpectedException;
+import org.mockito.Mock;
+import org.mockito.Mockito;
+import org.mockito.MockitoAnnotations;
+
+/**
+ * Test Case for {@link ArtifactProxyFactory}
+ * 
+ * @author Roberto E. Escobar
+ */
+public class ArtifactProxyFactoryTest {
+
+   @Rule
+   public ExpectedException thrown = ExpectedException.none();
+
+   // @formatter:off
+   @Mock private ArtifactReadable readable;
+   @Mock private ArtifactFactory artifactFactory;
+   @Mock private ArtifactImpl artifact;
+   @Mock private ArtifactImpl otherArtifact;
+   // @formatter:on
+
+   private String guid;
+   private final IOseeBranch branch = CoreBranches.COMMON;
+   private final IArtifactType artifactType = CoreArtifactTypes.Folder;
+   private ArtifactProxyFactory factory;
+
+   @Before
+   public void setup() {
+      MockitoAnnotations.initMocks(this);
+
+      guid = GUID.create();
+      factory = new ArtifactProxyFactory(artifactFactory);
+   }
+
+   @Test
+   public void testCreate() throws Throwable {
+      String expectedName = "NAME";
+
+      when(artifactFactory.createArtifact(branch, artifactType, guid)).thenReturn(artifact);
+
+      ArtifactWriteable actual = factory.create(branch, artifactType, guid, expectedName);
+
+      verify(artifactFactory).createArtifact(branch, artifactType, guid);
+      verify(artifact).setName(expectedName);
+
+      assertTrue(actual instanceof ProxyWriteable);
+      assertTrue(ProxyUtil.isProxy(actual));
+      assertEquals(artifact, factory.getProxiedObject(actual));
+   }
+
+   @SuppressWarnings("unchecked")
+   @Test
+   public void testCopy() throws Throwable {
+      Collection<? extends IAttributeType> types = Mockito.mock(Collection.class);
+      when(artifactFactory.copyArtifact(artifact, types, branch)).thenReturn(otherArtifact);
+
+      ArtifactWriteable actual = factory.copy(artifact, types, branch);
+
+      verify(artifactFactory).copyArtifact(artifact, types, branch);
+
+      assertTrue(actual instanceof ProxyWriteable);
+      assertTrue(ProxyUtil.isProxy(actual));
+      assertEquals(otherArtifact, factory.getProxiedObject(actual));
+   }
+
+   @Test
+   public void testIntroduce() throws OseeCoreException {
+      when(artifactFactory.introduceArtifact(artifact, branch)).thenReturn(otherArtifact);
+
+      ArtifactWriteable actual = factory.introduce(artifact, branch);
+
+      verify(artifactFactory).introduceArtifact(artifact, branch);
+
+      assertTrue(actual instanceof ProxyWriteable);
+      assertTrue(ProxyUtil.isProxy(actual));
+      assertEquals(otherArtifact, factory.getProxiedObject(actual));
+   }
+
+   @Test
+   public void testCreateReadable() {
+      ArtifactReadable actual = factory.createReadable(artifact);
+
+      assertFalse(actual instanceof ProxyWriteable);
+      assertTrue(actual instanceof HasProxiedObject);
+      assertTrue(ProxyUtil.isProxy(actual));
+      assertEquals(artifact, factory.getProxiedObject(actual));
+   }
+
+   @Test
+   public void testCreateWriteable() throws OseeCoreException {
+      ArtifactWriteable actual = factory.createWriteable(artifact);
+
+      assertTrue(actual instanceof ProxyWriteable);
+      assertTrue(ProxyUtil.isProxy(actual));
+      assertEquals(artifact, factory.getProxiedObject(actual));
+      assertEquals(artifact, factory.getOriginalObject(actual));
+   }
+
+   @Test
+   public void testAsProxyWriteable() throws OseeCoreException {
+      ArtifactWriteable proxied = factory.createWriteable(artifact);
+      ProxyWriteable<ArtifactImpl> actual = factory.asProxyWriteable(proxied);
+      assertNotNull(actual);
+
+      thrown.expect(OseeArgumentException.class);
+      thrown.expectMessage(new RegExMatcher("Unable to convert from \\[ArtifactImpl(.*?)\\] to ProxyWriteable"));
+      factory.asProxyWriteable(artifact);
+   }
+
+   @Test
+   public void testAsWriteable() throws OseeCoreException {
+      ArtifactWriteable actual = factory.asWriteable(artifact);
+      assertTrue(actual != artifact);
+      assertTrue(ProxyUtil.isProxy(actual));
+
+      ArtifactWriteable actual2 = factory.asWriteable(actual);
+      assertTrue(actual2 == actual);
+
+      thrown.expect(OseeArgumentException.class);
+      thrown.expectMessage(new RegExMatcher("Unable to convert from \\[ArtifactReadable(.*?)\\] to Writeable"));
+      factory.asWriteable(readable);
+   }
+
+   @Test
+   public void testAsWriteableWithNull() throws OseeCoreException {
+      thrown.expect(OseeArgumentException.class);
+      thrown.expectMessage("Unable to convert from [null] to Writeable");
+      factory.asWriteable(null);
+   }
+
+   private static final class RegExMatcher extends BaseMatcher<String> {
+
+      private final Matcher matcher;
+
+      public RegExMatcher(String regEx) {
+         this.matcher = Pattern.compile(regEx).matcher("");
+      }
+
+      @Override
+      public void describeTo(Description description) {
+         // nothing
+      }
+
+      @Override
+      public boolean matches(Object item) {
+         String value = (String) item;
+         matcher.reset(value);
+         return matcher.find();
+      }
+   };
+}
diff --git a/plugins/org.eclipse.osee.orcs.core.test/src/org/eclipse/osee/orcs/core/internal/search/QueryFactoryTest.java b/plugins/org.eclipse.osee.orcs.core.test/src/org/eclipse/osee/orcs/core/internal/proxy/ProxyTestSuite.java
index a0c4096e643..f39a589b568 100644
--- a/plugins/org.eclipse.osee.orcs.core.test/src/org/eclipse/osee/orcs/core/internal/search/QueryFactoryTest.java
+++ b/plugins/org.eclipse.osee.orcs.core.test/src/org/eclipse/osee/orcs/core/internal/proxy/ProxyTestSuite.java
@@ -8,24 +8,17 @@
  * Contributors:
  *     Boeing - initial API and implementation
  *******************************************************************************/
-package org.eclipse.osee.orcs.core.internal.search;
+package org.eclipse.osee.orcs.core.internal.proxy;
 
-import org.eclipse.osee.orcs.search.QueryFactory;
-import org.junit.Ignore;
-import org.junit.Test;
+import org.eclipse.osee.orcs.core.internal.proxy.handler.ProxyInvocationHandlerTestSuite;
+import org.junit.runner.RunWith;
+import org.junit.runners.Suite;
 
 /**
- * Test Case for {@link QueryFactory}
- * 
  * @author Roberto E. Escobar
  */
-public class QueryFactoryTest {
-
-   @Test
-   @Ignore
-   public void testX() {
-      //      QueryFactory factory = new QueryFactoryImpl();
-      //      factory.fromArtifact(branch, artifactToken);
-
-   }
+@RunWith(Suite.class)
+@Suite.SuiteClasses({ProxyInvocationHandlerTestSuite.class, ArtifactProxyFactoryTest.class})
+public class ProxyTestSuite {
+   // Test Suite
 }
diff --git a/plugins/org.eclipse.osee.orcs.core.test/src/org/eclipse/osee/orcs/core/internal/proxy/handler/ArtifactWriteableInvocationHandlerTest.java b/plugins/org.eclipse.osee.orcs.core.test/src/org/eclipse/osee/orcs/core/internal/proxy/handler/ArtifactWriteableInvocationHandlerTest.java
new file mode 100644
index 00000000000..26a8f10319d
--- /dev/null
+++ b/plugins/org.eclipse.osee.orcs.core.test/src/org/eclipse/osee/orcs/core/internal/proxy/handler/ArtifactWriteableInvocationHandlerTest.java
@@ -0,0 +1,266 @@
+/*******************************************************************************
+ * Copyright (c) 2012 Boeing.
+ * All rights reserved. This program and the accompanying materials
+ * are made available under the terms of the Eclipse Public License v1.0
+ * which accompanies this distribution, and is available at
+ * http://www.eclipse.org/legal/epl-v10.html
+ *
+ * Contributors:
+ *     Boeing - initial API and implementation
+ *******************************************************************************/
+package org.eclipse.osee.orcs.core.internal.proxy.handler;
+
+import static org.mockito.Mockito.reset;
+import static org.mockito.Mockito.times;
+import static org.mockito.Mockito.verify;
+import static org.mockito.Mockito.when;
+import java.lang.reflect.InvocationHandler;
+import java.lang.reflect.Method;
+import java.lang.reflect.Proxy;
+import java.util.ArrayList;
+import java.util.HashSet;
+import java.util.Iterator;
+import java.util.List;
+import java.util.Set;
+import junit.framework.Assert;
+import org.eclipse.osee.framework.core.enums.CoreAttributeTypes;
+import org.eclipse.osee.framework.core.exception.OseeCoreException;
+import org.eclipse.osee.orcs.core.internal.artifact.ArtifactFactory;
+import org.eclipse.osee.orcs.core.internal.artifact.ArtifactImpl;
+import org.eclipse.osee.orcs.core.internal.attribute.Attribute;
+import org.eclipse.osee.orcs.core.internal.proxy.AttributeProxyFactory;
+import org.eclipse.osee.orcs.core.internal.proxy.HasProxiedObject;
+import org.eclipse.osee.orcs.core.internal.proxy.ProxyUtil;
+import org.eclipse.osee.orcs.core.internal.proxy.ProxyWriteable;
+import org.eclipse.osee.orcs.data.ArtifactReadable;
+import org.eclipse.osee.orcs.data.ArtifactWriteable;
+import org.eclipse.osee.orcs.data.AttributeReadable;
+import org.eclipse.osee.orcs.data.AttributeWriteable;
+import org.junit.Before;
+import org.junit.Test;
+import org.mockito.Mock;
+import org.mockito.Mockito;
+import org.mockito.MockitoAnnotations;
+import org.mockito.invocation.InvocationOnMock;
+import org.mockito.stubbing.Answer;
+
+/**
+ * Test Case for {@link ArtifactWriteableInvocationHandler}
+ * 
+ * @author Roberto E. Escobar
+ */
+public class ArtifactWriteableInvocationHandlerTest {
+
+   //@formatter:off
+   @Mock private ArtifactImpl proxiedObject;
+   @Mock private ArtifactImpl copy;
+   @Mock private ArtifactFactory artifactFactory;
+   @Mock private AttributeProxyFactory attributeProxyFactory;
+   //@formatter:on
+
+   private ArtifactWriteableInvocationHandler handler;
+
+   @Before
+   public void setup() throws OseeCoreException {
+      MockitoAnnotations.initMocks(this);
+
+      handler = new ArtifactWriteableInvocationHandler(artifactFactory, attributeProxyFactory, proxiedObject);
+
+      when(artifactFactory.clone(proxiedObject)).thenReturn(copy);
+   }
+
+   @Test
+   @SuppressWarnings("unchecked")
+   public void testGetProxiedObject() {
+      ArtifactWriteable proxy = ProxyUtil.create(ArtifactWriteable.class, handler);
+
+      Assert.assertNotNull(proxy);
+      Assert.assertTrue(Proxy.isProxyClass(proxy.getClass()));
+      Assert.assertTrue(proxy instanceof HasProxiedObject);
+      ProxyWriteable<ArtifactReadable> proxied = (ProxyWriteable<ArtifactReadable>) proxy;
+      Assert.assertEquals(proxiedObject, proxied.getProxiedObject());
+      Assert.assertEquals(proxiedObject, proxied.getOriginalObject());
+   }
+
+   @Test
+   public void testMethodInvocation() throws Exception {
+      InvocationHandler spy = Mockito.spy(handler);
+      ArtifactWriteable proxy = ProxyUtil.create(ArtifactWriteable.class, spy);
+
+      Set<String> readMethods = new HashSet<String>();
+      for (Method method : ArtifactReadable.class.getMethods()) {
+         readMethods.add(method.getName());
+      }
+      for (Method method : Object.class.getMethods()) {
+         readMethods.add(method.getName());
+      }
+
+      boolean copied = false;
+
+      for (Method method : proxy.getClass().getMethods()) {
+         ArtifactImpl object;
+         if (!copied && readMethods.contains(method.getName())) {
+            object = proxiedObject;
+         } else {
+            object = copy;
+            copied = true;
+         }
+         ProxyTestHelper.checkNoneStaticMethodForwarding(method, proxy, object, spy);
+      }
+   }
+
+   @SuppressWarnings("unchecked")
+   @Test
+   public void testCopyOnWrite() throws OseeCoreException {
+      ArtifactWriteableInvocationHandler spy = Mockito.spy(handler);
+      ArtifactWriteable proxy = ProxyUtil.create(ArtifactWriteable.class, spy);
+
+      ProxyWriteable<ArtifactImpl> proxied = (ProxyWriteable<ArtifactImpl>) proxy;
+      Assert.assertEquals(proxiedObject, proxied.getProxiedObject());
+      Assert.assertEquals(proxiedObject, proxied.getOriginalObject());
+
+      Assert.assertTrue(spy.isCopyRequired());
+      proxy.createAttribute(null);
+
+      Assert.assertFalse(spy.isCopyRequired());
+      Assert.assertTrue(spy.isWriteAllowed());
+
+      verify(spy).createCopyForWrite(proxiedObject);
+
+      Assert.assertEquals(copy, proxied.getProxiedObject());
+      Assert.assertEquals(proxiedObject, proxied.getOriginalObject());
+
+      reset(spy);
+
+      proxy.createAttribute(CoreAttributeTypes.Name);
+      Assert.assertTrue(spy.isWriteAllowed());
+      verify(spy, times(0)).createCopyForWrite(proxiedObject);
+   }
+
+   @SuppressWarnings("unchecked")
+   @Test
+   public void testGetAttributes() throws OseeCoreException {
+      ArtifactWriteable proxy = ProxyUtil.create(ArtifactWriteable.class, handler);
+
+      AttributeReadable<Object> r1 = Mockito.mock(AttributeReadable.class);
+      AttributeReadable<Object> r2 = Mockito.mock(AttributeReadable.class);
+
+      Attribute<Object> attr1 = Mockito.mock(Attribute.class);
+      Attribute<Object> attr2 = Mockito.mock(Attribute.class);
+
+      List<Attribute<Object>> list = new ArrayList<Attribute<Object>>();
+      list.add(attr1);
+      list.add(attr2);
+
+      when(proxiedObject.getAttributes()).thenAnswer(new AttributesAnswer(list));
+      when(attributeProxyFactory.createReadable(attr1)).thenReturn(r1);
+      when(attributeProxyFactory.createReadable(attr2)).thenReturn(r2);
+
+      List<AttributeReadable<Object>> proxiedList = proxy.getAttributes();
+      Assert.assertEquals(list.size(), proxiedList.size());
+
+      Iterator<AttributeReadable<Object>> iterator = proxiedList.iterator();
+      Assert.assertEquals(r1, iterator.next());
+      Assert.assertEquals(r2, iterator.next());
+   }
+
+   @SuppressWarnings({"unchecked"})
+   @Test
+   public void testGetAttributesByType() throws OseeCoreException {
+      ArtifactWriteable proxy = ProxyUtil.create(ArtifactWriteable.class, handler);
+
+      AttributeReadable<String> r1 = Mockito.mock(AttributeReadable.class);
+      Attribute<String> attr1 = Mockito.mock(Attribute.class);
+
+      List<Attribute<String>> list = new ArrayList<Attribute<String>>();
+      list.add(attr1);
+
+      when(proxiedObject.getAttributes(CoreAttributeTypes.Name)).thenAnswer(new StringAttributesAnswer(list));
+      when(attributeProxyFactory.createReadable(attr1)).thenReturn(r1);
+
+      List<AttributeReadable<String>> proxiedList = proxy.getAttributes(CoreAttributeTypes.Name);
+      Assert.assertEquals(list.size(), proxiedList.size());
+
+      Iterator<AttributeReadable<String>> iterator = proxiedList.iterator();
+      Assert.assertEquals(r1, iterator.next());
+   }
+
+   @SuppressWarnings({"unchecked"})
+   @Test
+   public void testGetWriteableAttributes() throws OseeCoreException {
+      ArtifactWriteable proxy = ProxyUtil.create(ArtifactWriteable.class, handler);
+
+      AttributeWriteable<Object> r1 = Mockito.mock(AttributeWriteable.class);
+      AttributeWriteable<Object> r2 = Mockito.mock(AttributeWriteable.class);
+
+      Attribute<Object> attr1 = Mockito.mock(Attribute.class);
+      Attribute<Object> attr2 = Mockito.mock(Attribute.class);
+
+      List<Attribute<Object>> list = new ArrayList<Attribute<Object>>();
+      list.add(attr1);
+      list.add(attr2);
+
+      when(copy.getWriteableAttributes()).thenAnswer(new AttributesAnswer(list));
+      when(attributeProxyFactory.createWriteable(attr1)).thenReturn(r1);
+      when(attributeProxyFactory.createWriteable(attr2)).thenReturn(r2);
+
+      List<AttributeWriteable<Object>> proxiedList = proxy.getWriteableAttributes();
+      Assert.assertEquals(list.size(), proxiedList.size());
+
+      Iterator<AttributeWriteable<Object>> iterator = proxiedList.iterator();
+      Assert.assertEquals(r1, iterator.next());
+      Assert.assertEquals(r2, iterator.next());
+   }
+
+   @SuppressWarnings({"unchecked"})
+   @Test
+   public void testGetWriteableAttributesByType() throws OseeCoreException {
+      ArtifactWriteable proxy = ProxyUtil.create(ArtifactWriteable.class, handler);
+
+      AttributeWriteable<String> r1 = Mockito.mock(AttributeWriteable.class);
+      Attribute<String> attr1 = Mockito.mock(Attribute.class);
+
+      List<Attribute<String>> list = new ArrayList<Attribute<String>>();
+      list.add(attr1);
+
+      when(copy.getWriteableAttributes(CoreAttributeTypes.Name)).thenAnswer(new StringAttributesAnswer(list));
+      when(attributeProxyFactory.createWriteable(attr1)).thenReturn(r1);
+
+      List<AttributeWriteable<String>> proxiedList = proxy.getWriteableAttributes(CoreAttributeTypes.Name);
+      Assert.assertEquals(list.size(), proxiedList.size());
+
+      Iterator<AttributeWriteable<String>> iterator = proxiedList.iterator();
+      Assert.assertEquals(r1, iterator.next());
+   }
+
+   private static final class AttributesAnswer implements Answer<List<Attribute<Object>>> {
+
+      private final List<Attribute<Object>> list;
+
+      public AttributesAnswer(List<Attribute<Object>> list) {
+         this.list = list;
+      }
+
+      @Override
+      public List<Attribute<Object>> answer(InvocationOnMock invocation) throws Throwable {
+         return list;
+      }
+
+   }
+
+   private static final class StringAttributesAnswer implements Answer<List<Attribute<String>>> {
+
+      private final List<Attribute<String>> list;
+
+      public StringAttributesAnswer(List<Attribute<String>> list) {
+         this.list = list;
+      }
+
+      @Override
+      public List<Attribute<String>> answer(InvocationOnMock invocation) throws Throwable {
+         return list;
+      }
+
+   }
+
+}
diff --git a/plugins/org.eclipse.osee.orcs.core.test/src/org/eclipse/osee/orcs/core/internal/proxy/handler/ProxyInvocationHandlerTestSuite.java b/plugins/org.eclipse.osee.orcs.core.test/src/org/eclipse/osee/orcs/core/internal/proxy/handler/ProxyInvocationHandlerTestSuite.java
new file mode 100644
index 00000000000..ddd563bdd3f
--- /dev/null
+++ b/plugins/org.eclipse.osee.orcs.core.test/src/org/eclipse/osee/orcs/core/internal/proxy/handler/ProxyInvocationHandlerTestSuite.java
@@ -0,0 +1,26 @@
+/*******************************************************************************
+ * Copyright (c) 2004, 2007 Boeing.
+ * All rights reserved. This program and the accompanying materials
+ * are made available under the terms of the Eclipse Public License v1.0
+ * which accompanies this distribution, and is available at
+ * http://www.eclipse.org/legal/epl-v10.html
+ *
+ * Contributors:
+ *     Boeing - initial API and implementation
+ *******************************************************************************/
+package org.eclipse.osee.orcs.core.internal.proxy.handler;
+
+import org.junit.runner.RunWith;
+import org.junit.runners.Suite;
+
+/**
+ * @author Roberto E. Escobar
+ */
+@RunWith(Suite.class)
+@Suite.SuiteClasses({
+   ArtifactWriteableInvocationHandlerTest.class,
+   ReadableInvocationHandlerTest.class,
+   WriteableInvocationHandlerTest.class})
+public class ProxyInvocationHandlerTestSuite {
+   // Test Suite
+}
diff --git a/plugins/org.eclipse.osee.orcs.core.test/src/org/eclipse/osee/orcs/core/internal/proxy/handler/ProxyTestHelper.java b/plugins/org.eclipse.osee.orcs.core.test/src/org/eclipse/osee/orcs/core/internal/proxy/handler/ProxyTestHelper.java
new file mode 100644
index 00000000000..bc63a57f85a
--- /dev/null
+++ b/plugins/org.eclipse.osee.orcs.core.test/src/org/eclipse/osee/orcs/core/internal/proxy/handler/ProxyTestHelper.java
@@ -0,0 +1,101 @@
+/*******************************************************************************
+ * Copyright (c) 2012 Boeing.
+ * All rights reserved. This program and the accompanying materials
+ * are made available under the terms of the Eclipse Public License v1.0
+ * which accompanies this distribution, and is available at
+ * http://www.eclipse.org/legal/epl-v10.html
+ *
+ * Contributors:
+ *     Boeing - initial API and implementation
+ *******************************************************************************/
+package org.eclipse.osee.orcs.core.internal.proxy.handler;
+
+import static org.mockito.Mockito.verify;
+import java.lang.reflect.Method;
+import java.lang.reflect.Modifier;
+import java.util.Collection;
+import java.util.HashMap;
+import java.util.HashSet;
+import java.util.Map;
+import junit.framework.Assert;
+import org.eclipse.osee.framework.jdk.core.util.Lib;
+import org.mockito.Mockito;
+
+/**
+ * @author Roberto E. Escobar
+ */
+public final class ProxyTestHelper {
+
+   private final static Map<Class<?>, Object> defaultValues = new HashMap<Class<?>, Object>();
+   private final static Collection<String> skipObjectMethods = getObjectMethods();
+   static {
+      defaultValues.put(String.class, "hello");
+
+      defaultValues.put(Integer.class, 0);
+      defaultValues.put(int.class, 0);
+
+      defaultValues.put(Long.class, 0L);
+      defaultValues.put(long.class, 0L);
+
+      defaultValues.put(Character.class, '\0');
+      defaultValues.put(char.class, '\0');
+
+      defaultValues.put(Boolean.class, true);
+      defaultValues.put(boolean.class, true);
+
+      defaultValues.put(Float.class, 12314.02);
+      defaultValues.put(float.class, 12314.02);
+   }
+
+   private static Collection<String> getObjectMethods() {
+      Collection<String> skip = new HashSet<String>();
+      for (Method method : Object.class.getMethods()) {
+         skip.add(method.getName());
+      }
+      return skip;
+   }
+
+   private static Method getMethod(Object object, String name, Class<?>... paramTypes) {
+      Method method = null;
+      try {
+         method = object.getClass().getMethod(name, paramTypes);
+      } catch (Exception ex) {
+         // Do Nothing;
+      }
+      return method;
+   }
+
+   public static <T> void checkNoneStaticMethodForwarding(Method method, T proxy, T proxiedObject, Object handler) {
+      int modifiers = method.getModifiers();
+
+      if (!Modifier.isStatic(modifiers) && !skipObjectMethods.contains(method.getName())) {
+         Mockito.reset(handler);
+         try {
+            verifyMethodForwarding(method, proxy, proxiedObject, handler);
+         } catch (Exception ex) {
+            Assert.fail(String.format("Error on [%s]: [%s]\n", method.getName(), Lib.exceptionToString(ex)));
+         }
+      }
+   }
+
+   private static <T> void verifyMethodForwarding(Method method, T proxy, T proxiedObject, Object handler) throws Exception {
+      Class<?>[] paramTypes = method.getParameterTypes();
+      Object[] params = new Object[paramTypes.length];
+      for (int index = 0; index < paramTypes.length; index++) {
+         Class<?> type = paramTypes[index];
+         params[index] = defaultValues.get(type);
+      }
+
+      method.invoke(proxy, params);
+
+      Method methodOnMock = getMethod(proxiedObject, method.getName(), paramTypes);
+
+      if (methodOnMock != null) {
+         methodOnMock.invoke(verify(proxiedObject), params);
+      } else {
+         Method methodOnHandler = getMethod(handler, method.getName(), paramTypes);
+         Assert.assertNotNull(methodOnHandler);
+         methodOnHandler.invoke(verify(handler), params);
+      }
+   }
+}
diff --git a/plugins/org.eclipse.osee.orcs.core.test/src/org/eclipse/osee/orcs/core/internal/proxy/handler/ReadableInvocationHandlerTest.java b/plugins/org.eclipse.osee.orcs.core.test/src/org/eclipse/osee/orcs/core/internal/proxy/handler/ReadableInvocationHandlerTest.java
new file mode 100644
index 00000000000..f634664a8a8
--- /dev/null
+++ b/plugins/org.eclipse.osee.orcs.core.test/src/org/eclipse/osee/orcs/core/internal/proxy/handler/ReadableInvocationHandlerTest.java
@@ -0,0 +1,67 @@
+/*******************************************************************************
+ * Copyright (c) 2012 Boeing.
+ * All rights reserved. This program and the accompanying materials
+ * are made available under the terms of the Eclipse Public License v1.0
+ * which accompanies this distribution, and is available at
+ * http://www.eclipse.org/legal/epl-v10.html
+ *
+ * Contributors:
+ *     Boeing - initial API and implementation
+ *******************************************************************************/
+package org.eclipse.osee.orcs.core.internal.proxy.handler;
+
+import java.lang.reflect.InvocationHandler;
+import java.lang.reflect.Method;
+import java.lang.reflect.Proxy;
+import junit.framework.Assert;
+import org.eclipse.osee.orcs.core.internal.proxy.HasProxiedObject;
+import org.eclipse.osee.orcs.core.internal.proxy.ProxyUtil;
+import org.eclipse.osee.orcs.data.ArtifactReadable;
+import org.junit.Before;
+import org.junit.Test;
+import org.mockito.Mock;
+import org.mockito.Mockito;
+import org.mockito.MockitoAnnotations;
+
+/**
+ * Test Case for {@link ReadableInvocationHandler}
+ * 
+ * @author Roberto E. Escobar
+ */
+public class ReadableInvocationHandlerTest {
+
+   //@formatter:off
+   @Mock private ArtifactReadable proxiedObject;
+   //@formatter:on
+
+   private ReadableInvocationHandler<ArtifactReadable> handler;
+
+   @Before
+   public void setup() {
+      MockitoAnnotations.initMocks(this);
+
+      handler = new ReadableInvocationHandler<ArtifactReadable>(proxiedObject);
+   }
+
+   @Test
+   @SuppressWarnings("unchecked")
+   public void testGetProxiedObject() {
+      ArtifactReadable proxy = ProxyUtil.create(ArtifactReadable.class, handler);
+
+      Assert.assertNotNull(proxy);
+      Assert.assertTrue(Proxy.isProxyClass(proxy.getClass()));
+      Assert.assertTrue(proxy instanceof HasProxiedObject);
+      HasProxiedObject<ArtifactReadable> proxied = (HasProxiedObject<ArtifactReadable>) proxy;
+      Assert.assertEquals(proxiedObject, proxied.getProxiedObject());
+   }
+
+   @Test
+   public void testMethodInvocation() throws Exception {
+      InvocationHandler spy = Mockito.spy(handler);
+      ArtifactReadable proxy = ProxyUtil.create(ArtifactReadable.class, spy);
+
+      for (Method method : proxy.getClass().getMethods()) {
+         ProxyTestHelper.checkNoneStaticMethodForwarding(method, proxy, proxiedObject, spy);
+      }
+   }
+}
diff --git a/plugins/org.eclipse.osee.orcs.core.test/src/org/eclipse/osee/orcs/core/internal/proxy/handler/WriteableInvocationHandlerTest.java b/plugins/org.eclipse.osee.orcs.core.test/src/org/eclipse/osee/orcs/core/internal/proxy/handler/WriteableInvocationHandlerTest.java
new file mode 100644
index 00000000000..e0e008815aa
--- /dev/null
+++ b/plugins/org.eclipse.osee.orcs.core.test/src/org/eclipse/osee/orcs/core/internal/proxy/handler/WriteableInvocationHandlerTest.java
@@ -0,0 +1,97 @@
+/*******************************************************************************
+ * Copyright (c) 2012 Boeing.
+ * All rights reserved. This program and the accompanying materials
+ * are made available under the terms of the Eclipse Public License v1.0
+ * which accompanies this distribution, and is available at
+ * http://www.eclipse.org/legal/epl-v10.html
+ *
+ * Contributors:
+ *     Boeing - initial API and implementation
+ *******************************************************************************/
+package org.eclipse.osee.orcs.core.internal.proxy.handler;
+
+import static org.mockito.Mockito.reset;
+import static org.mockito.Mockito.times;
+import static org.mockito.Mockito.verify;
+import java.lang.reflect.InvocationHandler;
+import java.lang.reflect.Method;
+import java.lang.reflect.Proxy;
+import junit.framework.Assert;
+import org.eclipse.osee.framework.core.exception.OseeCoreException;
+import org.eclipse.osee.orcs.core.internal.proxy.HasProxiedObject;
+import org.eclipse.osee.orcs.core.internal.proxy.ProxyUtil;
+import org.eclipse.osee.orcs.core.internal.proxy.ProxyWriteable;
+import org.eclipse.osee.orcs.data.ArtifactReadable;
+import org.eclipse.osee.orcs.data.ArtifactWriteable;
+import org.junit.Before;
+import org.junit.Test;
+import org.mockito.Mock;
+import org.mockito.Mockito;
+import org.mockito.MockitoAnnotations;
+
+/**
+ * Test Case for {@link WriteableInvocationHandler}
+ * 
+ * @author Roberto E. Escobar
+ */
+public class WriteableInvocationHandlerTest {
+
+   @Mock
+   private ArtifactWriteable proxiedObject;
+
+   private WriteableInvocationHandler<ArtifactWriteable> handler;
+
+   @Before
+   public void setup() {
+      MockitoAnnotations.initMocks(this);
+
+      handler = new WriteableInvocationHandler<ArtifactWriteable>(proxiedObject);
+   }
+
+   @Test
+   @SuppressWarnings("unchecked")
+   public void testGetProxiedObject() {
+      ArtifactWriteable proxy = ProxyUtil.create(ArtifactWriteable.class, handler);
+
+      Assert.assertNotNull(proxy);
+      Assert.assertTrue(Proxy.isProxyClass(proxy.getClass()));
+      Assert.assertTrue(proxy instanceof HasProxiedObject);
+      ProxyWriteable<ArtifactReadable> proxied = (ProxyWriteable<ArtifactReadable>) proxy;
+      Assert.assertEquals(proxiedObject, proxied.getProxiedObject());
+      Assert.assertEquals(proxiedObject, proxied.getOriginalObject());
+   }
+
+   @SuppressWarnings("unchecked")
+   @Test
+   public void testCopyOnWrite() throws OseeCoreException {
+      WriteableInvocationHandler<ArtifactWriteable> spy = Mockito.spy(handler);
+      ArtifactWriteable proxy = ProxyUtil.create(ArtifactWriteable.class, spy);
+
+      ProxyWriteable<ArtifactReadable> proxied = (ProxyWriteable<ArtifactReadable>) proxy;
+      Assert.assertEquals(proxiedObject, proxied.getProxiedObject());
+      Assert.assertEquals(proxiedObject, proxied.getOriginalObject());
+
+      Assert.assertTrue(spy.isCopyRequired());
+      proxy.createAttribute(null);
+
+      Assert.assertFalse(spy.isCopyRequired());
+      Assert.assertTrue(spy.isWriteAllowed());
+      verify(spy).createCopyForWrite(proxiedObject);
+
+      reset(spy);
+
+      proxy.createAttribute(null);
+      Assert.assertTrue(spy.isWriteAllowed());
+      verify(spy, times(0)).createCopyForWrite(proxiedObject);
+   }
+
+   @Test
+   public void testMethodInvocation() throws Exception {
+      InvocationHandler spy = Mockito.spy(handler);
+      ArtifactWriteable proxy = ProxyUtil.create(ArtifactWriteable.class, spy);
+
+      for (Method method : proxy.getClass().getMethods()) {
+         ProxyTestHelper.checkNoneStaticMethodForwarding(method, proxy, proxiedObject, spy);
+      }
+   }
+}
diff --git a/plugins/org.eclipse.osee.orcs.core.test/src/org/eclipse/osee/orcs/core/internal/relation/RelationLoadingTest.java b/plugins/org.eclipse.osee.orcs.core.test/src/org/eclipse/osee/orcs/core/internal/relation/RelationLoadingTest.java
index 113eef06457..484112ef051 100644
--- a/plugins/org.eclipse.osee.orcs.core.test/src/org/eclipse/osee/orcs/core/internal/relation/RelationLoadingTest.java
+++ b/plugins/org.eclipse.osee.orcs.core.test/src/org/eclipse/osee/orcs/core/internal/relation/RelationLoadingTest.java
@@ -27,8 +27,8 @@ import org.eclipse.osee.framework.core.model.mocks.MockOseeDataAccessor;
 import org.eclipse.osee.framework.core.model.type.RelationType;
 import org.eclipse.osee.orcs.core.ds.RelationData;
 import org.eclipse.osee.orcs.core.ds.VersionData;
-import org.eclipse.osee.orcs.core.internal.artifact.RelationContainer;
 import org.junit.Assert;
+import org.junit.Ignore;
 import org.junit.Test;
 import org.mockito.Mockito;
 
@@ -54,6 +54,7 @@ public class RelationLoadingTest {
    }
 
    //@formatter:off
+   @Ignore
    @Test
    public void testRelatedArtifactsMatch() throws OseeCoreException, IOException {
       RelationTypeCache cache = createAndPopulate();
diff --git a/plugins/org.eclipse.osee.orcs.core.test/src/org/eclipse/osee/orcs/core/internal/search/QueryTestSuite.java b/plugins/org.eclipse.osee.orcs.core.test/src/org/eclipse/osee/orcs/core/internal/search/QueryTestSuite.java
index d45826abdda..50096957386 100644
--- a/plugins/org.eclipse.osee.orcs.core.test/src/org/eclipse/osee/orcs/core/internal/search/QueryTestSuite.java
+++ b/plugins/org.eclipse.osee.orcs.core.test/src/org/eclipse/osee/orcs/core/internal/search/QueryTestSuite.java
@@ -17,7 +17,7 @@ import org.junit.runners.Suite;
  * @author Roberto E. Escobar
  */
 @RunWith(Suite.class)
-@Suite.SuiteClasses({QueryFactoryTest.class, QueryStatisticsTest.class})
+@Suite.SuiteClasses({QueryStatisticsTest.class})
 public class QueryTestSuite {
    // Test Suite
 }
diff --git a/plugins/org.eclipse.osee.orcs.core.test/src/org/eclipse/osee/orcs/core/internal/transaction/OrcsTransactionImplTest.java b/plugins/org.eclipse.osee.orcs.core.test/src/org/eclipse/osee/orcs/core/internal/transaction/OrcsTransactionImplTest.java
index df33b368903..cd09c315edd 100644
--- a/plugins/org.eclipse.osee.orcs.core.test/src/org/eclipse/osee/orcs/core/internal/transaction/OrcsTransactionImplTest.java
+++ b/plugins/org.eclipse.osee.orcs.core.test/src/org/eclipse/osee/orcs/core/internal/transaction/OrcsTransactionImplTest.java
@@ -10,66 +10,130 @@
  *******************************************************************************/
 package org.eclipse.osee.orcs.core.internal.transaction;
 
-import static org.junit.Assert.*;
-import static org.mockito.Mockito.*;
+import static org.junit.Assert.assertNotNull;
+import static org.mockito.Mockito.doThrow;
+import static org.mockito.Mockito.mock;
+import static org.mockito.Mockito.verify;
+import static org.mockito.Mockito.when;
+import java.util.Arrays;
 import java.util.Collection;
+import java.util.Iterator;
+import java.util.List;
+import java.util.concurrent.Callable;
 import org.eclipse.osee.framework.core.data.IArtifactToken;
 import org.eclipse.osee.framework.core.data.IArtifactType;
 import org.eclipse.osee.framework.core.data.IAttributeType;
 import org.eclipse.osee.framework.core.data.IOseeBranch;
 import org.eclipse.osee.framework.core.enums.CoreArtifactTypes;
 import org.eclipse.osee.framework.core.exception.OseeCoreException;
+import org.eclipse.osee.framework.core.model.TransactionRecord;
 import org.eclipse.osee.framework.core.model.type.AttributeType;
 import org.eclipse.osee.framework.jdk.core.util.GUID;
 import org.eclipse.osee.logger.Log;
 import org.eclipse.osee.orcs.core.ds.BranchDataStore;
+import org.eclipse.osee.orcs.core.ds.TransactionResult;
 import org.eclipse.osee.orcs.core.internal.SessionContext;
-import org.eclipse.osee.orcs.core.internal.artifact.ArtifactFactory;
+import org.eclipse.osee.orcs.core.internal.proxy.ArtifactProxyFactory;
 import org.eclipse.osee.orcs.data.ArtifactReadable;
 import org.eclipse.osee.orcs.data.ArtifactWriteable;
+import org.junit.Assert;
 import org.junit.Before;
+import org.junit.Rule;
 import org.junit.Test;
+import org.junit.rules.ExpectedException;
 import org.mockito.Mock;
+import org.mockito.Mockito;
 import org.mockito.MockitoAnnotations;
 import org.mockito.invocation.InvocationOnMock;
 import org.mockito.stubbing.Answer;
 
 /**
+ * Test Case for {@link OrcsTransactionImpl}
+ * 
  * @author John Misinco
  */
 public class OrcsTransactionImplTest {
 
+   @Rule
+   public ExpectedException thrown = ExpectedException.none();
+
    // @formatter:off
    @Mock private Log logger;
    @Mock private SessionContext sessionContext;
    @Mock private BranchDataStore dataStore;
-   @Mock private ArtifactFactory artifactFactory;
+   @Mock private ArtifactProxyFactory artifactFactory;
+   @Mock private TxDataManager txManager;
    @Mock private IOseeBranch branch;
    @Mock private ArtifactWriteable expected;
    // @formatter:on
 
-   private OrcsTransactionImpl transaction;
+   private OrcsTransactionImpl tx;
    private String guid;
    private final IArtifactType artType = CoreArtifactTypes.Artifact;
 
    @Before
    public void init() {
       MockitoAnnotations.initMocks(this);
-      transaction = new OrcsTransactionImpl(logger, sessionContext, dataStore, artifactFactory, branch);
+      tx = new OrcsTransactionImpl(logger, sessionContext, dataStore, artifactFactory, txManager, branch);
+
       guid = GUID.create();
       when(expected.getGuid()).thenReturn(guid);
    }
 
    @Test
-   public void testCreateArtifact() throws OseeCoreException {
-      String name = "testCreateArtifact";
-      when(artifactFactory.createWriteableArtifact(branch, artType, guid)).thenReturn(expected);
+   public void testSetGetAuthor() {
+      ArtifactReadable source = mock(ArtifactReadable.class);
+      tx.setAuthor(source);
 
-      ArtifactWriteable artifact = transaction.createArtifact(artType, name, guid);
+      Assert.assertEquals(source, tx.getAuthor());
+   }
 
-      verify(expected).setName(name);
-      verify(artifactFactory).createWriteableArtifact(branch, artType, guid);
-      assertNotNull(artifact);
+   @Test
+   public void testSetGetComment() {
+      String comment = "This is my comment";
+      tx.setComment(comment);
+
+      Assert.assertEquals(comment, tx.getComment());
+   }
+
+   @Test
+   public void testGetTxData() throws OseeCoreException {
+      tx.getTxData();
+      verify(txManager).getChanges();
+   }
+
+   @Test
+   public void testAsWriteable() throws OseeCoreException {
+      ArtifactReadable source = mock(ArtifactReadable.class);
+      when(txManager.getOrAddWrite(source)).thenReturn(expected);
+
+      ArtifactWriteable actual = tx.asWritable(source);
+
+      Assert.assertEquals(actual, expected);
+      verify(txManager).getOrAddWrite(source);
+   }
+
+   @Test
+   public void testAsWriteableList() throws OseeCoreException {
+      ArtifactReadable sourceA = mock(ArtifactReadable.class);
+      ArtifactReadable sourceB = mock(ArtifactReadable.class);
+
+      ArtifactWriteable expectedA = mock(ArtifactWriteable.class);
+      ArtifactWriteable expectedB = mock(ArtifactWriteable.class);
+      when(txManager.getOrAddWrite(sourceA)).thenReturn(expectedA);
+      when(txManager.getOrAddWrite(sourceB)).thenReturn(expectedB);
+
+      List<ArtifactReadable> readables = Arrays.asList(sourceA, sourceB);
+
+      List<ArtifactWriteable> actuals = tx.asWritable(readables);
+
+      Assert.assertEquals(readables.size(), actuals.size());
+      verify(txManager).getOrAddWrite(sourceA);
+      verify(txManager).getOrAddWrite(sourceB);
+
+      Iterator<ArtifactWriteable> iterator = actuals.iterator();
+      Assert.assertEquals(expectedA, iterator.next());
+      Assert.assertEquals(expectedB, iterator.next());
    }
 
    @Test
@@ -79,17 +143,43 @@ public class OrcsTransactionImplTest {
 
       when(token.getName()).thenReturn(name);
       when(token.getArtifactType()).thenReturn(artType);
+
       when(token.getGuid()).thenReturn(guid);
-      when(artifactFactory.createWriteableArtifact(branch, artType, guid)).thenReturn(expected);
+      when(artifactFactory.create(branch, artType, guid, name)).thenReturn(expected);
+
+      ArtifactWriteable artifact = tx.createArtifact(token);
+
+      assertNotNull(artifact);
+      verify(artifactFactory).create(branch, artType, guid, name);
+      verify(txManager).addWrite(artifact);
+   }
+
+   @Test
+   public void testCreateArtifactTypeAndName() throws OseeCoreException {
+      String name = "testCreateArtifact";
+      when(artifactFactory.create(branch, artType, null, name)).thenReturn(expected);
 
-      ArtifactWriteable artifact = transaction.createArtifact(token);
+      ArtifactWriteable artifact = tx.createArtifact(artType, name);
 
-      verify(expected).setName(name);
-      verify(artifactFactory).createWriteableArtifact(branch, artType, guid);
       assertNotNull(artifact);
+      verify(artifactFactory).create(branch, artType, null, name);
+      verify(txManager).addWrite(artifact);
    }
 
    @Test
+   public void testCreateArtifactTypeNameGuid() throws OseeCoreException {
+      String name = "testCreateArtifact";
+      when(artifactFactory.create(branch, artType, guid, name)).thenReturn(expected);
+
+      ArtifactWriteable artifact = tx.createArtifact(artType, name, guid);
+
+      assertNotNull(artifact);
+      verify(artifactFactory).create(branch, artType, guid, name);
+      verify(txManager).addWrite(artifact);
+   }
+
+   @SuppressWarnings("unchecked")
+   @Test
    public void testDuplicateArtifact() throws OseeCoreException {
       ArtifactReadable source = mock(ArtifactReadable.class);
       final Collection<AttributeType> types = mock(Collection.class);
@@ -101,17 +191,124 @@ public class OrcsTransactionImplTest {
             return types;
          }
       });
-      when(artifactFactory.copyArtifact(source, types, branch)).thenReturn(expected);
+      when(artifactFactory.copy(source, types, branch)).thenReturn(expected);
+
+      ArtifactWriteable actual = tx.duplicateArtifact(source);
 
-      transaction.duplicateArtifact(source);
-      verify(artifactFactory.copyArtifact(source, types, branch));
+      Assert.assertTrue(actual != source);
+      verify(artifactFactory).copy(source, types, branch);
+      verify(txManager).addWrite(actual);
    }
 
    @Test
    public void testIntroduceArtifact() throws OseeCoreException {
       ArtifactReadable source = mock(ArtifactReadable.class);
-      when(artifactFactory.introduceArtifact(source, branch)).thenReturn(expected);
-      transaction.introduceArtifact(source);
-      verify(artifactFactory.introduceArtifact(source, branch));
+      when(artifactFactory.introduce(source, branch)).thenReturn(expected);
+
+      ArtifactWriteable actual = tx.introduceArtifact(source);
+
+      Assert.assertTrue(actual != source);
+      verify(artifactFactory).introduce(source, branch);
+      verify(txManager).addWrite(actual);
+   }
+
+   @Test
+   public void testCommitTwiceWhileInProgress() throws Exception {
+      OrcsTransactionImpl spy = Mockito.spy(tx);
+
+      when(spy.isCommitInProgress()).thenReturn(true);
+
+      thrown.expect(OseeCoreException.class);
+      thrown.expectMessage("Commit is already in progress");
+      spy.commit();
+   }
+
+   @SuppressWarnings("unchecked")
+   @Test
+   public void testCommitErrorDuringExecution() throws Exception {
+      final Callable<TransactionResult> callable = mock(Callable.class);
+      when(dataStore.commitTransaction(tx)).thenAnswer(new Answer<Callable<TransactionResult>>() {
+
+         @Override
+         public Callable<TransactionResult> answer(InvocationOnMock invocation) throws Throwable {
+            Assert.assertTrue(tx.isCommitInProgress());
+            return callable;
+         }
+      });
+
+      OseeCoreException exception = new OseeCoreException("Execution error");
+      when(callable.call()).thenThrow(exception);
+
+      Assert.assertFalse(tx.isCommitInProgress());
+
+      thrown.expect(OseeCoreException.class);
+      thrown.expectMessage(exception.getMessage());
+      tx.commit();
+
+      verify(txManager).onCommitStart();
+      verify(txManager).onCommitRollback();
+      verify(txManager).onCommitEnd();
+
+      Assert.assertFalse(tx.isCommitInProgress());
+   }
+
+   @SuppressWarnings("unchecked")
+   @Test
+   public void testCommitErrorDuringRollback() throws Exception {
+      final Callable<TransactionResult> callable = mock(Callable.class);
+      when(dataStore.commitTransaction(tx)).thenAnswer(new Answer<Callable<TransactionResult>>() {
+
+         @Override
+         public Callable<TransactionResult> answer(InvocationOnMock invocation) throws Throwable {
+            Assert.assertTrue(tx.isCommitInProgress());
+            return callable;
+         }
+      });
+
+      OseeCoreException exception = new OseeCoreException("Execution error");
+      doThrow(exception).when(txManager).onCommitRollback();
+
+      Assert.assertFalse(tx.isCommitInProgress());
+
+      thrown.expect(OseeCoreException.class);
+      thrown.expectMessage("Exception during rollback and commit");
+      tx.commit();
+
+      verify(txManager).onCommitStart();
+      verify(txManager).onCommitRollback();
+      verify(txManager).onCommitEnd();
+
+      Assert.assertFalse(tx.isCommitInProgress());
+   }
+
+   @SuppressWarnings("unchecked")
+   @Test
+   public void testCommit() throws Exception {
+      final Callable<TransactionResult> callable = mock(Callable.class);
+      when(dataStore.commitTransaction(tx)).thenAnswer(new Answer<Callable<TransactionResult>>() {
+
+         @Override
+         public Callable<TransactionResult> answer(InvocationOnMock invocation) throws Throwable {
+            Assert.assertTrue(tx.isCommitInProgress());
+            return callable;
+         }
+      });
+      TransactionResult txResult = mock(TransactionResult.class);
+      TransactionRecord newTx = mock(TransactionRecord.class);
+
+      when(callable.call()).thenReturn(txResult);
+      when(txResult.getTransaction()).thenReturn(newTx);
+
+      Assert.assertFalse(tx.isCommitInProgress());
+
+      TransactionRecord actual = tx.commit();
+
+      Assert.assertEquals(newTx, actual);
+
+      verify(txManager).onCommitStart();
+      verify(txManager).onCommitSuccess(txResult);
+      verify(txManager).onCommitEnd();
+
+      Assert.assertFalse(tx.isCommitInProgress());
    }
 }
diff --git a/plugins/org.eclipse.osee.orcs.core.test/src/org/eclipse/osee/orcs/core/internal/transaction/TransactionFactoryImplTest.java b/plugins/org.eclipse.osee.orcs.core.test/src/org/eclipse/osee/orcs/core/internal/transaction/TransactionFactoryImplTest.java
new file mode 100644
index 00000000000..8cce1aecf56
--- /dev/null
+++ b/plugins/org.eclipse.osee.orcs.core.test/src/org/eclipse/osee/orcs/core/internal/transaction/TransactionFactoryImplTest.java
@@ -0,0 +1,98 @@
+/*******************************************************************************
+ * Copyright (c) 2012 Boeing.
+ * All rights reserved. This program and the accompanying materials
+ * are made available under the terms of the Eclipse Public License v1.0
+ * which accompanies this distribution, and is available at
+ * http://www.eclipse.org/legal/epl-v10.html
+ *
+ * Contributors:
+ *     Boeing - initial API and implementation
+ *******************************************************************************/
+package org.eclipse.osee.orcs.core.internal.transaction;
+
+import junit.framework.Assert;
+import org.eclipse.osee.framework.core.data.IOseeBranch;
+import org.eclipse.osee.framework.core.enums.CoreBranches;
+import org.eclipse.osee.framework.core.exception.OseeArgumentException;
+import org.eclipse.osee.framework.core.exception.OseeCoreException;
+import org.eclipse.osee.logger.Log;
+import org.eclipse.osee.orcs.core.ds.BranchDataStore;
+import org.eclipse.osee.orcs.core.internal.SessionContext;
+import org.eclipse.osee.orcs.core.internal.proxy.ArtifactProxyFactory;
+import org.eclipse.osee.orcs.core.internal.transaction.TxDataManagerImpl.TxDataHandlerFactory;
+import org.eclipse.osee.orcs.data.ArtifactReadable;
+import org.eclipse.osee.orcs.transaction.OrcsTransaction;
+import org.junit.Before;
+import org.junit.Rule;
+import org.junit.Test;
+import org.junit.rules.ExpectedException;
+import org.mockito.Mock;
+import org.mockito.MockitoAnnotations;
+
+/**
+ * Test Case for {@link TransactionFactoryImpl}
+ * 
+ * @author Roberto E. Escobar
+ */
+public class TransactionFactoryImplTest {
+
+   @Rule
+   public ExpectedException thrown = ExpectedException.none();
+
+   // @formatter:off
+   @Mock private Log logger;
+   @Mock private SessionContext sessionContext;
+   @Mock private BranchDataStore branchDataStore;
+   @Mock private ArtifactProxyFactory artifactFactory;
+   @Mock private TxDataHandlerFactory dataFactory;
+   @Mock private ArtifactReadable expectedAuthor;
+   // @formatter:on
+
+   private final IOseeBranch expectedBranch = CoreBranches.COMMON;
+   private TransactionFactoryImpl factory;
+
+   @Before
+   public void init() {
+      MockitoAnnotations.initMocks(this);
+      factory = new TransactionFactoryImpl(logger, sessionContext, branchDataStore, artifactFactory, dataFactory);
+   }
+
+   @Test
+   public void testNullBranch() throws OseeCoreException {
+      thrown.expect(OseeArgumentException.class);
+      thrown.expectMessage("branch cannot be null");
+      factory.createTransaction(null, expectedAuthor, "my comment");
+   }
+
+   @Test
+   public void testNullAuthor() throws OseeCoreException {
+      thrown.expect(OseeArgumentException.class);
+      thrown.expectMessage("author cannot be null");
+      factory.createTransaction(expectedBranch, null, "my comment");
+   }
+
+   @Test
+   public void testNullComment() throws OseeCoreException {
+      thrown.expect(OseeArgumentException.class);
+      thrown.expectMessage("comment cannot be null");
+      factory.createTransaction(expectedBranch, expectedAuthor, null);
+   }
+
+   @Test
+   public void testEmptyComment() throws OseeCoreException {
+      thrown.expect(OseeArgumentException.class);
+      thrown.expectMessage("comment cannot be empty");
+      factory.createTransaction(expectedBranch, expectedAuthor, "");
+   }
+
+   @Test
+   public void testCreateTransaction() throws OseeCoreException {
+      String expectedComment = "This is my comment";
+
+      OrcsTransaction tx = factory.createTransaction(expectedBranch, expectedAuthor, expectedComment);
+      Assert.assertNotNull(tx);
+      Assert.assertEquals(expectedBranch, tx.getBranch());
+      Assert.assertEquals(expectedAuthor, tx.getAuthor());
+      Assert.assertEquals(expectedComment, tx.getComment());
+   }
+}
diff --git a/plugins/org.eclipse.osee.orcs.core.test/src/org/eclipse/osee/orcs/core/internal/transaction/TransactionTestSuite.java b/plugins/org.eclipse.osee.orcs.core.test/src/org/eclipse/osee/orcs/core/internal/transaction/TransactionTestSuite.java
index 0326a71240e..bff3f112e2e 100644
--- a/plugins/org.eclipse.osee.orcs.core.test/src/org/eclipse/osee/orcs/core/internal/transaction/TransactionTestSuite.java
+++ b/plugins/org.eclipse.osee.orcs.core.test/src/org/eclipse/osee/orcs/core/internal/transaction/TransactionTestSuite.java
@@ -10,11 +10,16 @@
  *******************************************************************************/
 package org.eclipse.osee.orcs.core.internal.transaction;
 
+import org.eclipse.osee.orcs.core.internal.transaction.handler.HandlerTestSuite;
 import org.junit.runner.RunWith;
 import org.junit.runners.Suite;
 
 @RunWith(Suite.class)
-@Suite.SuiteClasses({OrcsTransactionImplTest.class})
+@Suite.SuiteClasses({
+   HandlerTestSuite.class,
+   OrcsTransactionImplTest.class,
+   TransactionFactoryImplTest.class,
+   TxDataManagerImplTest.class})
 public class TransactionTestSuite {
    // Test Suite
 }
diff --git a/plugins/org.eclipse.osee.orcs.core.test/src/org/eclipse/osee/orcs/core/internal/transaction/TxDataManagerImplTest.java b/plugins/org.eclipse.osee.orcs.core.test/src/org/eclipse/osee/orcs/core/internal/transaction/TxDataManagerImplTest.java
new file mode 100644
index 00000000000..da296af5c44
--- /dev/null
+++ b/plugins/org.eclipse.osee.orcs.core.test/src/org/eclipse/osee/orcs/core/internal/transaction/TxDataManagerImplTest.java
@@ -0,0 +1,175 @@
+/*******************************************************************************
+ * Copyright (c) 2012 Boeing.
+ * All rights reserved. This program and the accompanying materials
+ * are made available under the terms of the Eclipse Public License v1.0
+ * which accompanies this distribution, and is available at
+ * http://www.eclipse.org/legal/epl-v10.html
+ *
+ * Contributors:
+ *     Boeing - initial API and implementation
+ *******************************************************************************/
+package org.eclipse.osee.orcs.core.internal.transaction;
+
+import static org.mockito.Mockito.mock;
+import static org.mockito.Mockito.times;
+import static org.mockito.Mockito.verify;
+import static org.mockito.Mockito.when;
+import java.util.ArrayList;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+import junit.framework.Assert;
+import org.eclipse.osee.framework.core.exception.OseeArgumentException;
+import org.eclipse.osee.framework.core.exception.OseeCoreException;
+import org.eclipse.osee.framework.jdk.core.util.GUID;
+import org.eclipse.osee.orcs.core.ds.ArtifactTransactionData;
+import org.eclipse.osee.orcs.core.ds.OrcsVisitor;
+import org.eclipse.osee.orcs.core.ds.TransactionResult;
+import org.eclipse.osee.orcs.core.internal.artifact.ArtifactImpl;
+import org.eclipse.osee.orcs.core.internal.proxy.ArtifactProxyFactory;
+import org.eclipse.osee.orcs.core.internal.proxy.ProxyWriteable;
+import org.eclipse.osee.orcs.core.internal.transaction.TxDataManagerImpl.TxDataHandlerFactory;
+import org.eclipse.osee.orcs.data.ArtifactWriteable;
+import org.junit.Before;
+import org.junit.Rule;
+import org.junit.Test;
+import org.junit.rules.ExpectedException;
+import org.mockito.Mock;
+import org.mockito.MockitoAnnotations;
+import org.mockito.invocation.InvocationOnMock;
+import org.mockito.stubbing.Answer;
+
+/**
+ * Test Case for {@link TxDataManagerImpl}
+ * 
+ * @author Roberto E. Escobar
+ */
+@SuppressWarnings("rawtypes")
+public class TxDataManagerImplTest {
+
+   @Rule
+   public ExpectedException thrown = ExpectedException.none();
+
+   // @formatter:off
+   @Mock ArtifactProxyFactory proxyFactory;
+   @Mock TxDataHandlerFactory dataFactory;
+   @Mock ArtifactWriteable expected;
+   @Mock ProxyWriteable proxy;
+   // @formatter:on
+
+   private TxDataManagerImpl txManager;
+   private String guid;
+
+   @Before
+   public void init() {
+      MockitoAnnotations.initMocks(this);
+
+      txManager = new TxDataManagerImpl(proxyFactory, dataFactory);
+
+      guid = GUID.create();
+      when(expected.getGuid()).thenReturn(guid);
+   }
+
+   @Test
+   public void testAddAndGetOrWrite() throws OseeCoreException {
+      Assert.assertEquals(0, txManager.size());
+      txManager.addWrite(expected);
+      Assert.assertEquals(1, txManager.size());
+
+      ArtifactWriteable actual = txManager.getOrAddWrite(expected);
+      Assert.assertTrue(expected == actual);
+      Assert.assertEquals(1, txManager.size());
+   }
+
+   @Test
+   public void testAddingAnotherInstanceOfWriteable() throws OseeCoreException {
+      Assert.assertEquals(0, txManager.size());
+      txManager.addWrite(expected);
+      Assert.assertEquals(1, txManager.size());
+
+      // Check no exception
+      txManager.addWrite(expected);
+      Assert.assertEquals(1, txManager.size());
+
+      ArtifactWriteable other = mock(ArtifactWriteable.class);
+      when(other.getGuid()).thenReturn(guid);
+
+      thrown.expect(OseeArgumentException.class);
+      thrown.expectMessage("Another instance of writeable detected - writeable tracking would be inconsistent");
+      txManager.addWrite(other);
+   }
+
+   @Test
+   @SuppressWarnings("unchecked")
+   public void testOnStart() throws OseeCoreException {
+      txManager.addWrite(expected);
+      when(proxyFactory.asProxyWriteable(expected)).thenReturn(proxy);
+
+      txManager.onCommitStart();
+      verify(proxy).setWritesAllowed(false);
+   }
+
+   @Test
+   @SuppressWarnings("unchecked")
+   public void testOnRollback() throws OseeCoreException {
+      txManager.addWrite(expected);
+      when(proxyFactory.asProxyWriteable(expected)).thenReturn(proxy);
+
+      txManager.onCommitRollback();
+      verify(proxy).setWritesAllowed(true);
+   }
+
+   @Test
+   public void testGetZeroChanges() throws OseeCoreException {
+      ArtifactImpl impl = mock(ArtifactImpl.class);
+
+      txManager.addWrite(expected);
+      when(expected.isDirty()).thenReturn(false);
+
+      txManager.getChanges();
+      verify(proxyFactory, times(0)).getProxiedObject(expected);
+      verify(impl, times(0)).accept(null);
+   }
+
+   @Test
+   public void testGetOneDirty() throws OseeCoreException {
+      ArtifactImpl impl = mock(ArtifactImpl.class);
+
+      txManager.addWrite(expected);
+      when(expected.isDirty()).thenReturn(true);
+      when(proxyFactory.getProxiedObject(expected)).thenReturn(impl);
+
+      List<ArtifactTransactionData> data = txManager.getChanges();
+
+      verify(proxyFactory).getProxiedObject(expected);
+      verify(dataFactory).createDirtyHandler(data);
+      verify(impl).accept(null);
+   }
+
+   @Test
+   public void testOnCommitSuccess() throws OseeCoreException {
+      final List<ArtifactTransactionData> list = new ArrayList<ArtifactTransactionData>();
+      Map<String, ArtifactWriteable> writeableArtifacts = new HashMap<String, ArtifactWriteable>();
+      writeableArtifacts.put(expected.getGuid(), expected);
+
+      TransactionResult result = mock(TransactionResult.class);
+      final ArtifactTransactionData txData = mock(ArtifactTransactionData.class);
+      OrcsVisitor vistor = mock(OrcsVisitor.class);
+      when(dataFactory.createUpdateHandler(writeableArtifacts)).thenReturn(vistor);
+      when(result.getData()).thenAnswer(new Answer<List<ArtifactTransactionData>>() {
+
+         @Override
+         public List<ArtifactTransactionData> answer(InvocationOnMock invocation) throws Throwable {
+            return list;
+         }
+
+      });
+      list.add(txData);
+      txManager.addWrite(expected);
+
+      txManager.onCommitSuccess(result);
+
+      verify(dataFactory).createUpdateHandler(writeableArtifacts);
+      verify(txData).accept(vistor);
+   }
+}
diff --git a/plugins/org.eclipse.osee.orcs.core.test/src/org/eclipse/osee/orcs/core/internal/transaction/handler/CollectAndCopyDirtyDataTest.java b/plugins/org.eclipse.osee.orcs.core.test/src/org/eclipse/osee/orcs/core/internal/transaction/handler/CollectAndCopyDirtyDataTest.java
new file mode 100644
index 00000000000..b2c8260095a
--- /dev/null
+++ b/plugins/org.eclipse.osee.orcs.core.test/src/org/eclipse/osee/orcs/core/internal/transaction/handler/CollectAndCopyDirtyDataTest.java
@@ -0,0 +1,99 @@
+/*******************************************************************************
+ * Copyright (c) 2012 Boeing.
+ * All rights reserved. This program and the accompanying materials
+ * are made available under the terms of the Eclipse Public License v1.0
+ * which accompanies this distribution, and is available at
+ * http://www.eclipse.org/legal/epl-v10.html
+ *
+ * Contributors:
+ *     Boeing - initial API and implementation
+ *******************************************************************************/
+package org.eclipse.osee.orcs.core.internal.transaction.handler;
+
+import static org.mockito.Mockito.times;
+import static org.mockito.Mockito.verify;
+import static org.mockito.Mockito.when;
+import java.util.ArrayList;
+import java.util.List;
+import junit.framework.Assert;
+import org.eclipse.osee.framework.core.exception.OseeCoreException;
+import org.eclipse.osee.orcs.core.ds.ArtifactData;
+import org.eclipse.osee.orcs.core.ds.ArtifactTransactionData;
+import org.eclipse.osee.orcs.core.ds.AttributeData;
+import org.eclipse.osee.orcs.core.ds.DataFactory;
+import org.eclipse.osee.orcs.core.internal.artifact.ArtifactImpl;
+import org.eclipse.osee.orcs.core.internal.attribute.Attribute;
+import org.eclipse.osee.orcs.core.internal.transaction.handler.CollectAndCopyDirtyData;
+import org.junit.Before;
+import org.junit.Test;
+import org.mockito.Mock;
+import org.mockito.MockitoAnnotations;
+
+/**
+ * Test Case for {@link CollectAndCopyDirtyData}
+ * 
+ * @author Roberto E. Escobar
+ */
+public class CollectAndCopyDirtyDataTest {
+
+   // @formatter:off
+   @Mock DataFactory dataFactory;
+   @Mock ArtifactImpl artifact;
+   @Mock Attribute<?> attribute;
+   
+   @Mock ArtifactData artSourceData;
+   @Mock AttributeData attrSourceData;
+   @Mock ArtifactData artCopyData;
+   @Mock AttributeData attrCopyData;
+   // @formatter:on
+
+   private List<ArtifactTransactionData> data;
+   private CollectAndCopyDirtyData handler;
+
+   @Before
+   public void init() {
+      MockitoAnnotations.initMocks(this);
+
+      data = new ArrayList<ArtifactTransactionData>();
+      handler = new CollectAndCopyDirtyData(dataFactory, data);
+
+      when(artifact.getOrcsData()).thenReturn(artSourceData);
+      when(attribute.getOrcsData()).thenReturn(attrSourceData);
+   }
+
+   @Test
+   public void testDontCollectNoneDirtyArtifact() throws OseeCoreException {
+      when(artifact.isDirty()).thenReturn(false);
+      handler.visit(artifact);
+      verify(dataFactory, times(0)).clone(artSourceData);
+
+      Assert.assertEquals(0, data.size());
+
+      when(attribute.isDirty()).thenReturn(false);
+      handler.visit(attribute);
+      verify(dataFactory, times(0)).clone(attrSourceData);
+
+      Assert.assertEquals(0, data.size());
+   }
+
+   @Test
+   public void testVisitAndCollectDirtyArtifact() throws OseeCoreException {
+      when(artifact.isDirty()).thenReturn(true);
+      when(attribute.isDirty()).thenReturn(true);
+      when(dataFactory.clone(artSourceData)).thenReturn(artCopyData);
+      when(dataFactory.clone(attrSourceData)).thenReturn(attrCopyData);
+
+      handler.visit(artifact);
+      handler.visit(attribute);
+
+      verify(dataFactory).clone(artSourceData);
+      verify(dataFactory).clone(attrSourceData);
+
+      Assert.assertEquals(1, data.size());
+
+      ArtifactTransactionData txData = data.iterator().next();
+
+      Assert.assertEquals(artCopyData, txData.getArtifactData());
+      Assert.assertEquals(attrCopyData, txData.getAttributeData().get(0));
+   }
+}
diff --git a/plugins/org.eclipse.osee.orcs.core.test/src/org/eclipse/osee/orcs/core/internal/transaction/handler/HandlerTestSuite.java b/plugins/org.eclipse.osee.orcs.core.test/src/org/eclipse/osee/orcs/core/internal/transaction/handler/HandlerTestSuite.java
new file mode 100644
index 00000000000..636d31f215c
--- /dev/null
+++ b/plugins/org.eclipse.osee.orcs.core.test/src/org/eclipse/osee/orcs/core/internal/transaction/handler/HandlerTestSuite.java
@@ -0,0 +1,20 @@
+/*******************************************************************************
+ * Copyright (c) 2012 Boeing.
+ * All rights reserved. This program and the accompanying materials
+ * are made available under the terms of the Eclipse Public License v1.0
+ * which accompanies this distribution, and is available at
+ * http://www.eclipse.org/legal/epl-v10.html
+ *
+ * Contributors:
+ *     Boeing - initial API and implementation
+ *******************************************************************************/
+package org.eclipse.osee.orcs.core.internal.transaction.handler;
+
+import org.junit.runner.RunWith;
+import org.junit.runners.Suite;
+
+@RunWith(Suite.class)
+@Suite.SuiteClasses({CollectAndCopyDirtyDataTest.class})
+public class HandlerTestSuite {
+   // Test Suite
+}