git-svn-id: http://svn.xp-dev.com/svn/mokhan-sait@2 da190166-9cfc-4ee1-ae03-434a172be219

9 files changed, 726 insertions, 0 deletions

diff --git a/slips/src/test/Marina.Test/Unit/DataAccess/DatabaseCommandTest.cs b/slips/src/test/Marina.Test/Unit/DataAccess/DatabaseCommandTest.cs
new file mode 100644
index 0000000..c08b272
--- /dev/null
+++ b/slips/src/test/Marina.Test/Unit/DataAccess/DatabaseCommandTest.cs
@@ -0,0 +1,48 @@
+using System.Data;

+using Marina.DataAccess;

+using MbUnit.Framework;

+using Rhino.Mocks;

+

+namespace Marina.Test.Unit.DataAccess {

+	[TestFixture]

+	public class DatabaseCommandTest {

+		private MockRepository _mockery;

+		private IDbCommand _mockCommand;

+

+		[SetUp]

+		public void Setup() {

+			_mockery = new MockRepository( );

+			_mockCommand = _mockery.DynamicMock< IDbCommand >( );

+		}

+

+		public IDatabaseCommand CreateSUT() {

+			return new DatabaseCommand( _mockCommand );

+		}

+

+		[Test]

+		public void Should_execute_the_command() {

+			IDataReader mockReader = _mockery.DynamicMock< IDataReader >( );

+

+			using ( _mockery.Record( ) ) {

+				Expect.Call( _mockCommand.ExecuteReader( ) ).Return( mockReader );

+			}

+

+			using ( _mockery.Playback( ) ) {

+				CreateSUT( ).ExecuteQuery( );

+			}

+		}

+

+		[Test]

+		public void Should_return_a_loaded_data_table() {

+			IDataReader mockReader = _mockery.DynamicMock< IDataReader >( );

+

+			using ( _mockery.Record( ) ) {

+				SetupResult.For( _mockCommand.ExecuteReader( ) ).Return( mockReader );

+			}

+

+			using ( _mockery.Playback( ) ) {

+				Assert.IsNotNull( CreateSUT( ).ExecuteQuery( ) );

+			}

+		}

+	}

+}
\ No newline at end of file
diff --git a/slips/src/test/Marina.Test/Unit/DataAccess/DatabaseConfigurationTest.cs b/slips/src/test/Marina.Test/Unit/DataAccess/DatabaseConfigurationTest.cs
new file mode 100644
index 0000000..3dc2d1f
--- /dev/null
+++ b/slips/src/test/Marina.Test/Unit/DataAccess/DatabaseConfigurationTest.cs
@@ -0,0 +1,33 @@
+using System.Configuration;

+using Marina.DataAccess;

+using MbUnit.Framework;

+

+namespace Marina.Test.Unit.DataAccess {

+	[TestFixture]

+	public class DatabaseConfigurationTest {

+		private ConnectionStringSettings _settings;

+

+		[SetUp]

+		public void Setup() {

+			_settings = new ConnectionStringSettings( "ConnectionName", string.Empty, string.Empty );

+		}

+

+		public IDatabaseConfiguration CreateSUT() {

+			return new DatabaseConfiguration( _settings );

+		}

+

+		[Test]

+		public void Should_return_connection_string() {

+			string connectionString = "MyConnectionString";

+			_settings.ConnectionString = connectionString;

+			Assert.AreEqual( connectionString, CreateSUT( ).ConnectionString( ) );

+		}

+

+		[Test]

+		public void Should_return_the_provider_name() {

+			string providerName = "MyProvider";

+			_settings.ProviderName = providerName;

+			Assert.AreEqual( providerName, CreateSUT( ).ProviderName( ) );

+		}

+	}

+}
\ No newline at end of file
diff --git a/slips/src/test/Marina.Test/Unit/DataAccess/DatabaseConnectionTest.cs b/slips/src/test/Marina.Test/Unit/DataAccess/DatabaseConnectionTest.cs
new file mode 100644
index 0000000..8cd8ec1
--- /dev/null
+++ b/slips/src/test/Marina.Test/Unit/DataAccess/DatabaseConnectionTest.cs
@@ -0,0 +1,167 @@
+using System.Data;

+using Marina.DataAccess;

