Search engine bug fix and unit tests

* add unit tests for search engine

ApplicationServices/UNTESTED/SearchEngineCommands.cs

@@ -1,4 +1,5 @@
-using System.IO;
+using System;
+using System.IO;
 using DataLayer;
 using LibationSearchEngine;
 
@@ -12,31 +13,43 @@ namespace ApplicationServices
 			engine.CreateNewIndex();
 		}
 
-		public static SearchResultSet Search(string searchString)
+		public static SearchResultSet Search(string searchString) => performSearchEngineFunc_safe(e =>
+			e.Search(searchString)
+		);
+
+		public static void UpdateBookTags(Book book) => performSearchEngineAction_safe(e =>
+			e.UpdateTags(book.AudibleProductId, book.UserDefinedItem.Tags)
+		);
+
+		public static void UpdateIsLiberated(Book book) => performSearchEngineAction_safe(e =>
+			e.UpdateIsLiberated(book.AudibleProductId)
+		);
+
+		private static void performSearchEngineAction_safe(Action<SearchEngine> action)
 		{
 			var engine = new SearchEngine(DbContexts.GetContext());
 			try
 			{
-				return engine.Search(searchString);
+				action(engine);
 			}
 			catch (FileNotFoundException)
 			{
 				FullReIndex();
-				return engine.Search(searchString);
+				action(engine);
 			}
 		}
 
-		public static void UpdateBookTags(Book book)
+		private static T performSearchEngineFunc_safe<T>(Func<SearchEngine, T> action)
 		{
 			var engine = new SearchEngine(DbContexts.GetContext());
 			try
 			{
-				engine.UpdateTags(book.AudibleProductId, book.UserDefinedItem.Tags);
+				return action(engine);
 			}
 			catch (FileNotFoundException)
 			{
 				FullReIndex();
-				engine.UpdateTags(book.AudibleProductId, book.UserDefinedItem.Tags);
+				return action(engine);
 			}
 		}
 	}

Libation.sln

@@ -86,6 +86,8 @@ Project("{2150E333-8FDC-42A3-9474-1A3956D46DE8}") = "0 Libation Tests", "0 Libat
 EndProject
 Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "InternalUtilities.Tests", "_Tests\InternalUtilities.Tests\InternalUtilities.Tests.csproj", "{8447C956-B03E-4F59-9DD4-877793B849D9}"
 EndProject
+Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "LibationSearchEngine.Tests", "_Tests\LibationSearchEngine.Tests\LibationSearchEngine.Tests.csproj", "{C5B21768-C7C9-4FCB-AC1E-187B223D5A98}"
+EndProject
 Global
 	GlobalSection(SolutionConfigurationPlatforms) = preSolution
 		Debug|Any CPU = Debug|Any CPU
@@ -208,6 +210,10 @@ Global
 		{8447C956-B03E-4F59-9DD4-877793B849D9}.Debug|Any CPU.Build.0 = Debug|Any CPU
 		{8447C956-B03E-4F59-9DD4-877793B849D9}.Release|Any CPU.ActiveCfg = Release|Any CPU
 		{8447C956-B03E-4F59-9DD4-877793B849D9}.Release|Any CPU.Build.0 = Release|Any CPU
+		{C5B21768-C7C9-4FCB-AC1E-187B223D5A98}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
+		{C5B21768-C7C9-4FCB-AC1E-187B223D5A98}.Debug|Any CPU.Build.0 = Debug|Any CPU
+		{C5B21768-C7C9-4FCB-AC1E-187B223D5A98}.Release|Any CPU.ActiveCfg = Release|Any CPU
+		{C5B21768-C7C9-4FCB-AC1E-187B223D5A98}.Release|Any CPU.Build.0 = Release|Any CPU
 	EndGlobalSection
 	GlobalSection(SolutionProperties) = preSolution
 		HideSolutionNode = FALSE
