[Adapdev-commits] Adapdev/src/Adapdev.Data.Tests/Schema SchemaBuilderTest.cs,NONE,1.1

[Sean M. <int...@us...>]

Update of /cvsroot/adapdev/Adapdev/src/Adapdev.Data.Tests/Schema
In directory sc8-pr-cvs1.sourceforge.net:/tmp/cvs-serv8050/src/Adapdev.Data.Tests/Schema

Added Files:
	SchemaBuilderTest.cs 
Log Message:


--- NEW FILE: SchemaBuilderTest.cs ---
using System;
using System.Data.OleDb;
using NUnit.Framework;

namespace Adapdev.Data.Schema.Tests
{
	using Adapdev.Data;
	using Adapdev.Data.Schema;

	/// <summary>
	/// Summary description for SchemaBuilderTest.
	/// </summary>
	/// 
	[TestFixture]
	public class SchemaBuilderTest
	{

		private string _oledbConnectionString = "Provider=sqloledb;Data Source=localhost;Initial Catalog=northwind;User Id=sa;Password=;";
		private string _mysqlConnectionString = "Data Source=localhost;Database=codus_test;User ID=;Password=;";

		[Test]
		public void BuildSqlServerOleDbSchema()
		{
			DatabaseSchema ds = SchemaBuilder.CreateDatabaseSchema(this._oledbConnectionString, Adapdev.Data.DbType.SQLSERVER, Adapdev.Data.DbProviderType.OLEDB);
			Assert.AreEqual(29, ds.Tables.Count, "Northwind should have 29 tables / views.");
			Assert.IsTrue(ds.Tables.Contains("Orders"));
			Assert.AreEqual(Adapdev.Data.DbProviderType.OLEDB, ds.DatabaseProviderType, "ProviderTypes don't match.");
			Assert.AreEqual(Adapdev.Data.DbType.SQLSERVER, ds.DatabaseType, "DataTypes don't match.");
			Assert.AreEqual("dbo", ds.GetTable("Orders").SchemaName);
			//Console.WriteLine(ds.GetTable("Orders"));

			foreach(ColumnSchema column in ds.GetTable("Orders").Columns.Values)
			{
				Console.WriteLine("{0} : {1}", column.Name, column.DataType);				
			}

		}

		[Test]
		public void BuildSqlServerSqlSchema()
		{
			DatabaseSchema ds = SchemaBuilder.CreateDatabaseSchema(this._oledbConnectionString, Adapdev.Data.DbType.SQLSERVER, Adapdev.Data.DbProviderType.SQLSERVER);
			Assert.AreEqual(29, ds.Tables.Count, "Northwind should have 29 tables / views.");
			Assert.IsTrue(ds.Tables.Contains("Orders"));
			Assert.AreEqual(Adapdev.Data.DbProviderType.SQLSERVER, ds.DatabaseProviderType, "ProviderTypes don't match.");
			Assert.AreEqual(Adapdev.Data.DbType.SQLSERVER, ds.DatabaseType, "DataTypes don't match.");

			foreach(ColumnSchema column in ds.GetTable("Orders").Columns.Values)
			{
				Console.WriteLine("{0} : {1}", column.Name, column.DataType);				
			}
		}

		[Test]
		public void PrintSqlServerSqlSchema()
		{
			int i = 0;
			Console.WriteLine(new OleDbSchemaBuilder(null, ref i).PrintOleDbSchema(this._oledbConnectionString, OleDbSchemaGuid.Tables, ""));
		}

		[Test]
		public void BuildMySqlSchema()
		{
			DatabaseSchema ds = SchemaBuilder.CreateDatabaseSchema(this._mysqlConnectionString, Adapdev.Data.DbType.MYSQL, Adapdev.Data.DbProviderType.MYSQL);
			Assert.AreEqual(4, ds.Tables.Count, "codus_test should have 4 tables");
			Assert.IsTrue(ds.Tables.Contains("alldatatypes"));
			Assert.AreEqual(Adapdev.Data.DbProviderType.MYSQL, ds.DatabaseProviderType, "ProviderTypes don't match.");
			Assert.AreEqual(Adapdev.Data.DbType.MYSQL, ds.DatabaseType, "DataTypes don't match.");
		}

		[Test,Ignore("")]
		public void PrintMySqlSchema()
		{
			int i = 0;
			Console.WriteLine(new MySqlSchemaBuilder(null, ref i).PrintReaderSchema(this._mysqlConnectionString, "alldatatypes"));
		}


		[Test]
		public void ProviderConfig() {
			ProviderConfig pc = new ProviderConfig();
			Assert.AreEqual(5 ,pc.ConnectionTypes.Count, "Should have 5 Connection Types in the ProviderConfig collection");
			Assert.IsTrue(pc.ConnectionTypes.Contains("Microsoft Access"),"Could not find Microsoft Access");
			Assert.IsTrue(pc.ConnectionTypes.Contains("SQL Server"),"Could not find SQL Server");
			Assert.IsTrue(pc.ConnectionTypes.Contains("SQL Server - Trusted"), "Could not find SQL Server - Trusted");
			Assert.IsTrue(pc.ConnectionTypes.Contains("Oracle"), "Could not find Oracle");
			Assert.IsTrue(pc.ConnectionTypes.Contains("Oracle - Trusted"), "Could not find Oracle -Trusted");
		}