+using MbUnit.Framework;

+using Rhino.Mocks;

+

+namespace Marina.Test.Unit.DataAccess {

+	[TestFixture]

+	public class DatabaseConnectionTest {

+		private MockRepository _mockery;

+		private IDatabaseConfiguration _mockConfiguration;

+		private IDatabaseProviderFactory _mockProviderFactory;

+

+		[SetUp]

+		public void Setup() {

+			_mockery = new MockRepository( );

+			_mockConfiguration = _mockery.DynamicMock< IDatabaseConfiguration >( );

+			_mockProviderFactory = _mockery.DynamicMock< IDatabaseProviderFactory >( );

+		}

+

+		public IDatabaseConnection CreateSUT() {

+			return new DatabaseConnection( _mockConfiguration, _mockProviderFactory );

+		}

+

+		[Test]

+		public void Should_create_connection_for_provider_name() {

+			string providerName = "System.Data.SqlClient";

+

+			IDbConnection mockConnection = _mockery.DynamicMock< IDbConnection >( );

+			using ( _mockery.Record( ) ) {

+				SetupResult.For( _mockConfiguration.ProviderName( ) ).Return( providerName );

+

+				Expect.Call( _mockProviderFactory.CreateConnectionFor( providerName ) ).Return( mockConnection );

+			}

+

+			using ( _mockery.Playback( ) ) {

+				CreateSUT( ).CreateCommandFor( "" );

+			}

+		}

+

+		[RowTest]

+		[Row( "MyConnectionString" )]

+		[Row( "MyStringOfConnection" )]

+		[Row( "MyConnectionString3" )]

+		public void Should_set_the_connections_connection_string_to( string connectionString ) {

+			string providerName = "System.Data.SqlClient";

+

+			IDbConnection mockConnection = _mockery.DynamicMock< IDbConnection >( );

+			using ( _mockery.Record( ) ) {

+				SetupResult.For( _mockConfiguration.ConnectionString( ) ).Return( connectionString );

+				SetupResult.For( _mockConfiguration.ProviderName( ) ).Return( providerName );

+				SetupResult.For( _mockProviderFactory.CreateConnectionFor( providerName ) ).Return( mockConnection );

+

+				mockConnection.ConnectionString = connectionString;

+			}

+

+			using ( _mockery.Playback( ) ) {

+				CreateSUT( ).CreateCommandFor( "" );

+			}

+		}

+

+		[Test]

+		public void Should_create_a_command_object_using_the_connection() {

+			string providerName = "System.Data.SqlClient";

+			string connectionString = "MyConnectionString";

+

+			IDbConnection mockConnection = _mockery.DynamicMock< IDbConnection >( );

+			IDbCommand mockCommand = _mockery.DynamicMock< IDbCommand >( );

+

+			using ( _mockery.Record( ) ) {

+				SetupResult.For( _mockConfiguration.ConnectionString( ) ).Return( connectionString );

+				SetupResult.For( _mockConfiguration.ProviderName( ) ).Return( providerName );

+				SetupResult.For( _mockProviderFactory.CreateConnectionFor( providerName ) ).Return( mockConnection );

+

+				Expect.Call( mockConnection.CreateCommand( ) ).Return( mockCommand );

+			}

+

+			using ( _mockery.Playback( ) ) {

+				CreateSUT( ).CreateCommandFor( "" );

+			}

+		}

+

+		[RowTest]

+		[Row( "Select * From Auctions" )]

+		[Row( "Select * From Pets" )]

+		public void Should_set_the_commands_text_and_type( string sqlQuery ) {

+			string providerName = "System.Data.SqlClient";

+			string connectionString = "MyConnectionString";

+

+			IDbConnection mockConnection = _mockery.DynamicMock< IDbConnection >( );

+			IDbCommand mockCommand = _mockery.DynamicMock< IDbCommand >( );

+

+			using ( _mockery.Record( ) ) {

+				SetupResult.For( _mockConfiguration.ConnectionString( ) ).Return( connectionString );

+				SetupResult.For( _mockConfiguration.ProviderName( ) ).Return( providerName );

+				SetupResult.For( _mockProviderFactory.CreateConnectionFor( providerName ) ).Return( mockConnection );

+				SetupResult.For( mockConnection.CreateCommand( ) ).Return( mockCommand );

+

+				mockCommand.CommandText = sqlQuery;

+				mockCommand.CommandType = CommandType.Text;

+			}

+

+			using ( _mockery.Playback( ) ) {

+				CreateSUT( ).CreateCommandFor( sqlQuery );

+			}

+		}

+

+		[Test]

+		public void Should_return_new_database_command() {

+			string providerName = "System.Data.SqlClient";

+			string connectionString = "MyConnectionString";

+

+			IDbConnection mockConnection = _mockery.DynamicMock< IDbConnection >( );

+			IDbCommand mockCommand = _mockery.DynamicMock< IDbCommand >( );

+

+			using ( _mockery.Record( ) ) {

+				SetupResult.For( _mockConfiguration.ConnectionString( ) ).Return( connectionString );

+				SetupResult.For( _mockConfiguration.ProviderName( ) ).Return( providerName );

+				SetupResult.For( _mockProviderFactory.CreateConnectionFor( providerName ) ).Return( mockConnection );

+				SetupResult.For( mockConnection.CreateCommand( ) ).Return( mockCommand );

+			}

+

+			using ( _mockery.Playback( ) ) {

+				Assert.IsNotNull( CreateSUT( ).CreateCommandFor( "" ) );

+			}

+		}

+

+		[Test]

+		public void Should_close_connection_when_disposed() {

+			string providerName = "System.Data.SqlClient";

+			string connectionString = "MyConnectionString";

+

+			IDbConnection mockConnection = _mockery.DynamicMock< IDbConnection >( );

+

+			using ( _mockery.Record( ) ) {

+				SetupResult.For( _mockConfiguration.ConnectionString( ) ).Return( connectionString );

+				SetupResult.For( _mockConfiguration.ProviderName( ) ).Return( providerName );

+				SetupResult.For( _mockProviderFactory.CreateConnectionFor( providerName ) ).Return( mockConnection );

+

+				mockConnection.Close( );

+			}

+

+			using ( _mockery.Playback( ) ) {

+				CreateSUT( ).Dispose( );

+			}

+		}

+

+		[Test]

+		public void Should_open_connection_when_created() {

+			string providerName = "System.Data.SqlClient";

+			string connectionString = "MyConnectionString";

+

+			IDbConnection mockConnection = _mockery.DynamicMock< IDbConnection >( );

+

+			using ( _mockery.Record( ) ) {

+				SetupResult.For( _mockConfiguration.ConnectionString( ) ).Return( connectionString );

+				SetupResult.For( _mockConfiguration.ProviderName( ) ).Return( providerName );

+				SetupResult.For( _mockProviderFactory.CreateConnectionFor( providerName ) ).Return( mockConnection );

+

+				mockConnection.Open( );

+			}

+

+			using ( _mockery.Playback( ) ) {

+				CreateSUT( );

+			}

+		}

+	}

+}
\ No newline at end of file
diff --git a/slips/src/test/Marina.Test/Unit/DataAccess/DatabaseGatewayTest.cs b/slips/src/test/Marina.Test/Unit/DataAccess/DatabaseGatewayTest.cs
new file mode 100644
index 0000000..f53d1ec
--- /dev/null
+++ b/slips/src/test/Marina.Test/Unit/DataAccess/DatabaseGatewayTest.cs
@@ -0,0 +1,91 @@
+using System.Data;

