openjpa-persistence-jdbc/src/test/java/org/apache/openjpa/persistence/jdbc/meta/TestLRSProxies.java

/*
 * TestLRSProxies.java
 *
 * Created on October 3, 2006, 5:01 PM
 *
 * To change this template, choose Tools | Template Manager
 * and open the template in the editor.
 */

/*
 * Licensed to the Apache Software Foundation (ASF) under one
 * or more contributor license agreements.  See the NOTICE file
 * distributed with this work for additional information
 * regarding copyright ownership.  The ASF licenses this file
 * to you under the Apache License, Version 2.0 (the
 * "License"); you may not use this file except in compliance
 * with the License.  You may obtain a copy of the License at
 *
 * http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing,
 * software distributed under the License is distributed on an
 * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
 * KIND, either express or implied.  See the License for the
 * specific language governing permissions and limitations
 * under the License.    
 */
package org.apache.openjpa.persistence.jdbc.meta;

import java.util.*;
import org.apache.openjpa.jdbc.conf.JDBCConfiguration;
import org.apache.openjpa.lib.jdbc.JDBCEvent;

import org.apache.openjpa.persistence.jdbc.common.apps.*;


import java.lang.annotation.Annotation;
import junit.framework.*;
import javax.persistence.EntityManager;
import javax.persistence.EntityManagerFactory;
import org.apache.openjpa.persistence.OpenJPAEntityManagerFactory;
import org.apache.openjpa.persistence.OpenJPAEntityManager;


public class TestLRSProxies extends org.apache.openjpa.persistence.jdbc.kernel.BaseJDBCTest{
   
    private Object _oid = null;
    private Object _coid = null;
    
    public TestLRSProxies(String casename) {
        super(casename);
    }
    
    
    /** Creates a new instance of TestLRSProxies */
    public TestLRSProxies() {
    }
    public void setUp() {
       deleteAll(LRSPC.class);
       deleteAll(LRSCompoundPC.class);
        
        LRSPC pc = new LRSPC("main");
        
        pc.getStringSet().add("val1");
        pc.getStringSet().add("val2");
        pc.getStringSet().add("val3");
        
        pc.getRelSet().add(new LRSPC("set1"));
        pc.getRelSet().add(new LRSPC("set2"));
        pc.getRelSet().add(new LRSPC("set3"));
        
        pc.getStringCollection().add("val1");
        pc.getStringCollection().add("val2");
        pc.getStringCollection().add("val3");
        
        pc.getRelCollection().add(new LRSPC("set1"));
        pc.getRelCollection().add(new LRSPC("set2"));
        pc.getRelCollection().add(new LRSPC("set3"));
        
        pc.getStringMap().put("key1", "1");
        pc.getStringMap().put("key2", "2");
        pc.getStringMap().put("key3", "3");
        
        pc.getRelMap().put("key1", new LRSPC("map1"));
        pc.getRelMap().put("key2", new LRSPC("map2"));
        pc.getRelMap().put("key3", new LRSPC("map3"));
        
        LRSCompoundPC cpc = new LRSCompoundPC("main");
        
        cpc.getStringSet().add("val1");
        cpc.getStringSet().add("val2");
        cpc.getStringSet().add("val3");
        
        cpc.getRelSet().add(new LRSCompoundPC("set1"));
        cpc.getRelSet().add(new LRSCompoundPC("set2"));
        cpc.getRelSet().add(new LRSCompoundPC("set3"));
        
        cpc.getStringCollection().add("val1");
        cpc.getStringCollection().add("val2");
        cpc.getStringCollection().add("val3");
        
        cpc.getRelCollection().add(new LRSCompoundPC("set1"));
        cpc.getRelCollection().add(new LRSCompoundPC("set2"));
        cpc.getRelCollection().add(new LRSCompoundPC("set3"));
        
        cpc.getStringMap().put("key1", "1");
        cpc.getStringMap().put("key2", "2");
        cpc.getStringMap().put("key3", "3");
        
        cpc.getRelMap().put("key1", new LRSCompoundPC("map1"));
        cpc.getRelMap().put("key2", new LRSCompoundPC("map2"));
        cpc.getRelMap().put("key3", new LRSCompoundPC("map3"));
        
        
        
        OpenJPAEntityManager pm = getEm(false, false);
        
        startTx(pm);
        pm.persist(pc);
        pm.persist(cpc);
        endTx(pm);
        _oid = pm.getObjectId(pc);
        _coid = pm.getObjectId(cpc);
        pm.close();
    }
    
