feat: remove FluentAssertions

guitarrapc · guitarrapc · commit 77decbaafe95 · 2025-02-05T15:10:16.000+09:00
diff --git a/Directory.Packages.props b/Directory.Packages.props
@@ -8,7 +8,6 @@
     <!-- Tests -->
     <PackageVersion Include="GitHubActionsTestLogger" Version="2.4.1" />
     <PackageVersion Include="coverlet.msbuild" Version="6.0.4" />
-    <PackageVersion Include="FluentAssertions" Version="7.0.0" />
     <PackageVersion Include="Microsoft.NET.Test.Sdk" Version="17.12.0" />
     <PackageVersion Include="xunit" Version="2.9.3" />
     <PackageVersion Include="xunit.runner.visualstudio" Version="3.0.1" />
diff --git a/tests/UnityBuildRunner.Core.Tests/DefaultErrorFilterTest.cs b/tests/UnityBuildRunner.Core.Tests/DefaultErrorFilterTest.cs
@@ -1,7 +1,3 @@
-using FluentAssertions;
-using System.Collections.Generic;
-using Xunit;
-
 namespace UnityBuildRunner.Core.Tests;
 
 public class DefaultErrorFilterTest
@@ -26,28 +22,28 @@ Unloading 64 Unused Serialized files (Serialized files now loaded: 0)
         DisplayProgressbar: Unity license")]
     public void DetectCSharpCompileError(params string[] inputs)
     {
-        IErrorFilter errorFilter = new DefaultErrorFilter();
+        var errorFilter = new DefaultErrorFilter();
         var results = new List<string>();
         foreach (var input in inputs)
         {
             errorFilter.Filter(input, result => results.Add(result.MatchPattern));
         }
 
-        results.Should().NotBeEmpty();
+        Assert.NotEmpty(results);
     }
 
     [Theory]
     [InlineData("Multiple Unity instances cannot open the same project.")]
     [InlineData("Unity has not been activated")]
     public void DetectUnityError(params string[] inputs)
     {
-        IErrorFilter errorFilter = new DefaultErrorFilter();
+        var errorFilter = new DefaultErrorFilter();
         var results = new List<string>();
         foreach (var input in inputs)
         {
             errorFilter.Filter(input, result => results.Add(result.MatchPattern));
         }
-        results.Should().NotBeEmpty();
+        Assert.NotEmpty(results);
     }
 
     [Theory]
@@ -67,13 +63,13 @@ public void DetectUnityError(params string[] inputs)
         "Shader error in 'Shader Graphs/UrpFoo': Compilation failed (other error) 'out of memory during compilation")]
     public void SkipShaderError(params string[] inputs)
     {
-        IErrorFilter errorFilter = new DefaultErrorFilter();
+        var errorFilter = new DefaultErrorFilter();
         var results = new List<string>();
         foreach (var input in inputs)
         {
             errorFilter.Filter(input, result => results.Add(result.MatchPattern));
         }
-        results.Should().BeEmpty();
+        Assert.Empty(results);
     }
 
     [Theory]
@@ -82,12 +78,12 @@ public void SkipShaderError(params string[] inputs)
         "System memory in use before: 63.0 MB.", "DisplayProgressbar: Unity Package Manager")]
     public void SkipNormalMessage(params string[] inputs)
     {
-        IErrorFilter errorFilter = new DefaultErrorFilter();
+        var errorFilter = new DefaultErrorFilter();
         var results = new List<string>();
         foreach (var input in inputs)
         {
             errorFilter.Filter(input, result => results.Add(result.MatchPattern));
         }
-        results.Should().BeEmpty();
+        Assert.Empty(results);
     }
 }
diff --git a/tests/UnityBuildRunner.Core.Tests/DefaultStrictErrorFilterTest.cs b/tests/UnityBuildRunner.Core.Tests/DefaultStrictErrorFilterTest.cs
@@ -1,7 +1,3 @@
-using FluentAssertions;
-using System.Collections.Generic;
-using Xunit;
-
 namespace UnityBuildRunner.Core.Tests;
 
 public class DefaultStrictErrorFilterTest
