testconnection.java

Jena推理机

/*
  (c) Copyright 2002, 2003, 2004, 2005, 2006, 2007 Hewlett-Packard Development Company, LP
  [See end of file]
  $Id: TestConnection.java,v 1.31 2007/01/02 11:50:15 andy_seaborne Exp $
*/

package com.hp.hpl.jena.db.test;

/**
 * 
 * This tests basic open/create operations on the modelRDB.
 * 
 * To run, you must have a mySQL database operational on
 * localhost with a database name of "test" and allow use
 * by a user named "test" with an empty password.
 * 
 * (based in part on model tests written earlier by bwm and kers)
 * 
 * @author csayers
 * @version 0.1
*/

import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;

import com.hp.hpl.jena.db.*;
import com.hp.hpl.jena.db.impl.IRDBDriver;

import junit.framework.*;

import com.hp.hpl.jena.rdf.model.*;
import com.hp.hpl.jena.shared.*;
import com.hp.hpl.jena.vocabulary.DB;

public class TestConnection extends TestCase {
    
    protected static Log logger = LogFactory.getLog( TestConnection.class );
	
	String DefModel = GraphRDB.DEFAULT;    
        
    public TestConnection( String name )
        { super( name ); }
    
    public static TestSuite suite()
        { return new TestSuite( TestConnection.class ); }           
    
    protected void setUp() throws java.lang.Exception {    	
    }
    
    protected void tearDown() throws java.lang.Exception {
    }
    
    private static void loadClass()
        {
        try { Class.forName(TestPackage.M_DBDRIVER_CLASS); }
        catch (Exception e) { throw new JenaException( e ); }
        }
        
    public static IDBConnection makeTestConnection() 
        {
        loadClass();
        return new DBConnection
            (
            TestPackage.M_DB_URL, 
            TestPackage.M_DB_USER, 
            TestPackage.M_DB_PASSWD, 
            TestPackage.M_DB
            );
        }
        
    public static IDBConnection makeAndCleanTestConnection()
        {
        IDBConnection result = makeTestConnection();
        boolean tryClean = true;
        boolean didClean = false;
        boolean tryUnlock = true;
        String err = null;
        while ( tryClean && !didClean ) {
        	try {
        		result.cleanDB();
        		didClean = true;
        	} catch (Exception e) {
        		err = err + "\n" + e;
        		if ( tryUnlock ) {
        			tryUnlock = false;
        			if ( result.getDriver().DBisLocked() )
        				try {
        					result.getDriver().unlockDB();
        				} catch ( Exception e1 ) {
        					err = err + "\n" + e1;
        				}
        		} else
        			tryClean = false;
        	}
        }
        if ( didClean == false )
        	throw new JenaException("Failed to clean database.\n" + err);       
        return result;
        }
        
/*	public void testNoClass() throws java.lang.Exception {
		try {
			IDBConnection conn = new DBConnection(
			TestPackage.M_DB_URL, 
			TestPackage.M_DB_USER, 
			TestPackage.M_DB_PASSWD, 
			TestPackage.M_DB);
			conn.cleanDB();
			assertTrue(false); // should not get here
		} catch (Exception e) {
		}
	} */

    public void testRecovery() throws java.lang.Exception {
        IDBConnection conn = makeAndCleanTestConnection();
        ModelRDB m = null;
        try {
		m = ModelRDB.createModel(conn, "myName");
		m.close();
        } catch ( Exception e ) {
			assertTrue(false);
        }
		try {
			m = ModelRDB.createModel(conn, "myName");
			assertTrue(false);
		} catch ( Exception e ) {
		}
    	conn.close();
    }

    
    public void testDBConnect() throws java.lang.Exception {
		IDBConnection conn = makeTestConnection();
    	conn.close();
    }
    
	public void testBadConnection() throws java.lang.Exception {
		/*
		 * try { IDBConnection conn = new DBConnection( "Bad URL",
		 * TestPackage.M_DB_USER, TestPackage.M_DB_PASSWD, TestPackage.M_DB);
		 * conn.cleanDB(); assertTrue(false); // should not get here } catch
		 * (Exception e) { }
		 */
		try {
			IDBConnection conn = new DBConnection(
			TestPackage.M_DB_URL, 
			TestPackage.M_DB_USER, 
			TestPackage.M_DB_PASSWD, 
			"Bad DB");
			conn.cleanDB();
			assertTrue(false); // should not get here
		} catch (Exception e) {
		}
	}
    
    
    public void testConstructDefaultModel() throws java.lang.Exception {
		IDBConnection conn = makeAndCleanTestConnection();
		ModelRDB m = ModelRDB.createModel(conn);
		m.remove();
    	conn.close();
    }
    