@@ -242,6 +248,7 @@ Global
 		{E7EFD64D-6630-4426-B09C-B6862A92E3FD} = {F0CBB7A7-D3FB-41FF-8F47-CF3F6A592249}
 		{F3B04A3A-20C8-4582-A54A-715AF6A5D859} = {8679CAC8-9164-4007-BDD2-F004810EDA14}
 		{8447C956-B03E-4F59-9DD4-877793B849D9} = {67E66E82-5532-4440-AFB3-9FB1DF9DEF53}
+		{C5B21768-C7C9-4FCB-AC1E-187B223D5A98} = {67E66E82-5532-4440-AFB3-9FB1DF9DEF53}
 	EndGlobalSection
 	GlobalSection(ExtensibilityGlobals) = postSolution
 		SolutionGuid = {615E00ED-BAEF-4E8E-A92A-9B82D87942A9}

LibationLauncher/LibationLauncher.csproj

@@ -13,7 +13,7 @@
     <!-- <PublishSingleFile>true</PublishSingleFile> -->
     <RuntimeIdentifier>win-x64</RuntimeIdentifier>
 
-    <Version>4.1.8.1</Version>
+    <Version>4.2.3.1</Version>
   </PropertyGroup>
 
   <ItemGroup>

LibationSearchEngine/UNTESTED/LuceneRegex.cs

@@ -42,5 +42,58 @@ namespace LibationSearchEngine
         //   positive look behind: beginning  space  {  [  :
         //   positive look ahead: end  space  ]  }
         public static Regex NumbersRegex { get; } = new Regex(@"(?<=^|\s|\{|\[|:)(\d+\.?\d*)(?=$|\s|\]|\})", RegexOptions.Compiled);
+
+        /// <summary>
+        /// proper bools are single keywords which are turned into keyword:True
+        /// if bordered by colons or inside brackets, they are not stand-alone bool keywords
+        /// the negative lookbehind and lookahead patterns prevent bugs where a bool keyword is also a user-defined tag:
+        ///   [israted]
+        ///     parseTag => tags:israted
+        ///     replaceBools => tags:israted:True
+        ///   or
+        ///     [israted]
+        ///       replaceBools => israted:True
+        ///         parseTag => [israted:True]
+        /// also don't want to apply :True where the value already exists:
+        ///   israted:false => israted:false:True
+        ///   
+        /// despite using parans, lookahead and lookbehind are zero-length assertions which do not capture. therefore the bool search keyword is still $1 since it's the first and only capture
+        /// </summary>
+        private static string boolPattern_parameterized { get; }
+            = @"
+### IMPORTANT: 'ignore whitespace' is only partially honored in character sets
+### - new lines are ok
+### - ANY leading whitespace is treated like actual matching spaces  :(
+
+                    ### can't begin with colon. incorrect syntax
+                    ### can't begin with open bracket: this signals the start of a tag
+(?<!                # begin negative lookbehind
+  [:\[]             #   char set: colon and open bracket, escaped
+  \s*               #   optional space
+)                   # end negative lookbehind
+
+\b                  # word boundary
+  ({0})             #   captured bool search keyword. this is the $1 reference used in regex.Replace
+\b                  # word boundary
+
+                    ### can't end with colon. this signals that the bool's value already exists
+                    ### can't begin with close bracket: this signals the end of a tag
+(?!                 # begin negative lookahead
+  \s*               #   optional space
+  [:\]]             #   char set: colon and close bracket, escaped
+)                   # end negative lookahead
+";
+        private static Dictionary<string, Regex> boolRegexDic { get; } = new Dictionary<string, Regex>();
+        public static Regex GetBoolRegex(string boolSearch)
+        {
+            if (boolRegexDic.TryGetValue(boolSearch, out var regex))
+                return regex;
+
+            var boolPattern = string.Format(boolPattern_parameterized, boolSearch);
+            regex = new Regex(boolPattern, RegexOptions.IgnorePatternWhitespace | RegexOptions.IgnoreCase | RegexOptions.Compiled);
+            boolRegexDic.Add(boolSearch, regex);
+
+            return regex;
+        }
     }
 }

LibationSearchEngine/UNTESTED/SearchEngine.cs

@@ -26,9 +26,16 @@ namespace LibationSearchEngine
 
         public const string _ID_ = "_ID_";
         public const string TAGS = "tags";