+using Marina.DataAccess;

+using MbUnit.Framework;

+using Rhino.Mocks;

+

+namespace Marina.Test.Unit.DataAccess {

+	[TestFixture]

+	public class DatabaseGatewayTest {

+		private MockRepository _mockery;

+		private IDatabaseConnectionFactory _mockConnectionFactory;

+

+		[SetUp]

+		public void Setup() {

+			_mockery = new MockRepository( );

+			_mockConnectionFactory = _mockery.DynamicMock< IDatabaseConnectionFactory >( );

+		}

+

+		public IDatabaseGateway CreateSUT() {

+			return new DatabaseGateway( _mockConnectionFactory );

+		}

+

+		[Test]

+		public void Should_leverage_factory_to_create_a_new_connection() {

+			IDatabaseConnection mockConnection = _mockery.DynamicMock< IDatabaseConnection >( );

+			using ( _mockery.Record( ) ) {

+				Expect.Call( _mockConnectionFactory.Create( ) ).Return( mockConnection );

+			}

+

+			using ( _mockery.Playback( ) ) {

+				CreateSUT( ).LoadTableUsing( "" );

+			}

+		}

+

+		[Test]

+		public void Should_create_command_using_database_connection() {

+			IDatabaseConnection mockConnection = _mockery.DynamicMock< IDatabaseConnection >( );

+			IDatabaseCommand mockCommand = _mockery.DynamicMock< IDatabaseCommand >( );

+			string sqlQuery = "SELECT * FROM ?";

+

+			using ( _mockery.Record( ) ) {

+				SetupResult.For( _mockConnectionFactory.Create( ) ).Return( mockConnection );

+				Expect.Call( mockConnection.CreateCommandFor( sqlQuery ) ).Return( mockCommand );

+			}

+

+			using ( _mockery.Playback( ) ) {

+				CreateSUT( ).LoadTableUsing( sqlQuery );

+			}

+		}

+

+		[RowTest]

+		[Row( "SELECT * FROM Cars" )]

+		[Row( "SELECT * FROM Persons" )]

+		public void Should_execute_query_on_command( string sqlQuery ) {

+			IDatabaseConnection mockConnection = _mockery.DynamicMock< IDatabaseConnection >( );

+			IDatabaseCommand mockCommand = _mockery.DynamicMock< IDatabaseCommand >( );

+

+			DataTable table = new DataTable( );

+			using ( _mockery.Record( ) ) {

+				SetupResult.For( _mockConnectionFactory.Create( ) ).Return( mockConnection );

+				SetupResult.For( mockConnection.CreateCommandFor( sqlQuery ) ).Return( mockCommand );

+				Expect.Call( mockCommand.ExecuteQuery( ) ).Return( table );

+			}

+

+			using ( _mockery.Playback( ) ) {

+				Assert.AreEqual( table, CreateSUT( ).LoadTableUsing( sqlQuery ) );

+			}

+		}

+

+		[Test]

+		public void Should_close_the_connection_after_executing_the_command() {

+			IDatabaseConnection mockConnection = _mockery.DynamicMock< IDatabaseConnection >( );

+			IDatabaseCommand mockCommand = _mockery.DynamicMock< IDatabaseCommand >( );

+			string sqlQuery = "SELECT * FROM ?";

+

+			DataTable table = new DataTable( );

+			using ( _mockery.Record( ) ) {

+				SetupResult.For( _mockConnectionFactory.Create( ) ).Return( mockConnection );

+				SetupResult.For( mockConnection.CreateCommandFor( sqlQuery ) ).Return( mockCommand );

+

+				using ( _mockery.Ordered( ) ) {

+					Expect.Call( mockCommand.ExecuteQuery( ) ).Return( table );

+					mockConnection.Dispose( );

+				}

+			}

+

+			using ( _mockery.Playback( ) ) {

+				CreateSUT( ).LoadTableUsing( sqlQuery );

+			}

+		}

+	}

+}
\ No newline at end of file
diff --git a/slips/src/test/Marina.Test/Unit/DataAccess/Mappers/CustomerDataMapperTest.cs b/slips/src/test/Marina.Test/Unit/DataAccess/Mappers/CustomerDataMapperTest.cs
new file mode 100644
index 0000000..81e170b
--- /dev/null
+++ b/slips/src/test/Marina.Test/Unit/DataAccess/Mappers/CustomerDataMapperTest.cs
@@ -0,0 +1,86 @@
+using System.Collections.Generic;

