Skip to content

Commit 94699f3

Browse files
hazzikhazzik
authored
Convert NUnit Asserts to fluent model (#644)
+semver:patch
1 parent 1c01f7b commit 94699f3

File tree

10 files changed

+79
-185
lines changed

10 files changed

+79
-185
lines changed

‎.editorconfig

Lines changed: 2 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -19,6 +19,8 @@ csharp_style_namespace_declarations = file_scoped
1919

2020
dotnet_diagnostic.ide0161.severity = warning
2121
dotnet_diagnostic.NUnit1032.severity = suggestion
22+
dotnet_diagnostic.NUnit1028.severity = none
23+
dotnet_diagnostic.NUnit2045.severity = none
2224

2325
# ReSharper properties
2426
resharper_default_private_modifier = implicit

‎src/FluentNHibernate.Testing/Cfg/ExceptionSerializationTests.cs

Lines changed: 1 addition & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -27,7 +27,7 @@ public void ShouldSerializeFluentConfigurationExceptionCorrectly()
2727
var result = formatter.Deserialize(stream) as FluentConfigurationException;
2828

2929
original.Message.ShouldEqual(result.Message);
30-
CollectionAssert.AreEquivalent(original.PotentialReasons, result.PotentialReasons);
30+
Assert.That(result.PotentialReasons, Is.EquivalentTo(original.PotentialReasons));
3131
}
3232
}
3333

‎src/FluentNHibernate.Testing/ConventionsTests/AccessConventionTests.cs

Lines changed: 22 additions & 22 deletions
Original file line numberDiff line numberDiff line change
@@ -44,7 +44,7 @@ public void SetUp()
4444
[Test]
4545
public void IdIsSet()
4646
{
47-
Assert.AreEqual(expectedAccess, ((IdMapping)parent.Id).Access);
47+
Assert.That(((IdMapping)parent.Id).Access, Is.EqualTo(expectedAccess));
4848
}
4949

5050
[Test]
@@ -53,79 +53,79 @@ public void CompositeIdIsSet()
5353
CompositeIdMapping id;
5454

5555
id = ((CompositeIdMapping)compositeId.Id);
56-
Assert.AreEqual(expectedAccess, id.Access);
57-
Assert.AreEqual(expectedAccess, id.Keys.First(x => x.Name.Equals("IdA")).Access);
58-
Assert.AreEqual(expectedAccess, id.Keys.First(x => x.Name.Equals("IdB")).Access);
56+
Assert.That(id.Access, Is.EqualTo(expectedAccess));
57+
Assert.That(id.Keys.First(x => x.Name.Equals("IdA")).Access, Is.EqualTo(expectedAccess));
58+
Assert.That(id.Keys.First(x => x.Name.Equals("IdB")).Access, Is.EqualTo(expectedAccess));
5959

6060
id = ((CompositeIdMapping)oneToOne.Id);
61-
Assert.AreEqual(expectedAccess, id.Access);
62-
Assert.AreEqual(expectedAccess, id.Keys.First(x => x.Name.Equals("Parent")).Access);
61+
Assert.That(id.Access, Is.EqualTo(expectedAccess));
62+
Assert.That(id.Keys.First(x => x.Name.Equals("Parent")).Access, Is.EqualTo(expectedAccess));
6363
}
6464

6565
[Test]
6666
public void VersionIsSet()
6767
{
68-
Assert.AreEqual(expectedAccess, parent.Version.Access);
68+
Assert.That(parent.Version.Access, Is.EqualTo(expectedAccess));
6969
}
7070

7171
[Test]
7272
public void PropertyIsSet()
7373
{
74-
Assert.AreEqual(expectedAccess, parent.Properties.First(x => x.Name.Equals("Property")).Access);
74+
Assert.That(parent.Properties.First(x => x.Name.Equals("Property")).Access, Is.EqualTo(expectedAccess));
7575
}
7676

