[Dotnetmock-developer] dotnetmock/DotNetMock.Framework.Tests/Data MockCommandTests.cs,NONE,1.1 MockDataParameterCollectionTests.cs,NONE,1.1 MockDataParameterTests.cs,NONE,1.1 MockDataReaderTests.cs,NONE,1.1 MockDbConnectionTests.cs,NONE,1.1

[<gc...@us...>]

Update of /cvsroot/dotnetmock/dotnetmock/DotNetMock.Framework.Tests/Data
In directory sc8-pr-cvs1:/tmp/cvs-serv9039/Data

Added Files:
	MockCommandTests.cs MockDataParameterCollectionTests.cs 
	MockDataParameterTests.cs MockDataReaderTests.cs 
	MockDbConnectionTests.cs 
Log Message:



--- NEW FILE: MockCommandTests.cs ---
using System;
using System.Data;
using NUnit.Framework;
using DotNetMock.Data;

namespace DotNetMock.Tests.Data
{
	/// <summary>
	/// Summary description for MockCommandTests.
	/// </summary>
	[TestFixture]
	public class MockCommandTests
	{
		private MockCommand _mockCmd = null;
		[TearDown]
		public void Destroy()
		{
			_mockCmd = null;
		}
		[Test]
		public void CommandTextProperty()
		{
			_mockCmd = new MockCommand();
			_mockCmd.SetExpectedCommandText(@"user id=sa;password=password;Connect Timeout=30");
			_mockCmd.CommandText = @"user id=sa;password=password;Connect Timeout=30";
			_mockCmd.Verify();
		}
		[Test]
		[ExpectedException(typeof(AssertionException))]
		public void InValidCommandTextProperty()
		{
			_mockCmd = new MockCommand();
			_mockCmd.SetExpectedCommandText(@"user id=sa;password=password;Connect Timeout=30");
			_mockCmd.Verify();
		}
		[Test]
		public void CommandTimeoutProperty()
		{
			_mockCmd = new MockCommand();
			_mockCmd.SetExpectedCommandTimeout(0);
			_mockCmd.CommandTimeout = 0;
			_mockCmd.Verify();
		}
		[Test]
		[ExpectedException(typeof(NotImplementedException))]
		public void InValidCommandTimeoutProperty()
		{
			_mockCmd = new MockCommand();
			_mockCmd.SetExpectedCommandTimeout(30);
			_mockCmd.CommandTimeout = 30;
			_mockCmd.Verify();
		}
		[Test]
		public void CommandTypeProperty()
		{
			_mockCmd = new MockCommand();
			_mockCmd.SetExpectedCommandType(System.Data.CommandType.Text);
			_mockCmd.CommandType = System.Data.CommandType.Text;
			_mockCmd.Verify();
		}
		[Test]
		[ExpectedException(typeof(NotImplementedException))]
		public void InValidCommandTypeProperty()
		{
			_mockCmd = new MockCommand();
			_mockCmd.SetExpectedCommandType(System.Data.CommandType.StoredProcedure);
			_mockCmd.CommandType = System.Data.CommandType.StoredProcedure;
			_mockCmd.Verify();
		}
		[Test]
		public void ConnectionProperty()
		{
			_mockCmd = new MockCommand();
			MockDbConnection mockConnection = new MockDbConnection();
			MockTransaction mockTransaction = new MockTransaction();

			_mockCmd.Transaction = mockTransaction;
			NUnit.Framework.Assertion.AssertNotNull(_mockCmd.Transaction);
			_mockCmd.Connection = mockConnection;
			NUnit.Framework.Assertion.AssertNotNull(_mockCmd.Connection);
			NUnit.Framework.Assertion.AssertEquals(typeof(MockDbConnection), _mockCmd.Connection.GetType());
			_mockCmd.Dispose();
		}
		[Test]
		public void ParametersProperty()
		{
			_mockCmd = new MockCommand();
			MockDataParameter mockParameter = new MockDataParameter("@inpID", "123456");
			_mockCmd.SetExpectedParameter(mockParameter);
			_mockCmd.Parameters.Add(mockParameter);
			_mockCmd.Verify();
			NUnit.Framework.Assertion.AssertEquals(typeof(MockDataParameterCollection), _mockCmd.Parameters.GetType());
		}
		[Test]
		[ExpectedException(typeof(AssertionException))]
		public void InValidParametersProperty()
		{		
			_mockCmd = new MockCommand();
			_mockCmd.SetExpectedParameter(new MockDataParameter("@inpID", "123456"));
			_mockCmd.Verify();
		}	
		[Test]
		public void ExecuteCalls()
		{
			_mockCmd = new MockCommand();
			_mockCmd.SetExpectedExecuteCalls(5);
			_mockCmd.ExecuteNonQuery();
			_mockCmd.ExecuteReader();
			_mockCmd.ExecuteScalar();
			_mockCmd.ExecuteScalar();
			_mockCmd.ExecuteNonQuery();
			_mockCmd.Verify();
		}
		[Test]
		[ExpectedException(typeof(AssertionException))]
		public void InValidExecuteCalls()
		{
			_mockCmd = new MockCommand();
			_mockCmd.SetExpectedExecuteCalls(2);
			_mockCmd.ExecuteNonQuery();
			_mockCmd.Verify();
		}
	}
}

