Skip to content

Commit 371388c

Browse files
yreynhoutyreynhout
committed
Landed stream naming
1 parent 6a57a73 commit 371388c

15 files changed

+1403
-0
lines changed

‎.gitignore

+2
Original file line numberDiff line numberDiff line change
@@ -5,6 +5,8 @@
55
*.suo
66
*.user
77
*.sln.docstates
8+
attic
9+
packages
810

911
# Build results
1012
[Dd]ebug/

‎src/StreamSource.Tests/Framework/EqualityAssertion.cs

+268
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,268 @@
1+
using System;
2+
using System.Collections.Generic;
3+
using System.Linq;
4+
using NUnit.Framework;
5+
6+
namespace StreamSource.Framework
7+
{
8+
public class EqualityAssertion
9+
{
10+
private readonly EqualityAssertionOptions _options;
11+
private readonly IEqualityTestCase[] _cases;
12+
13+
public EqualityAssertion(object instance, EqualityAssertionOptions options = null)
14+
{
15+
if (instance == null)
16+
throw new ArgumentNullException("instance");
17+
_options = options ?? new EqualityAssertionOptions();
18+
var cases = new List<IEqualityTestCase>();
19+
if (_options.VerifyObjectEquals)
20+
{
21+
cases.Add(new ObjectEqualsTestCase(instance, null, false));
22+
cases.Add(new ObjectEqualsTestCase(instance, instance, true));
23+
}
24+
if (_options.VerifyTypeEquals)
25+
{
26+
cases.Add(new TypeEqualsTestCase(instance, null, false));
27+
cases.Add(new TypeEqualsTestCase(instance, instance, true));
28+
}
29+
if (_options.VerifyEqualsOperator)
30+
{
31+
cases.Add(new EqualsOperatorTestCase(instance, null, false));
32+
cases.Add(new EqualsOperatorTestCase(instance, instance, true));
33+
}
34+
if (_options.VerifyNotEqualsOperator)
35+
{
36+
cases.Add(new NotEqualsOperatorTestCase(instance, null, true));
37+
cases.Add(new NotEqualsOperatorTestCase(instance, instance, false));
38+
}
39+
_cases = cases.ToArray();
40+
}
41+
42+
EqualityAssertion(EqualityAssertionOptions options, IEqualityTestCase[] cases)
43+
{
44+
_options = options;
45+
_cases = cases;
46+
}
47+
48+
public EqualityAssertion VerifyEqual(object left, object right)
49+
{
50+
if (left == null) throw new ArgumentNullException("left");
51+
if (right == null) throw new ArgumentNullException("right");
52+
var cases = new List<IEqualityTestCase>();
53+
if (_options.VerifyObjectEquals) cases.Add(new ObjectEqualsTestCase(left, right, true));
54+
if (_options.VerifyTypeEquals) cases.Add(new TypeEqualsTestCase(left, right, true));
55+
if (_options.VerifyGetHashCode) cases.Add(new GetHashCodeTestCase(left, right, true));
56+
if (_options.VerifyEqualsOperator) cases.Add(new EqualsOperatorTestCase(left, right, true));
57+
if (_options.VerifyNotEqualsOperator) cases.Add(new NotEqualsOperatorTestCase(left, right, false));
58+
return new EqualityAssertion(_options, _cases.Concat(cases).ToArray());
59+
}
60+
61+
public EqualityAssertion VerifyNotEqual(object left, object right)
62+
{
63+
if (left == null) throw new ArgumentNullException("left");
64+
if (right == null) throw new ArgumentNullException("right");
65+
var cases = new List<IEqualityTestCase>();
66+
if (_options.VerifyObjectEquals) cases.Add(new ObjectEqualsTestCase(left, right, false));
67+
if (_options.VerifyTypeEquals) cases.Add(new TypeEqualsTestCase(left, right, false));
68+
if (_options.VerifyGetHashCode) cases.Add(new GetHashCodeTestCase(left, right, false));
69+
if (_options.VerifyEqualsOperator) cases.Add(new EqualsOperatorTestCase(left, right, false));
70+
if (_options.VerifyNotEqualsOperator) cases.Add(new NotEqualsOperatorTestCase(left, right, true));
71+
return new EqualityAssertion(_options, _cases.Concat(cases).ToArray());
72+
}
73+
74+
public void Assert()
75+
{
76+
foreach (var @case in _cases)
77+
{
78+
@case.Assert();
79+
}
80+
}
81+
82+
interface IEqualityTestCase
83+
{
84+
void Assert();
85+
}
86+
87+
class ObjectEqualsTestCase : IEqualityTestCase
88+
{
89+
private readonly object _left;
90+
private readonly object _right;
91+
private readonly bool _result;
92+
93+
public ObjectEqualsTestCase(object left, object right, bool result)
94+
{
95+
_left = left;
96+
_right = right;
97+
_result = result;
98+
}
99+
100+
public void Assert()
101+
{
102+
var actual = _left.Equals(_right);
103+
NUnit.Framework.Assert.That(actual, Is.EqualTo(_result),
104+
"{0}.Equals((object) other) failed",
105+
_left.GetType().Name);
106+
}
107+
}
108+
109+
class TypeEqualsTestCase : IEqualityTestCase
110+
{
111+
private readonly object _left;
112+
private readonly object _right;
113+
private readonly bool _result;
114+
115+
public TypeEqualsTestCase(object left, object right, bool result)
116+
{
117+
_left = left;
118+
_right = right;
119+
_result = result;
120+
}
121+
122+
public void Assert()
123+
{
124+
if (_right == null || _right.GetType() == _left.GetType())
125+
{
126+
var method = _left.GetType().GetMethods().
127+
SingleOrDefault(_ =>
128+
_.Name == "Equals" &&
129+
_.ReturnType == typeof(bool) &&
130+
_.GetParameters().Count() == 1 &&
131+
_.GetParameters().Single().ParameterType == _left.GetType());
132+
if (method == null)
133+
{
134+
NUnit.Framework.Assert.Fail(
135+
"Method not found: {0}.Equals({0} other)",
136+
_left.GetType().Name);
137+
}
138+
else
139+
{
140+
var actual = (bool) method.Invoke(_left, new[] {_right});
141+
NUnit.Framework.Assert.That(actual, Is.EqualTo(_result),
142+
"{0}.Equals(({0}) other) failed",
143+
_left.GetType().Name);
144+
}
145+
}
146+
else
147+
{
148+
var method = _left.GetType().GetMethods().
149+
SingleOrDefault(_ =>
150+
_.Name == "Equals" &&
151+
_.ReturnType == typeof (bool) &&
152+
_.GetParameters().Count() == 1 &&
153+
_.GetParameters().Single().ParameterType == _right.GetType());
154+
if (method == null)
155+
{
156+
NUnit.Framework.Assert.Fail(
157+
"Method not found: {0}.Equals({1} other)",
158+
_left.GetType().Name,
159+
_right.GetType().Name);
160+
}
161+
else
162+
{
163+
var actual = (bool)method.Invoke(_left, new[] { _right });
164+
NUnit.Framework.Assert.That(actual, Is.EqualTo(_result),
165+
"{0}.Equals(({1}) other) failed",
166+
_left.GetType().Name,
167+
_right.GetType().Name);
168+
}
169+
}
170+
}
171+
}
172+
173+
class GetHashCodeTestCase : IEqualityTestCase
174+
{
175+
private readonly object _left;
176+
private readonly object _right;
177+
private readonly bool _result;
178+
179+
public GetHashCodeTestCase(object left, object right, bool result)
180+
{
181+
_left = left;
182+
_right = right;
183+
_result = result;
184+
}
185+
186+
public void Assert()
187+
{
188+
var actual = _left.GetHashCode().Equals(_right.GetHashCode());
189+
NUnit.Framework.Assert.That(actual, Is.EqualTo(_result),
190+
"{0}.GetHashCode().Equals({1}.GetHashCode()) failed",
191+
_left.GetType().Name,
192+
_right.GetType().Name);
193+
}
194+
}
195+
196+
class EqualsOperatorTestCase : IEqualityTestCase
197+
{
198+
private readonly object _left;
199+
private readonly object _right;
200+
private readonly bool _result;
201+
202+
public EqualsOperatorTestCase(object left, object right, bool result)
203+
{
204+
_left = left;
205+
_right = right;
206+
_result = result;
207+
}
208+
209+
public void Assert()
210+
{
211+
if (_right == null || _right.GetType() == _left.GetType())
212+
{
213+
var method = _left.GetType().GetMethod("op_Equality", new[] { _left.GetType(), _left.GetType() });
214+
var actual = (bool)method.Invoke(null, new[] { _left, _right });
215+
NUnit.Framework.Assert.That(actual, Is.EqualTo(_result),
216+
"{0} == {1} failed",
217+
_left.GetType().Name,
218+
_right == null ? _left.GetType().Name : _right.GetType().Name);
219+
}
220+
else
221+
{
222+
var method = _left.GetType().GetMethod("op_Equality", new[] { _left.GetType(), _right.GetType() });
223+
var actual = (bool)method.Invoke(null, new[] { _left, _right });
224+
NUnit.Framework.Assert.That(actual, Is.EqualTo(_result),
225+
"{0} == {1} failed",
226+
_left.GetType().Name,
227+
_right.GetType().Name);
228+
}
229+
}
230+
}
231+
232+
class NotEqualsOperatorTestCase : IEqualityTestCase
233+
{
234+
private readonly object _left;
235+
private readonly object _right;
236+
private readonly bool _result;
237+
238+
public NotEqualsOperatorTestCase(object left, object right, bool result)
239+
{
240+
_left = left;
241+
_right = right;
242+
_result = result;
243+
}
244+
245+
public void Assert()
246+
{
247+
if (_right == null || _right.GetType() == _left.GetType())
248+
{
249+
var method = _left.GetType().GetMethod("op_Inequality", new[] { _left.GetType(), _left.GetType() });
250+
var actual = (bool)method.Invoke(null, new[] { _left, _right });
251+
NUnit.Framework.Assert.That(actual, Is.EqualTo(_result),
252+
"{0} != {1} failed",
253+
_left.GetType().Name,
254+
_right == null ? _left.GetType().Name : _right.GetType().Name);
255+
}
256+
else
257+
{
258+
var method = _left.GetType().GetMethod("op_Inequality", new[] { _left.GetType(), _right.GetType() });
259+
var actual = (bool)method.Invoke(null, new[] { _left, _right });
260+
NUnit.Framework.Assert.That(actual, Is.EqualTo(_result),
261+
"{0} != {1} failed",
262+
_left.GetType().Name,
263+
_right.GetType().Name);
264+
}
265+
}
266+
}
267+
}
268+
}