    public void testConstructAndOpenDefaultModel() throws java.lang.Exception {
        IDBConnection conn = makeAndCleanTestConnection();
		ModelRDB m = ModelRDB.createModel(conn);
		m.close();
		ModelRDB m2 = ModelRDB.open(conn);
		m2.remove();
		conn.close();
    }
        
    public void testConstructNamedModel() throws java.lang.Exception {
        IDBConnection conn = makeAndCleanTestConnection();
		ModelRDB m = ModelRDB.createModel(conn, "myName");
		m.remove();
    	conn.close();
    }
    
	public void testBadNamedModel() throws java.lang.Exception {
		IDBConnection conn = makeAndCleanTestConnection();
		ModelRDB m = null;
		try {
			m = ModelRDB.createModel(conn, DefModel);
			assertTrue(false);
		} catch (Exception e) {
		}
		conn.close();
	}
	
	public void testBadNamedFactoryModel() throws java.lang.Exception {
		IDBConnection conn = makeAndCleanTestConnection();
		ModelMaker maker = ModelFactory.createModelRDBMaker(conn);
		Model m = null;
		try {
			m  = maker.createModel(DefModel);
			assertTrue(false);
		} catch (Exception e) {
		}
		conn.close();
	}
	
	public void testReconstructDefaultModel() throws java.lang.Exception {
		IDBConnection conn = makeAndCleanTestConnection();
		ModelRDB m = ModelRDB.createModel(conn);
		m.remove();
		ModelRDB m1 = ModelRDB.createModel(conn);
		m1.remove();
		conn.close();
	}
    
	public void testReconstructNamedModel() throws java.lang.Exception {
		IDBConnection conn = makeAndCleanTestConnection();
		ModelRDB m = ModelRDB.createModel(conn, "myName");
		m.remove();
		ModelRDB m1 = ModelRDB.createModel(conn, "myName");
		m1.remove();
		conn.close();
	}

        
    public void testConstructAndOpenNamedModel() throws java.lang.Exception {
        IDBConnection conn = makeAndCleanTestConnection();
		ModelRDB m = ModelRDB.createModel(conn, "myName");
		m.close();
		ModelRDB m2 = ModelRDB.open(conn, "myName");
		m2.remove();
    	conn.close();
    }
        
    public void testConstructParamaterizedModel() throws java.lang.Exception {
        IDBConnection conn = makeAndCleanTestConnection();
		ModelRDB m = ModelRDB.createModel(conn, ModelRDB.getDefaultModelProperties(conn));
		m.remove();
    	conn.close();
    }
        
    public void testConstructAndOpenParamaterizedModel() throws java.lang.Exception {
        IDBConnection conn = makeAndCleanTestConnection();
		ModelRDB m = ModelRDB.createModel(conn, ModelRDB.getDefaultModelProperties(conn));
		m.close();
		ModelRDB m2 = ModelRDB.open(conn);
		m2.remove();
    	conn.close();
    }
        
	public void testConstructNamedParamaterizedModel() throws java.lang.Exception {
        IDBConnection conn = makeAndCleanTestConnection();
		ModelRDB m = ModelRDB.createModel(conn, "myName", ModelRDB.getDefaultModelProperties(conn));
		m.remove();
    	conn.close();
    }
        
	public void testConstructAndOpenNamedParamaterizedModel() throws java.lang.Exception {
        IDBConnection conn = makeAndCleanTestConnection();
		ModelRDB m = ModelRDB.createModel(conn, "myName", ModelRDB.getDefaultModelProperties(conn));
		m.close();
		ModelRDB m2 = ModelRDB.open(conn, "myName");
		m2.remove();
    	conn.close();
    }
    
	public void testOpenNamedNonExistentModel() throws java.lang.Exception {
        IDBConnection conn = makeTestConnection();
		try {
			ModelRDB m2 = ModelRDB.open(conn, "myName");
			m2.remove();
			conn.close();
			assertTrue("Successfully opened non-existent model", false);
		} catch ( RDFRDBException e ) {
			conn.close();
		}   
	}