--- NEW FILE: MockDataParameterCollectionTests.cs ---
using System;
using NUnit.Framework;
using DotNetMock;
using DotNetMock.Data;
using System.Data;

namespace DotNetMock.Tests.Data
{
	[TestFixture]
	public class MockDataParameterCollectionTests
	{
		private MockDataParameterCollection _mockDataParameterCollection = null;

		[SetUp]
		public void Init()
		{
			_mockDataParameterCollection = new MockDataParameterCollection();
		}

		[TearDown]
		public void Destroy()
		{
			_mockDataParameterCollection = null;
		}

		[Test]
		public void AddOneParameter()
		{
			MockDataParameter mockDP1 = new MockDataParameter("@inpID", "123456");
			
			_mockDataParameterCollection.AddExpected(mockDP1);
			_mockDataParameterCollection.Add(mockDP1);
			_mockDataParameterCollection.Verify();
		}
		[Test]
		public void AddMultipleParameters()
		{
			MockDataParameter mockDP1 = new MockDataParameter("@inpID", "123456");
			MockDataParameter mockDP2 = new MockDataParameter("@password", "mock");
			_mockDataParameterCollection.AddExpected(mockDP1);
			_mockDataParameterCollection.AddExpected(mockDP2);
			_mockDataParameterCollection.Add(new MockDataParameter("@inpID", "123456"));
			_mockDataParameterCollection.Add(new MockDataParameter("@password", "mock"));
			_mockDataParameterCollection.Verify();
		}
		[Test]
		public void AddNewParameterStringValue()
		{
			_mockDataParameterCollection.Add("@inpID", "123456");
			MockDataParameter mockDP = new MockDataParameter("@inpID", "123456");
			_mockDataParameterCollection.AddExpected(mockDP);
			_mockDataParameterCollection.Verify();
		}
		[Test]
		public void AddNewParameterNameType()
		{
			_mockDataParameterCollection.Add("@inpID", DbType.String);
			MockDataParameter mockDP = new MockDataParameter("@inpID", DbType.String);
			_mockDataParameterCollection.AddExpected(mockDP);
			_mockDataParameterCollection.Verify();
		}
		[Test]
		public void ValidContains()
		{
			_mockDataParameterCollection.Add("@inpID", "123456");
			NUnit.Framework.Assertion.Assert(_mockDataParameterCollection.Contains("@inpID"));
			_mockDataParameterCollection.Add("@inpPassword", "password");
			NUnit.Framework.Assertion.Assert(_mockDataParameterCollection.Contains("@inpID"));
			NUnit.Framework.Assertion.Assert(_mockDataParameterCollection.Contains("@inpPassword"));

		}
		[Test]
		public void InValidContains()
		{
			IDataParameter mockDP = _mockDataParameterCollection.Add("@inpID", "123456");
			NUnit.Framework.Assertion.Assert(!_mockDataParameterCollection.Contains("@inpPassword"));
		}
		[Test]
		public void ValidRemoveAt()
		{
			_mockDataParameterCollection.Add("@inpID", "123456");
			_mockDataParameterCollection.Add("@inpPassword", "password");
			NUnit.Framework.Assertion.Assert(_mockDataParameterCollection.Contains("@inpID"));
			NUnit.Framework.Assertion.Assert(_mockDataParameterCollection.Contains("@inpPassword"));
			_mockDataParameterCollection.RemoveAt("@inpID");
			NUnit.Framework.Assertion.Assert(!_mockDataParameterCollection.Contains("@inpID"));
			NUnit.Framework.Assertion.Assert(_mockDataParameterCollection.Contains("@inpPassword"));
		}
		[Test]
		[ExpectedException(typeof(ApplicationException))]
		public void InValidRemoveAt()
		{
			IDataParameter mockDP = _mockDataParameterCollection.Add("@inpID", "123456");
			_mockDataParameterCollection.RemoveAt("@inpPassword");
		}
		[Test]
		public void IndexOf()
		{
			_mockDataParameterCollection.Add("@inpID", "123456");
			_mockDataParameterCollection.Add("@inpPassword", "password");
			_mockDataParameterCollection.Add("@inpThird", "third");
			NUnit.Framework.Assertion.AssertEquals("Indexes do not equal", 1, _mockDataParameterCollection.IndexOf("@inpPassword"));
			NUnit.Framework.Assertion.AssertEquals("Indexes do not equal", 0, _mockDataParameterCollection.IndexOf("@inpID"));
		}
		[Test]
		[ExpectedException(typeof(ApplicationException))]
		public void InValidIndexOf()
		{
			IDataParameter mockDP = _mockDataParameterCollection.Add("@inpID", "123456");
			IDataParameter mockDP1 = _mockDataParameterCollection.Add("@inpPassword", "password");
			IDataParameter mockDP2 = _mockDataParameterCollection.Add("@inpThird", "third");
			NUnit.Framework.Assertion.AssertEquals("Index not found", 4, _mockDataParameterCollection.IndexOf("@inpFake"));
		}
		[Test]
		public void ValidIndexer()
		{
			MockDataParameter mockDP = new MockDataParameter("@inpID", "123456");
			_mockDataParameterCollection.Add(mockDP);
			NUnit.Framework.Assertion.AssertEquals("Parameters not equal", "@inpID", _mockDataParameterCollection["@inpID"]);
		}
		[Test]
		[ExpectedException(typeof(ApplicationException))]
		public void InValidIndexer()
		{
			MockDataParameter mockDP = new MockDataParameter("@inpID", "654321");
			_mockDataParameterCollection.Add(mockDP);
			NUnit.Framework.Assertion.AssertEquals("Parameters not equal", mockDP, _mockDataParameterCollection["@inpPadssword"]);
		}
		[Test]
		[ExpectedException(typeof(NotImplementedException))]
		public void InValidInsert()
		{
			_mockDataParameterCollection.Insert(3, "fake");
		}
		[Test]
		[ExpectedException(typeof(NotImplementedException))]
		public void InValidIListIndexOf()
		{
			object badValue = new object();
			int index = _mockDataParameterCollection.IndexOf(badValue);
		}
		[Test]
		[ExpectedException(typeof(NotImplementedException))]
		public void InValidRemove()
		{
			object badValue = new object();
			_mockDataParameterCollection.Remove(badValue);
		}
		[Test]
		[ExpectedException(typeof(NotImplementedException))]
		public void InValidIListContains()
		{
			object badValue = new object();
			_mockDataParameterCollection.Contains(badValue);
		}
	}
}