+using Marina.DataAccess;

+using Marina.DataAccess.DataMappers;

+using Marina.Domain.Interfaces;

+using Marina.Infrastructure;

+using MbUnit.Framework;

+using Rhino.Mocks;

+

+namespace Marina.Test.Unit.DataAccess.Mappers {

+	[TestFixture]

+	public class CustomerDataMapperTest {

+		private MockRepository _mockery;

+		private IDatabaseGateway _mockGateway;

+		private IBoatDataMapper _boatMapper;

+		private ILeaseDataMapper _leaseDataMapper;

+		private IRegistrationDataMapper _registrationMapper;

+

+		[SetUp]

+		public void Setup() {

+			_mockery = new MockRepository( );

+			_mockGateway = _mockery.DynamicMock< IDatabaseGateway >( );

+			_boatMapper = _mockery.DynamicMock< IBoatDataMapper >( );

+			_leaseDataMapper = _mockery.DynamicMock< ILeaseDataMapper >( );

+			_registrationMapper = _mockery.DynamicMock< IRegistrationDataMapper >( );

+		}

+

+		public ICustomerDataMapper CreateSUT() {

+			return new CustomerDataMapper( _mockGateway, _boatMapper, _leaseDataMapper, _registrationMapper );

+		}

+

+		[Test]

+		public void Should_leverage_mapper_to_load_customers_boats() {

+			long customerId = 32;

+

+			IList< IBoat > boats = new List< IBoat >( );

+			IBoat boat = _mockery.DynamicMock< IBoat >( );

+			boats.Add( boat );

+

+			using ( _mockery.Record( ) ) {

+				Expect.Call( _boatMapper.AllBoatsFor( customerId ) ).Return( boats );

+			}

+

+			using ( _mockery.Playback( ) ) {

+				ICustomer customer = CreateSUT( ).FindBy( customerId );

+				Assert.AreEqual( 1, ListFactory.From( customer.RegisteredBoats( ) ).Count );

+				Assert.IsTrue( ListFactory.From( customer.RegisteredBoats( ) ).Contains( boat ) );

+			}

+		}

+

+		[Test]

+		public void Should_leverage_mapper_to_load_customer_leases() {

+			long customerId = 32;

+			IList< ISlipLease > leases = new List< ISlipLease >( );

+			ISlipLease lease = _mockery.DynamicMock< ISlipLease >( );

+			leases.Add( lease );

+

+			using ( _mockery.Record( ) ) {

+				Expect

+					.Call( _leaseDataMapper.AllLeasesFor( customerId ) )

+					.Return( leases );

+			}

+

+			using ( _mockery.Playback( ) ) {

+				ICustomer customer = CreateSUT( ).FindBy( customerId );

+				Assert.AreEqual( 1, ListFactory.From( customer.Leases( ) ).Count );

+				Assert.IsTrue( ListFactory.From( customer.Leases( ) ).Contains( lease ) );

+			}

+		}

+

+		[Test]

+		public void Should_leverage_mapper_to_load_customer_registration() {

+			long customerId = 59;

+

+			IRegistration registration = _mockery.DynamicMock< IRegistration >( );

+

+			using ( _mockery.Record( ) ) {

+				Expect.Call( _registrationMapper.For( customerId ) ).Return( registration );

+			}

+

+			using ( _mockery.Playback( ) ) {

+				ICustomer customer = CreateSUT( ).FindBy( customerId );

+				Assert.AreEqual( registration, customer.Registration( ) );

+			}

+		}

+	}

+}
\ No newline at end of file
diff --git a/slips/src/test/Marina.Test/Unit/DataAccess/Repositories/CustomerRepositoryTest.cs b/slips/src/test/Marina.Test/Unit/DataAccess/Repositories/CustomerRepositoryTest.cs
new file mode 100644
index 0000000..afc21fc
--- /dev/null
+++ b/slips/src/test/Marina.Test/Unit/DataAccess/Repositories/CustomerRepositoryTest.cs
@@ -0,0 +1,142 @@
+using Marina.DataAccess;