+        // special field for each book which includes all major parts of the book's metadata. enables non-targetting searching
         public const string ALL = "all";
 
-        private static ReadOnlyDictionary<string, Func<LibraryBook, string>> idIndexRules { get; }
+        // the workaround which allows displaying all books when query is empty
+        public const string ALL_QUERY = "*:*";
+
+        public SearchEngine(LibationContext context) => this.context = context;
+
+		#region index rules
+		private static ReadOnlyDictionary<string, Func<LibraryBook, string>> idIndexRules { get; }
             = new ReadOnlyDictionary<string, Func<LibraryBook, string>>(
                 new Dictionary<string, Func<LibraryBook, string>>
                 {
@@ -38,6 +45,7 @@ namespace LibationSearchEngine
                     ["ASIN"] = lb => lb.Book.AudibleProductId
                 }
                 );
+
         private static ReadOnlyDictionary<string, Func<LibraryBook, string>> stringIndexRules { get; }
             = new ReadOnlyDictionary<string, Func<LibraryBook, string>>(
                 new Dictionary<string, Func<LibraryBook, string>>
@@ -98,6 +106,7 @@ namespace LibationSearchEngine
                     ["MyRating"] = lb => lb.Book.UserDefinedItem.Rating.OverallRating.ToLuceneString()
                 }
                 );
+
         private static ReadOnlyDictionary<string, Func<LibraryBook, bool>> boolIndexRules { get; }
             = new ReadOnlyDictionary<string, Func<LibraryBook, bool>>(
                 new Dictionary<string, Func<LibraryBook, bool>>
@@ -114,12 +123,17 @@ namespace LibationSearchEngine
                     ["IsRated"] = lb => lb.Book.UserDefinedItem.Rating.OverallRating > 0f,
                     ["Rated"] = lb => lb.Book.UserDefinedItem.Rating.OverallRating > 0f,
 
-                    ["IsAuthorNarrated"] = lb => isAuthorNarrated(lb),
-                    ["AuthorNarrated"] = lb => isAuthorNarrated(lb),
+                    ["IsAuthorNarrated"] = isAuthorNarrated,
+                    ["AuthorNarrated"] = isAuthorNarrated,
 
                     [nameof(Book.IsAbridged)] = lb => lb.Book.IsAbridged,
                     ["Abridged"] = lb => lb.Book.IsAbridged,
-                });
+
+                    // this will only be evaluated at time of re-index. ie: state of files moved later will be out of sync until next re-index
+                    ["IsLiberated"] = lb => isLiberated(lb.Book.AudibleProductId),
+                    ["Liberated"] = lb => isLiberated(lb.Book.AudibleProductId),
+                }
+                );
 
         private static bool isAuthorNarrated(LibraryBook lb)
         {
@@ -128,6 +142,8 @@ namespace LibationSearchEngine
             return authors.Intersect(narrators).Any();
         }
 
+        private static bool isLiberated(string id) => AudibleFileStorage.Audio.Exists(id);
+
         // use these common fields in the "all" default search field
         private static IEnumerable<Func<LibraryBook, string>> allFieldIndexRules { get; }
             = new List<Func<LibraryBook, string>>
@@ -137,8 +153,10 @@ namespace LibationSearchEngine
                 stringIndexRules[nameof(Book.AuthorNames)],
                 stringIndexRules[nameof(Book.NarratorNames)]
             };
+		#endregion
 
-        public static IEnumerable<string> GetSearchIdFields()
+		#region get search fields. used for display in help
+		public static IEnumerable<string> GetSearchIdFields()
         {
             foreach (var key in idIndexRules.Keys)
                 yield return key;
@@ -173,11 +191,13 @@ namespace LibationSearchEngine
             foreach (var key in numberIndexRules.Keys)
                 yield return key;
         }
+		#endregion
 