--- NEW FILE: MockDataParameterTests.cs ---
using System;
using System.Data;
using NUnit.Framework;
using DotNetMock.Data;

namespace DotNetMock.Tests.Data
{
	/// <summary>
	/// Summary description for MockDataParameterTests.
	/// </summary>
	[TestFixture]
	public class MockDataParameterTests
	{
		private MockDataParameter _mockDataParameter = null;

		[SetUp]
		public void Init()
		{
			
		}

		[TearDown]
		public void Destroy()
		{
			_mockDataParameter = null;
		}
		
		[Test]
		[ExpectedException(typeof(AssertionException))]
		public void IsNullable()
		{
			_mockDataParameter = new MockDataParameter();

			_mockDataParameter.SetExpectedNullable(true);
			_mockDataParameter.IsNullable = true;
			_mockDataParameter.Verify();

			_mockDataParameter.SetExpectedNullable(false);

			_mockDataParameter.Verify();	
		}

		[Test]
		[ExpectedException(typeof(AssertionException))]
		public void ConstructorNameValue()
		{
			_mockDataParameter = new MockDataParameter("@inpID", "123456");

			_mockDataParameter.SetExpectedName("@inpID");
			_mockDataParameter.SetExpectedValue("123456");

			_mockDataParameter.Verify();

			_mockDataParameter.SetExpectedName("@inpPassword");
			_mockDataParameter.SetExpectedValue("654321");
			
			
			_mockDataParameter.Verify();
		}
		[Test]
		public void ConstructorNameTypeSourceColumn()
		{
			_mockDataParameter = new MockDataParameter("@inpID", DbType.String, "ID");
			_mockDataParameter.SetExpectedName("@inpID");
			_mockDataParameter.SetExpectedType(DbType.String);
			_mockDataParameter.SetExpectedSourceColumn("ID");
			
			_mockDataParameter.Verify();
			_mockDataParameter.SetExpectedType(DbType.Int32);

			try 
			{
				_mockDataParameter.Verify();
				NUnit.Framework.Assertion.Fail("Should have thrown an exception.");
			}
			catch (NUnit.Framework.AssertionException ex) 
			{
			}
			_mockDataParameter.SetExpectedSourceColumn("Fake");
			_mockDataParameter.SetExpectedType(DbType.String);
			try 
			{
				_mockDataParameter.Verify();
				NUnit.Framework.Assertion.Fail("Should have thrown an exception.");
			}
			catch (NUnit.Framework.AssertionException ex)
			{

			}
		}
		[Test]
		[ExpectedException(typeof(AssertionException))]
		public void ConstructorNameType()
		{
			_mockDataParameter = new MockDataParameter("@inpID", DbType.String);
			_mockDataParameter.SetExpectedName("@inpID");
			_mockDataParameter.SetExpectedType(DbType.String);
			_mockDataParameter.Verify();

			_mockDataParameter.SetExpectedType(DbType.Int32);

			_mockDataParameter.Verify();			
		}
		[Test]
		[ExpectedException(typeof(AssertionException))]
		public void SetValue()
		{
			_mockDataParameter = new MockDataParameter();
			_mockDataParameter.SetExpectedValue("ID");
			_mockDataParameter.SetExpectedType(DbType.String);
			
			_mockDataParameter.Value = "ID";

			_mockDataParameter.Verify();

			_mockDataParameter.SetExpectedType(DbType.Int32);

			_mockDataParameter.Verify();	
		}
	}
}