7777
[Test]
7878
public void JoinedPropertyIsSet()
7979
{
80-
Assert.AreEqual(expectedAccess, parent.Joins.SelectMany(x => x.Properties).First(x => x.Name.Equals("JoinedProperty")).Access);
80+
Assert.That(parent.Joins.SelectMany(x => x.Properties).First(x => x.Name.Equals("JoinedProperty")).Access, Is.EqualTo(expectedAccess));
8181
}
8282

8383
[Test]
8484
public void ComponentIsSet()
8585
{
86-
Assert.AreEqual(expectedAccess, parent.Components.First(x => x.Name.Equals("Component")).Access);
86+
Assert.That(parent.Components.First(x => x.Name.Equals("Component")).Access, Is.EqualTo(expectedAccess));
8787
}
8888

8989
[Test]
9090
public void DynamicComponentIsSet()
9191
{
92-
Assert.AreEqual(expectedAccess, parent.Components.First(x => x.Name.Equals("Dynamic")).Access);
92+
Assert.That(parent.Components.First(x => x.Name.Equals("Dynamic")).Access, Is.EqualTo(expectedAccess));
9393
}
9494

9595
[Test]
9696
public void OneToOneIsSet()
9797
{
98-
Assert.AreEqual(expectedAccess, parent.OneToOnes.First(x => x.Name.Equals("One")).Access);
98+
Assert.That(parent.OneToOnes.First(x => x.Name.Equals("One")).Access, Is.EqualTo(expectedAccess));
9999
}
100100

101101
[Test]
102102
public void OneToManyIsSet()
103103
{
104-
Assert.AreEqual(expectedAccess, parent.Collections.First(x => x.Name.Equals("MapOne")).Access);
105-
Assert.AreEqual(expectedAccess, parent.Collections.First(x => x.Name.Equals("SetOne")).Access);
106-
Assert.AreEqual(expectedAccess, parent.Collections.First(x => x.Name.Equals("ListOne")).Access);
107-
Assert.AreEqual(expectedAccess, parent.Collections.First(x => x.Name.Equals("BagOne")).Access);
104+
Assert.That(parent.Collections.First(x => x.Name.Equals("MapOne")).Access, Is.EqualTo(expectedAccess));
105+
Assert.That(parent.Collections.First(x => x.Name.Equals("SetOne")).Access, Is.EqualTo(expectedAccess));
106+
Assert.That(parent.Collections.First(x => x.Name.Equals("ListOne")).Access, Is.EqualTo(expectedAccess));
107+
Assert.That(parent.Collections.First(x => x.Name.Equals("BagOne")).Access, Is.EqualTo(expectedAccess));
108108
}
109109

110110
[Test]
111111
public void ManyToManyIsSet()
112112
{
113-
Assert.AreEqual(expectedAccess, parent.Collections.First(x => x.Name.Equals("MapMany")).Access);
114-
Assert.AreEqual(expectedAccess, parent.Collections.First(x => x.Name.Equals("SetMany")).Access);
115-
Assert.AreEqual(expectedAccess, parent.Collections.First(x => x.Name.Equals("ListMany")).Access);
116-
Assert.AreEqual(expectedAccess, parent.Collections.First(x => x.Name.Equals("BagMany")).Access);
113+
Assert.That(parent.Collections.First(x => x.Name.Equals("MapMany")).Access, Is.EqualTo(expectedAccess));
114+
Assert.That(parent.Collections.First(x => x.Name.Equals("SetMany")).Access, Is.EqualTo(expectedAccess));
115+
Assert.That(parent.Collections.First(x => x.Name.Equals("ListMany")).Access, Is.EqualTo(expectedAccess));
116+
Assert.That(parent.Collections.First(x => x.Name.Equals("BagMany")).Access, Is.EqualTo(expectedAccess));
117117
}
118118

119119
[Test]
120120
public void ManyToOneIsSet()
121121
{
122-
Assert.AreEqual(expectedAccess, manyToOne.References.First(x => x.Name.Equals("Parent")).Access);
122+
Assert.That(manyToOne.References.First(x => x.Name.Equals("Parent")).Access, Is.EqualTo(expectedAccess));
123123
}
124124