-        private Directory getIndex() => FSDirectory.Open(SearchEngineDirectory);
-
-        public SearchEngine(LibationContext context) => this.context = context;
-
+		#region create and update index
+        /// <summary>
+        /// create new. ie: full re-index
+        /// </summary>
+        /// <param name="overwrite"></param>
         public void CreateNewIndex(bool overwrite = true)
         {
             // 300 products
@@ -211,6 +231,22 @@ namespace LibationSearchEngine
             log();
         }
 
+		/// <summary>Long running. Use await Task.Run(() => UpdateBook(productId))</summary>
+		public void UpdateBook(string productId)
+        {
+            var libraryBook = context.GetLibraryBook_Flat_NoTracking(productId);
+            var term = new Term(_ID_, productId);
+
+            var document = createBookIndexDocument(libraryBook);
+            var createNewIndex = false;
+
+			using var index = getIndex();
+			using var analyzer = new StandardAnalyzer(Version);
+			using var ixWriter = new IndexWriter(index, analyzer, createNewIndex, IndexWriter.MaxFieldLength.UNLIMITED);
+			ixWriter.DeleteDocuments(term);
+			ixWriter.AddDocument(document);
+		}
+
         private static Document createBookIndexDocument(LibraryBook libraryBook)
         {
             var doc = new Document();
@@ -248,77 +284,100 @@ namespace LibationSearchEngine
             return doc;
         }
 
-		/// <summary>Long running. Use await Task.Run(() => UpdateBook(productId))</summary>
-		public void UpdateBook(string productId)
-        {
-            var libraryBook = context.GetLibraryBook_Flat_NoTracking(productId);
-            var term = new Term(_ID_, productId);
+        // update single document entry
+        // all fields, including 'tags' are case-specific
+        public void UpdateTags(string productId, string tags) => updateAnalyzedField(productId, TAGS, tags);
 
-            var document = createBookIndexDocument(libraryBook);
-            var createNewIndex = false;
+        // all fields are case-specific
+        private static void updateAnalyzedField(string productId, string fieldName, string newValue)
+            => updateDocument(
+                productId,
+                d =>
+                {
+                    // fields are key value pairs. MULTIPLE FIELDS CAN POTENTIALLY HAVE THE SAME KEY.
+                    // ie: must remove old before adding new else will create unwanted duplicates.
+                    d.RemoveField(fieldName);
+                    d.AddAnalyzed(fieldName, newValue);
+                });
 
-			using var index = getIndex();
-			using var analyzer = new StandardAnalyzer(Version);
-			using var ixWriter = new IndexWriter(index, analyzer, createNewIndex, IndexWriter.MaxFieldLength.UNLIMITED);
-			ixWriter.DeleteDocuments(term);
-			ixWriter.AddDocument(document);
-		}
+        // update single document entry
+        public void UpdateIsLiberated(string productId)
+            => updateDocument(
+                productId,
+                d =>
+                {
+                    // fields are key value pairs. MULTIPLE FIELDS CAN POTENTIALLY HAVE THE SAME KEY.
+                    // ie: must remove old before adding new else will create unwanted duplicates.
+                    var v = isLiberated(productId);
+                    d.RemoveField("IsLiberated");
+                    d.AddBool("IsLiberated", v);
+                    d.RemoveField("Liberated");
+                    d.AddBool("Liberated", v);
+                });
 
-        public void UpdateTags(string productId, string tags)
+        private static void updateDocument(string productId, Action<Document> action)
         {
             var productTerm = new Term(_ID_, productId);
 
-			using var index = getIndex();
+            using var index = getIndex();
 
-			// get existing document
-			using var searcher = new IndexSearcher(index);
-			var query = new TermQuery(productTerm);
-			var docs = searcher.Search(query, 1);
-			var scoreDoc = docs.ScoreDocs.SingleOrDefault();
-			if (scoreDoc == null)
-				throw new Exception("document not found");
-			var document = searcher.Doc(scoreDoc.Doc);
+            // get existing document
+            using var searcher = new IndexSearcher(index);
+            var query = new TermQuery(productTerm);
+            var docs = searcher.Search(query, 1);
+            var scoreDoc = docs.ScoreDocs.SingleOrDefault();
+            if (scoreDoc == null)
+                throw new Exception("document not found");
+            var document = searcher.Doc(scoreDoc.Doc);
 
 
-			// update document entry with new tags
-			// fields are key value pairs and MULTIPLE FIELDS CAN HAVE THE SAME KEY. must remove old before adding new
-			// REMEMBER: all fields, including 'tags' are case-specific
-			document.RemoveField(TAGS);
-			document.AddAnalyzed(TAGS, tags);
+            // perform update
+            action(document);
 
-			// update index
-			var createNewIndex = false;
-			using var analyzer = new StandardAnalyzer(Version);
-			using var ixWriter = new IndexWriter(index, analyzer, createNewIndex, IndexWriter.MaxFieldLength.UNLIMITED);
-			ixWriter.UpdateDocument(productTerm, document, analyzer);
-		}
 