--- NEW FILE: MockDataReaderTests.cs ---
using System;
using System.Data;
using DotNetMock.Data;
using NUnit.Framework;

namespace DotNetMock.Tests.Data
{
	[TestFixture]
	public class MockDataReaderTests
	{
		private MockDataReader _reader = null;

		[SetUp]
		public void Init()
		{
			_reader = new MockDataReader();
		}

		[TearDown]
		public void Destroy() 
		{
			_reader = null;
		}
		[Test]
		public void RecordsAffectedSuccess()
		{
			_reader.SetRecordsAffectedCount(1);
			Assertion.AssertEquals("Records affected not equal.", 1, _reader.RecordsAffected);
		}
		[Test]
		[ExpectedException(typeof(AssertionException))]
		public void RecordsAffectedFails()
		{
			_reader.SetRecordsAffectedCount(2);
			Assertion.AssertEquals(3, _reader.RecordsAffected);
		}
		[Test]
		public void CloseCountCallsSuccess()
		{
			_reader.SetExpectedCloseCalls(3);
			_reader.Close();
			_reader.Close();
			_reader.Close();
			_reader.Verify();
		}
		[Test]
		[ExpectedException(typeof(AssertionException))]
		public void CloseCountCallsFails()
		{
			_reader.SetExpectedCloseCalls(1);
			_reader.Close();
			_reader.Close();
			_reader.Verify();
		}
		[Test]
		public void GetSchemsTableSuccess()
		{
			DataTable dataTable = new DataTable();
			dataTable.Columns.Add(new DataColumn("ID", typeof(int)));
			dataTable.Columns.Add(new DataColumn("Password", typeof(string)));
			dataTable.Columns.Add(new DataColumn("Email", typeof(string)));
			_reader.SetSchemaTable(dataTable);
			DataTable dataTable2 = new DataTable();
			dataTable2.Columns.Add(new DataColumn("ID", typeof(int)));
			dataTable2.Columns.Add(new DataColumn("Password", typeof(string)));
			dataTable2.Columns.Add(new DataColumn("Email", typeof(string)));
			Assertion.Equals(dataTable2, _reader.GetSchemaTable());
		}
		[Test]
		public void GetSchemaTableFails()
		{
			Assertion.AssertNull("Schema Table isn't empty.", _reader.GetSchemaTable());
		}
		[Test]
		public void IsClosedSuccess()
		{
			_reader.SetIsClosedValue(true);
			Assertion.Assert(_reader.IsClosed);
		}
		[Test]
		public void IsCloseDefaultValue()
		{
			 Assertion.Assert(!_reader.IsClosed);
		}
		[Test]
		public void ReadCountCallsSuccess()
		{
			_reader.SetExpectedReadCalls(3);
			_reader.Read();
			_reader.Read();
			_reader.Read();
			_reader.Verify();
		}
		[Test]
		[ExpectedException(typeof(AssertionException))]
		public void ReadCountCallsFails()
		{
			_reader.SetExpectedReadCalls(2);
			_reader.Read();
			_reader.Read();
			_reader.Read();
			_reader.Verify();
		}
		[Test]
		public void ReadSuccess() 
		{
			_reader.SetExpectedReadCalls(3);

			_reader.SetRows(createObjectValues());

			while (_reader.Read()) 
			{

			}
			_reader.Verify();
		}