125125
[Test]
126126
public void AnyIsSet()
127127
{
128-
Assert.AreEqual(expectedAccess, parent.Anys.First(x => x.Name.Equals("Any")).Access);
128+
Assert.That(parent.Anys.First(x => x.Name.Equals("Any")).Access, Is.EqualTo(expectedAccess));
129129
}
130130

131131
private class BackfieldAccessConvention : AccessConvention

‎src/FluentNHibernate.Testing/DomainModel/Mapping/MappingTester.cs

Lines changed: 11 additions & 12 deletions
Original file line numberDiff line numberDiff line change
@@ -93,19 +93,18 @@ public virtual MappingTester<T> HasThisManyChildNodes(int expected)
9393

9494
public virtual MappingTester<T> HasAttribute(string name, string value)
9595
{
96-
Assert.IsNotNull(currentElement, "Couldn't find element matching '" + currentPath + "'");
96+
Assert.That(currentElement, Is.Not.Null, $"Couldn't find element matching '{currentPath}'");
9797

9898
var actual = currentElement.GetAttribute(name);
9999

100-
Assert.AreEqual(value, actual,
101-
"Attribute '" + name + "' of '" + currentPath + "' didn't match.");
100+
Assert.That(actual, Is.EqualTo(value), $"Attribute '{name}' of '{currentPath}' didn't match.");
102101

103102
return this;
104103
}
105104

106105
public virtual MappingTester<T> HasAttribute(string name, Func<string, bool> predicate)
107106
{
108-
Assert.IsNotNull(currentElement, "Couldn't find element matching '" + currentPath + "'");
107+
Assert.That(currentElement, Is.Not.Null, $"Couldn't find element matching '{currentPath}'");
109108

110109
currentElement.HasAttribute(name).ShouldBeTrue();
111110

@@ -116,28 +115,28 @@ public virtual MappingTester<T> HasAttribute(string name, Func<string, bool> pre
116115

117116
public virtual MappingTester<T> DoesntHaveAttribute(string name)
118117
{
119-
Assert.IsFalse(currentElement.HasAttribute(name), "Found attribute '" + name + "' on element.");
118+
Assert.That(currentElement.HasAttribute(name), Is.False, $"Found attribute '{name}' on element.");
120119

121120
return this;
122121
}
123122

124123
public virtual MappingTester<T> Exists()
125124
{
126-
Assert.IsNotNull(currentElement, "Couldn't find element matching '" + currentPath + "'");
125+
Assert.That(currentElement, Is.Not.Null, $"Couldn't find element matching '{currentPath}'");
127126

128127
return this;
129128
}
130129

131130
public virtual MappingTester<T> DoesntExist()
132131
{
133-
Assert.IsNull(currentElement);
132+
Assert.That(currentElement, Is.Null);
134133

135134
return this;
136135
}
137136

138137
public virtual MappingTester<T> HasName(string name)
139138
{
140-
Assert.AreEqual(name, currentElement.Name, "Expected current element to have the name '" + name + "' but found '" + currentElement.Name + "'.");
139+
Assert.That(currentElement.Name, Is.EqualTo(name), $"Expected current element to have the name '{name}' but found '{currentElement.Name}'.");
141140

142141
return this;
143142
}
@@ -160,12 +159,12 @@ public override string ToString()
160159

161160
public MappingTester<T> ChildrenDontContainAttribute(string key, string value)
162161
{
163-
Assert.IsNotNull(currentElement, "Couldn't find element matching '" + currentPath + "'");
162+
Assert.That(currentElement, Is.Not.Null, $"Couldn't find element matching '{currentPath}'");
164163

165164
foreach (XmlElement node in currentElement.ChildNodes)
166165
{
167166
if (node.HasAttribute(key))
168-
Assert.AreNotEqual(node.Attributes[key].Value, value);
167+
Assert.That(value, Is.Not.EqualTo(node.Attributes[key].Value));
169168
}
170169
return this;
171170
}
@@ -191,9 +190,9 @@ public virtual MappingTester<T> ShouldBeInParentAtPosition(int elementPosition)
191190
else
192191
{
193192
XmlElement elementAtPosition = (XmlElement)currentElement.ParentNode.ChildNodes.Item(elementPosition);
194-
Assert.IsTrue(elementAtPosition == currentElement, "Expected '" + currentElement.Name + "' but was '" + elementAtPosition.Name + "'");
193+
Assert.That(elementAtPosition, Is.EqualTo(currentElement), $"Expected '{currentElement.Name}' but was '{elementAtPosition.Name}'");
195194
}
196195

197196
return this;
198197
}
199-
}
198+
}

