From 144c13c5e4d74afa6d40ccb310c091356849d59c Mon Sep 17 00:00:00 2001
From: Thanos Papathanasiou <ThanosPapathanasiou@hotmail.com>
Date: Tue, 23 Jun 2015 22:44:49 +0300
Subject: [PATCH] Completed the four user stories

The acceptance tests for the four user stories are located in the
ContentManagerTests file.
All other unit tests are found in the TextAnalyserTests.cs

I did not use Moq since the code was simple enough It wasn't needed.
The test took more than one hour to complete.

When executed the program does the following:
1. Scans the text for the user
2. Adds the word 'people' to the bad words list and scans the text again
3. Shows the filtered text
4. Removes 'people' from the bad words list and shows the filtered text
again
5. Shows the non-filtered text
---
 .../ContentConsole.Test.Unit.csproj           |  8 ++
 .../ContentManagerTests.cs                    | 81 +++++++++++++++++
 ContentConsole.Test.Unit/TextAnalyserTests.cs | 83 +++++++++++++++++
 ContentConsole/ContentConsole.csproj          |  2 +
 ContentConsole/ContentManager.cs              | 35 ++++++++
 ContentConsole/Program.cs                     | 71 +++++++++------
 ContentConsole/TextAnalyser.cs                | 89 +++++++++++++++++++
 7 files changed, 340 insertions(+), 29 deletions(-)
 create mode 100644 ContentConsole.Test.Unit/ContentManagerTests.cs
 create mode 100644 ContentConsole.Test.Unit/TextAnalyserTests.cs
 create mode 100644 ContentConsole/ContentManager.cs
 create mode 100644 ContentConsole/TextAnalyser.cs

diff --git a/ContentConsole.Test.Unit/ContentConsole.Test.Unit.csproj b/ContentConsole.Test.Unit/ContentConsole.Test.Unit.csproj
index f1b05c0..583b46b 100644
--- a/ContentConsole.Test.Unit/ContentConsole.Test.Unit.csproj
+++ b/ContentConsole.Test.Unit/ContentConsole.Test.Unit.csproj
@@ -47,11 +47,19 @@
     <Reference Include="System.Xml" />
   </ItemGroup>
   <ItemGroup>
+    <Compile Include="ContentManagerTests.cs" />
     <Compile Include="Properties\AssemblyInfo.cs" />
+    <Compile Include="TextAnalyserTests.cs" />
   </ItemGroup>
   <ItemGroup>
     <None Include="packages.config" />
   </ItemGroup>
+  <ItemGroup>
+    <ProjectReference Include="..\ContentConsole\ContentConsole.csproj">
+      <Project>{70da2b36-ebf3-4438-9f95-ecc828a64527}</Project>
+      <Name>ContentConsole</Name>
+    </ProjectReference>
+  </ItemGroup>
   <Import Project="$(MSBuildToolsPath)\Microsoft.CSharp.targets" />
   <Import Project="$(SolutionDir)\.nuget\NuGet.targets" Condition="Exists('$(SolutionDir)\.nuget\NuGet.targets')" />
   <!-- To modify your build process, add your task inside one of the targets below and uncomment it. 