‎src/StreamSource.Tests/Framework/EqualityAssertionOptions.cs

+30
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,30 @@
1+
namespace StreamSource.Framework
2+
{
3+
public class EqualityAssertionOptions
4+
{
5+
public static readonly EqualityAssertionOptions EqualsGetHashCode = new EqualityAssertionOptions
6+
{
7+
VerifyEqualsOperator = false,
8+
VerifyNotEqualsOperator = false
9+
};
10+
11+
public EqualityAssertionOptions()
12+
{
13+
VerifyObjectEquals = true;
14+
VerifyTypeEquals = true;
15+
VerifyEqualsOperator = true;
16+
VerifyNotEqualsOperator = true;
17+
VerifyGetHashCode = true;
18+
}
19+
20+
public bool VerifyObjectEquals { get; set; }
21+
22+
public bool VerifyTypeEquals { get; set; }
23+
24+
public bool VerifyEqualsOperator { get; set; }
25+
26+
public bool VerifyNotEqualsOperator { get; set; }
27+
28+
public bool VerifyGetHashCode { get; set; }
29+
}
30+
}

‎src/StreamSource.Tests/Naming/StreamNameComponentTests.cs

+80
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,80 @@
1+
using System;
2+
using NUnit.Framework;
3+
using StreamSource.Framework;
4+
5+
namespace StreamSource.Naming
6+
{
7+
[TestFixture]
8+
public class StreamNameComponentTests
9+
{
10+
[Test]
11+
public void NameCanNotBeNull()
12+
{
13+
Assert.Throws<ArgumentNullException>(() => SutFactoryWithName(null));
14+
}
15+
16+
[Test]
17+
public void ValueCanNotBeNull()
18+
{
19+
Assert.Throws<ArgumentNullException>(() => SutFactoryWithValue(null));
20+
}
21+
22+
[Test]
23+
public void NameReturnsExpectedResult()
24+
{
25+
var sut = SutFactoryWithName("name");
26+
Assert.That(sut.Name, Is.EqualTo("name"));
27+
}
28+
29+
[Test]
30+
public void ValueReturnsExpectedResult()
31+
{
32+
var sut = SutFactoryWithValue("value");
33+
Assert.That(sut.Value, Is.EqualTo("value"));
34+
}
35+
36+
[Test]
37+
public void VerifyEquality()
38+
{
39+
new EqualityAssertion(SutFactory()).
40+
VerifyEqual(SutFactory("name", "value"), SutFactory("name", "value")).
41+
VerifyNotEqual(SutFactory("name", "value1"), SutFactory("name", "value2")).
42+
VerifyNotEqual(SutFactory("name1", "value"), SutFactory("name2", "value")).
43+
Assert();
44+
}
45+
46+
[TestCase("name", "value", "name=value")]
47+
[TestCase("name\\", "value", "name\\\\=value")]
48+
[TestCase("name=", "value", "name\\==value")]
49+
[TestCase("name,", "value", "name\\,=value")]
50+
[TestCase("name", "value\\", "name=value\\\\")]
51+
[TestCase("name", "value=", "name=value\\=")]
52+
[TestCase("name", "value,", "name=value\\,")]
53+
public void ToStringReturnsExpectedResult(string name, string value, string expected)
54+
{
55+
var sut = SutFactory(name, value);
56+
var result = sut.ToString();
57+
Assert.That(result, Is.EqualTo(expected));
58+
}
59+
60+
private static StreamNameComponent SutFactoryWithName(string name)
61+
{
62+
return SutFactory(name, Guid.NewGuid().ToString("N"));
63+
}
64+
65+
private static StreamNameComponent SutFactoryWithValue(string value)
66+
{
67+
return SutFactory(Guid.NewGuid().ToString("N"), value);
68+
}
69+
70+
private static StreamNameComponent SutFactory()
71+
{
72+
return SutFactory(Guid.NewGuid().ToString("N"), Guid.NewGuid().ToString("N"));
73+
}
74+
75+
private static StreamNameComponent SutFactory(string name, string value)
76+
{
77+
return new StreamNameComponent(name, value);
78+
}
79+
}
80+
}

0 commit comments

Comments
 (0)