root/trunk/Fdo/Python/UnitTest/Src/ApplySchemaTest.py

# File : \\otwqa\Providers\qa\tools\FdoPythonWrappers\UnitTests\lib\ApplySchemaTest.py
#
# Description: Defines the ApplySchema unit test class
#
# Copyright (C) 2004-2007  Autodesk, Inc.
# 
# This library is free software; you can redistribute it and/or
# modify it under the terms of version 2.1 of the GNU Lesser
# General Public License as published by the Free Software Foundation.
# 
# This library is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
# Lesser General Public License for more details.
# 
# You should have received a copy of the GNU Lesser General Public
# License along with this library; if not, write to the Free Software
# Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
#

# Import Python libs
import unittest
import traceback
import string
import os.path
from ConfigParser import *
import re

# Import FDO libs
from FDO import *
from SdfConnectionFactory import *
from SdfFileFactory import *


G_INI_FILENAME="./Input/UnitTestConfig.ini"


class ApplySchemaTest(unittest.TestCase):
        """
        Unit test for FDO Command classes.  

        This class has the following dependencies:
        1. A config file called input/UnitTestConfig.ini must exist
        2. input/UnitTestConfig.ini must contain the following entries:

                [Connection]
                ConnectString=<A FDO connection string>
                ProviderName=<An FDO provider name. Can also be a regular expression>

        """     
        _oConfig = ConfigParser()       
        _oConnection = None

        def setUp(self):
                """
                Initialize resources required by the test.
                Creates, initializes and open a FdoIConnection

                Arguments:
                        None

                Returns:
                        none
                """

                # Create the SDF file
                SdfFileFactory.createFromIni(G_INI_FILENAME, True)

                # Get a SDF connection
                self._oConfig.read([G_INI_FILENAME])
                self._oConnection = SdfConnectionFactory.create()               
                
                # Read the .ini file and configure the connection
                sConnectString = self._oConfig.get("Connection", "ConnectString")
                self._oConnection.SetConnectionString(sConnectString)
                self._oConnection.Open()

        
        def testApplySchema(self):
                """Test the Apply Schema command against an SDF datasource"""
                self.assertEquals(self._oConnection.GetConnectionState(), FdoConnectionState_Open)
                
                # Apply the schema to the datastore
                oApplySchemaCmd = self._oConnection.CreateCommand(FdoCommandType_ApplySchema)
                oApplySchemaCmd = FdoICommandToFdoIApplySchema(oApplySchemaCmd)
                oApplySchemaCmd.SetFeatureSchema(self._createFeatureSchema("TestSchema"))
                oApplySchemaCmd.Execute()               
                oApplySchemaCmd.Release()               
                
                # Verify that the Feature Schema has been correctly created
                oDescribeSchemaCmd = self._oConnection.CreateCommand(FdoCommandType_DescribeSchema)
                oDescribeSchemaCmd = FdoICommandToFdoIDescribeSchema(oDescribeSchemaCmd)
                self.assertEquals(oDescribeSchemaCmd.__class__.__name__, "FdoIDescribeSchema")
                oSchemaCol = oDescribeSchemaCmd.Execute()
                oDescribeSchemaCmd.Release()
                self.assertEquals(oSchemaCol.GetCount(), 1)
                
                # Validate the properties of the schema
                oSchema = oSchemaCol.GetItem(0)
                self.assert_(oSchema.GetName(), 'TestSchema')           
                
                # Validate the classes in the schema
                oClasses = oSchema.GetClasses()
                self.assertEquals(oClasses.GetCount(), 2)
                
                # Validate the SewerPipe feature class
                oClass = oClasses.FindItem("SewerPipe")
                self.assert_(oClass.GetName(), 'SewerPipe')
                self.assert_(oClass.GetQualifiedName(), 'TestSchema:SewerPipe')
                
                # Validate the properties of the SewerPipe feature class
                oProperties = oClass.GetProperties()
                self.assertEquals(oProperties.GetCount(), 4)            
                                
                # Cleanup
                oProperties.Release()
                oClass.Release()                
                oClasses.Release()
                oSchema.Release()
                oSchemaCol.Release()
                

        def _createFeatureSchema(self, sSchemaName):
                """Creates a FDO Feature schema instance"""
                oNewSchema = FdoFeatureSchema.Create(sSchemaName, sSchemaName)
                oClasses = oNewSchema.GetClasses()
                
                # Create the classes to add to the schema
                # Note: if you add more classes here, you must update testApplySchema()
                oClasses.Add(self._createFeatureClass("SewerPipe"))
                oClasses.Add(self._createFeatureClass("WaterPipe"))                             
                oClasses.Release()
                
                return oNewSchema       
        
        
        def _createFeatureClass(self, sClassName):
                """
                Creates an FDO Feature class definition
                
                Note: if you add more properties here, you must update testApplySchema()
                """
                
                # Initialize a FdoFeatureclass instance
                oNewClass = FdoFeatureClass.Create(sClassName, sClassName)
                oProperties = oNewClass.GetProperties()
                oIdentityProperties = oNewClass.GetIdentityProperties()
                
                # Create the identity property
                oIdProperty = self._createDataProperty("FeatureId", FdoDataType_Int32)
                oProperties.Add(oIdProperty)
                oIdentityProperties.Add(oIdProperty)
                oIdentityProperties.Release()
                
                # Create the properties for the class           
                oProperties.Add(self._createDataProperty("Length", FdoDataType_Double))
                oProperties.Add(self._createDataProperty("Diameter", FdoDataType_Double))
                oProperties.Add(self._createDataProperty("Owner", FdoDataType_String))          
                        
                oProperties.Release()
                return oNewClass
                
                
        def _createDataProperty(self, sPropertyName, enumDataType):
                """
                Creates a simple data property.  Default characteristics, such as length
                and scale are assigned.
                
                Arguments:
                        sPropertyName (mandatory input)
                                Name of the new property to create
                                
                        enumDataType (mandatory input)
                                A FdoDataType value
                                
                Returns:
                        A FdoDataPropertyDefinition instance
                
                """
                oNewProperty = FdoDataPropertyDefinition.Create(sPropertyName, sPropertyName)
                oNewProperty.SetDataType(enumDataType)
                oNewProperty.SetNullable(True)
                
                if enumDataType == FdoDataType_String:
                        oNewProperty.SetLength(32)
                        
                if enumDataType == FdoDataType_Decimal:
                        oNewProperty.SetPrecision(16)
                        oNewProperty.SetScale(4)
                        
                return oNewProperty


        def tearDown(self):
                """
                Releases any resources created or connected during the test

                Arguments:
                        None

                Returns:
                        none
                """
                # Close any open FdoIConnections
                if not self._oConnection is None:
                        if self._oConnection.__class__.__name__ == 'FdoIConnection':
                                self._oConnection.Close()
                                self._oConnection.Release()
                print "\nTesting ApplySchemaTest..."