diff --git a/ContentConsole.Test.Unit/ContentManagerTests.cs b/ContentConsole.Test.Unit/ContentManagerTests.cs
new file mode 100644
index 0000000..5a54136
--- /dev/null
+++ b/ContentConsole.Test.Unit/ContentManagerTests.cs
@@ -0,0 +1,81 @@
+using System;
+using System.CodeDom;
+using System.Collections.Generic;
+using System.Linq;
+using System.Runtime.CompilerServices;
+using System.Text;
+using System.Threading.Tasks;
+using Moq;
+using NUnit.Framework;
+
+namespace ContentConsole.Test.Unit
+{
+    [TestFixture]
+    public class ContentManagerTests
+    {
+        [Category("Story 1")]
+        [TestCase("text", 0)]
+        [TestCase("The weather in Manchester in winter is bad. It rains all the time - it must be horrible for people visiting.", 2)]
+        public void ScanText_Test(string text, int numberOfNegativeWords)
+        {
+            var ta = new TextAnalyser(new List<string>() {"swine", "bad", "nasty", "horrible"});
+            var cm = new ContentManager(ta, text);
+
+            string expected = String.Format("Scanned the text:{0}{1}{0}Total Number of negative words: {2}",
+                Environment.NewLine, text, numberOfNegativeWords);
+            string returned = cm.ScanText();
+
+            Assert.AreEqual(expected, returned);
+        }
+
+        [Category("Story 2")]
+        [TestCase("text people", 0, 1)]
+        [TestCase("The weather in Manchester in winter is bad. It rains all the time - it must be horrible for people visiting.", 2, 3)]
+        public void ScanText_Test(string text, int originalNumberOfNegativeWords, int newNumberOfNegativeWords)
+        {
+            var ta = new TextAnalyser(new List<string>() { "swine", "bad", "nasty", "horrible" });
+            var cm = new ContentManager(ta, text);
+
+            string expected = String.Format("Scanned the text:{0}{1}{0}Total Number of negative words: {2}",
+                Environment.NewLine, text, originalNumberOfNegativeWords);
+            string returned = cm.ScanText();
+            Assert.AreEqual(expected, returned);
+
+            //administrator doesn't like people and adds the word to the negative list
+            cm.TextAnalyser.AddBadWord("people");
+
+            expected = String.Format("Scanned the text:{0}{1}{0}Total Number of negative words: {2}",
+                Environment.NewLine, text, newNumberOfNegativeWords);
+            returned = cm.ScanText();
+            Assert.AreEqual(expected, returned);
+        }
+
+        [Category("Story 3")]
+        [TestCase("Horrible", "H######e")]
+        [TestCase("The weather in Manchester in winter is bad. It rains all the time - it must be horrible for people visiting.",
+                  "The weather in Manchester in winter is b#d. It rains all the time - it must be h######e for people visiting.")]
+        public void ReadText_Returns_Filtered_Text(string text, string expectedFilteredText)
+        {
+            var ta = new TextAnalyser(new List<string>() { "swine", "bad", "nasty", "horrible" });
+            var cm = new ContentManager(ta, text);
+
+            string actualFilteredText = cm.ReadText();
+            Assert.AreEqual(expectedFilteredText, actualFilteredText);
+        }
+
+        [Category("Story 4")]
+        [TestCase("Horrible", "Horrible")]
+        [TestCase("The weather in Manchester in winter is bad. It rains all the time - it must be horrible for people visiting.",
+                  "The weather in Manchester in winter is bad. It rains all the time - it must be horrible for people visiting.")]
+        public void ReadText_Returns_Unfiltered_Text_When_Parameter_Is_Passed(string text, string expectedFilteredText)
+        {
+            var ta = new TextAnalyser(new List<string>() { "swine", "bad", "nasty", "horrible" });
+            var cm = new ContentManager(ta, text);
+
+            string actualFilteredText = cm.ReadText(filter:false);
+            Assert.AreEqual(expectedFilteredText, actualFilteredText);
+        }
+    }
+
+
+}
diff --git a/ContentConsole.Test.Unit/TextAnalyserTests.cs b/ContentConsole.Test.Unit/TextAnalyserTests.cs
new file mode 100644
index 0000000..0aaa5d8
--- /dev/null
+++ b/ContentConsole.Test.Unit/TextAnalyserTests.cs
@@ -0,0 +1,83 @@
+using System;
+using System.Collections;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+using NUnit.Framework;
+
+namespace ContentConsole.Test.Unit
+{
+    [TestFixture]
+    public class TextAnalyserTests
+    {
+        [TestCase("This contains one bad word", 1)]
+        [TestCase("This contains one Bad word", 1)]
+        [TestCase("This contains one Bad. word", 1)]
+        public void Analyse_Given_Text_With_One_Bad_Word_Returns_One(string text, int badWordsExpected)
+        {
+            var badWords = new List<String>() {"bad"};
+            var textAnalyser = new TextAnalyser(badWords);
+            var badWordsFound = textAnalyser.Analyse(text);
+
+            Assert.AreEqual(badWordsExpected, badWordsFound);
+        }
+
+        [TestCase("This contains zero superbad words", 0)]
+        public void Analyse_Given_Bad_Word_As_Substring_Of_Good_Word_Returns_Zero(string text, int badWordsExpected)
+        {
+            var badWords = new List<String>() { "bad" };
+            var textAnalyser = new TextAnalyser(badWords);
+            var badWordsFound = textAnalyser.Analyse(text);
+
+            Assert.AreEqual(badWordsExpected, badWordsFound);
+        }
+
+        [TestCase("bad", 1)]
+        [TestCase("Bad", 1)]
+        public void AddBadWord_Given_Existing_Word_Does_Nothing(string badWord, int expectedBadWordsCount)
+        {
+            var badWords = new List<String>() { "bad" };
+            var textAnalyser = new TextAnalyser(badWords);
+            textAnalyser.AddBadWord(badWord);
+            var badWordsCount = textAnalyser.CountBadWords();
+
+            Assert.AreEqual(expectedBadWordsCount, badWordsCount);
+        }
+
+        [TestCase("worse", 1)]
+        public void RemoveBadWord_Given_Unknown_Word_Does_Nothing(string badWord, int expectedBadWordsCount)
+        {
+            var badWords = new List<String>() { "bad" };
+            var textAnalyser = new TextAnalyser(badWords);
+            textAnalyser.RemoveBadWord(badWord);
+            var badWordsCount = textAnalyser.CountBadWords();
+
+            Assert.AreEqual(expectedBadWordsCount, badWordsCount);
+        }
+
+        [TestCase("bad", 0)]
+        [TestCase("Bad", 0)]
+        public void RemoveBadWord_Given_Existing_Word_Removes_It(string badWord, int expectedBadWordsCount)
+        {
+            var badWords = new List<String>() { "bad" };
+            var textAnalyser = new TextAnalyser(badWords);
+            textAnalyser.RemoveBadWord(badWord);
+            var badWordsCount = textAnalyser.CountBadWords();
+
+            Assert.AreEqual(expectedBadWordsCount, badWordsCount);
+        }
+
+        [TestCase("bad", "b#d")]
+        [TestCase("Bad", "B#d")]
+        [TestCase("Horrible", "H######e")]
+        public void Filter_Given_Existing_Word_Returns_Filtered_Version(string badWord, string expectedFilteredBadWord)
+        {
+            var badWords = new List<String>() { "bad", "horrible" };
+            var textAnalyser = new TextAnalyser(badWords);
+            var actualFilteredBadWord = textAnalyser.Filter(badWord);
+
+            Assert.AreEqual(expectedFilteredBadWord, actualFilteredBadWord);
+        }
+    }
+}
diff --git a/ContentConsole/ContentConsole.csproj b/ContentConsole/ContentConsole.csproj
index 113bcb7..cc32c6c 100644
--- a/ContentConsole/ContentConsole.csproj
+++ b/ContentConsole/ContentConsole.csproj
@@ -42,6 +42,8 @@
     <Reference Include="System.Xml" />
   </ItemGroup>
   <ItemGroup>