	public void testOpenUnnamedNonExistentModel() throws java.lang.Exception {
        IDBConnection conn = makeTestConnection();
		try {
			conn.cleanDB();
			ModelRDB m2 = ModelRDB.open(conn);
			m2.remove();
			conn.close();
			assertTrue("Successfully opened unnamed non-existent model", false);
		} catch ( RDFRDBException e ) {
			conn.close();
		}   
	}

	public void testCreateExistingModel() throws java.lang.Exception {
        IDBConnection conn = makeAndCleanTestConnection();
		ModelRDB m = ModelRDB.createModel(conn, "myName", ModelRDB.getDefaultModelProperties(conn));
		try {
			ModelRDB m2 = ModelRDB.createModel(conn, "myName", ModelRDB.getDefaultModelProperties(conn));
			m.remove(); m2.remove();
			conn.close();
			assertTrue("Successfully created pre-existing model", false);
		} catch ( RDFRDBException e ) {
			m.remove();
			conn.close();
		}
	}
	
	public void addToDBGraphProp ( Model model, Property prop, String val ) {
		// first, get URI of the graph
		StmtIterator iter = model.listStatements(
			new SimpleSelector(null, DB.graphName, (RDFNode) null));
		assertTrue(iter.hasNext());
		
		Statement stmt = iter.nextStatement();
		assertTrue(iter.hasNext() == false);
		Resource graphURI = stmt.getSubject();
		Literal l = model.createLiteral(val);
		Statement s = model.createStatement(graphURI,prop,l);
		model.add(s);
		assertTrue(model.contains(s));
	}
	
	public void testConstructDefSchemaModel() throws java.lang.Exception {
		IDBConnection conn = makeAndCleanTestConnection();
		conn.getDriver().setStoreWithModel("");
		// Model props = ModelRDB.getDefaultModelProperties(conn);
		// addToDBGraphProp(props,DB.graphDBSchema,DefModel);
		// ModelRDB m = ModelRDB.createModel(conn, props);
		ModelRDB m = ModelRDB.createModel(conn);
		m.remove();
		conn.close();
	}
	
	public void testConstructBadSchemaModel() throws java.lang.Exception {
		IDBConnection conn = makeAndCleanTestConnection();
		// Model props = ModelRDB.getDefaultModelProperties(conn);
		// addToDBGraphProp(props,DB.graphDBSchema,"SCHEMA_DOES_NOT_EXIST");
		conn.getDriver().setStoreWithModel(DefModel);
		try {
			// ModelRDB m = ModelRDB.createModel(conn, props);
			ModelRDB m = ModelRDB.createModel(conn);
			m.remove();
			assertFalse("Created model with non-existent schema",true);
		} catch (RDFRDBException e) {
		}
		conn.getDriver().setStoreWithModel("MODEL_DOES_NOT_EXIST");
		try {
			// ModelRDB m = ModelRDB.createModel(conn, props);
			ModelRDB m = ModelRDB.createModel(conn);
			m.remove();
			assertFalse("Created model with non-existent schema",true);
		} catch (RDFRDBException e) {
		}
		conn.close();
	}
	
	public void testConstructNamedModelDefSchema() throws java.lang.Exception {
		// this named model uses the default schema
		IDBConnection conn = makeAndCleanTestConnection();
		// Model props = ModelRDB.getDefaultModelProperties(conn);
		// addToDBGraphProp(props,DB.graphDBSchema,DefModel);
		conn.getDriver().setStoreWithModel(null);
		// ModelRDB m = ModelRDB.createModel(conn, "myName", props);
		ModelRDB m = ModelRDB.createModel(conn, "myName");
		m.remove();
		conn.close();
	}

	public void testConstructNamedModelDefSchema1() throws java.lang.Exception {
		// same as testConstructNamedModelDefSchema except the default model already exists.
		// should new model should share tables with default. no way now to verify this
		// from the API though. have to check it manually.
		IDBConnection conn = makeAndCleanTestConnection();
		// ModelRDB mdef = ModelRDB.createModel(conn, ModelRDB.getDefaultModelProperties(conn));
		// Model props = ModelRDB.getDefaultModelProperties(conn);
		// addToDBGraphProp(props,DB.graphDBSchema,DefModel);
		// ModelRDB m = ModelRDB.createModel(conn, "myName", props);
		ModelRDB mdef = ModelRDB.createModel(conn);
		conn.getDriver().setStoreWithModel(DefModel);
		ModelRDB m = ModelRDB.createModel(conn, "myName");
		mdef.remove(); m.remove();
		conn.close();
	}
	
	public void testConstructNamedModelDefSchema2() throws java.lang.Exception {