    public void testStringSet() {
        stringCollectionTest(_oid, true, true);
        stringCollectionTest(_coid, true, true);
    }
    
    public void testStringSetRetain() {
        stringCollectionTest(_oid, false, true);
        stringCollectionTest(_coid, false, true);
    }
    
    public void testStringCollection() {
        stringCollectionTest(_oid, true, false);
        stringCollectionTest(_coid, true, false);
    }
    
    public void testStringCollectionRetain() {
        stringCollectionTest(_oid, false, false);
        stringCollectionTest(_coid, false, false);
    }
    
    private void stringCollectionTest(Object oid, boolean close,
            boolean isSet) {
        //FIXME jthomas
        //PersistenceManager pm = getPM(!close, !close);
        OpenJPAEntityManager pm =null;
        startTx(pm);
        
        LRSPCIntf pc = (LRSPCIntf) pm.getObjectId(oid);
        
        // check that orig values are correct
        Collection set = isSet ? pc.getStringSet() : pc.getStringCollection();
        assertEquals(3, set.size());
        assertTrue(set.contains("val1"));
        assertTrue(set.contains("val2"));
        assertTrue(set.contains("val3"));
        if (!isSet) {
            Iterator itr = set.iterator();
            assertEquals("val1", itr.next());
            assertEquals("val2", itr.next());
            assertEquals("val3", itr.next());
            //FIXME jthomas
            //KodoJDOHelper.close(itr);
        }
        
        // do some mods to try to confuse the proxy
        set.remove("val1");
        set.remove("val1");
        set.add("val4");
        set.remove("val4");
        set.add("val5");
        set.add("val6");
        assertStringCollectionChanged(set, isSet);
        endTx(pm);
        if (close) {
            pm.close();
            pm = getEm(false, false);
        }
        
        // re-retrieve and check set
        pc = (LRSPCIntf) pm.getObjectId(oid);
        set = isSet ? pc.getStringSet() : pc.getStringCollection();
        assertStringCollectionChanged(set, isSet);
        pm.close();
    }
    
    private void assertStringCollectionChanged(Collection set, boolean isSet) {
        assertEquals(4, set.size());
        assertTrue(!set.contains("val1"));
        assertTrue(set.contains("val2"));
        assertTrue(set.contains("val3"));
        assertTrue(!set.contains("val4"));
        assertTrue(set.contains("val5"));
        assertTrue(set.contains("val6"));
        if (!isSet) {
            Iterator itr = set.iterator();
            assertEquals("val2", itr.next());
            assertEquals("val3", itr.next());
            assertEquals("val5", itr.next());
            assertEquals("val6", itr.next());
            assertTrue(!itr.hasNext());
            //FIXME jthomas
            //KodoJDOHelper.close(itr);
        }
    }
    
    public void testStringMap() {
        stringMapTest(_oid, true);
        stringMapTest(_coid, true);
    }
    
    public void testStringMapRetain() {
        stringMapTest(_oid, false);
        stringMapTest(_coid, false);
    }
    
    private void stringMapTest(Object oid, boolean close) {
        OpenJPAEntityManager pm = getEm(!close, !close);
        startTx(pm);
        LRSPCIntf pc = (LRSPCIntf) pm.getObjectId(oid);
        
        // check that orig values are correct
        Map map = pc.getStringMap();
        assertEquals(3, map.size());
        assertEquals("1", map.get("key1"));
        assertEquals("2", map.get("key2"));
        assertEquals("3", map.get("key3"));
        
        // do some mods to try to confuse the proxy
        map.put("key1", "1a");
        map.put("key1", "1b");
        map.put("key2", "4");
        map.remove("key2");
        map.remove("foo");
        map.put("key5", "5");
        assertStringMapChanged(map);
        endTx(pm);
        
        if (close) {
            pm.close();
            pm = getEm(false, false);
        }
        
        // re-retrieve and check map
        pc = (LRSPCIntf) pm.getObjectId(oid);
        map = pc.getStringMap();
        assertStringMapChanged(map);
        pm.close();
    }
    