@@ -26,28 +22,28 @@ Unloading 64 Unused Serialized files (Serialized files now loaded: 0)
         DisplayProgressbar: Unity license")]
     public void DetectCSharpCompileError(params string[] inputs)
     {
-        IErrorFilter errorFilter = new DefaultStrictErrorFilter();
+        var errorFilter = new DefaultStrictErrorFilter();
         var results = new List<string>();
         foreach (var input in inputs)
         {
             errorFilter.Filter(input, result => results.Add(result.MatchPattern));
         }
 
-        results.Should().NotBeEmpty();
+        Assert.NotEmpty(results);
     }
 
     [Theory]
     [InlineData("Multiple Unity instances cannot open the same project.")]
     [InlineData("Unity has not been activated")]
     public void DetectUnityError(params string[] inputs)
     {
-        IErrorFilter errorFilter = new DefaultStrictErrorFilter();
+        var errorFilter = new DefaultStrictErrorFilter();
         var results = new List<string>();
         foreach (var input in inputs)
         {
             errorFilter.Filter(input, result => results.Add(result.MatchPattern));
         }
-        results.Should().NotBeEmpty();
+        Assert.NotEmpty(results);
     }
 
     [Theory]
@@ -67,13 +63,13 @@ public void DetectUnityError(params string[] inputs)
         "Shader error in 'Shader Graphs/UrpFoo': Compilation failed (other error) 'out of memory during compilation")]
     public void SkipShaderError(params string[] inputs)
     {
-        IErrorFilter errorFilter = new DefaultStrictErrorFilter();
+        var errorFilter = new DefaultStrictErrorFilter();
         var results = new List<string>();
         foreach (var input in inputs)
         {
             errorFilter.Filter(input, result => results.Add(result.MatchPattern));
         }
-        results.Should().NotBeEmpty();
+        Assert.NotEmpty(results);
     }
 
     [Theory]
@@ -82,12 +78,12 @@ public void SkipShaderError(params string[] inputs)
         "System memory in use before: 63.0 MB.", "DisplayProgressbar: Unity Package Manager")]
     public void SkipNormalMessage(params string[] inputs)
     {
-        IErrorFilter errorFilter = new DefaultStrictErrorFilter();
+        var errorFilter = new DefaultStrictErrorFilter();
         var results = new List<string>();
         foreach (var input in inputs)
         {
             errorFilter.Filter(input, result => results.Add(result.MatchPattern));
         }
-        results.Should().BeEmpty();
+        Assert.Empty(results);
     }
 }
diff --git a/tests/UnityBuildRunner.Core.Tests/GlocalUsing.cs b/tests/UnityBuildRunner.Core.Tests/GlocalUsing.cs
@@ -0,0 +1 @@
+global using Xunit;
diff --git a/tests/UnityBuildRunner.Core.Tests/SettingsUnitTests.cs b/tests/UnityBuildRunner.Core.Tests/SettingsUnitTests.cs
@@ -1,9 +1,4 @@
-using FluentAssertions;
-using System;
-using System.IO;
-using System.Linq;
-using Xunit;
-
+#pragma warning disable CA1816 // Dispose methods should call SuppressFinalize
 namespace UnityBuildRunner.Core.Tests;
 
 public class DefaultSettingsTest : IDisposable
@@ -33,19 +28,19 @@ public void Dispose()
     [Fact]
     public void UnityPathCanReadFromArguments()
     {
-        ISettings settings = DefaultSettings.Parse(Array.Empty<string>(), _unityPath, _timeout);
-        settings.UnityPath.Should().Be(_unityPath);
+        var settings = DefaultSettings.Parse([], _unityPath, _timeout);
+        Assert.Equal(_unityPath, settings.UnityPath);
     }
 
     [Fact]
     public void UnityPathCanReadFromEnvironment()
     {
         var envName = "UnityPath";
         Environment.SetEnvironmentVariable(envName, _unityPath, EnvironmentVariableTarget.Process);
-        Environment.GetEnvironmentVariable(envName).Should().NotBeNull();
+        Assert.NotNull(Environment.GetEnvironmentVariable(envName));
 
-        ISettings settings = DefaultSettings.Parse(Array.Empty<string>(), "", _timeout);
-        settings.UnityPath.Should().Be(_unityPath);
+        var settings = DefaultSettings.Parse([], "", _timeout);
+        Assert.Equal(_unityPath, settings.UnityPath);
 
         Environment.SetEnvironmentVariable(envName, null, EnvironmentVariableTarget.Process);
     }
