Rearrange test files

2024-01-21 14:29:58 -05:00
parent 1345074c71
commit 3835ed984e
8 changed files with 8 additions and 8 deletions
--- a/src/MyWebLog.Tests/Data/CategoryDataTests.fs
+++ b/src/MyWebLog.Tests/Data/CategoryDataTests.fs
@@ -0,0 +1,15 @@
+module CategoryDataTests
+
+open Expecto
+open MyWebLog
+open MyWebLog.Data
+
+/// Tests for the Add method
+let addTests (data: IData) = task {
+    let category =
+        { Category.Empty with Id = CategoryId "added-cat"; WebLogId = WebLogId "test"; Name = "Added"; Slug = "added" }
+    do! data.Category.Add category 
+    let! stored = data.Category.FindById (CategoryId "added-cat") (WebLogId "test")
+    Expect.isSome stored "The category should have been added"
+}
+
--- a/src/MyWebLog.Tests/Data/ConvertersTests.fs
+++ b/src/MyWebLog.Tests/Data/ConvertersTests.fs
@@ -0,0 +1,296 @@
+module ConvertersTests
+
+open Expecto
+open Microsoft.FSharpLu.Json
+open MyWebLog
+open MyWebLog.Converters.Json
+open Newtonsoft.Json
+
+/// Unit tests for the CategoryIdConverter type
+let categoryIdConverterTests = testList "CategoryIdConverter" [
+    let opts = JsonSerializerSettings()
+    opts.Converters.Add(CategoryIdConverter())
+    test "succeeds when serializing" {
+        let after = JsonConvert.SerializeObject(CategoryId "test-cat-id", opts)
+        Expect.equal after "\"test-cat-id\"" "Category ID serialized incorrectly"
+    }
+    test "succeeds when deserializing" {
+        let after = JsonConvert.DeserializeObject<CategoryId>("\"test-cat-id\"", opts)
+        Expect.equal after (CategoryId "test-cat-id") "Category ID not serialized incorrectly"
+    }
+]
+
+/// Unit tests for the CommentIdConverter type
+let commentIdConverterTests = testList "CommentIdConverter" [
+    let opts = JsonSerializerSettings()
+    opts.Converters.Add(CommentIdConverter())
+    test "succeeds when serializing" {
+        let after = JsonConvert.SerializeObject(CommentId "test-id", opts)
+        Expect.equal after "\"test-id\"" "Comment ID serialized incorrectly"
+    }
+    test "succeeds when deserializing" {
+        let after = JsonConvert.DeserializeObject<CommentId>("\"my-test\"", opts)
+        Expect.equal after (CommentId "my-test") "Comment ID deserialized incorrectly"
+    }
+]
+
+/// Unit tests for the CommentStatusConverter type
+let commentStatusConverterTests = testList "CommentStatusConverter" [
+    let opts = JsonSerializerSettings()
+    opts.Converters.Add(CommentStatusConverter())
+    test "succeeds when serializing" {
+        let after = JsonConvert.SerializeObject(Approved, opts)
+        Expect.equal after "\"Approved\"" "Comment status serialized incorrectly"
+    }
+    test "succeeds when deserializing" {
+        let after = JsonConvert.DeserializeObject<CommentStatus>("\"Spam\"", opts)
+        Expect.equal after Spam "Comment status deserialized incorrectly"
+    }
+]
+
+/// Unit tests for the CustomFeedIdConverter type
+let customFeedIdConverterTests = testList "CustomFeedIdConverter" [
+    let opts = JsonSerializerSettings()
+    opts.Converters.Add(CustomFeedIdConverter())
+    test "succeeds when serializing" {
+        let after = JsonConvert.SerializeObject(CustomFeedId "my-feed", opts)
+        Expect.equal after "\"my-feed\"" "Custom feed ID serialized incorrectly"
+    }
+    test "succeeds when deserializing" {
+        let after = JsonConvert.DeserializeObject<CustomFeedId>("\"feed-me\"", opts)
+        Expect.equal after (CustomFeedId "feed-me") "Custom feed ID deserialized incorrectly"
+    }
+]
+
+/// Unit tests for the CustomFeedSourceConverter type
+let customFeedSourceConverterTests = testList "CustomFeedSourceConverter" [
+    let opts = JsonSerializerSettings()
+    opts.Converters.Add(CustomFeedSourceConverter())
+    test "succeeds when serializing" {
+        let after = JsonConvert.SerializeObject(Category (CategoryId "abc-123"), opts)
+        Expect.equal after "\"category:abc-123\"" "Custom feed source serialized incorrectly"
+    }
+    test "succeeds when deserializing" {
+        let after = JsonConvert.DeserializeObject<CustomFeedSource>("\"tag:testing\"", opts)
+        Expect.equal after (Tag "testing") "Custom feed source deserialized incorrectly"
+    }
+]
+
+/// Unit tests for the ExplicitRating type
+let explicitRatingConverterTests = testList "ExplicitRatingConverter" [
+    let opts = JsonSerializerSettings()
+    opts.Converters.Add(ExplicitRatingConverter())
+    test "succeeds when serializing" {
+        let after = JsonConvert.SerializeObject(Yes, opts)
+        Expect.equal after "\"yes\"" "Explicit rating serialized incorrectly"
+    }
+    test "succeeds when deserializing" {
+        let after = JsonConvert.DeserializeObject<ExplicitRating>("\"clean\"", opts)
+        Expect.equal after Clean "Explicit rating deserialized incorrectly"
+    }
+]
+
+/// Unit tests for the MarkupText type
+let markupTextConverterTests = testList "MarkupTextConverter" [
+    let opts = JsonSerializerSettings()
+    opts.Converters.Add(MarkupTextConverter())
+    test "succeeds when serializing" {
+        let after = JsonConvert.SerializeObject(Html "<h4>test</h4>", opts)
+        Expect.equal after "\"HTML: <h4>test</h4>\"" "Markup text serialized incorrectly"
+    }
+    test "succeeds when deserializing" {
+        let after = JsonConvert.DeserializeObject<MarkupText>("\"Markdown: #### test\"", opts)
+        Expect.equal after (Markdown "#### test") "Markup text deserialized incorrectly"
+    }
+]
+
+/// Unit tests for the PermalinkConverter type
+let permalinkConverterTests = testList "PermalinkConverter" [
+    let opts = JsonSerializerSettings()
+    opts.Converters.Add(PermalinkConverter())
+    test "succeeds when serializing" {
+        let after = JsonConvert.SerializeObject(Permalink "2022/test", opts)
+        Expect.equal after "\"2022/test\"" "Permalink serialized incorrectly"
+    }
+    test "succeeds when deserializing" {
+        let after = JsonConvert.DeserializeObject<Permalink>("\"2023/unit.html\"", opts)
+        Expect.equal after (Permalink "2023/unit.html") "Permalink deserialized incorrectly"
+    }
+]
+
+/// Unit tests for the PageIdConverter type
+let pageIdConverterTests = testList "PageIdConverter" [
+    let opts = JsonSerializerSettings()
+    opts.Converters.Add(PageIdConverter())
+    test "succeeds when serializing" {
+        let after = JsonConvert.SerializeObject(PageId "test-page", opts)
+        Expect.equal after "\"test-page\"" "Page ID serialized incorrectly"
+    }
+    test "succeeds when deserializing" {
+        let after = JsonConvert.DeserializeObject<PageId>("\"page-test\"", opts)
+        Expect.equal after (PageId "page-test") "Page ID deserialized incorrectly"
+    }
+]
+
+/// Unit tests for the PodcastMedium type
+let podcastMediumConverterTests = testList "PodcastMediumConverter" [
+    let opts = JsonSerializerSettings()
+    opts.Converters.Add(PodcastMediumConverter())
+    test "succeeds when serializing" {
+        let after = JsonConvert.SerializeObject(Audiobook, opts)
+        Expect.equal after "\"audiobook\"" "Podcast medium serialized incorrectly"
+    }
+    test "succeeds when deserializing" {
+        let after = JsonConvert.DeserializeObject<PodcastMedium>("\"newsletter\"", opts)
+        Expect.equal after Newsletter "Podcast medium deserialized incorrectly"
+    }
+]
+
+/// Unit tests for the PostIdConverter type
+let postIdConverterTests = testList "PostIdConverter" [
+    let opts = JsonSerializerSettings()
+    opts.Converters.Add(PostIdConverter())
+    test "succeeds when serializing" {
+        let after = JsonConvert.SerializeObject(PostId "test-post", opts)
+        Expect.equal after "\"test-post\"" "Post ID serialized incorrectly"
+    }
+    test "succeeds when deserializing" {
+        let after = JsonConvert.DeserializeObject<PostId>("\"post-test\"", opts)
+        Expect.equal after (PostId "post-test") "Post ID deserialized incorrectly"
+    }
+]
+
+/// Unit tests for the TagMapIdConverter type
+let tagMapIdConverterTests = testList "TagMapIdConverter" [
+    let opts = JsonSerializerSettings()
+    opts.Converters.Add(TagMapIdConverter())
+    test "succeeds when serializing" {
+        let after = JsonConvert.SerializeObject(TagMapId "test-map", opts)
+        Expect.equal after "\"test-map\"" "Tag map ID serialized incorrectly"
+    }
+    test "succeeds when deserializing" {
+        let after = JsonConvert.DeserializeObject<TagMapId>("\"map-test\"", opts)
+        Expect.equal after (TagMapId "map-test") "Tag map ID deserialized incorrectly"
+    }
+]
+
+/// Unit tests for the ThemeAssetIdConverter type
+let themeAssetIdConverterTests = testList "ThemeAssetIdConverter" [
+    let opts = JsonSerializerSettings()
+    opts.Converters.Add(ThemeAssetIdConverter())
+    test "succeeds when serializing" {
+        let after = JsonConvert.SerializeObject(ThemeAssetId (ThemeId "test", "unit.jpg"), opts)
+        Expect.equal after "\"test/unit.jpg\"" "Theme asset ID serialized incorrectly"
+    }
+    test "succeeds when deserializing" {
+        let after = JsonConvert.DeserializeObject<ThemeAssetId>("\"theme/test.png\"", opts)
+        Expect.equal after (ThemeAssetId (ThemeId "theme", "test.png")) "Theme asset ID deserialized incorrectly"
+    }
+]
+
+/// Unit tests for the ThemeIdConverter type
+let themeIdConverterTests = testList "ThemeIdConverter" [
+    let opts = JsonSerializerSettings()
+    opts.Converters.Add(ThemeIdConverter())
+    test "succeeds when serializing" {
+        let after = JsonConvert.SerializeObject(ThemeId "test-theme", opts)
+        Expect.equal after "\"test-theme\"" "Theme ID serialized incorrectly"
+    }
+    test "succeeds when deserializing" {
+        let after = JsonConvert.DeserializeObject<ThemeId>("\"theme-test\"", opts)
+        Expect.equal after (ThemeId "theme-test") "Theme ID deserialized incorrectly"
+    }
+]
+
+/// Unit tests for the UploadIdConverter type
+let uploadIdConverterTests = testList "UploadIdConverter" [
+    let opts = JsonSerializerSettings()
+    opts.Converters.Add(UploadIdConverter())
+    test "succeeds when serializing" {
+        let after = JsonConvert.SerializeObject(UploadId "test-up", opts)
+        Expect.equal after "\"test-up\"" "Upload ID serialized incorrectly"
+    }
+    test "succeeds when deserializing" {
+        let after = JsonConvert.DeserializeObject<UploadId>("\"up-test\"", opts)
+        Expect.equal after (UploadId "up-test") "Upload ID deserialized incorrectly"
+    }
+]
+
+/// Unit tests for the WebLogIdConverter type
+let webLogIdConverterTests = testList "WebLogIdConverter" [
+    let opts = JsonSerializerSettings()
+    opts.Converters.Add(WebLogIdConverter())
+    test "succeeds when serializing" {
+        let after = JsonConvert.SerializeObject(WebLogId "test-web", opts)
+        Expect.equal after "\"test-web\"" "Web log ID serialized incorrectly"
+    }
+    test "succeeds when deserializing" {
+        let after = JsonConvert.DeserializeObject<WebLogId>("\"web-test\"", opts)
+        Expect.equal after (WebLogId "web-test") "Web log ID deserialized incorrectly"
+    }
+]
+
+/// Unit tests for the WebLogUserIdConverter type
+let webLogUserIdConverterTests = testList "WebLogUserIdConverter" [
+    let opts = JsonSerializerSettings()
+    opts.Converters.Add(WebLogUserIdConverter())
+    test "succeeds when serializing" {
+        let after = JsonConvert.SerializeObject(WebLogUserId "test-user", opts)
+        Expect.equal after "\"test-user\"" "Web log user ID serialized incorrectly"
+    }
+    test "succeeds when deserializing" {
+        let after = JsonConvert.DeserializeObject<WebLogUserId>("\"user-test\"", opts)
+        Expect.equal after (WebLogUserId "user-test") "Web log user ID deserialized incorrectly"
+    }
+]
+
+open NodaTime.Serialization.JsonNet
+
+/// Unit tests for the Json.configure function
+let configureTests = test "Json.configure succeeds" {
+    let has typ (converter: JsonConverter) = converter.GetType() = typ
+    let ser = configure (JsonSerializer.Create())
+    Expect.hasCountOf ser.Converters 1u (has typeof<CategoryIdConverter>) "Category ID converter not found"
+    Expect.hasCountOf ser.Converters 1u (has typeof<CommentIdConverter>) "Comment ID converter not found"
+    Expect.hasCountOf ser.Converters 1u (has typeof<CommentStatusConverter>) "Comment status converter not found"
+    Expect.hasCountOf ser.Converters 1u (has typeof<CustomFeedIdConverter>) "Custom feed ID converter not found"
+    Expect.hasCountOf ser.Converters 1u (has typeof<CustomFeedSourceConverter>) "Custom feed source converter not found"
+    Expect.hasCountOf ser.Converters 1u (has typeof<ExplicitRatingConverter>) "Explicit rating converter not found"
+    Expect.hasCountOf ser.Converters 1u (has typeof<MarkupTextConverter>) "Markup text converter not found"
+    Expect.hasCountOf ser.Converters 1u (has typeof<PermalinkConverter>) "Permalink converter not found"
+    Expect.hasCountOf ser.Converters 1u (has typeof<PageIdConverter>) "Page ID converter not found"
+    Expect.hasCountOf ser.Converters 1u (has typeof<PodcastMediumConverter>) "Podcast medium converter not found"
+    Expect.hasCountOf ser.Converters 1u (has typeof<PostIdConverter>) "Post ID converter not found"
+    Expect.hasCountOf ser.Converters 1u (has typeof<TagMapIdConverter>) "Tag map ID converter not found"
+    Expect.hasCountOf ser.Converters 1u (has typeof<ThemeAssetIdConverter>) "Theme asset ID converter not found"
+    Expect.hasCountOf ser.Converters 1u (has typeof<ThemeIdConverter>) "Theme ID converter not found"
+    Expect.hasCountOf ser.Converters 1u (has typeof<UploadIdConverter>) "Upload ID converter not found"
+    Expect.hasCountOf ser.Converters 1u (has typeof<WebLogIdConverter>) "Web log ID converter not found"
+    Expect.hasCountOf ser.Converters 1u (has typeof<WebLogUserIdConverter>) "Web log user ID converter not found"
+    Expect.hasCountOf ser.Converters 1u (has typeof<CompactUnionJsonConverter>) "F# type converter not found"
+    Expect.hasCountOf ser.Converters 1u (has (NodaConverters.InstantConverter.GetType())) "NodaTime converter not found"
+    Expect.equal ser.NullValueHandling NullValueHandling.Ignore "Null handling set incorrectly"
+    Expect.equal ser.MissingMemberHandling MissingMemberHandling.Ignore "Missing member handling set incorrectly"
+}
+
+/// All tests for the Data.Converters file
+let all = testList "Converters" [
+    categoryIdConverterTests
+    commentIdConverterTests
+    commentStatusConverterTests
+    customFeedIdConverterTests
+    customFeedSourceConverterTests
+    explicitRatingConverterTests
+    markupTextConverterTests
+    permalinkConverterTests
+    pageIdConverterTests
+    podcastMediumConverterTests
+    postIdConverterTests
+    tagMapIdConverterTests
+    themeAssetIdConverterTests
+    themeIdConverterTests
+    uploadIdConverterTests
+    webLogIdConverterTests
+    webLogUserIdConverterTests
+    configureTests
+]
--- a/src/MyWebLog.Tests/Data/SQLiteDataTests.fs
+++ b/src/MyWebLog.Tests/Data/SQLiteDataTests.fs
@@ -0,0 +1,59 @@
+module SQLiteDataTests
+
+open BitBadger.Documents
+open Expecto
+open Microsoft.Extensions.Logging.Abstractions
+open MyWebLog
+open MyWebLog.Converters
+open MyWebLog.Data
+open Newtonsoft.Json
+
+/// JSON serializer 
+let ser = Json.configure (JsonSerializer.CreateDefault())
+
+/// Create a SQLiteData instance for testing
+let mkData () =
+    Sqlite.Configuration.useConnectionString "Data Source=./test-db.db"
+    let conn = Sqlite.Configuration.dbConn ()
+    SQLiteData(conn, NullLogger<SQLiteData>(), ser) :> IData
+
+/// Dispose the connection associated with the SQLiteData instance
+let dispose (data: IData) =
+    (data :?> SQLiteData).Conn.Dispose()
+
+/// Set up the environment for the SQLite tests
+let environmentSetUp = testList "Environment" [
+    testTask "creating database" {
+        let data = mkData ()
+        try
+            do! data.StartUp()
+            do! Maintenance.Backup.restoreBackup "root-weblog.json" None false data
+        finally dispose data
+    }
+]
+
+/// Integration tests for the Category implementation in SQLite
+let categoryTests = testList "Category" [
+    testTask "Add succeeds" {
+        let data = mkData ()
+        try do! CategoryDataTests.addTests data
+        finally dispose data
+    }
+]
+
+
+open System.IO
+
+/// Delete the SQLite database
+let environmentCleanUp = test "Clean Up" {
+    File.Delete "test-db.db"
+    Expect.isFalse (File.Exists "test-db.db") "The test SQLite database should have been deleted"
+} 
+
+/// All SQLite data tests
+let all =
+    testList "SQLiteData"
+        [ environmentSetUp
+          categoryTests
+          environmentCleanUp ]
+    |> testSequenced
--- a/src/MyWebLog.Tests/Data/UtilsTests.fs
+++ b/src/MyWebLog.Tests/Data/UtilsTests.fs
@@ -0,0 +1,96 @@
+module UtilsTests
+
+open Expecto
+open MyWebLog
+open MyWebLog.Data
+open NodaTime
+
+/// Unit tests for the orderByHierarchy function
+let orderByHierarchyTests = test "orderByHierarchy succeeds" {
+    let rawCats =
+        [ { Category.Empty with Id = CategoryId "a"; Name = "Audio"; Slug = "audio"; ParentId = Some (CategoryId "p") }
+          { Category.Empty with
+              Id          = CategoryId "b"
+              Name        = "Breaking"
+              Description = Some "Breaking News" 
+              Slug        = "breaking"
+              ParentId    = Some (CategoryId "n") }
+          { Category.Empty with Id = CategoryId "l"; Name = "Local"; Slug = "local"; ParentId = Some (CategoryId "b") }
+          { Category.Empty with Id = CategoryId "n"; Name = "News"; Slug = "news" }
+          { Category.Empty with Id = CategoryId "p"; Name = "Podcast"; Slug = "podcast" }
+          { Category.Empty with Id = CategoryId "v"; Name = "Video"; Slug = "vid"; ParentId = Some (CategoryId "p") } ]
+    let cats = Utils.orderByHierarchy rawCats None None [] |> List.ofSeq
+    Expect.equal cats.Length 6 "There should have been 6 categories"
+    Expect.equal cats[0].Id "n" "The first top-level category should have been News"
+    Expect.equal cats[0].Slug "news" "Slug for News not filled properly"
+    Expect.isEmpty cats[0].ParentNames "Parent names for News not filled properly"
+    Expect.equal cats[1].Id "b" "Breaking should have been just below News"
+    Expect.equal cats[1].Slug "news/breaking" "Slug for Breaking not filled properly"
+    Expect.equal cats[1].Name "Breaking" "Name not filled properly"
+    Expect.equal cats[1].Description (Some "Breaking News") "Description not filled properly"
+    Expect.equal cats[1].ParentNames [| "News" |] "Parent names for Breaking not filled properly"
+    Expect.equal cats[2].Id "l" "Local should have been just below Breaking"
+    Expect.equal cats[2].Slug "news/breaking/local" "Slug for Local not filled properly"
+    Expect.equal cats[2].ParentNames [| "News"; "Breaking" |] "Parent names for Local not filled properly"
+    Expect.equal cats[3].Id "p" "Podcast should have been the next top-level category"
+    Expect.equal cats[3].Slug "podcast" "Slug for Podcast not filled properly"
+    Expect.isEmpty cats[3].ParentNames "Parent names for Podcast not filled properly"
+    Expect.equal cats[4].Id "a" "Audio should have been just below Podcast"
+    Expect.equal cats[4].Slug "podcast/audio" "Slug for Audio not filled properly"
+    Expect.equal cats[4].ParentNames [| "Podcast" |] "Parent names for Audio not filled properly"
+    Expect.equal cats[5].Id "v" "Video should have been below Audio"
+    Expect.equal cats[5].Slug "podcast/vid" "Slug for Video not filled properly"
+    Expect.equal cats[5].ParentNames [| "Podcast" |] "Parent names for Video not filled properly"
+    Expect.hasCountOf cats 6u (fun it -> it.PostCount = 0) "All post counts should have been 0"
+}
+
+/// Unit tests for the diffLists function
+let diffListsTests = testList "diffLists" [
+    test "succeeds with identical lists" {
+        let removed, added = Utils.diffLists [ 1; 2; 3 ] [ 1; 2; 3 ] id
+        Expect.isEmpty removed "There should have been no removed items returned"
+        Expect.isEmpty added "There should have been no added items returned"
+    }
+    test "succeeds with differing lists" {
+        let removed, added = Utils.diffLists [ 1; 2; 3 ] [ 3; 4; 5 ] string
+        Expect.equal removed [ 1; 2 ] "Removed items incorrect"
+        Expect.equal added [ 4; 5 ] "Added items incorrect"
+    }
+]
+
+/// Unit tests for the diffRevisions function
+let diffRevisionsTests = testList "diffRevisions" [
+    test "succeeds with identical lists" {
+        let oldItems =
+            [ { AsOf = Noda.epoch + Duration.FromDays 3; Text = Html "<p>test" }
+              { AsOf = Noda.epoch; Text = Html "<p>test test" } ]
+        let newItems =
+            [ { AsOf = Noda.epoch; Text = Html "<p>test test" }
+              { AsOf = Noda.epoch + Duration.FromDays 3; Text = Html "<p>test" } ]
+        let removed, added = Utils.diffRevisions oldItems newItems
+        Expect.isEmpty removed "There should have been no removed items returned"
+        Expect.isEmpty added "There should have been no added items returned"
+    }
+    test "succeeds with differing lists" {
+        let oldItems =
+            [ { AsOf = Noda.epoch + Duration.FromDays 3; Text = Html "<p>test" }
+              { AsOf = Noda.epoch + Duration.FromDays 2; Text = Html "<p>tests" }
+              { AsOf = Noda.epoch; Text = Html "<p>test test" } ]
+        let newItems =
+            [ { AsOf = Noda.epoch + Duration.FromDays 4; Text = Html "<p>tests" }
+              { AsOf = Noda.epoch + Duration.FromDays 3; Text = Html "<p>test" }
+              { AsOf = Noda.epoch; Text = Html "<p>test test" } ]
+        let removed, added = Utils.diffRevisions oldItems newItems
+        Expect.equal removed.Length 1 "There should be 1 removed item"
+        Expect.equal removed[0].AsOf (Noda.epoch + Duration.FromDays 2) "Expected removed item incorrect"
+        Expect.equal added.Length 1 "There should be 1 added item"
+        Expect.equal added[0].AsOf (Noda.epoch + Duration.FromDays 4) "Expected added item incorrect"
+    }
+]
+
+/// All tests for the Utils file
+let all = testList "Utils" [
+    orderByHierarchyTests
+    diffListsTests
+    diffRevisionsTests
+]