‎src/FluentNHibernate.Testing/FluentInterfaceTests/ClassMapFilterPartModelGenerationTests.cs

Lines changed: 2 additions & 2 deletions
Original file line numberDiff line numberDiff line change
@@ -20,7 +20,7 @@ public void MapShouldAddFilterMappingToClassMapping()
2020

2121
private void CheckFirstFilterWithoutCondition(ClassMapping mapping)
2222
{
23-
if (mapping.Filters.Count() == 0) Assert.Fail("No filter added");
23+
if (!mapping.Filters.Any()) Assert.Fail("No filter added");
2424
if (mapping.Filters.First().Name != "test") Assert.Fail("Wrong filter name added");
2525
}
2626

@@ -37,4 +37,4 @@ public void MapShouldAddFilterMappingWithoutConditionToClassMapping()
3737
.Mapping(m => m.ApplyFilter<TestFilter>())
3838
.ModelShouldMatch(CheckFirstFilterWithoutCondition);
3939
}
40-
}
40+
}

‎src/FluentNHibernate.Testing/Infrastructure/ContainerTester.cs

Lines changed: 2 additions & 2 deletions
Original file line numberDiff line numberDiff line change
@@ -31,12 +31,12 @@ public void ShouldThrowExceptionWhenResolvingUnregisteredType()
3131
Action act = () => container.Resolve<IExample>();
3232

3333
act.ShouldThrow<ResolveException>()
34-
.WithMessage("Unable to resolve dependency: '" + typeof(IExample).FullName + "'");
34+
.WithMessage($"Unable to resolve dependency: '{typeof(IExample).FullName}'");
3535
}
3636

3737
private interface IExample
3838
{}
3939

4040
private class Example : IExample
4141
{}
42-
}
42+
}

‎src/FluentNHibernate.Testing/PersistenceModelTests/SeparateSubclassVisitorFixture.cs

Lines changed: 12 additions & 12 deletions
Original file line numberDiff line numberDiff line change
@@ -33,8 +33,8 @@ public void Should_add_subclass_that_implements_the_parent_interface()
3333
providers.Add(new StringFooMap());
3434
var sut = CreateSut();
3535
sut.ProcessClass(fooMapping);
36-
Assert.AreEqual(1, fooMapping.Subclasses.Count());
37-
Assert.AreEqual(1, fooMapping.Subclasses.Where(sub => sub.Type.Equals(typeof(Foo<string>))).Count());
36+
Assert.That(fooMapping.Subclasses.Count(), Is.EqualTo(1));
37+
Assert.That(fooMapping.Subclasses.Count(sub => sub.Type == typeof(Foo<string>)), Is.EqualTo(1));
3838
}
3939

4040
[Test]
@@ -50,8 +50,8 @@ public void Should_add_subclass_that_implements_the_parent_base()
5050
providers.Add(new StringFooMap());
5151
var sut = CreateSut();
5252
sut.ProcessClass(fooMapping);
53-
Assert.AreEqual(1, fooMapping.Subclasses.Count());
54-
Assert.AreEqual(1, fooMapping.Subclasses.Where(sub => sub.Type.Equals(typeof(Foo<string>))).Count());
53+
Assert.That(fooMapping.Subclasses.Count(), Is.EqualTo(1));
54+
Assert.That(fooMapping.Subclasses.Count(sub => sub.Type == typeof(Foo<string>)), Is.EqualTo(1));
5555
}
5656