@@ -56,9 +51,9 @@ public void UnityPathCanReadFromEnvironment()
     public void UnityPathMissingShouldThrow(string envName, string unityPath)
     {
         Environment.SetEnvironmentVariable(envName, unityPath, EnvironmentVariableTarget.Process);
-        Environment.GetEnvironmentVariable(envName).Should().NotBeNull();
+        Assert.NotNull(Environment.GetEnvironmentVariable(envName));
 
-        Assert.Throws<ArgumentNullException>(() => DefaultSettings.Parse(Array.Empty<string>(), "", _timeout));
+        Assert.Throws<ArgumentNullException>(() => DefaultSettings.Parse([], "", _timeout));
 
         Environment.SetEnvironmentVariable(envName, null, EnvironmentVariableTarget.Process);
     }
@@ -68,11 +63,11 @@ public void UnityPathMissingShouldThrow(string envName, string unityPath)
     [InlineData(new[] { "-logfile", "hoge.log", "-bathmode", "-nographics", "-projectpath", "HogemogeProject", "-executeMethod", "MethodName", "-quite" }, "hoge.log")]
     public void ParseLogfile(string[] args, string logfile)
     {
-        ISettings settings = DefaultSettings.Parse(args, _unityPath, _timeout);
+        var settings = DefaultSettings.Parse(args, _unityPath, _timeout);
         var log = DefaultSettings.ParseLogFile(args);
-        log.Should().Be(logfile);
-        settings.LogFilePath.Should().Be(logfile);
-        settings.Args.Length.Should().Be(args.Length);
+        Assert.Equal(logfile, log);
+        Assert.Equal(logfile, settings.LogFilePath);
+        Assert.Equal(args.Length, settings.Args.Length);
     }
 
     [Theory]
