Савельев Григорий

TagsCloud.Tests/DefaultPostFormatterTests.cs

@@ -0,0 +1,28 @@
+using FluentAssertions;
+using NUnit.Framework;
+using TagsCloud.Formatters;
+
+namespace TagsCloud.Tests;
+
+[TestFixture]
+public class DefaultPostFormatterTests
+{
+    private readonly DefaultPostFormatter defaultFormatter = new();
+
+    [TestCase("Mercedes-Benz", "Mercedes")]
+    [TestCase("Hello, world!", "Hello")]
+    [TestCase("123", "")]
+    [TestCase("Apple Orange Banana", "Apple")]
+    [TestCase("", "")]
+    [TestCase("      circle", "circle")]
+    [TestCase("circle      ", "circle")]
+    [TestCase("$$$", "")]
+    [TestCase("A", "A")]
+    [TestCase("   ___   Juice", "")]
+    [TestCase("                   ", "")]
+    public void Formatter_Should_CutLineToFirstNonLetterCharacter(string line, string expected)
+    {
+        var actual = defaultFormatter.Format(line);
+        actual.ShouldBeEquivalentTo(expected);
+    }
+}

TagsCloud.Tests/FileReadersTests.cs

@@ -0,0 +1,63 @@
+using FluentAssertions;
+using NUnit.Framework;
+using System.Reflection;
+using System.Text.RegularExpressions;
+using TagsCloud.Contracts;
+using TagsCloud.Formatters;
+
+namespace TagsCloud.Tests;
+
+[TestFixture]
+public partial class FileReadersTests
+{
+    [OneTimeSetUp]
+    public void OneTimeSetUp()
+    {
+        expectedLines = File.ReadAllLines($"{testDataPath}.txt")
+                            .Select(line => line.Split(separators, StringSplitOptions.RemoveEmptyEntries))
+                            .Select(array => array[0])
+                            .Where(word => char.IsLetter(word[0]))
+                            .ToArray();
+    }
+
+    private readonly string testDataPath = Path.Join("TestData", "test_data");
+    private readonly IPostFormatter defaultFormatter = new DefaultPostFormatter();
+    private readonly char[] separators = { ' ', ',', '.', ':', ';', '!', '?' };
+    private string[] expectedLines;
+
+    private readonly IFileReader[] fileReaders =
+        Assembly
+            .GetAssembly(typeof(IFileReader))!
+            .GetTypes()
+            .Where(type => type.GetInterfaces().Any(inter => inter == typeof(IFileReader)))
+            .Select(reader => (IFileReader)Activator.CreateInstance(reader)!)
+            .ToArray();
+
+    [Test]
+    public void Readers_Should_ReadFileContentCorrectly()
+    {
+        foreach (var reader in fileReaders)
+        {
+            var actualLines = reader
+                              .ReadContent($"{testDataPath}.{reader.SupportedExtension}", defaultFormatter)
+                              .Where(line => !string.IsNullOrEmpty(line));
+
+            actualLines.ShouldAllBeEquivalentTo(expectedLines);
+        }
+    }
+
+    [Test]
+    public void ReadersNames_Should_MatchSupportedExtensions()
+    {
+        foreach (var reader in fileReaders)
+        {
+            var match = ReaderNamePattern().Match(reader.GetType().Name);
+
+            match.Success.Should().Be(true);
+            match.Groups[1].Value.ToLower().ShouldBeEquivalentTo(reader.SupportedExtension);
+        }
+    }
+
+    [GeneratedRegex("([A-Z]\\w*)FileReader")]
+    private static partial Regex ReaderNamePattern();
+}

TagsCloud.Tests/GlobalTest.cs