5757
[Test]
@@ -67,7 +67,7 @@ public void Should_not_add_subclassmap_that_does_not_implement_parent_interface(
6767
providers.Add(new StandAloneMap());
6868
var sut = CreateSut();
6969
sut.ProcessClass(fooMapping);
70-
Assert.AreEqual(0, fooMapping.Subclasses.Count());
70+
Assert.That(fooMapping.Subclasses.Count(), Is.EqualTo(0));
7171
}
7272

7373
[Test]
@@ -83,7 +83,7 @@ public void Should_not_add_subclassmap_that_does_not_implement_parent_base()
8383
providers.Add(new StandAloneMap());
8484
var sut = CreateSut();
8585
sut.ProcessClass(fooMapping);
86-
Assert.AreEqual(0, fooMapping.Subclasses.Count());
86+
Assert.That(fooMapping.Subclasses.Count(), Is.EqualTo(0));
8787
}
8888

8989
[Test]
@@ -101,8 +101,8 @@ public void Should_not_add_subclassmap_that_implements_a_subclass_of_the_parent_
101101
providers.Add(new StringFooMap());
102102
var sut = CreateSut();
103103
sut.ProcessClass(fooMapping);
104-
Assert.AreEqual(1, fooMapping.Subclasses.Count());
105-
Assert.AreEqual(1, fooMapping.Subclasses.Where(sub => sub.Type.Equals(typeof(BaseImpl))).Count());
104+
Assert.That(fooMapping.Subclasses.Count(), Is.EqualTo(1));
105+
Assert.That(fooMapping.Subclasses.Count(sub => sub.Type == typeof(BaseImpl)), Is.EqualTo(1));
106106
}
107107

108108
[Test]
@@ -120,8 +120,8 @@ public void Should_not_add_subclassmap_that_implements_a_subclass_of_the_parent_
120120
providers.Add(new StringFooMap());
121121
var sut = CreateSut();
122122
sut.ProcessClass(fooMapping);
123-
Assert.AreEqual(1, fooMapping.Subclasses.Count());
124-
Assert.AreEqual(1, fooMapping.Subclasses.Where(sub => sub.Type.Equals(typeof(BaseImpl))).Count());
123+
Assert.That(fooMapping.Subclasses.Count(), Is.EqualTo(1));
124+
Assert.That(fooMapping.Subclasses.Count(sub => sub.Type == typeof(BaseImpl)), Is.EqualTo(1));
125125
}
126126

127127
[Test]
@@ -132,8 +132,8 @@ public void Should_add_explicit_extend_subclasses_to_their_parent()
132132
providers.Add(new ExtendsChildMap());
133133
var sut = CreateSut();
134134
sut.ProcessClass(fooMapping);
135-
Assert.AreEqual(1, fooMapping.Subclasses.Count());
136-
Assert.AreEqual(1, fooMapping.Subclasses.Where(sub => sub.Type.Equals(typeof(ExtendsChild))).Count());
135+
Assert.That(fooMapping.Subclasses.Count(), Is.EqualTo(1));
136+
Assert.That(fooMapping.Subclasses.Count(sub => sub.Type == typeof(ExtendsChild)), Is.EqualTo(1));
137137
}
138138

139139
[Test]

‎src/FluentNHibernate.Testing/Serialization/SerializationFixture.cs

Lines changed: 1 addition & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -18,7 +18,7 @@ public void all_itypes_should_be_serializables()
1818

1919
foreach (var userTypeType in userTypes)
2020
{
21-
Assert.IsTrue(userTypeType.IsSerializable, string.Format("{0} should be serializable.", userTypeType.Name));
21+
Assert.That(userTypeType.IsSerializable, $"{userTypeType.Name} should be serializable.");
2222
}
2323
}
2424
}

0 commit comments

Comments
 (0)