+            // update index
+            var createNewIndex = false;
+            using var analyzer = new StandardAnalyzer(Version);
+            using var ixWriter = new IndexWriter(index, analyzer, createNewIndex, IndexWriter.MaxFieldLength.UNLIMITED);
+            ixWriter.UpdateDocument(productTerm, document, analyzer);
+        }
+		#endregion
+
+		#region search
         public SearchResultSet Search(string searchString)
         {
-            if (string.IsNullOrWhiteSpace(searchString))
-                searchString = "*:*";
+            Serilog.Log.Logger.Debug("original search string: {@DebugInfo}", new { searchString });
+            searchString = FormatSearchQuery(searchString);
+            Serilog.Log.Logger.Debug("formatted search string: {@DebugInfo}", new { searchString });
 
-            #region apply formatting
-            searchString = parseTag(searchString);
+            var results = generalSearch(searchString);
+            Serilog.Log.Logger.Debug("Hit(s): {@DebugInfo}", new { count = results.Docs.Count() });
+            displayResults(results);
+
+            return results;
+        }
+
+        public static string FormatSearchQuery(string searchString)
+        {
+            if (string.IsNullOrWhiteSpace(searchString))
+                return ALL_QUERY;
 
             searchString = replaceBools(searchString);
 
+            searchString = parseTag(searchString);
+
             // in ranges " TO " must be uppercase
             searchString = searchString.Replace(" to ", " TO ");
 
             searchString = padNumbers(searchString);
 
             searchString = lowerFieldNames(searchString);
-            #endregion
 
-            var results = generalSearch(searchString);
-
-            displayResults(results);
-
-            return results;
+            return searchString;
         }
 
-        private static string parseTag(string tagSearchString)
+		#region format query string
+		private static string parseTag(string tagSearchString)
         {
             var allMatches = LuceneRegex
                 .TagRegex
@@ -337,9 +396,10 @@ namespace LibationSearchEngine
 
         private static string replaceBools(string searchString)
         {
-            // negative look-ahead for optional spaces then colon. don't want to double-up. eg:"israted:false" => "israted:false:True"
             foreach (var boolSearch in boolIndexRules.Keys)
-                searchString = Regex.Replace(searchString, $@"\b({boolSearch})\b(?!\s*:)", @"$1:True", RegexOptions.IgnoreCase);
+                searchString =
+                    LuceneRegex.GetBoolRegex(boolSearch)
+                    .Replace(searchString, @"$1:True");
 
             return searchString;
         }
@@ -376,13 +436,10 @@ namespace LibationSearchEngine
 
             return searchString;
         }
-
-        public int MaxSearchResultsToReturn { get; set; } = 999;
+        #endregion
 
         private SearchResultSet generalSearch(string searchString)
         {
-            Console.WriteLine($"searchString: {searchString}");
-
             var defaultField = ALL;
 
 			using var index = getIndex();
@@ -403,14 +460,14 @@ namespace LibationSearchEngine
 					boolQuery.Add(new MatchAllDocsQuery(), Occur.MUST);
 			}
 
-			Console.WriteLine($"  query: {query}");
-
 			var docs = searcher
-				.Search(query, MaxSearchResultsToReturn)
+				.Search(query, searcher.MaxDoc + 1)
 				.ScoreDocs
 				.Select(ds => new ScoreDocExplicit(searcher.Doc(ds.Doc), ds.Score))
 				.ToList();
