slips/src/test/Marina.Test/Unit/DataAccess/Repositories/CustomerRepositoryTest.cs


1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
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 );
			}
		}
	}
}