		[Test]
		[ExpectedException(typeof(AssertionException))]
		public void ReadFailure() 
		{
			_reader.SetExpectedReadCalls(2);

			_reader.SetRows(createObjectValues());

			while (_reader.Read()) 
			{

			}
			_reader.Verify();
		}
		[Test]
		public void GetValueSuccess() 
		{
			_reader.SetExpectedReadCalls(3);
			_reader.SetRows(createObjectValues());

			int rowCount = 0;
			while (_reader.Read()) 
			{
				for (int i = 0; i <= 1; i++) 
				{
					Assertion.AssertEquals("Items not equal.", "Row " + rowCount + ", Column " + i, _reader.GetValue(i + 1));
				}
				rowCount++;
			}
			_reader.Verify();
		}
		[Test]
		public void IndexerIntSuccess() 
		{
			_reader.SetExpectedReadCalls(3);
			_reader.SetRows(createObjectValues());

			int rowCount = 0;
			while (_reader.Read()) 
			{
				for (int i = 0; i <= 1; i++) 
				{
					Assertion.AssertEquals("Items not equal.", "Row " + rowCount + ", Column " + i, _reader[i + 1]);
				}
				rowCount++;
			}
			_reader.Verify();
		}
		[Test]
		[ExpectedException(typeof(IndexOutOfRangeException))]
		public void IndexerIntFails() 
		{
			_reader.SetExpectedReadCalls(3);
			_reader.SetRows(createObjectValues());

			int rowCount = 0;
			while (_reader.Read()) 
			{
				for (int i = 0; i <= 1; i++) 
				{
					Assertion.AssertEquals("Items not equal.", "Row " + rowCount + ", Column " + i, _reader[i + 3]);
				}
				rowCount++;
			}
			_reader.Verify();
		}
		[Test]
		public void GetIntSuccess()
		{
			object[,] values = new object[2,2];
			values[0,0] = 0;
			values[0,1] = 1;
			values[1,0] = 0;
			values[1,1] = 1;
			_reader.SetRows(values);
			_reader.SetExpectedReadCalls(3);

			while (_reader.Read())
			{
				Assertion.AssertEquals(0, _reader.GetInt32(1));
				Assertion.AssertEquals(1, _reader.GetInt32(2));
			}
			_reader.Verify();
		}
		[Test]
			[ExpectedException(typeof(IndexOutOfRangeException))]
		public void GetIntFails() 
		{
			object[,] values = new object[2,2];
			values[0,0] = 0;
			values[0,1] = 1;
			values[1,0] = 0;
			values[1,1] = 1;
			_reader.SetRows(values);
			_reader.SetExpectedReadCalls(3);

			while (_reader.Read())
			{
				Assertion.AssertEquals(0, _reader.GetInt32(0));
				Assertion.AssertEquals(1, _reader.GetInt32(1));
			}
			_reader.Verify();
		}
		[Test]
		public void IndexerStringSuccess() 
		{
			_reader.SetExpectedReadCalls(2);
			DataTable dataTable = new DataTable();
			dataTable.Columns.Add(new DataColumn("ID", typeof(int)));
			dataTable.Columns.Add(new DataColumn("Password", typeof(string)));
			_reader.SetSchemaTable(dataTable);
			
			object[,] values = new object[1,2];
			values[0,0] = 123456;
			values[0,1] = "password";
			_reader.SetRows(values);

			while (_reader.Read()) 
			{
				Assertion.AssertEquals(123456, _reader["ID"]);
				Assertion.AssertEquals("password", _reader["Password"]);
			}
			_reader.Verify();
		}
		[Test]
		[ExpectedException(typeof(IndexOutOfRangeException))]
		public void IndexerStringFails()
		{
			DataTable dataTable = new DataTable();
			dataTable.Columns.Add(new DataColumn("ID", typeof(int)));
			dataTable.Columns.Add(new DataColumn("Password", typeof(string)));
			_reader.SetSchemaTable(dataTable);
			
			object[,] values = new object[2,2];
			values[0,0] = 123456;
			values[0,1] = "password";
			_reader.SetRows(values);

			while (_reader.Read()) 
			{
				Assertion.AssertEquals(123456, _reader["Fakes"]);
			}
			_reader.Verify();
		}
		private object[,] createObjectValues() 
		{
			object[,] values = new object[2,2];
			values[0,0] = "Row 0, Column 0";
			values[0,1] = "Row 0, Column 1";
			values[1,0] = "Row 1, Column 0";
			values[1,1] = "Row 1, Column 1";
			return values;
		}

	}
}