@@ -0,0 +1,116 @@
+using FluentAssertions;
+using NUnit.Framework;
+using SixLabors.ImageSharp;
+using TagsCloud.Builders;
+using TagsCloud.Entities;
+using TagsCloudVisualization;
+
+namespace TagsCloud.Tests;
+
+[TestFixture]
+public class GlobalTest
+{
+    [OneTimeSetUp]
+    public void OneTimeSetUp()
+    {
+        var textParts = new HashSet<string> { "S" };
+        var colors = new HashSet<string> { "#de2114", "#07f727", "#7707f7" };
+        var (width, height) = (1920, 1080);
+
+        var inputOptions = new InputOptionsBuilder()
+                           .SetWordsCase(CaseType.Upper)
+                           .SetCastPolitics(true)
+                           .SetExcludedWords(excludedWords)
+                           .SetLanguageParts(textParts)
+                           .SetLanguagePolitics(true)
+                           .BuildOptions();
+
+        var cloudOptions = new CloudOptionsBuilder()
+                           .SetColors(colors)
+                           .SetLayout(
+                               PointGeneratorType.Spiral,
+                               new PointF((float)width / 2, (float)height / 2),
+                               0.1f,
+                               (float)Math.PI / 180)
+                           .SetColoringStrategy(ColoringStrategy.AllRandom)
+                           .SetMeasurerType(MeasurerType.Linear)
+                           .SetFontFamily(string.Empty)
+                           .SetSortingType(SortType.Ascending)
+                           .SetFontSizeBounds(35, 100)
+                           .BuildOptions();
+
+        var outputOptions = new OutputOptionsBuilder()
+                            .SetImageFormat(ImageFormat.Jpeg)
+                            .SetImageSize(new Size(width, height))
+                            .SetImageBackgroundColor("#ffffff")
+                            .BuildOptions();
+
+        var engine = new TagCloudEngine(inputOptions, cloudOptions, outputOptions);
+        wordGroups = engine.GenerateTagCloud(Path.Join("TestData", "data.txt"), outputPath);
+    }
+
+    private readonly HashSet<string> excludedWords = new(StringComparer.OrdinalIgnoreCase)
+    {
+        "Ноутбук",
+        "Камера"
+    };
+
+    private const string outputPath = "tagcloud_image.jpeg";
+
+    private readonly HashSet<string> verbs = new(StringComparer.OrdinalIgnoreCase)
+    {
+        "Программировать",
+        "Прыгать",
+        "Бегать",
+        "Играть"
+    };
+
+    private readonly HashSet<string> englishWords = new(StringComparer.OrdinalIgnoreCase)
+    {
+        "America",
+        "Russia",
+        "Germany",
+        "Apple",
+        "TV",
+        "Join",
+        "Split"
+    };
+
+    private HashSet<WordTagGroup> wordGroups;
+
+    [Test]
+    public void WordGroups_Should_ContainOnlyRussianWords()
+    {
+        wordGroups.Should().NotContain(group => englishWords.Contains(group.WordInfo.Text));
+    }
+
+    [Test]
+    public void WordGroups_ShouldNot_ContainVerbs()
+    {
+        wordGroups.Should().NotContain(group => verbs.Contains(group.WordInfo.Text));
+    }
+
+    [Test]
+    public void WordGroups_ShouldNot_ContainExcludedWords()
+    {
+        wordGroups.Should().NotContain(group => excludedWords.Contains(group.WordInfo.Text));
+    }
+
+    [Test]
+    public void WordGroupsWords_Should_BeUpperCase()
+    {
+        foreach (var group in wordGroups)
+            AreLettersUpperCase(group.WordInfo.Text).Should().Be(true);
+    }
+
+    [Test]
+    public void TagCloud_Should_CreateImageFile()
+    {
+        File.Exists(outputPath).Should().Be(true);
+    }
+
+    private static bool AreLettersUpperCase(string word)
+    {
+        return word.Where(char.IsLetter).All(letter => letter == char.ToUpper(letter));
+    }
+}

TagsCloud.Tests/TagsCloud.Tests.csproj

@@ -18,6 +18,22 @@
 
     <ItemGroup>
         <ProjectReference Include="..\TagsCloudVisualization\TagsCloudVisualization.csproj"/>
+        <ProjectReference Include="..\TagsCloud\TagsCloud.csproj"/>
+    </ItemGroup>
+
+    <ItemGroup>
+        <None Update="TestData\test_data.txt">
+            <CopyToOutputDirectory>PreserveNewest</CopyToOutputDirectory>
+        </None>
+        <None Update="TestData\test_data.docx">
+            <CopyToOutputDirectory>PreserveNewest</CopyToOutputDirectory>
+        </None>
+        <None Update="TestData\test_data.csv">
+            <CopyToOutputDirectory>PreserveNewest</CopyToOutputDirectory>
+        </None>
+        <None Update="TestData\data.txt">
+            <CopyToOutputDirectory>PreserveNewest</CopyToOutputDirectory>
+        </None>
     </ItemGroup>
 
 </Project>

TagsCloud.Tests/TestData/data.txt

@@ -0,0 +1,25 @@
+Программировать
+Играет
+Germany
+Бегает
+Прыгают
+Apple
+Join
+Split
+TV
+Бегать
+Бегать
+Russia
+Russia
+Russia
+Бегать
+Камера
+Камера
+Играть
+Играть
+Прыжок
+Ноутбук
+Планшет
+Яблоко
+America
+Ноутбук

TagsCloud.Tests/TestData/test_data.csv

@@ -0,0 +1,14 @@
+Lorem                           ,
+  consectetur 1 2 3 4 5,
+   Praesent,
+    Nunc   --->,
+     Maecenas,
+      Fusce,
+       Nullam (5 + 5 = 10), 
+      Nulla world!,
+     Vivamus Hello,
+    Aenean, 
+   Mauris  <<<-,    
+  Nullam,
+ nec Microsoft Power point,
+Aliquam nec,  

TagsCloud.Tests/TestData/test_data.txt