+using Marina.DataAccess.DataMappers;

+using Marina.DataAccess.Repositories;

+using Marina.Domain.Interfaces;

+using Marina.Domain.Repositories;

+using MbUnit.Framework;

+using Rhino.Mocks;

+

+namespace Marina.Test.Unit.DataAccess.Repositories {

+	[TestFixture]

+	public class CustomerRepositoryTest {

+		private MockRepository _mockery;

+		private IIdentityMap< ICustomer > _mockIdentityMap;

+		private ICustomerDataMapper _mockMapper;

+

+		[SetUp]

+		public void Setup() {

+			_mockery = new MockRepository( );

+			_mockIdentityMap = _mockery.DynamicMock< IIdentityMap< ICustomer > >( );

+			_mockMapper = _mockery.DynamicMock< ICustomerDataMapper >( );

+		}

+

+		public ICustomerRepository CreateSUT() {

+			return CreateSUT( _mockIdentityMap, _mockMapper );

+		}

+

+		private ICustomerRepository CreateSUT( IIdentityMap< ICustomer > identityMap, ICustomerDataMapper mapper ) {

+			return new CustomerRepository( identityMap, mapper );

+		}

+

+		[Test]

+		public void Should_check_identity_map_to_see_if_customer_is_loaded() {

+			ICustomer customer = _mockery.DynamicMock< ICustomer >( );

+			long customerId = 23455;

+

+			using ( _mockery.Record( ) ) {

+				Expect.Call( _mockIdentityMap.ContainsObjectWithIdOf( customerId ) ).Return( true );

+				Expect.Call( _mockIdentityMap.FindObjectWithIdOf( customerId ) ).Return( customer );

+			}

+

+			using ( _mockery.Playback( ) ) {

+				Assert.AreEqual( customer, CreateSUT( ).FindBy( customerId ) );

+			}

+		}

+

+		[Test]

+		public void Should_leverage_mapper_to_load_customer_if_not_in_identity_map() {

+			ICustomer customer = _mockery.DynamicMock< ICustomer >( );

+			long customerId = 23455;

+

+			using ( _mockery.Record( ) ) {

+				SetupResult.For( _mockIdentityMap.ContainsObjectWithIdOf( customerId ) ).Return( false );

+				Expect.Call( _mockMapper.FindBy( customerId ) ).Return( customer );

+			}

+

+			using ( _mockery.Playback( ) ) {

+				Assert.AreEqual( customer, CreateSUT( ).FindBy( customerId ) );

+			}

+		}

+

+		[Test]

+		public void Should_add_customer_to_identity_map_after_retrieving_from_mapper() {

+			ICustomer customer = _mockery.DynamicMock< ICustomer >( );

+			long customerId = 23455;

+

+			using ( _mockery.Record( ) ) {

+				SetupResult.For( _mockIdentityMap.ContainsObjectWithIdOf( customerId ) ).Return( false );

+				SetupResult.For( _mockMapper.FindBy( customerId ) ).Return( customer );

+				_mockIdentityMap.Add( customer );

+			}

+

+			using ( _mockery.Playback( ) ) {

+				Assert.AreEqual( customer, CreateSUT( ).FindBy( customerId ) );

+			}

+		}

+

+		[Test]

+		public void Should_create_a_new_customer() {

+			using ( _mockery.Record( ) ) {}

+

+			using ( _mockery.Playback( ) ) {

+				ICustomer newCustomer = CreateSUT( ).NewCustomer( );

+				Assert.AreEqual( -1, newCustomer.ID( ) );

+			}

+		}

+

+		[Test]

+		public void Should_leverage_mapper_to_insert_new_customer() {

+			ICustomer customer = _mockery.DynamicMock< ICustomer >( );

+			long customerId = 34;

+

+			using ( _mockery.Record( ) ) {

+				SetupResult.For( customer.ID( ) ).Return( customerId );

+				SetupResult.For( _mockIdentityMap.ContainsObjectWithIdOf( customerId ) ).Return( false );

+

+				_mockMapper.Insert( customer );

+			}

+

+			using ( _mockery.Playback( ) ) {

+				CreateSUT( ).Save( customer );

+			}

+		}

+

+		[Test]

+		public void Should_add_new_customer_to_identity_map_after_insert() {

+			ICustomer customer = _mockery.DynamicMock< ICustomer >( );

+			long customerId = 34;

+

+			using ( _mockery.Record( ) ) {

+				SetupResult.For( customer.ID( ) ).Return( customerId );

+				SetupResult.For( _mockIdentityMap.ContainsObjectWithIdOf( customerId ) ).Return( false );

+				using ( _mockery.Ordered( ) ) {

+					_mockMapper.Insert( customer );

+					_mockIdentityMap.Add( customer );

+				}

+			}

+

+			using ( _mockery.Playback( ) ) {

+				CreateSUT( ).Save( customer );

+			}

+		}

+

+		[Test]

+		public void Should_leverage_mapper_to_update_customer() {

+			ICustomer customer = _mockery.DynamicMock< ICustomer >( );

+			IIdentityMap< ICustomer > identityMap = _mockery.CreateMock< IIdentityMap< ICustomer > >( );

+			ICustomerDataMapper dataMapper = _mockery.CreateMock< ICustomerDataMapper >( );

+			long customerId = 46;

+

+			using ( _mockery.Record( ) ) {

+				SetupResult.For( customer.ID( ) ).Return( customerId );

+				SetupResult.For( identityMap.ContainsObjectWithIdOf( customerId ) ).Return( true );

+

+				dataMapper.Update( customer );

+			}

+

+			using ( _mockery.Playback( ) ) {

+				CreateSUT( identityMap, dataMapper ).Save( customer );

+			}

+		}

+	}

+}
\ No newline at end of file
diff --git a/slips/src/test/Marina.Test/Unit/DataAccess/Repositories/DockRepositoryTest.cs b/slips/src/test/Marina.Test/Unit/DataAccess/Repositories/DockRepositoryTest.cs
new file mode 100644
index 0000000..5d17679
--- /dev/null
+++ b/slips/src/test/Marina.Test/Unit/DataAccess/Repositories/DockRepositoryTest.cs
@@ -0,0 +1,38 @@
+using Marina.DataAccess.DataMappers;