+    <Compile Include="ContentManager.cs" />
+    <Compile Include="TextAnalyser.cs" />
     <Compile Include="Program.cs" />
     <Compile Include="Properties\AssemblyInfo.cs" />
   </ItemGroup>
diff --git a/ContentConsole/ContentManager.cs b/ContentConsole/ContentManager.cs
new file mode 100644
index 0000000..8b3a3d9
--- /dev/null
+++ b/ContentConsole/ContentManager.cs
@@ -0,0 +1,35 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+
+namespace ContentConsole
+{
+    public class ContentManager
+    {
+        public readonly TextAnalyser TextAnalyser;
+        private readonly String text;
+
+        public ContentManager(TextAnalyser textAnalyser, string text)
+        {
+            this.TextAnalyser = textAnalyser;
+            this.text = text;
+        }
+
+        public string ScanText()
+        {
+            int numberOfNegativeWords = TextAnalyser.Analyse(text);
+            return String.Format("Scanned the text:{0}{1}{0}Total Number of negative words: {2}",
+                Environment.NewLine, text, numberOfNegativeWords);
+        }
+
+        public string ReadText(bool filter = true)
+        {
+            if (filter)
+                return TextAnalyser.Filter(text);
+            else
+                return text;
+        }
+    }
+}
diff --git a/ContentConsole/Program.cs b/ContentConsole/Program.cs
index af4df25..8705d2b 100644
--- a/ContentConsole/Program.cs
+++ b/ContentConsole/Program.cs
@@ -1,4 +1,5 @@
 using System;