    private void assertStringMapChanged(Map map) {
        assertEquals(3, map.size());
        assertEquals("1b", map.get("key1"));
        assertEquals("3", map.get("key3"));
        assertEquals("5", map.get("key5"));
        assertNull(map.get("key2"));
        assertTrue(map.containsKey("key1"));
        assertFalse(map.containsKey("key2"));
        assertTrue(map.containsValue("5"));
        assertFalse(map.containsValue("1"));
        
        Iterator itr = map.entrySet().iterator();
        Map.Entry entry;
        int count = 0;
        for (; itr.hasNext(); count++) {
            entry = (Map.Entry) itr.next();
            if (entry.getKey().equals("key1"))
                assertEquals("1b", entry.getValue());
            else if (entry.getKey().equals("key3"))
                assertEquals("3", entry.getValue());
            else if (entry.getKey().equals("key5"))
                assertEquals("5", entry.getValue());
            else
                fail("Bad key: " + entry.getKey());
        }
        assertEquals(3, count);
        //FIXME
        //KodoJDOHelper.close(itr);
    }
    
    public void testRelSet() {
        relCollectionTest(_oid, true, true);
        relCollectionTest(_coid, true, true);
    }
    
    public void testRelSetRetain() {
        relCollectionTest(_oid, false, true);
        relCollectionTest(_coid, false, true);
    }
    
    public void testRelCollection() {
        relCollectionTest(_oid, true, false);
        relCollectionTest(_coid, true, false);
    }
    
    public void testRelCollectionRetain() {
        relCollectionTest(_oid, false, false);
        relCollectionTest(_coid, false, false);
    }
    
    private void relCollectionTest(Object oid, boolean close, boolean isSet) {
        OpenJPAEntityManager pm = getEm(!close, !close);
        startTx(pm);
        LRSPCIntf pc = (LRSPCIntf) pm.getObjectId(oid);
        
        // check that orig values are correct
        Collection set = isSet ? pc.getRelSet() : pc.getRelCollection();
        assertEquals(3, set.size());
        Collection ordered = new TreeSet();
        Iterator itr = set.iterator();
        ordered.add(itr.next());
        ordered.add(itr.next());
        ordered.add(itr.next());
        assertTrue(!itr.hasNext());
        //FIXME
        //KodoJDOHelper.close(itr);
        itr = ordered.iterator();
        LRSPCIntf set1 = (LRSPCIntf) itr.next();
        if (!isSet) {
            LRSPCIntf set2 = (LRSPCIntf) itr.next();
            LRSPCIntf set3 = (LRSPCIntf) itr.next();
            assertEquals("set1", set1.getStringField());
            assertEquals("set2", set2.getStringField());
            assertEquals("set3", set3.getStringField());
        }
        assertTrue(set.contains(set1));
        assertFalse(set.contains(pc));
        
        // do some mods to try to confuse the proxy
        set.remove(set1);
        set.remove(set1);
        LRSPCIntf set4 = pc.newInstance("set4");
        set.add(set4);
        set.remove(set4);
        LRSPCIntf set5 = pc.newInstance("set5");
        set.add(set5);
        assertRelCollectionChanged(pc, isSet);
        endTx(pm);
        
        if (close) {
            pm.close();
            pm = getEm(false, false);
        }
        
        // re-retrieve and check set
        pc = (LRSPCIntf) pm.getObjectId(oid);
        assertRelCollectionChanged(pc, isSet);
        pm.close();
    }
    