-			return new SearchResultSet(query.ToString(), docs);
+            var queryString = query.ToString();
+            Serilog.Log.Logger.Debug("query: {@DebugInfo}", new { queryString });
+			return new SearchResultSet(queryString, docs);
 		}
 
         private IEnumerable<Occur> getOccurs_recurs(BooleanQuery query)
@@ -430,7 +487,6 @@ namespace LibationSearchEngine
 
         private void displayResults(SearchResultSet docs)
         {
-            Console.WriteLine($"Hit(s): {docs.Docs.Count()}");
             //for (int i = 0; i < docs.Docs.Count(); i++)
             //{
             //    var sde = docs.Docs.First();
@@ -438,13 +494,14 @@ namespace LibationSearchEngine
             //    Document doc = sde.Doc;
             //    float score = sde.Score;
 
-            //    Console.WriteLine($"{(i + 1)}) score={score}. Fields:");
+            //    Serilog.Log.Logger.Debug($"{(i + 1)}) score={score}. Fields:");
             //    var allFields = doc.GetFields();
             //    foreach (var f in allFields)
-            //        Console.WriteLine($"   [{f.Name}]={f.StringValue}");
+            //        Serilog.Log.Logger.Debug($"   [{f.Name}]={f.StringValue}");
             //}
-
-            //Console.WriteLine();
         }
+		#endregion
+
+		private static Directory getIndex() => FSDirectory.Open(SearchEngineDirectory);
     }
 }

LibationWinForms/UNTESTED/BookLiberation/ProcessorAutomationController.cs

@@ -74,6 +74,16 @@ namespace LibationWinForms.BookLiberation
             backupBook.DecryptBook.Begin += (_, __) => wireUpEvents(backupBook.DecryptBook);
             backupBook.DownloadPdf.Begin += (_, __) => wireUpEvents(backupBook.DownloadPdf);
 
+            // must occur before completedAction. A common use case is:
+            // - filter by -liberated
+            // - liberate only that book
+            //   completedAction is to refresh grid
+            // - want to see that book disappear from grid
+            // also for this to work, updateIsLiberated can NOT be async
+            backupBook.DownloadBook.Completed += updateIsLiberated;
+            backupBook.DecryptBook.Completed += updateIsLiberated;
+            backupBook.DownloadPdf.Completed += updateIsLiberated;
+
             if (completedAction != null)
             {
                 backupBook.DownloadBook.Completed += completedAction;
@@ -84,6 +94,8 @@ namespace LibationWinForms.BookLiberation
             return backupBook;
         }
 
+        private static void updateIsLiberated(object sender, LibraryBook e) => ApplicationServices.SearchEngineCommands.UpdateIsLiberated(e.Book);
+
         private static (AutomatedBackupsForm, LogMe) attachToBackupsForm(BackupBook backupBook)
         {
             #region create form and logger

LibationWinForms/UNTESTED/ProductsGrid.cs

@@ -201,6 +201,9 @@ namespace LibationWinForms
             // update cells incl Liberate button text
             dataGridView.InvalidateRow(rowId);
 
+            // needed in case filtering by -IsLiberated and it gets changed to Liberated. want to immediately show the change
+            filter();
+
             BackupCountsChanged?.Invoke(this, EventArgs.Empty);
         }
 
@@ -396,8 +399,6 @@ namespace LibationWinForms
             }
             currencyManager.ResumeBinding();
 			VisibleCountChanged?.Invoke(this, dataGridView.AsEnumerable().Count(r => r.Visible));
-
-			var luceneSearchString_debug = searchResults.SearchString;
         }
         #endregion
 

_Tests/LibationSearchEngine.Tests/LibationSearchEngine.Tests.csproj