+using Marina.DataAccess.Repositories;

+using Marina.Domain.Interfaces;

+using Marina.Domain.Repositories;

+using MbUnit.Framework;

+using Rhino.Mocks;

+

+namespace Marina.Test.Unit.DataAccess.Repositories {

+	[TestFixture]

+	public class DockRepositoryTest {

+		private MockRepository _mockery;

+		private IDockDataMapper mockMapper;

+

+		[SetUp]

+		public void Setup() {

+			_mockery = new MockRepository( );

+			mockMapper = _mockery.DynamicMock< IDockDataMapper >( );

+		}

+

+		public IDockRepository CreateSUT() {

+			return new DockRepository( mockMapper );

+		}

+

+		[Test]

+		public void Should_leverage_mapper_to_retrieve_dock_by_id() {

+			IDock dock = _mockery.DynamicMock< IDock >( );

+			long dockId = 2;

+

+			using ( _mockery.Record( ) ) {

+				Expect.Call( mockMapper.FindBy( dockId ) ).Return( dock );

+			}

+

+			using ( _mockery.Playback( ) ) {

+				Assert.AreEqual( dock, CreateSUT( ).FindBy( dockId ) );

+			}

+		}

+	}

+}
\ No newline at end of file
diff --git a/slips/src/test/Marina.Test/Unit/DataAccess/Repositories/IdentityMapTest.cs b/slips/src/test/Marina.Test/Unit/DataAccess/Repositories/IdentityMapTest.cs
new file mode 100644
index 0000000..9ff01c8
--- /dev/null
+++ b/slips/src/test/Marina.Test/Unit/DataAccess/Repositories/IdentityMapTest.cs
@@ -0,0 +1,71 @@
+using Marina.DataAccess;