@@ -0,0 +1,18 @@
+    Lorem! ipsum dolor sit amet, 
+       consectetur :) adipiscing elit. 
+--->>>>>>>>>>>>>>>>>>>>>>       
+  @@@@
+   Praesent blandit consequat tristique. Donec felis purus, consequat eget enim et, tempus porttitor felis. -> 
+    Nunc @@@ semper nulla a ante vulputate mattis. 
+        Maecenas pellentesque vestibulum nisl, ut elementum ante sagittis nec. 
+           Fusce semper finibus nibh at vehicula. 
+             Nullam, auctor euismod risus, ac interdum leo. Nulla pulvinar turpis eu interdum volutpat.
+             Nulla, dignissim vestibulum leo, vel mollis quam. Pellentesque sed erat dictum,  commodo arcu ut, euismod urna. 
+   ######################
+          Vivamus, eu venenatis velit. 
+              Aenean rhoncus et lectus et aliquam. 
+                  Mauris quis est odio. Vivamus id condimentum nunc. 
+                      Nullam sagittis dictum leo, 
+                         nec egestas ligula accumsan eget. 
+<><><><>
+                             Aliquam enim dui, pharetra accumsan tincidunt id, imperdiet quis quam. 

TagsCloud.Tests/TextAnalyzerTests.cs

@@ -0,0 +1,35 @@
+using FluentAssertions;
+using NUnit.Framework;
+using TagsCloud.TextAnalysisTools;
+using TagsCloudVisualization;
+
+namespace TagsCloud.Tests;
+
+[TestFixture]
+public class TextAnalyzerTests
+{
+    [Test]
+    public void TextAnalyzer_Should_DistinguishRussianAndOtherWords()
+    {
+        var testData = GetTestGroups().ToArray();
+        var groups = testData
+                     .Select(data => data.Group)
+                     .ToHashSet();
+
+        TextAnalyzer.FillWithAnalysis(groups);
+
+        foreach (var (group, isEnglish) in testData)
+            group.WordInfo.IsRussian.Should().Be(isEnglish);
+    }
+
+    private static IEnumerable<(WordTagGroup Group, bool isRussian)> GetTestGroups()
+    {
+        yield return (new WordTagGroup("Apple", 1), false);
+        yield return (new WordTagGroup("Игра", 1), true);
+        yield return (new WordTagGroup("BMW", 1), false);
+        yield return (new WordTagGroup("Богатырь", 1), true);
+        yield return (new WordTagGroup("Математика", 1), true);
+        yield return (new WordTagGroup("C#", 1), false);
+        yield return (new WordTagGroup("Fibonacci", 1), false);
+    }
+}

TagsCloud/FileReaders/TxtFileReader.cs

@@ -13,7 +13,6 @@ public IEnumerable<string> ReadContent(string filename, IPostFormatter postForma
     {
         return File
                .ReadLines(filename)
-               .Where(line => !string.IsNullOrEmpty(line))
                .Select(line => postFormatter is null ? line : postFormatter.Format(line));
     }
 }

TagsCloud/Formatters/DefaultPostFormatter.cs

@@ -9,8 +9,10 @@ public class DefaultPostFormatter : IPostFormatter
 {
     public string Format(string input)
     {
-        var idx = GetFirstNonLetterIndex(input);
-        return idx == -1 ? input : input[..idx];
+        var trimmedInput = input.TrimStart();
+        var endIdx = GetFirstNonLetterIndex(trimmedInput);
+
+        return endIdx == -1 ? trimmedInput : trimmedInput[..endIdx];
     }
 
     private static int GetFirstNonLetterIndex(string line)

TagsCloud/Processors/InputProcessor.cs

@@ -33,10 +33,14 @@ public HashSet<WordTagGroup> CollectWordGroupsFromFile(string filename)
         var reader = FindFileReader(filename);
         var wordGroups = reader
                          .ReadContent(filename, postFormatter)
+                         .Where(line => !string.IsNullOrEmpty(line))
                          .GroupBy(line => line)
                          .Select(group => new WordTagGroup(group.Key, group.Count()))
                          .ToHashSet();
 
+        if (wordGroups.Count == 0)
+            throw new ArgumentException("No words found! Check file structure.");
+
         TextAnalyzer.FillWithAnalysis(wordGroups);
         filterConveyor.ApplyFilters(wordGroups);
 

TagsCloud/TagCloudEngine.cs

@@ -1,6 +1,7 @@
 using Microsoft.Extensions.DependencyInjection;
 using TagsCloud.Contracts;
 using TagsCloud.Extensions;
+using TagsCloudVisualization;
 
 namespace TagsCloud;
 
@@ -21,7 +22,7 @@ public TagCloudEngine(
                           .BuildServiceProvider();
     }
 
-    public void GenerateTagCloud(string inputFile, string outputFile)
+    public HashSet<WordTagGroup> GenerateTagCloud(string inputFile, string outputFile)
     {
         var textProcessor = serviceProvider.GetRequiredService<IInputProcessor>();
         var cloudProcessor = serviceProvider.GetRequiredService<ICloudProcessor>();
@@ -34,5 +35,7 @@ public void GenerateTagCloud(string inputFile, string outputFile)
         cloudProcessor.SetColors(groups);
 
         outputProcessor.SaveVisualization(groups, outputFile);
+
+        return groups;
     }
 }