@@ -0,0 +1,24 @@
+<Project Sdk="Microsoft.NET.Sdk">
+
+  <PropertyGroup>
+    <TargetFramework>net5.0</TargetFramework>
+
+    <IsPackable>false</IsPackable>
+  </PropertyGroup>
+
+  <ItemGroup>
+    <PackageReference Include="Microsoft.NET.Test.Sdk" Version="16.9.4" />
+    <PackageReference Include="MSTest.TestAdapter" Version="2.2.3" />
+    <PackageReference Include="MSTest.TestFramework" Version="2.2.3" />
+    <PackageReference Include="coverlet.collector" Version="3.0.3">
+      <PrivateAssets>all</PrivateAssets>
+      <IncludeAssets>runtime; build; native; contentfiles; analyzers; buildtransitive</IncludeAssets>
+    </PackageReference>
+  </ItemGroup>
+
+  <ItemGroup>
+    <ProjectReference Include="..\..\..\Dinah.Core\_Tests\TestCommon\TestCommon.csproj" />
+    <ProjectReference Include="..\..\LibationSearchEngine\LibationSearchEngine.csproj" />
+  </ItemGroup>
+
+</Project>

_Tests/LibationSearchEngine.Tests/SearchEngineTests.cs

@@ -0,0 +1,78 @@
+using System;
+using System.Collections.Generic;
+using System.IO;
+using System.Linq;
+using System.Net;
+using System.Net.Http;
+using System.Threading;
+using System.Threading.Tasks;
+using Dinah.Core;
+using FluentAssertions;
+using FluentAssertions.Common;
+using LibationSearchEngine;
+using Microsoft.VisualStudio.TestPlatform.Common.Filtering;
+using Microsoft.VisualStudio.TestTools.UnitTesting;
+using Moq;
+using Moq.Protected;
+using Newtonsoft.Json;
+using Newtonsoft.Json.Linq;
+using TestCommon;
+
+namespace SearchEngineTests
+{
+	[TestClass]
+	public class FormatSearchQuery
+	{
+		[TestMethod]
+		// null, empty, whitespace -- *:*
+		[DataRow(null, "*:*")]
+		[DataRow("", "*:*")]
+		[DataRow("   ", "*:*")]
+
+		// tag surrounded by spaces
+		[DataRow("[foo]", "tags:foo")]
+		[DataRow("  [foo]", "  tags:foo")]
+		[DataRow("[foo]  ", "tags:foo  ")]
+		[DataRow("  [foo]  ", "  tags:foo  ")]
+		[DataRow("-[foo]", "-tags:foo")]
+		[DataRow("  -[foo]", "  -tags:foo")]
+		[DataRow("-[foo]  ", "-tags:foo  ")]
+		[DataRow("  -[foo]  ", "  -tags:foo  ")]
+
+		// tag case irrelevant
+		[DataRow("[FoO]", "tags:FoO")]
+
+		// bool keyword surrounded by spaces
+		[DataRow("israted", "israted:True")]
+		[DataRow("  israted", "  israted:True")]
+		[DataRow("israted  ", "israted:True  ")]
+		[DataRow("  israted  ", "  israted:True  ")]
+		[DataRow("-israted", "-israted:True")]
+		[DataRow("  -israted", "  -israted:True")]
+		[DataRow("-israted  ", "-israted:True  ")]
+		[DataRow("  -israted  ", "  -israted:True  ")]
+
+		// bool keyword. Append :True
+		[DataRow("israted", "israted:True")]
+
+		// bool keyword with [:bool]. Do not add :True
+		[DataRow("israted:True", "israted:True")]
+		[DataRow("isRated:false", "israted:false")]
+
+		// tag which happens to be a bool keyword >> parse as tag
+		[DataRow("[israted]", "tags:israted")]
+
+		// numbers with "to". TO all caps, numbers [8.2] format
+		[DataRow("1 to 10", "00000001.00 TO 00000010.00")]
+		[DataRow("19990101 to 20001231", "19990101.00 TO 20001231.00")]
+
+		// field to lowercase
+		[DataRow("Author:Doyle", "author:Doyle")]
+		// bool field to lowercase
+		[DataRow("IsRated", "israted:True")]
+		[DataRow("-isRATED", "-israted:True")]
+
+		public void FormattingTest(string input, string output)
+			=> SearchEngine.FormatSearchQuery(input).Should().Be(output);
+	}
+}