+using Marina.DataAccess.Exceptions;

+using Marina.Domain;

+using Marina.Domain.Interfaces;

+using MbUnit.Framework;

+

+namespace Marina.Test.Unit.DataAccess.Repositories {

+	[TestFixture]

+	public class IdentityMapTest {

+		public IIdentityMap< IDomainObject > CreateSUT() {

+			return new IdentityMap< IDomainObject >( );

+		}

+		

+		// should not be able to add an object with an id of -1

+

+		[Test]

+		public void Should_be_able_to_add_a_new_domain_object_to_the_identitiy_map() {

+			IDomainObject objectThatHasBeenAddedToMap = new DomainObject( 1 );

+			IDomainObject objectThatHasNotBeenAddedToMap = new DomainObject( 2 );

+

+			IIdentityMap< IDomainObject > map = CreateSUT( );

+			map.Add( objectThatHasBeenAddedToMap );

+

+			Assert.IsTrue( map.ContainsObjectWithIdOf( objectThatHasBeenAddedToMap.ID( ) ) );

+			Assert.IsFalse( map.ContainsObjectWithIdOf( objectThatHasNotBeenAddedToMap.ID( ) ) );

+		}

+

+		[Test]

+		public void Should_return_true_if_searching_for_a_() {

+			IIdentityMap< IDomainObject > map = CreateSUT( );

+

+			int id = 1;

+			map.Add( new DomainObject( id ) );

+

+			Assert.IsTrue( map.ContainsObjectWithIdOf( id ) );

+			Assert.IsFalse( map.ContainsObjectWithIdOf( 2 ) );

+		}

+

+		[Test]

+		public void Should_be_able_to_retrieve_an_object_that_has_been_added_to_the_map() {

+			IIdentityMap< IDomainObject > map = CreateSUT( );

+			IDomainObject objectAddedToMap = new DomainObject( 1 );

+			map.Add( objectAddedToMap );

+

+			Assert.AreEqual( objectAddedToMap, map.FindObjectWithIdOf( 1 ) );

+		}

+

+		[Test]

+		public void Should_return_null_if_the_object_is_not_in_the_map() {

+			Assert.IsNull( CreateSUT( ).FindObjectWithIdOf( 1 ) );

+		}

+

+		[Test]

+		[ExpectedException( typeof( ObjectAlreadyAddedToIdentityMapException ) )]

+		public void Should_not_be_able_to_add_an_object_that_has_already_been_added() {

+			IIdentityMap< IDomainObject > map = CreateSUT( );

+			IDomainObject addedObject = new DomainObject( 1 );

+			map.Add( addedObject );

+			map.Add( addedObject );

+		}

+

+		[Test]

+		[ExpectedException( typeof( ObjectAlreadyAddedToIdentityMapException ) )]

+		public void Should_not_be_able_to_add_an_object_with_the_same_id_as_one_that_was_already_added() {

+			IIdentityMap< IDomainObject > map = CreateSUT( );

+			int id = 1;

+			map.Add( new DomainObject( id ) );

+			map.Add( new DomainObject( id ) );

+		}

+	}

+}
\ No newline at end of file
diff --git a/slips/src/test/Marina.Test/Unit/DataAccess/Repositories/SlipRepositoryTest.cs b/slips/src/test/Marina.Test/Unit/DataAccess/Repositories/SlipRepositoryTest.cs
new file mode 100644
index 0000000..31b5d7a
--- /dev/null
+++ b/slips/src/test/Marina.Test/Unit/DataAccess/Repositories/SlipRepositoryTest.cs
@@ -0,0 +1,50 @@
+using System.Collections.Generic;

