ProcessFilesTests.cs 7.0 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227
  1. using System;
  2. using System.Collections.Generic;
  3. using System.IO;
  4. using System.Linq;
  5. using Xunit;
  6. namespace ProcessFilesTests
  7. {
  8. public class ProcessFilesTests
  9. {
  10. private readonly string testFolder = "./testFiles";
  11. private readonly string testFile = "./testFiles/test1.txt";
  12. private readonly List<string> expectedInSubFolder =
  13. [
  14. "test2.txt",
  15. "test3.txt"
  16. ];
  17. private readonly List<string> expectedInSubFolderMultipleExtensions = ["test.json"];
  18. private const string ExpectedInFolder = "test1.txt";
  19. public ProcessFilesTests()
  20. {
  21. expectedInSubFolder.Add(ExpectedInFolder);
  22. expectedInSubFolderMultipleExtensions.AddRange(expectedInSubFolder);
  23. }
  24. [Fact]
  25. public void ProcessFolderTest()
  26. {
  27. var result = string.Empty;
  28. void TestAction(string value)
  29. {
  30. result = Path.GetFileName(value);
  31. }
  32. var test = new ProcessFiles.ProcessFiles();
  33. var errors = test.Process([testFolder], "txt", TestAction);
  34. Assert.Empty(errors);
  35. Assert.Equal(ExpectedInFolder, result);
  36. }
  37. private static bool CheckResult(List<string> result, List<string> expected)
  38. {
  39. if (!result.Count.Equals(expected.Count))
  40. return false;
  41. foreach (var item in result)
  42. {
  43. if (!expected.Contains(item))
  44. return false;
  45. }
  46. return true;
  47. }
  48. [Fact]
  49. public void ProcessFolderRecursiveTest()
  50. {
  51. var result = new List<string>();
  52. void TestAction(string value)
  53. {
  54. result.Add(Path.GetFileName(value));
  55. }
  56. var test = new ProcessFiles.ProcessFiles();
  57. var errors = test.Process([testFolder], "txt", TestAction, true);
  58. Assert.Empty(errors);
  59. Assert.True(CheckResult(result, expectedInSubFolder));
  60. }
  61. [Fact]
  62. public void ProcessFolderAndFileTest()
  63. {
  64. var result = new List<string>();
  65. void TestAction(string value)
  66. {
  67. result.Add(Path.GetFileName(value));
  68. }
  69. var test = new ProcessFiles.ProcessFiles();
  70. var errors = test.Process(["./testFiles/subFolder", testFile], "txt", TestAction);
  71. Assert.Empty(errors);
  72. Assert.True(CheckResult(result, expectedInSubFolder));
  73. }
  74. [Fact]
  75. public void ProcessFileTest()
  76. {
  77. var result = string.Empty;
  78. void TestAction(string value)
  79. {
  80. result = Path.GetFileName(value);
  81. }
  82. var test = new ProcessFiles.ProcessFiles();
  83. var errors = test.Process([testFile], "txt", TestAction);
  84. Assert.Empty(errors);
  85. Assert.Equal(ExpectedInFolder, result);
  86. }
  87. [Fact]
  88. public void ProcessFileNotExistTest()
  89. {
  90. var result = string.Empty;
  91. void TestAction(string value)
  92. {
  93. result = value;
  94. }
  95. var test = new ProcessFiles.ProcessFiles();
  96. var errors = test.Process(["./testFiles/test.txt"], "txt", TestAction);
  97. Assert.NotEmpty(errors);
  98. Assert.Empty(result);
  99. }
  100. [Fact]
  101. public void ProcessDirectoryNotExistTest()
  102. {
  103. var result = string.Empty;
  104. void TestAction(string value)
  105. {
  106. result = value;
  107. }
  108. var test = new ProcessFiles.ProcessFiles();
  109. var errors = test.Process(["./nonExistent"], "txt", TestAction);
  110. Assert.NotEmpty(errors);
  111. Assert.Empty(result);
  112. }
  113. [Fact]
  114. public void ProcessFileNotMatchExtensionTest()
  115. {
  116. var result = string.Empty;
  117. void TestAction(string value)
  118. {
  119. result = value;
  120. }
  121. var test = new ProcessFiles.ProcessFiles();
  122. var errors = test.Process([testFile], "abc", TestAction);
  123. Assert.NotEmpty(errors);
  124. Assert.Empty(result);
  125. }
  126. [Fact]
  127. public void ProcessFolderRecursiveMultipleExtensionsTest()
  128. {
  129. var result = new List<string>();
  130. void TestAction(string value)
  131. {
  132. result.Add(Path.GetFileName(value));
  133. }
  134. var test = new ProcessFiles.ProcessFiles();
  135. var errors = test.Process([testFolder], ["txt", "json"], TestAction, true);
  136. Assert.Empty(errors);
  137. Assert.True(CheckResult(result, expectedInSubFolderMultipleExtensions));
  138. }
  139. [Fact]
  140. public void ProcessFileOnceTest()
  141. {
  142. var result = new Dictionary<string, int>();
  143. void TestAction(string value)
  144. {
  145. if (result.ContainsKey(value)) result[value]++;
  146. else result.Add(value, 1);
  147. }
  148. var test = new ProcessFiles.ProcessFiles();
  149. var errors = test.Process([testFolder], ["txt", "TxT"], TestAction);
  150. Assert.Empty(errors);
  151. Assert.Empty(result.Values.Where(x => x > 1).ToList());
  152. }
  153. [Fact]
  154. public void ProcessThrowsIfInvalidExtension()
  155. {
  156. var test = new ProcessFiles.ProcessFiles();
  157. foreach (var character in ProcessFiles.ProcessFiles.InvalidCharactersForExtension)
  158. {
  159. Assert.Throws<ArgumentException>(() => test.Process([testFolder], $"test{character}test", Console.WriteLine));
  160. }
  161. }
  162. [Fact]
  163. public void ProcessErrorsFromSameInstanceAccumulate()
  164. {
  165. var result = string.Empty;
  166. void TestAction(string value)
  167. {
  168. result = value;
  169. }
  170. var test = new ProcessFiles.ProcessFiles();
  171. var errors1 = test.Process(["./testFiles/test.txt"], "txt", TestAction);
  172. var errors2 = test.Process(["./nonExistent"], "txt", TestAction);
  173. Assert.NotEmpty(errors1);
  174. Assert.NotEmpty(errors2);
  175. Assert.Contains(errors1, x => errors2.Contains(x));
  176. }
  177. [Fact]
  178. public void ProcessErrorsFromDifferemtInstancesDontAccumulate()
  179. {
  180. var result = string.Empty;
  181. void TestAction(string value)
  182. {
  183. result = value;
  184. }
  185. var test = new ProcessFiles.ProcessFiles();
  186. var errors1 = test.Process(["./testFiles/test.txt"], "txt", TestAction);
  187. var test2 = new ProcessFiles.ProcessFiles();
  188. var errors2 = test2.Process(["./nonExistent"], "txt", TestAction);
  189. Assert.NotEmpty(errors1);
  190. Assert.NotEmpty(errors2);
  191. Assert.DoesNotContain(errors1, x => errors2.Contains(x));
  192. }
  193. }
  194. }