    private void assertRelCollectionChanged(LRSPCIntf pc, boolean isSet) {
        Collection set = isSet ? pc.getRelSet() : pc.getRelCollection();
        assertEquals(3, set.size());
        Collection ordered = new TreeSet();
        Iterator itr = set.iterator();
        ordered.add(itr.next());
        ordered.add(itr.next());
        ordered.add(itr.next());
        assertTrue(!itr.hasNext());
        //FIXME
        //KodoJDOHelper.close(itr);
        itr = ordered.iterator();
        LRSPCIntf set2 = (LRSPCIntf) itr.next();
        if (!isSet) {
            LRSPCIntf set3 = (LRSPCIntf) itr.next();
            LRSPCIntf set5 = (LRSPCIntf) itr.next();
            assertEquals("set2", set2.getStringField());
            assertEquals("set3", set3.getStringField());
            assertEquals("set5", set5.getStringField());
        }
        assertTrue(set.contains(set2));
        assertFalse(set.contains(pc));
    }
    
    public void testRelMap() {
        relMapTest(_oid, true);
        relMapTest(_coid, true);
    }
    
    public void testRelMapRetain() {
        relMapTest(_oid, false);
        relMapTest(_coid, false);
    }
    
    private void relMapTest(Object oid, boolean close) {
        OpenJPAEntityManager pm = getEm(!close, !close);
        startTx(pm);
        LRSPCIntf pc = (LRSPCIntf) pm.getObjectId(oid);
        
        // check that orig values are correct
        Map map = pc.getRelMap();
        assertEquals(3, map.size());
        LRSPCIntf map1 = (LRSPCIntf) map.get("key1");
        LRSPCIntf map2 = (LRSPCIntf) map.get("key2");
        LRSPCIntf map3 = (LRSPCIntf) map.get("key3");
        assertEquals("map1", map1.getStringField());
        assertEquals("map2", map2.getStringField());
        assertEquals("map3", map3.getStringField());
        assertTrue(map.containsKey("key1"));
        assertFalse(map.containsKey("key4"));
        assertTrue(map.containsValue(map1));
        assertFalse(map.containsValue(pc));
        
        // do some mods to try to confuse the proxy
        LRSPCIntf map1a = pc.newInstance("map1a");
        map.put("key1", map1a);
        LRSPCIntf map1b = pc.newInstance("map1b");
        map.put("key1", map1b);
        map.remove("key2");
        map.put("key4", pc.newInstance("map4"));
        map.remove("key4");
        map.remove("foo");
        map.put("key5", pc.newInstance("map5"));
        assertRelMapChanged(pc);
        endTx(pm);
        
        if (close) {
            pm.close();
            pm = getEm(false, false);
        }
        
        // re-retrieve and check map
        pc = (LRSPCIntf) pm.getObjectId(oid);
        assertRelMapChanged(pc);
        pm.close();
    }
    
    private void assertRelMapChanged(LRSPCIntf pc) {
        Map map = pc.getRelMap();
        assertEquals(3, map.size());
        LRSPCIntf map1b = (LRSPCIntf) map.get("key1");
        LRSPCIntf map3 = (LRSPCIntf) map.get("key3");
        LRSPCIntf map5 = (LRSPCIntf) map.get("key5");
        assertEquals("map1b", map1b.getStringField());
        assertEquals("map3", map3.getStringField());
        assertEquals("map5", map5.getStringField());
        assertTrue(map.containsKey("key1"));
        assertFalse(map.containsKey("key2"));
        assertTrue(map.containsValue(map1b));
        assertFalse(map.containsValue(pc));
        
        Iterator itr = map.entrySet().iterator();
        Map.Entry entry;
        int count = 0;
        for (; itr.hasNext(); count++) {
            entry = (Map.Entry) itr.next();
            if (entry.getKey().equals("key1"))
                assertEquals(map1b, entry.getValue());
            else if (entry.getKey().equals("key3"))
                assertEquals(map3, entry.getValue());
            else if (entry.getKey().equals("key5"))
                assertEquals(map5, entry.getValue());
            else
                fail("Bad key: " + entry.getKey());
        }
        assertEquals(3, count);
        //FIXME
        //KodoJDOHelper.close(itr);
    }
    