+using Marina.DataAccess.DataMappers;

+using Marina.DataAccess.Repositories;

+using Marina.Domain.Interfaces;

+using Marina.Domain.Repositories;

+using Marina.Infrastructure;

+using MbUnit.Framework;

+using Rhino.Mocks;

+

+namespace Marina.Test.Unit.DataAccess.Repositories {

+	[TestFixture]

+	public class SlipRepositoryTest {

+		private MockRepository _mockery;

+		private ISlipDataMapper _mockMapper;

+

+		[SetUp]

+		public void Setup() {

+			_mockery = new MockRepository( );

+			_mockMapper = _mockery.DynamicMock< ISlipDataMapper >( );

+		}

+

+		public ISlipsRepository CreateSUT() {

+			return new SlipsRepository( _mockMapper );

+		}

+

+		[Test]

+		public void Should_leverage_mapper_to_convert_from_table_to_a_domain_object() {

+			ISlip unleasedSlip = _mockery.DynamicMock< ISlip >( );

+			ISlip leasedSlip = _mockery.DynamicMock< ISlip >( );

+

+			IList< ISlip > slips = new List< ISlip >( );

+			slips.Add( unleasedSlip );

+			slips.Add( leasedSlip );

+

+			using ( _mockery.Record( ) ) {

+				SetupResult.For( unleasedSlip.IsLeased( ) ).Return( false );

+				SetupResult.For( leasedSlip.IsLeased( ) ).Return( true );

+

+				Expect.Call( _mockMapper.AllSlips( ) ).Return( new RichEnumerable< ISlip >( slips ) );

+			}

+

+			using ( _mockery.Playback( ) ) {

+				IRichList< ISlip > foundSlips = ListFactory.From( CreateSUT( ).AllAvailableSlips( ) );

+

+				Assert.IsTrue( foundSlips.Contains( unleasedSlip ) );

+				Assert.IsFalse( foundSlips.Contains( leasedSlip ) );

+			}

+		}

+	}

+}
\ No newline at end of file