openjpa-persistence-jdbc/src/test/java/org/apache/openjpa/persistence/jdbc/schema/TestXMLSchemaParser.java

/*
 * TestXMLSchemaParser.java
 *
 * Created on October 6, 2006, 2:42 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.schema;

import java.io.IOException;
import java.sql.Types;
import java.util.*;
import org.apache.openjpa.jdbc.conf.JDBCConfiguration;
import org.apache.openjpa.jdbc.conf.JDBCConfigurationImpl;
import org.apache.openjpa.jdbc.schema.Column;
import org.apache.openjpa.jdbc.schema.ForeignKey;
import org.apache.openjpa.jdbc.schema.Index;
import org.apache.openjpa.jdbc.schema.PrimaryKey;
import org.apache.openjpa.jdbc.schema.Schema;
import org.apache.openjpa.jdbc.schema.SchemaGroup;
import org.apache.openjpa.jdbc.schema.Sequence;
import org.apache.openjpa.jdbc.schema.Table;
import org.apache.openjpa.jdbc.schema.XMLSchemaParser;

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 TestXMLSchemaParser extends org.apache.openjpa.persistence.jdbc.kernel.BaseJDBCTest{
        
    protected JDBCConfiguration conf = null;
    private SchemaGroup _group = null;
    
    
    /** Creates a new instance of TestXMLSchemaParser */
    public TestXMLSchemaParser() {
    }
    
    public TestXMLSchemaParser(String test) {
        super(test);
    }
    
    public void setUp()
    throws Exception {
        this.conf = new JDBCConfigurationImpl();
        _group = getSchemaGroup();
    }
    
    /**
     * Parses the schema group from the schema XML
     * resources in this package.
     */
    protected SchemaGroup parseSchemaGroup()
    throws IOException {
        XMLSchemaParser parser = new SCMSchemaParser(this.conf);
        parser.parse(TestXMLSchemaParser.class, false);
        parser.parse(TestSchema.class, false);    // will go up to package level
        return parser.getSchemaGroup();
    }
    
    /**
     * Return the schema group to use in testing.  Returns
     * {@link #parseSchemaGroup} by default.
     */
    protected SchemaGroup getSchemaGroup()
    throws Exception {
        return parseSchemaGroup();
    }
    
    /**
     * Checks the generated schema group for accuracy.
     */
    public void testSchemaParsing() {
        assertEquals(2, _group.getSchemas().length);
        assertEquals("SCHEMA1", _group.getSchema("SCHEMA1").getName());
        assertEquals("SCHEMA2", _group.getSchema("SCHEMA2").getName());
    }
    
    /**
     * Checks the pased sequences.
     */
    public void testSequenceParsing() {
        Schema schema = _group.getSchema("SCHEMA1");
        assertEquals(2, schema.getSequences().length);
        assertEquals(0, _group.getSchema("SCHEMA2").getSequences().length);
        
        Sequence seq1 = schema.getSequence("SEQ1");
        assertNotNull(seq1);
        assertEquals("SEQ1", seq1.getName());
        assertEquals(seq1, _group.findSequence("SEQ1"));
        assertEquals(seq1, _group.findSequence("SCHEMA1.SEQ1"));
        assertEquals(1, seq1.getInitialValue());
        assertEquals(1, seq1.getIncrement());
        assertEquals(0, seq1.getAllocate());
        
        Sequence seq2 = schema.getSequence("SEQ2");
        assertNotNull(seq2);
        assertEquals(3, seq2.getInitialValue());
        assertEquals(5, seq2.getIncrement());
        assertEquals(50, seq2.getAllocate());
    }
    
    /**
     * Checks table and column parsing.
     */
    public void testTableColumnParsing() {
        Schema schema1 = _group.getSchema("SCHEMA1");
        Table[] tables = schema1.getTables();
        assertEquals(2, tables.length);
        assertEquals("TABLE1", tables[0].getName());
        assertEquals("TABLE3", tables[1].getName());
        
        Column[] cols = tables[0].getColumns();
        assertEquals(2, cols.length);
        assertEquals("COL1", cols[0].getName());
        assertEquals("COL2", cols[1].getName());
        assertEquals(Types.VARCHAR, cols[0].getType());
        assertEquals(Types.FLOAT, cols[1].getType());
        assertTrue(cols[0].isNotNull());
        assertTrue(!cols[1].isNotNull());
        assertEquals("def", cols[0].getDefault());
        assertNull(cols[1].getDefault());
    }
    
    /**
     * Test that primary keys are resolved correctly.
     */
    public void testPrimaryKeyParsing() {
        Table table = _group.getSchema("SCHEMA1").getTable("TABLE1");
        PrimaryKey pk = table.getPrimaryKey();
        assertNotNull(pk);
        assertEquals("PK1", pk.getName());
        assertTrue(pk.isLogical());
        assertEquals(1, pk.getColumns().length);
        assertEquals(table.getColumn("COL1"), pk.getColumns()[0]);
        
        table = _group.getSchema("SCHEMA2").getTable("TABLE2");
        pk = table.getPrimaryKey();
        assertNotNull(pk);
        assertEquals("PK2", pk.getName());
        assertTrue(!pk.isLogical());
        assertEquals(2, pk.getColumns().length);
        assertEquals(table.getColumn("COL1"), pk.getColumns()[0]);
        assertEquals(table.getColumn("COL2"), pk.getColumns()[1]);
    }
    
    /**
     * Test that indexes are resolved correctly.
     */
    public void testIndexParsing() {
        Table table = _group.getSchema("SCHEMA1").getTable("TABLE1");
        Index idx = table.getIndex("IDX1");
        assertNotNull(idx);
        assertTrue(idx.isUnique());
        assertEquals(1, idx.getColumns().length);
        assertEquals(table.getColumn("COL2"), idx.getColumns()[0]);
        
        table = _group.getSchema("SCHEMA2").getTable("TABLE2");
        idx = table.getIndex("IDX2");
        assertNotNull(idx);
        assertTrue(!idx.isUnique());
        assertEquals(2, idx.getColumns().length);
        assertEquals(table.getColumn("COL1"), idx.getColumns()[0]);
        assertEquals(table.getColumn("COL2"), idx.getColumns()[1]);
    }
    
    /**
     * Test that foreign keys are resolved correctly.
     */
    public void testForeignKeyParsing() {
        Table table1 = _group.getSchema("SCHEMA1").getTable("TABLE1");
        Table table2 = _group.getSchema("SCHEMA2").getTable("TABLE2");
        
        ForeignKey fk = table1.getForeignKeys()[0];
        assertEquals("FK1", fk.getName());
        assertNotNull(fk);
        assertEquals(ForeignKey.ACTION_RESTRICT, fk.getDeleteAction());
        Column[] cols = fk.getColumns();
        Column[] pkCols = fk.getPrimaryKeyColumns();
        assertEquals(2, cols.length);
        assertEquals(2, pkCols.length);
        assertEquals(table1.getColumn("COL1"), cols[0]);
        assertEquals(table2.getColumn("COL1"), pkCols[0]);
        assertEquals(table1.getColumn("COL2"), cols[1]);
        assertEquals(table2.getColumn("COL2"), pkCols[1]);
        
        fk = table2.getForeignKeys()[0];
        assertEquals("FK2", fk.getName());
        assertNotNull(fk);
        assertEquals(ForeignKey.ACTION_NONE, fk.getDeleteAction());
        cols = fk.getColumns();
        pkCols = fk.getPrimaryKeyColumns();
        assertEquals(1, cols.length);
        assertEquals(1, pkCols.length);
        assertEquals(table2.getColumn("COL2"), cols[0]);
        assertEquals(table1.getColumn("COL1"), pkCols[0]);
    }
    
    public static void main(String[] args) {
        //main(TestXMLSchemaParser.class);
    }
    
    public static class SCMSchemaParser
            extends XMLSchemaParser {
        
        public SCMSchemaParser(JDBCConfiguration conf) {
            super(conf);
            setSuffix(".scm");
        }
    }
    
}