--- NEW FILE: MockDbConnectionTests.cs ---
using System;
using DotNetMock.Data;
using NUnit.Framework;

namespace DotNetMock.Tests.Data
{
	[TestFixture]
	public class MockDbConnectionTests
	{
		private MockDbConnection _mockConnection = null;

		[SetUp]
		public void Init()
		{
			_mockConnection = new MockDbConnection();
		}

		[TearDown]
		public void Destroy()
		{
			_mockConnection.Dispose();
			_mockConnection = null;
		}

		[Test]
		public void CloseCalls()
		{
			_mockConnection.SetExpectedCloseCalls(3);
			_mockConnection.Close();
			_mockConnection.Close();
			_mockConnection.Close();
			_mockConnection.Verify();
		}

		[Test]
		[ExpectedException(typeof(AssertionException))]
		public void InvalidCloseCalls()
		{
			_mockConnection.SetExpectedCloseCalls(1);
			_mockConnection.Close();
			_mockConnection.Close();
			_mockConnection.Verify();
		}
		[Test]
		public void ConnectionString()
		{
			_mockConnection.SetExpectedConnectionString("DSN=localhost");
			_mockConnection.ConnectionString = "DSN=localhost";
			_mockConnection.Verify();
		}
		[Test]
		[ExpectedException(typeof(AssertionException))]
		public void InvalidConnectionString()
		{
			_mockConnection.SetExpectedConnectionString("DSN=localhost");
			_mockConnection.ConnectionString = "DSN=";
			_mockConnection.Verify();
		}
	}
}