+using System.Collections.Generic;
 
 namespace ContentConsole
 {
@@ -6,39 +7,51 @@ public static class Program
     {
         public static void Main(string[] args)
         {
-            string bannedWord1 = "swine";
-            string bannedWord2 = "bad";
-            string bannedWord3 = "nasty";
-            string bannedWord4 = "horrible";
-
-            string content =
-                "The weather in Manchester in winter is bad. It rains all the time - it must be horrible for people visiting.";
-
-            int badWords = 0;
-            if (content.Contains(bannedWord1))
-            {
-                badWords = badWords + 1;
-            }
-            if (content.Contains(bannedWord2))
-            {
-                badWords = badWords + 1;
-            }
-            if (content.Contains(bannedWord3))
-            {
-                badWords = badWords + 1;
-            }
-            if (content.Contains(bannedWord4))
-            {
-                badWords = badWords + 1;
-            }
-
-            Console.WriteLine("Scanned the text:");
-            Console.WriteLine(content);
-            Console.WriteLine("Total Number of negative words: " + badWords);
+            List<string> badWords = new List<string>() {"swine", "bad", "nasty", "horrible"};
+            string content = "The weather in Manchester in winter is bad. It rains all the time - it must be horrible for people visiting.";
+
+            var textAnalyser = new TextAnalyser(badWords);
+            var contentManager = new ContentManager(textAnalyser, content);
+
+            //Story 1
+            Console.WriteLine("User can scan text");
+            Console.WriteLine(contentManager.ScanText());
+
+            Console.WriteLine();
+
+            //Story 2
+            Console.WriteLine("Administrator doesn't like 'people' and adds them to the bad words list");
+            contentManager.TextAnalyser.AddBadWord("people");
+            Console.WriteLine(contentManager.ScanText());
+
+            Console.WriteLine();
+
+            //Story 3
+            Console.WriteLine("When reading, readers should see the filtered bad words instead of the actual ones");
+            Console.WriteLine(contentManager.ReadText());
+
+            Console.WriteLine();
+            Console.WriteLine("Readers convinced the administrator that 'people' are not that bad so he removed them from the list");
+            contentManager.TextAnalyser.RemoveBadWord("people");
+
+            Console.WriteLine();
+
+            Console.WriteLine("Now readers should see the word 'people' not filtered");
+            Console.WriteLine(contentManager.ReadText());
+
+            Console.WriteLine();
+
+            //Story 4
+            Console.WriteLine("Content Curators wish to see the original text");
+            Console.WriteLine(contentManager.ReadText(filter:false));
+
+            Console.WriteLine();
 
             Console.WriteLine("Press ANY key to exit.");
             Console.ReadKey();
         }
+
+
     }
 
 }
diff --git a/ContentConsole/TextAnalyser.cs b/ContentConsole/TextAnalyser.cs
new file mode 100644
index 0000000..100ba06
--- /dev/null
+++ b/ContentConsole/TextAnalyser.cs
@@ -0,0 +1,89 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+
+namespace ContentConsole
+{
+    public class TextAnalyser
+    {
+        /// <summary>
+        /// A collection of case insensitive unique bad words
+        /// </summary>
+        private readonly IList<string> badWords;
+
+        public TextAnalyser(IList<string> badWords)
+        {
+            this.badWords = badWords;
+        }
+
+        public int Analyse(string text)
+        {
+            //TODO: this works for the given string but it would fail with other cases, regular expressions could be used instead.
+            char[] splitCharacters = new[] { ' ', '.' };
+            string[] words = text.Split(splitCharacters);
+
+            int count = 0;
+            foreach(var word in words)
+            {
+                if(badWords.Contains(word, StringComparer.InvariantCultureIgnoreCase))
+                    count++;
+            }
+
+            return count;
+        }
+
+        public string Filter(string text)
+        {
+            var filteredPhrase = new StringBuilder(text);
+            var comparison = StringComparison.InvariantCultureIgnoreCase;
+
+            foreach(string badword in badWords)
+            {
+                int index = text.IndexOf(badword, comparison);
+                if(index != -1)
+                {
+                    for(int i = index + 1; i < index + badword.Length - 1; i++)
+                    {
+                        filteredPhrase[i] = '#';
+                    }
+                }
+            }
+            return filteredPhrase.ToString();
+        }
+
+        public void AddBadWord(string word)
+        {
+            if (badWords.Contains(word, StringComparer.InvariantCultureIgnoreCase))
+                return;
+
+            badWords.Add(word);
+        }
+
+        public void RemoveBadWord(string word)
+        {
+            int index;
+            bool foundOne = false;
+            for (index = 0; index < badWords.Count; index++)
+            {
+                if (0 == String.Compare(badWords[index], word, StringComparison.InvariantCultureIgnoreCase))
+                {
+                    foundOne = true;
+                    break;
+                }
+            }
+
+            //there is only one to be found given that all IList<string> badWords elements are unique
+            if (foundOne)
+            {
+                badWords.RemoveAt(index);
+            }
+        }
+
+        public int CountBadWords()
+        {
+            return badWords.Count;
+        }
+    }
+}