		[Test]
		public void ConnectionTypes() {
			DbConnectionTypes ct = new DbConnectionTypes();
			Assert.AreEqual(0, ct.Count, "Should be zero items");
			ct.Add("test", new DbConnectionType());
			Assert.AreEqual(1, ct.Count, "Should be one item");
			Assert.IsTrue(ct.Contains("test"),"Should contain test");
			ct.Remove("test");
			Assert.AreEqual(0, ct.Count, "Should be zero items after deleting the item");

			ct.Add(new DbConnectionType("zarniwoop",DbType.SQLSERVER, "OLEDB",true, true, true, true, false));
			ct.Add(new DbConnectionType("beeblebrox",DbType.SQLSERVER, "OLEDB",true, true, true, true, false));
			ct.Add(new DbConnectionType("magrathea",DbType.SQLSERVER, "OLEDB",true, true, true, true, false));
			ct.Add(new DbConnectionType("marvin",DbType.SQLSERVER, "OLEDB",true, true, true, true, false));
			ct.Add(new DbConnectionType("vogon",DbType.SQLSERVER, "OLEDB",true, true, true, true, false));

			Assert.AreEqual("beeblebrox", ct.GetByIndex(0).Name);
			Assert.AreEqual("magrathea", ct.GetByIndex(1).Name);
			Assert.AreEqual("marvin", ct.GetByIndex(2).Name);
			Assert.AreEqual("vogon", ct.GetByIndex(3).Name);
			Assert.AreEqual("zarniwoop", ct.GetByIndex(4).Name);

			ct.Clear();
			Assert.AreEqual(0, ct.Count, "Should be zero items after clearing the collection");
		}
		
		[Test]
		public void ConnectionType() {
			DbConnectionType ct = new DbConnectionType();
			Assert.IsNotNull(ct);

			ct = new DbConnectionType("TestType",DbType.SQLSERVER, "OLEDB", true, true, true, true, false);
			Assert.IsFalse(ct.SupportsFile);
			Assert.IsTrue(ct.SupportsServer);
			ct.SupportsServer = false;
			Assert.IsTrue(ct.SupportsFile);
			Assert.IsFalse(ct.SupportsServer);

			ct.DbType = DbType.ACCESS;
			Assert.AreEqual("ACCESS", ct.DbTypeName);
		}

		[Test]
		[ExpectedException(typeof(ApplicationException))]
		public void ConnectionTypeInternalFails() {
			DbConnectionType ct = new DbConnectionType("TestType",DbType.SQLSERVER, "OLEDB", true, true, true, true, false);
			Assert.AreEqual("OLEDB", ct.InternalProviderName);
			Assert.IsNull(ct.InternalProvider);
		}

		[Test]
		public void ConnectionProviders() {
			DbConnectionProviders cp = new DbConnectionProviders();
			Assert.AreEqual(0, cp.Count, "Should be zero items");
			cp.Add("test", new DbConnectionProvider());
			Assert.AreEqual(1, cp.Count, "Should be one item");
			Assert.IsTrue(cp.Contains("test"),"Should contain test");
			cp.Remove("test");
			Assert.AreEqual(0, cp.Count, "Should be zero items after deleting the item");

			DbConnectionType ct = new DbConnectionType("TestType",DbType.SQLSERVER,"OLEDB", true, true, true, true, false);
			ct.Providers = cp;

			cp.Add(new DbConnectionProvider("zarniwoop","SQLSERVER", "provider=mssqlserver", ct));
			cp.Add(new DbConnectionProvider("beeblebrox","SQLSERVER", "provider=mssqlserver", ct));
			cp.Add(new DbConnectionProvider("magrathea","SQLSERVER", "provider=mssqlserver", ct));
			cp.Add(new DbConnectionProvider("marvin","SQLSERVER", "provider=mssqlserver", ct));
			cp.Add(new DbConnectionProvider("vogon","SQLSERVER", "provider=mssqlserver", ct));

			Assert.AreEqual("beeblebrox", cp.GetByIndex(0).Name, "Items out of order");
			Assert.AreEqual("magrathea", cp.GetByIndex(1).Name, "Items out of order");
			Assert.AreEqual("marvin", cp.GetByIndex(2).Name, "Items out of order");
			Assert.AreEqual("vogon", cp.GetByIndex(3).Name, "Items out of order");
			Assert.AreEqual("zarniwoop", cp.GetByIndex(4).Name, "Items out of order");

			cp.Clear();
			Assert.AreEqual(0, cp.Count, "Should be zero items after clearing the collection");
		}

		[Test]
		public void ConnectionProvider() {

			DbConnectionType ct = new DbConnectionType("TestType",DbType.SQLSERVER,"OLEDB", true, true, true, true, false);
			DbConnectionProvider cp = new DbConnectionProvider();
			Assert.IsNotNull(cp);

			cp = new DbConnectionProvider("TestProvider1", "SQLSERVER", "provider=mssqlserver", ct);
			ct.Providers.Add(cp);
			cp = new DbConnectionProvider("TestProvider2", "OLEDB", "provider=mssqlserver", ct);
			ct.Providers.Add(cp);

			Assert.AreEqual(2, ct.Providers.Count, "Should be two providers.");

			cp.DbType = DbType.ACCESS;
			Assert.AreEqual("ACCESS", cp.DbTypeName);
			cp.ProviderType = DbProviderType.OLEDB;
			Assert.AreEqual("OLEDB", cp.ProviderTypeName);

			ct.InternalProviderName = "TestProvider2";
			Assert.AreEqual("TestProvider2", ct.InternalProvider.Name, "Internal Provider should be 'TestProvider2'");

			Assert.IsNotNull(cp.Parent,"Parent should not be Null. Should be 'TestType'");
			Assert.IsNotNull(cp.Parent.InternalProvider,"Internal provider should be defined");
			Assert.AreEqual(cp.Parent.InternalProvider.ConnectionString("TestServer"), cp.ConnectionString("TestServer"));
			
			cp = new DbConnectionProvider("TestProvider","OLEDB", "{0},{1},{2},{3}", ct);
			Assert.AreEqual("A,B,C,D", cp.ConnectionString("A","B","C","D"));
		}


	}
}