@@ -85,8 +80,8 @@ public void ParseLogfile(string[] args, string logfile)
     [InlineData(new[] { "-bathmode", "-nographics", "-projectpath", " ", @"foo\bar\baz\", "-executeMethod", "MethodName", "-quite" }, new[] { "-bathmode", "-nographics", "-projectpath", @"foo\bar\baz\", "-executeMethod", "MethodName", "-quite", "-logFile", "unitybuild.log" })]
     public void ArgsShouldNotContainNullOrWhiteSpace(string[] actual, string[] expected)
     {
-        ISettings settings = DefaultSettings.Parse(actual, _unityPath, _timeout);
-        settings.Args.SequenceEqual(expected).Should().BeTrue();
+        var settings = DefaultSettings.Parse(actual, _unityPath, _timeout);
+        Assert.True(settings.Args.SequenceEqual(expected));
     }
 
     [Theory]
@@ -102,8 +97,8 @@ public void ArgsShouldNotContainNullOrWhiteSpace(string[] actual, string[] expec
     [InlineData(new[] { "-logfile", "\"hoge.log\"", "-bathmode", "-nographics", "-projectpath", @"""foo\bar\baz""", "-executeMethod", "\"MethodName\"", "-quite" }, "-logfile \"hoge.log\" -bathmode -nographics -projectpath \"foo\\bar\\baz\" -executeMethod \"MethodName\" -quite")] // input is already quoted
     public void ArgsumentStringShouldFormated(string[] actual, string expected)
     {
-        ISettings settings = DefaultSettings.Parse(actual, _unityPath, _timeout);
-        settings.ArgumentString.Should().Be(expected);
+        var settings = DefaultSettings.Parse(actual, _unityPath, _timeout);
+        Assert.Equal(expected, settings.ArgumentString);
     }
 
     [Theory]
@@ -114,7 +109,7 @@ public void ArgsumentStringShouldFormated(string[] actual, string expected)
     [InlineData("log.log", true)]
     public void IsValidLogFilePath(string? logFilePath, bool expected)
     {
-        DefaultSettings.IsValidLogFileName(logFilePath).Should().Be(expected);
+        Assert.Equal(expected, DefaultSettings.IsValidLogFileName(logFilePath));
     }
 
     [Theory]
@@ -137,6 +132,6 @@ public void QuoteStringInvalidInput(string input)
     [InlineData("foo", "\"foo\"")]
     public void QuoteStringValidValue(string input, string expected)
     {
-        DefaultSettings.QuoteString(input).Should().Be(expected);
+        Assert.Equal(expected, DefaultSettings.QuoteString(input));
     }
 }
diff --git a/tests/UnityBuildRunner.Core.Tests/UnityBuildRunner.Core.Tests.csproj b/tests/UnityBuildRunner.Core.Tests/UnityBuildRunner.Core.Tests.csproj
@@ -13,7 +13,6 @@
       <PrivateAssets>all</PrivateAssets>
       <IncludeAssets>runtime; build; native; contentfiles; analyzers; buildtransitive</IncludeAssets>
     </PackageReference>
-    <PackageReference Include="FluentAssertions" />
     <PackageReference Include="Microsoft.NET.Test.Sdk" />
     <PackageReference Include="xunit" />
     <PackageReference Include="xunit.runner.visualstudio">

Original file line number	Diff line number	Diff line change
`@@ -1,7 +1,3 @@`
`1`		`-using FluentAssertions;`
`2`		`-using System.Collections.Generic;`
`3`		`-using Xunit;`
`4`		`-`
`5`	`1`	`namespace UnityBuildRunner.Core.Tests;`
`6`	`2`
`7`	`3`	`public class DefaultErrorFilterTest`
`@@ -26,28 +22,28 @@ Unloading 64 Unused Serialized files (Serialized files now loaded: 0)`
`26`	`22`	`DisplayProgressbar: Unity license")]`
`27`	`23`	`public void DetectCSharpCompileError(params string[] inputs)`
`28`	`24`	`{`
`29`		`- IErrorFilter errorFilter = new DefaultErrorFilter();`
	`25`	`+ var errorFilter = new DefaultErrorFilter();`
`30`	`26`	`var results = new List<string>();`
`31`	`27`	`foreach (var input in inputs)`
`32`	`28`	`{`
`33`	`29`	`errorFilter.Filter(input, result => results.Add(result.MatchPattern));`
`34`	`30`	`}`
`35`	`31`
`36`		`- results.Should().NotBeEmpty();`
	`32`	`+ Assert.NotEmpty(results);`
`37`	`33`	`}`
`38`	`34`
`39`	`35`	`[Theory]`
`40`	`36`	`[InlineData("Multiple Unity instances cannot open the same project.")]`
`41`	`37`	`[InlineData("Unity has not been activated")]`
`42`	`38`	`public void DetectUnityError(params string[] inputs)`
`43`	`39`	`{`
`44`		`- IErrorFilter errorFilter = new DefaultErrorFilter();`
	`40`	`+ var errorFilter = new DefaultErrorFilter();`
`45`	`41`	`var results = new List<string>();`
`46`	`42`	`foreach (var input in inputs)`
`47`	`43`	`{`
`48`	`44`	`errorFilter.Filter(input, result => results.Add(result.MatchPattern));`
`49`	`45`	`}`
`50`		`- results.Should().NotBeEmpty();`
	`46`	`+ Assert.NotEmpty(results);`
`51`	`47`	`}`
`52`	`48`
`53`	`49`	`[Theory]`
`@@ -67,13 +63,13 @@ public void DetectUnityError(params string[] inputs)`
`67`	`63`	`"Shader error in 'Shader Graphs/UrpFoo': Compilation failed (other error) 'out of memory during compilation")]`
`68`	`64`	`public void SkipShaderError(params string[] inputs)`
`69`	`65`	`{`
`70`		`- IErrorFilter errorFilter = new DefaultErrorFilter();`
	`66`	`+ var errorFilter = new DefaultErrorFilter();`
`71`	`67`	`var results = new List<string>();`
`72`	`68`	`foreach (var input in inputs)`
`73`	`69`	`{`
`74`	`70`	`errorFilter.Filter(input, result => results.Add(result.MatchPattern));`
`75`	`71`	`}`
`76`		`- results.Should().BeEmpty();`
	`72`	`+ Assert.Empty(results);`
`77`	`73`	`}`
`78`	`74`
`79`	`75`	`[Theory]`
`@@ -82,12 +78,12 @@ public void SkipShaderError(params string[] inputs)`
`82`	`78`	`"System memory in use before: 63.0 MB.", "DisplayProgressbar: Unity Package Manager")]`
`83`	`79`	`public void SkipNormalMessage(params string[] inputs)`
`84`	`80`	`{`
`85`		`- IErrorFilter errorFilter = new DefaultErrorFilter();`
	`81`	`+ var errorFilter = new DefaultErrorFilter();`
`86`	`82`	`var results = new List<string>();`
`87`	`83`	`foreach (var input in inputs)`
`88`	`84`	`{`
`89`	`85`	`errorFilter.Filter(input, result => results.Add(result.MatchPattern));`
`90`	`86`	`}`
`91`		`- results.Should().BeEmpty();`
	`87`	`+ Assert.Empty(results);`
`92`	`88`	`}`
`93`	`89`	`}`
Original file line number	Diff line number	Diff line change
`@@ -1,9 +1,4 @@`
`1`		`-using FluentAssertions;`
`2`		`-using System;`
`3`		`-using System.IO;`
`4`		`-using System.Linq;`
`5`		`-using Xunit;`
`6`		`-`
	`1`	`+#pragma warning disable CA1816 // Dispose methods should call SuppressFinalize`
`7`	`2`	`namespace UnityBuildRunner.Core.Tests;`
`8`	`3`
`9`	`4`	`public class DefaultSettingsTest : IDisposable`
`@@ -33,19 +28,19 @@ public void Dispose()`
`33`	`28`	`[Fact]`
`34`	`29`	`public void UnityPathCanReadFromArguments()`
`35`	`30`	`{`
`36`		`- ISettings settings = DefaultSettings.Parse(Array.Empty<string>(), _unityPath, _timeout);`
`37`		`- settings.UnityPath.Should().Be(_unityPath);`
	`31`	`+ var settings = DefaultSettings.Parse([], _unityPath, _timeout);`
	`32`	`+ Assert.Equal(_unityPath, settings.UnityPath);`
`38`	`33`	`}`
`39`	`34`
`40`	`35`	`[Fact]`
`41`	`36`	`public void UnityPathCanReadFromEnvironment()`
`42`	`37`	`{`
`43`	`38`	`var envName = "UnityPath";`
`44`	`39`	`Environment.SetEnvironmentVariable(envName, _unityPath, EnvironmentVariableTarget.Process);`
`45`		`- Environment.GetEnvironmentVariable(envName).Should().NotBeNull();`
	`40`	`+ Assert.NotNull(Environment.GetEnvironmentVariable(envName));`
`46`	`41`
`47`		`- ISettings settings = DefaultSettings.Parse(Array.Empty<string>(), "", _timeout);`
`48`		`- settings.UnityPath.Should().Be(_unityPath);`
	`42`	`+ var settings = DefaultSettings.Parse([], "", _timeout);`
	`43`	`+ Assert.Equal(_unityPath, settings.UnityPath);`
`49`	`44`
`50`	`45`	`Environment.SetEnvironmentVariable(envName, null, EnvironmentVariableTarget.Process);`
`51`	`46`	`}`
`@@ -56,9 +51,9 @@ public void UnityPathCanReadFromEnvironment()`
`56`	`51`	`public void UnityPathMissingShouldThrow(string envName, string unityPath)`
`57`	`52`	`{`
`58`	`53`	`Environment.SetEnvironmentVariable(envName, unityPath, EnvironmentVariableTarget.Process);`
`59`		`- Environment.GetEnvironmentVariable(envName).Should().NotBeNull();`
	`54`	`+ Assert.NotNull(Environment.GetEnvironmentVariable(envName));`
`60`	`55`
`61`		`- Assert.Throws<ArgumentNullException>(() => DefaultSettings.Parse(Array.Empty<string>(), "", _timeout));`
	`56`	`+ Assert.Throws<ArgumentNullException>(() => DefaultSettings.Parse([], "", _timeout));`
`62`	`57`
`63`	`58`	`Environment.SetEnvironmentVariable(envName, null, EnvironmentVariableTarget.Process);`
`64`	`59`	`}`
`@@ -68,11 +63,11 @@ public void UnityPathMissingShouldThrow(string envName, string unityPath)`
`68`	`63`	`[InlineData(new[] { "-logfile", "hoge.log", "-bathmode", "-nographics", "-projectpath", "HogemogeProject", "-executeMethod", "MethodName", "-quite" }, "hoge.log")]`
`69`	`64`	`public void ParseLogfile(string[] args, string logfile)`
`70`	`65`	`{`
`71`		`- ISettings settings = DefaultSettings.Parse(args, _unityPath, _timeout);`
	`66`	`+ var settings = DefaultSettings.Parse(args, _unityPath, _timeout);`
`72`	`67`	`var log = DefaultSettings.ParseLogFile(args);`
`73`		`- log.Should().Be(logfile);`
`74`		`- settings.LogFilePath.Should().Be(logfile);`
`75`		`- settings.Args.Length.Should().Be(args.Length);`
	`68`	`+ Assert.Equal(logfile, log);`
	`69`	`+ Assert.Equal(logfile, settings.LogFilePath);`
	`70`	`+ Assert.Equal(args.Length, settings.Args.Length);`
`76`	`71`	`}`
`77`	`72`
`78`	`73`	`[Theory]`
`@@ -85,8 +80,8 @@ public void ParseLogfile(string[] args, string logfile)`
`85`	`80`	`[InlineData(new[] { "-bathmode", "-nographics", "-projectpath", " ", @"foo\bar\baz\", "-executeMethod", "MethodName", "-quite" }, new[] { "-bathmode", "-nographics", "-projectpath", @"foo\bar\baz\", "-executeMethod", "MethodName", "-quite", "-logFile", "unitybuild.log" })]`
`86`	`81`	`public void ArgsShouldNotContainNullOrWhiteSpace(string[] actual, string[] expected)`
`87`	`82`	`{`
`88`		`- ISettings settings = DefaultSettings.Parse(actual, _unityPath, _timeout);`
`89`		`- settings.Args.SequenceEqual(expected).Should().BeTrue();`
	`83`	`+ var settings = DefaultSettings.Parse(actual, _unityPath, _timeout);`
	`84`	`+ Assert.True(settings.Args.SequenceEqual(expected));`
`90`	`85`	`}`
`91`	`86`
`92`	`87`	`[Theory]`
`@@ -102,8 +97,8 @@ public void ArgsShouldNotContainNullOrWhiteSpace(string[] actual, string[] expec`
`102`	`97`	`[InlineData(new[] { "-logfile", "\"hoge.log\"", "-bathmode", "-nographics", "-projectpath", @"""foo\bar\baz""", "-executeMethod", "\"MethodName\"", "-quite" }, "-logfile \"hoge.log\" -bathmode -nographics -projectpath \"foo\\bar\\baz\" -executeMethod \"MethodName\" -quite")] // input is already quoted`
`103`	`98`	`public void ArgsumentStringShouldFormated(string[] actual, string expected)`
`104`	`99`	`{`
`105`		`- ISettings settings = DefaultSettings.Parse(actual, _unityPath, _timeout);`
`106`		`- settings.ArgumentString.Should().Be(expected);`
	`100`	`+ var settings = DefaultSettings.Parse(actual, _unityPath, _timeout);`
	`101`	`+ Assert.Equal(expected, settings.ArgumentString);`
`107`	`102`	`}`
`108`	`103`
`109`	`104`	`[Theory]`
`@@ -114,7 +109,7 @@ public void ArgsumentStringShouldFormated(string[] actual, string expected)`
`114`	`109`	`[InlineData("log.log", true)]`
`115`	`110`	`public void IsValidLogFilePath(string? logFilePath, bool expected)`
`116`	`111`	`{`
`117`		`- DefaultSettings.IsValidLogFileName(logFilePath).Should().Be(expected);`
	`112`	`+ Assert.Equal(expected, DefaultSettings.IsValidLogFileName(logFilePath));`
`118`	`113`	`}`
`119`	`114`
`120`	`115`	`[Theory]`
`@@ -137,6 +132,6 @@ public void QuoteStringInvalidInput(string input)`
`137`	`132`	`[InlineData("foo", "\"foo\"")]`
`138`	`133`	`public void QuoteStringValidValue(string input, string expected)`
`139`	`134`	`{`
`140`		`- DefaultSettings.QuoteString(input).Should().Be(expected);`
	`135`	`+ Assert.Equal(expected, DefaultSettings.QuoteString(input));`
`141`	`136`	`}`
`142`	`137`	`}`