    public void testTransfer() {
        // cannot transfer an lrs from one field to another
        
        OpenJPAEntityManager pm = getEm(true, true);
        LRSPC pc = (LRSPC) pm.getObjectId(_oid);
        LRSPC map1 = (LRSPC) pc.getRelMap().get("key1");
        assertNotNull(map1);
        
        startTx(pm);
        Map map = pc.getRelMap();
        pc.setRelMap(null);
        map1.setRelMap(map);
        
        try {
            endTx(pm);
            fail("Allowed transfer of lrs field");
        } catch (Exception jue) {
        }
        if (pm.getTransaction().isActive())
            pm.getTransaction().rollback();
        pm.close();
    }
    
    public void testShare() {
        OpenJPAEntityManager pm = getEm(true, true);
        LRSPC pc = (LRSPC) pm.getObjectId(_oid);
        LRSPC map1 = (LRSPC) pc.getRelMap().get("key1");
        assertNotNull(map1);
        
        startTx(pm);
        Map map = pc.getRelMap();
        map1.setRelMap(map);
        endTx(pm);
        assertTrue(pc.getRelMap() != map1.getRelMap());
        assertEquals(3, map1.getRelMap().size());
        assertTrue(map1.getRelMap().containsValue(map1));
        pm.close();
        
        // make sure it sticks
        pm = getEm(true, true);
        pc = (LRSPC) pm.getObjectId(_oid);
        map1 = (LRSPC) pc.getRelMap().get("key1");
        assertEquals(map1, map1.getRelMap().get("key1"));
        pm.close();
    }
    
    public void testRollback() {
        //FIXME
        //PersistenceManagerFactory factory = getPMFactory(new String[]{
        //    "openjpa.RestoreMutableValues", "true",
        //});
        OpenJPAEntityManagerFactory factory =null;
        OpenJPAEntityManager pm = factory.createEntityManager();
        LRSPC pc = (LRSPC) pm.getObjectId(_oid);
        startTx(pm);
        pc.getStringCollection().remove("val2");
        pc.getStringCollection().add("val4");
        rollbackTx(pm);
        assertTrue(pc.getStringCollection().contains("val2"));
        assertFalse(pc.getStringCollection().contains("val4"));
        pm.close();
        factory.close();
    }
    
    public void testReplace() {
        OpenJPAEntityManager pm = getEm(false, false);
        startTx(pm);
        LRSPC pc = (LRSPC) pm.getObjectId(_oid);
        
        // totally replace set
        Collection set = new HashSet();
        set.add("new");
        pc.setStringCollection(set);
        
        endTx(pm);
        pm.close();
        
        // re-retrieve and check set
        pm = getEm(false, false);
        pc = (LRSPC) pm.getObjectId(_oid);
        
        set = pc.getStringCollection();
        assertEquals(1, set.size());
        assertTrue(set.contains("new"));
        pm.close();
    }
    
    public void testAdd()
    throws Exception {
/*
        //FIXME
        //KodoPersistenceManagerFactory pmf = getPMFactory(new String []{
        //    "openjpa.jdbc.JDBCListeners", Listener.class.getName(),
        //});
        OpenJPAEntityManagerFactory pmf =null;
        JDBCConfiguration conf = (JDBCConfiguration) pmf.getConfiguration();
        //FIXME need to fix inner class
        //Listener l = (Listener) conf.getJDBCListenerInstances()[0];
        OpenJPAEntityManager pm = pmf.createEntityManager();
        try {
            startTx(pm);
            LRSPC pc = (LRSPC) pm.getObjectId(_oid);
            l.count = 0;
            pc.getStringCollection().add("testAddStringValue");
            endTx(pm);
            assertEquals(3, l.count);
        } catch (Exception e) {
            if (pm.getTransaction().isActive())
                pm.getTransaction().rollback();
            throw e;
        } finally {
            pm.close();
        }
 */
    }
    
    private OpenJPAEntityManager getEm(boolean optimistic,boolean retainValues) {
        OpenJPAEntityManager em = (OpenJPAEntityManager)currentEntityManager();
        em.setNontransactionalRead(true);
        em.setRetainState(retainValues);
        em.setOptimistic(optimistic);
        return em;
    }
    
    //FIXME - could not find AbstractJDBCListener because of package imports in source file
/*
    public static class Listener extends AbstractJDBCListener {
 
        public int count = 0;
 
        public void afterExecuteStatement(JDBCEvent ev) {
            count++;
        }
    }
 */
}