Move OpenGraph property generation to models (#52)

- Add auto-OpenGraph field to web log
- Only generate properties for posts/pages without them if this flag is set
- Set flag to yes on v3 database migration
- Add JSON converter for OpenGraph type
- Add tests for models

src/MyWebLog.Tests/Data/ConvertersTests.fs

@@ -90,7 +90,7 @@ let explicitRatingConverterTests = testList "ExplicitRatingConverter" [
     }
 ]
 
-/// Unit tests for the MarkupText type
+/// Unit tests for the MarkupTextConverter type
 let markupTextConverterTests = testList "MarkupTextConverter" [
     let opts = JsonSerializerSettings()
     opts.Converters.Add(MarkupTextConverter())
@@ -104,6 +104,20 @@ let markupTextConverterTests = testList "MarkupTextConverter" [
     }
 ]
 
+/// Unit tests for the OpenGraphTypeConverter type
+let openGraphTypeConverterTests = testList "OpenGraphTypeConverter" [
+    let opts = JsonSerializerSettings()
+    opts.Converters.Add(OpenGraphTypeConverter())
+    test "succeeds when serializing" {
+        let after = JsonConvert.SerializeObject(VideoTvShow, opts)
+        Expect.equal after "\"video.tv_show\"" "OpenGraph type serialized incorrectly"
+    }
+    test "succeeds when deserializing" {
+        let after = JsonConvert.DeserializeObject<OpenGraphType>("\"book\"", opts)
+        Expect.equal after Book "OpenGraph type deserialized incorrectly"
+    }
+]
+
 /// Unit tests for the PermalinkConverter type
 let permalinkConverterTests = testList "PermalinkConverter" [
     let opts = JsonSerializerSettings()
@@ -257,6 +271,7 @@ let configureTests = test "Json.configure succeeds" {
     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<OpenGraphTypeConverter>) "OpenGraph type 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"
@@ -282,6 +297,7 @@ let all = testList "Converters" [
     customFeedSourceConverterTests
     explicitRatingConverterTests
     markupTextConverterTests
+    openGraphTypeConverterTests
     permalinkConverterTests
     pageIdConverterTests
     podcastMediumConverterTests

src/MyWebLog.Tests/Data/PageDataTests.fs

@@ -1,6 +1,6 @@
 /// <summary>
 /// Integration tests for <see cref="IPageData" /> implementations
-/// </summary> 
+/// </summary>
 module PageDataTests
 
 open System
@@ -35,8 +35,9 @@ let ``Add succeeds`` (data: IData) = task {
           Text            = "<h1>A new page</h1>"
           Metadata        = [ { Name = "Meta Item"; Value = "Meta Value" } ]
           PriorPermalinks = [ Permalink "2024/the-new-page.htm" ]
-          Revisions       = [ { AsOf = Noda.epoch + Duration.FromDays 3; Text = Html "<h1>A new page</h1>" } ] }
-    do! data.Page.Add page 
+          Revisions       = [ { AsOf = Noda.epoch + Duration.FromDays 3; Text = Html "<h1>A new page</h1>" } ]
+          OpenGraph       = Some { OpenGraphProperties.Empty with Type = Book } }
+    do! data.Page.Add page
     let! stored = data.Page.FindFullById (PageId "added-page") (WebLogId "test")
     Expect.isSome stored "The page should have been added"
     let pg = stored.Value
@@ -53,6 +54,7 @@ let ``Add succeeds`` (data: IData) = task {
     Expect.equal pg.Metadata page.Metadata "Metadata not saved properly"
     Expect.equal pg.PriorPermalinks page.PriorPermalinks "Prior permalinks not saved properly"
     Expect.equal pg.Revisions page.Revisions "Revisions not saved properly"
+    Expect.equal pg.OpenGraph page.OpenGraph "OpenGraph properties not saved properly"
 }
 
 let ``All succeeds`` (data: IData) = task {

src/MyWebLog.Tests/Data/PostDataTests.fs

@@ -1,6 +1,6 @@
 /// <summary>
 /// Integration tests for <see cref="IPostData" /> implementations
-/// </summary> 
+/// </summary>
 module PostDataTests
 
 open System
@@ -54,7 +54,7 @@ let ``Add succeeds`` (data: IData) = task {
         { Id              = PostId "a-new-post"
           WebLogId        = WebLogId "test"
           AuthorId        = WebLogUserId "test-author"
-          Status          = Published 
+          Status          = Published
           Title           = "A New Test Post"
           Permalink       = Permalink "2020/test-post.html"
           PublishedOn     = Some (Noda.epoch + Duration.FromMinutes 1L)
@@ -66,7 +66,8 @@ let ``Add succeeds`` (data: IData) = task {
           Episode         = Some { Episode.Empty with Media = "test-ep.mp3" }
           Metadata        = [ { Name = "Meta"; Value = "Data" } ]
           PriorPermalinks = [ Permalink "2020/test-post-a.html" ]
-          Revisions       = [ { AsOf = Noda.epoch + Duration.FromMinutes 1L; Text = Html "<p>Test text here" } ] }
+          Revisions       = [ { AsOf = Noda.epoch + Duration.FromMinutes 1L; Text = Html "<p>Test text here" } ]
+          OpenGraph       = Some { OpenGraphProperties.Empty with Type = VideoMovie } }
     do! data.Post.Add post
     let! stored = data.Post.FindFullById post.Id post.WebLogId
     Expect.isSome stored "The added post should have been retrieved"
@@ -87,6 +88,7 @@ let ``Add succeeds`` (data: IData) = task {
     Expect.equal it.Metadata post.Metadata "Metadata items not saved properly"
     Expect.equal it.PriorPermalinks post.PriorPermalinks "Prior permalinks not saved properly"
     Expect.equal it.Revisions post.Revisions "Revisions not saved properly"
+    Expect.equal it.OpenGraph post.OpenGraph "OpenGraph properties not saved correctly"
 }
 
 let ``CountByStatus succeeds`` (data: IData) = task {

src/MyWebLog.Tests/Data/WebLogDataTests.fs

@@ -1,6 +1,6 @@
 /// <summary>
 /// Integration tests for <see cref="IWebLogData" /> implementations
-/// </summary> 
+/// </summary>
 module WebLogDataTests
 
 open System
@@ -25,14 +25,15 @@ let ``Add succeeds`` (data: IData) = task {
               Rss           =
                   { IsFeedEnabled     = true
                     FeedName          = "my-feed.xml"
-                    ItemsInFeed       = None 
+                    ItemsInFeed       = None
                     IsCategoryEnabled = false
                     IsTagEnabled      = false
                     Copyright         = Some "go for it"
                     CustomFeeds       = [] }
               AutoHtmx      = true
               Uploads       = Disk
-              RedirectRules = [ { From = "/here"; To = "/there"; IsRegex = false } ] }
+              RedirectRules = [ { From = "/here"; To = "/there"; IsRegex = false } ]
+              AutoOpenGraph = false }
     let! webLog = data.WebLog.FindById (WebLogId "new-weblog")
     Expect.isSome webLog "The web log should have been returned"
     let it = webLog.Value
@@ -48,6 +49,7 @@ let ``Add succeeds`` (data: IData) = task {
     Expect.isTrue it.AutoHtmx "Auto htmx flag is incorrect"
     Expect.equal it.Uploads Disk "Upload destination is incorrect"
     Expect.equal it.RedirectRules [ { From = "/here"; To = "/there"; IsRegex = false } ] "Redirect rules are incorrect"
+    Expect.isFalse it.AutoOpenGraph "Auto OpenGraph flag is incorrect"
     let rss = it.Rss
     Expect.isTrue rss.IsFeedEnabled "Is feed enabled flag is incorrect"
     Expect.equal rss.FeedName "my-feed.xml" "Feed name is incorrect"

src/MyWebLog.Tests/Domain/SupportTypesTests.fs

@@ -257,6 +257,346 @@ let markupTextTests = testList "MarkupText" [
     ]
 ]
 
+/// Unit tests for the OpenGraphAudio type
+let openGraphAudioTests = testList "OpenGraphAudio" [
+    testList "Properties" [
+        test "succeeds with minimum required" {
+            let props = Array.ofSeq { OpenGraphAudio.Empty with Url = "http://test.this" }.Properties
+            Expect.hasLength props 1 "There should be one property"
+            Expect.equal props[0] ("og:audio", "http://test.this") "The URL was not written correctly"
+        }
+        test "succeeds with secure URL" {
+            let props = Array.ofSeq { OpenGraphAudio.Empty with Url = "https://test.this" }.Properties
+            Expect.hasLength props 2 "There should be two properties"
+            Expect.equal props[0] ("og:audio", "https://test.this") "The URL was not written correctly"
+            Expect.equal
+                props[1] ("og:audio:secure_url", "https://test.this") "The Secure URL was not written correctly"
+        }
+        test "succeeds with all properties filled" {
+            let props =
+                { Url       = "http://test.this"
+                  SecureUrl = Some "https://test.other"
+                  Type      = Some "audio/mpeg" }.Properties
+                |> Array.ofSeq
+            Expect.hasLength props 3 "There should be three properties"
+            Expect.equal props[0] ("og:audio", "http://test.this") "The URL was not written correctly"
+            Expect.equal
+                props[1] ("og:audio:secure_url", "https://test.other") "The Secure URL was not written correctly"
+            Expect.equal props[2] ("og:audio:type", "audio/mpeg") "The MIME type was not written correctly"
+        }
+        test "succeeds when deriving AAC" {
+            let props = Array.ofSeq { OpenGraphAudio.Empty with Url = "/this/cool.file.aac" }.Properties
+            Expect.hasLength props 2 "There should be two properties"
+            Expect.equal props[1] ("og:audio:type", "audio/aac") "The MIME type for AAC was not derived correctly"
+        }
+        test "succeeds when deriving MP3" {
+            let props = Array.ofSeq { OpenGraphAudio.Empty with Url = "/an.other/song.mp3" }.Properties
+            Expect.hasLength props 2 "There should be two properties"
+            Expect.equal props[1] ("og:audio:type", "audio/mpeg") "The MIME type for MP3 was not derived correctly"
+        }
+        test "succeeds when deriving OGA" {
+            let props = Array.ofSeq { OpenGraphAudio.Empty with Url = "/talks/speex.oga" }.Properties
+            Expect.hasLength props 2 "There should be two properties"
+            Expect.equal props[1] ("og:audio:type", "audio/ogg") "The MIME type for OGA was not derived correctly"
+        }
+        test "succeeds when deriving WAV" {
+            let props = Array.ofSeq { OpenGraphAudio.Empty with Url = "/some/old.school.wav" }.Properties
+            Expect.hasLength props 2 "There should be two properties"
+            Expect.equal props[1] ("og:audio:type", "audio/wav") "The MIME type for WAV was not derived correctly"
+        }
+        test "succeeds when deriving WEBA" {
+            let props = Array.ofSeq { OpenGraphAudio.Empty with Url = "/new/format/file.weba" }.Properties
+            Expect.hasLength props 2 "There should be two properties"
+            Expect.equal props[1] ("og:audio:type", "audio/webm") "The MIME type for WEBA was not derived correctly"
+        }
+        test "succeeds when type cannot be derived" {
+            let props = Array.ofSeq { OpenGraphAudio.Empty with Url = "/profile.jpg" }.Properties
+            Expect.hasLength props 1 "There should be one property (only URL; no type derived)"
+        }
+    ]
+]
+
+/// Tests for the OpenGraphImage type
+let openGraphImageTests = testList "OpenGraphImage" [
+    testList "Properties" [
+        test "succeeds with minimum required" {
+            let props = Array.ofSeq { OpenGraphImage.Empty with Url = "http://test.url" }.Properties
+            Expect.hasLength props 1 "There should be one property"
+            Expect.equal props[0] ("og:image", "http://test.url") "The URL was not written correctly"
+        }
+        test "succeeds with secure URL" {
+            let props = Array.ofSeq { OpenGraphImage.Empty with Url = "https://secure.url" }.Properties
+            Expect.hasLength props 2 "There should be two properties"
+            Expect.equal props[0] ("og:image", "https://secure.url") "The URL was not written correctly"
+            Expect.equal
+                props[1] ("og:image:secure_url", "https://secure.url") "The Secure URL was not written correctly"
+        }
+        test "succeeds with all properties filled" {
+            let props =
+                { Url       = "http://test.this"
+                  SecureUrl = Some "https://test.other"
+                  Type      = Some "image/jpeg"
+                  Width     = Some 400
+                  Height    = Some 600
+                  Alt       = Some "This ought to be good" }.Properties
+                |> Array.ofSeq
+            Expect.hasLength props 6 "There should be six properties"
+            Expect.equal props[0] ("og:image", "http://test.this") "The URL was not written correctly"
+            Expect.equal
+                props[1] ("og:image:secure_url", "https://test.other") "The Secure URL was not written correctly"
+            Expect.equal props[2] ("og:image:type", "image/jpeg") "The MIME type was not written correctly"
+            Expect.equal props[3] ("og:image:width", "400") "The width was not written correctly"
+            Expect.equal props[4] ("og:image:height", "600") "The height was not written correctly"
+            Expect.equal props[5] ("og:image:alt", "This ought to be good") "The alt text was not written correctly"
+        }
+        test "succeeds when deriving BMP" {
+            let props = Array.ofSeq { OpenGraphImage.Empty with Url = "/old/windows.bmp" }.Properties
+            Expect.hasLength props 2 "There should be two properties"
+            Expect.equal props[1] ("og:image:type", "image/bmp") "The MIME type for BMP was not derived correctly"
+        }
+        test "succeeds when deriving GIF" {
+            let props = Array.ofSeq { OpenGraphImage.Empty with Url = "/its.a.soft.g.gif" }.Properties
+            Expect.hasLength props 2 "There should be two properties"
+            Expect.equal props[1] ("og:image:type", "image/gif") "The MIME type for GIF was not derived correctly"
+        }
+        test "succeeds when deriving ICO" {
+            let props = Array.ofSeq { OpenGraphImage.Empty with Url = "/favicon.ico" }.Properties
+            Expect.hasLength props 2 "There should be two properties"
+            Expect.equal
+                props[1] ("og:image:type", "image/vnd.microsoft.icon") "The MIME type for ICO was not derived correctly"
+        }
+        test "succeeds when deriving JPEG" {
+            let props = Array.ofSeq { OpenGraphImage.Empty with Url = "/big/name/photo.jpeg" }.Properties
+            Expect.hasLength props 2 "There should be two properties"
+            Expect.equal props[1] ("og:image:type", "image/jpeg") "The MIME type for JPEG was not derived correctly"
+        }
+        test "succeeds when deriving PNG" {
+            let props = Array.ofSeq { OpenGraphImage.Empty with Url = "/some/nice/graphic.png" }.Properties
+            Expect.hasLength props 2 "There should be two properties"
+            Expect.equal props[1] ("og:image:type", "image/png") "The MIME type for PNG was not derived correctly"
+        }
+        test "succeeds when deriving SVG" {
+            let props = Array.ofSeq { OpenGraphImage.Empty with Url = "/fancy-new-vector.svg" }.Properties
+            Expect.hasLength props 2 "There should be two properties"
+            Expect.equal props[1] ("og:image:type", "image/svg+xml") "The MIME type for SVG was not derived correctly"
+        }
+        test "succeeds when deriving TIF" {
+            let props = Array.ofSeq { OpenGraphImage.Empty with Url = "/tagged/file.tif" }.Properties
+            Expect.hasLength props 2 "There should be two properties"
+            Expect.equal props[1] ("og:image:type", "image/tiff") "The MIME type for TIF was not derived correctly"
+        }
+        test "succeeds when deriving TIFF" {
+            let props = Array.ofSeq { OpenGraphImage.Empty with Url = "/tagged/file.two.tiff" }.Properties
+            Expect.hasLength props 2 "There should be two properties"
+            Expect.equal props[1] ("og:image:type", "image/tiff") "The MIME type for TIFF was not derived correctly"
+        }
+        test "succeeds when deriving WEBP" {
+            let props = Array.ofSeq { OpenGraphImage.Empty with Url = "/modern/photo.webp" }.Properties
+            Expect.hasLength props 2 "There should be two properties"
+            Expect.equal props[1] ("og:image:type", "image/webp") "The MIME type for WEBP was not derived correctly"
+        }
+        test "succeeds when type cannot be derived" {
+            let props = Array.ofSeq { OpenGraphImage.Empty with Url = "/intro.mp3" }.Properties
+            Expect.hasLength props 1 "There should be one property (only URL; no type derived)"
+        }
+    ]
+]
+
+/// Unit tests for the OpenGraphVideo type
+let openGraphVideoTests = testList "OpenGraphVideo" [
+    testList "Properties" [
+        test "succeeds with minimum required" {
+            let props = Array.ofSeq { OpenGraphVideo.Empty with Url = "http://url.test" }.Properties
+            Expect.hasLength props 1 "There should be one property"
+            Expect.equal props[0] ("og:video", "http://url.test") "The URL was not written correctly"
+        }
+        test "succeeds with secure URL" {
+            let props = Array.ofSeq { OpenGraphVideo.Empty with Url = "https://url.secure" }.Properties
+            Expect.hasLength props 2 "There should be two properties"
+            Expect.equal props[0] ("og:video", "https://url.secure") "The URL was not written correctly"
+            Expect.equal
+                props[1] ("og:video:secure_url", "https://url.secure") "The Secure URL was not written correctly"
+        }
+        test "succeeds with all properties filled" {
+            let props =
+                { Url       = "http://test.this"
+                  SecureUrl = Some "https://test.other"
+                  Type      = Some "video/mpeg"
+                  Width     = Some 1200
+                  Height    = Some 900 }.Properties
+                |> Array.ofSeq
+            Expect.hasLength props 5 "There should be five properties"
+            Expect.equal props[0] ("og:video", "http://test.this") "The URL was not written correctly"
+            Expect.equal
+                props[1] ("og:video:secure_url", "https://test.other") "The Secure URL was not written correctly"
+            Expect.equal props[2] ("og:video:type", "video/mpeg") "The MIME type was not written correctly"
+            Expect.equal props[3] ("og:video:width", "1200") "The width was not written correctly"
+            Expect.equal props[4] ("og:video:height", "900") "The height was not written correctly"
+        }
+        test "succeeds when deriving AVI" {
+            let props = Array.ofSeq { OpenGraphVideo.Empty with Url = "/my.video.avi" }.Properties
+            Expect.hasLength props 2 "There should be two properties"
+            Expect.equal props[1] ("og:video:type", "video/x-msvideo") "The MIME type for AVI was not derived correctly"
+        }
+        test "succeeds when deriving MP4" {
+            let props = Array.ofSeq { OpenGraphVideo.Empty with Url = "/chapters/1/01.mp4" }.Properties
+            Expect.hasLength props 2 "There should be two properties"
+            Expect.equal props[1] ("og:video:type", "video/mp4") "The MIME type for MP4 was not derived correctly"
+        }
+        test "succeeds when deriving MPEG" {
+            let props = Array.ofSeq { OpenGraphVideo.Empty with Url = "/viral/video.mpeg" }.Properties
+            Expect.hasLength props 2 "There should be two properties"
+            Expect.equal props[1] ("og:video:type", "video/mpeg") "The MIME type for MPEG was not derived correctly"
+        }
+        test "succeeds when deriving OGV" {
+            let props = Array.ofSeq { OpenGraphVideo.Empty with Url = "/open/video/example.ogv" }.Properties
+            Expect.hasLength props 2 "There should be two properties"
+            Expect.equal props[1] ("og:video:type", "video/ogg") "The MIME type for OGV was not derived correctly"
+        }
+        test "succeeds when deriving WEBM" {
+            let props = Array.ofSeq { OpenGraphVideo.Empty with Url = "/images/hero.webm" }.Properties
+            Expect.hasLength props 2 "There should be two properties"
+            Expect.equal props[1] ("og:video:type", "video/webm") "The MIME type for WEBM was not derived correctly"
+        }
+        test "succeeds when type cannot be derived" {
+            let props = Array.ofSeq { OpenGraphVideo.Empty with Url = "/favicon.ico" }.Properties
+            Expect.hasLength props 1 "There should be one property (only URL; no type derived)"
+        }
+    ]
+]
+
+/// Unit tests for the OpenGraphType type
+let openGraphTypeTests = testList "OpenGraphType" [
+    testList "Parse" [
+        test "succeeds for \"article\"" {
+            Expect.equal (OpenGraphType.Parse "article") Article "\"article\" not parsed correctly"
+        }
+        test "succeeds for \"book\"" {
+            Expect.equal (OpenGraphType.Parse "book") Book "\"book\" not parsed correctly"
+        }
+        test "succeeds for \"music.album\"" {
+            Expect.equal (OpenGraphType.Parse "music.album") MusicAlbum "\"music.album\" not parsed correctly"
+        }
+        test "succeeds for \"music.playlist\"" {
+            Expect.equal (OpenGraphType.Parse "music.playlist") MusicPlaylist "\"music.playlist\" not parsed correctly"
+        }
+        test "succeeds for \"music.radio_station\"" {
+            Expect.equal
+                (OpenGraphType.Parse "music.radio_station")
+                MusicRadioStation
+                "\"music.radio_station\" not parsed correctly"
+        }
+        test "succeeds for \"music.song\"" {
+            Expect.equal (OpenGraphType.Parse "music.song") MusicSong "\"music.song\" not parsed correctly"
+        }
+        test "succeeds for \"payment.link\"" {
+            Expect.equal (OpenGraphType.Parse "payment.link") PaymentLink "\"payment.link\" not parsed correctly"
+        }
+        test "succeeds for \"profile\"" {
+            Expect.equal (OpenGraphType.Parse "profile") Profile "\"profile\" not parsed correctly"
+        }
+        test "succeeds for \"video.episode\"" {
+            Expect.equal (OpenGraphType.Parse "video.episode") VideoEpisode "\"video.episode\" not parsed correctly"
+        }
+        test "succeeds for \"video.movie\"" {
+            Expect.equal (OpenGraphType.Parse "video.movie") VideoMovie "\"video.movie\" not parsed correctly"
+        }
+        test "succeeds for \"video.other\"" {
+            Expect.equal (OpenGraphType.Parse "video.other") VideoOther "\"video.other\" not parsed correctly"
+        }
+        test "succeeds for \"video.tv_show\"" {
+            Expect.equal (OpenGraphType.Parse "video.tv_show") VideoTvShow "\"video.tv_show\" not parsed correctly"
+        }
+        test "succeeds for \"website\"" {
+            Expect.equal (OpenGraphType.Parse "website") Website "\"website\" not parsed correctly"
+        }
+        test "fails for invalid type" {
+            Expect.throwsT<ArgumentException>
+                (fun () -> ignore (OpenGraphType.Parse "anthology")) "Invalid value should have raised an exception"
+        }
+    ]
+    testList "ToString" [
+        test "succeeds for Article" {
+            Expect.equal (string Article) "article" "Article string incorrect"
+        }
+        test "succeeds for Book" {
+            Expect.equal (string Book) "book" "Book string incorrect"
+        }
+        test "succeeds for MusicAlbum" {
+            Expect.equal (string MusicAlbum) "music.album" "MusicAlbum string incorrect"
+        }
+        test "succeeds for MusicPlaylist" {
+            Expect.equal (string MusicPlaylist) "music.playlist" "MusicPlaylist string incorrect"
+        }
+        test "succeeds for MusicRadioStation" {
+            Expect.equal (string MusicRadioStation) "music.radio_station" "MusicRadioStation string incorrect"
+        }
+        test "succeeds for MusicSong" {
+            Expect.equal (string MusicSong) "music.song" "MusicSong string incorrect"
+        }
+        test "succeeds for PaymentLink" {
+            Expect.equal (string PaymentLink) "payment.link" "PaymentLink string incorrect"
+        }
+        test "succeeds for Profile" {
+            Expect.equal (string Profile) "profile" "Profile string incorrect"
+        }
+        test "succeeds for VideoEpisode" {
+            Expect.equal (string VideoEpisode) "video.episode" "VideoEpisode string incorrect"
+        }
+        test "succeeds for VideoMovie" {
+            Expect.equal (string VideoMovie) "video.movie" "VideoMovie string incorrect"
+        }
+        test "succeeds for VideoOther" {
+            Expect.equal (string VideoOther) "video.other" "VideoOther string incorrect"
+        }
+        test "succeeds for VideoTvShow" {
+            Expect.equal (string VideoTvShow) "video.tv_show" "VideoTvShow string incorrect"
+        }
+        test "succeeds for Website" {
+            Expect.equal (string Website) "website" "Website string incorrect"
+        }
+    ]
+]
+
+/// Unit tests for the OpenGraphProperties type
+let openGraphPropertiesTests = testList "OpenGraphProperties" [
+    testList "Properties" [
+        test "succeeds with minimal values" {
+            let props =
+                { OpenGraphProperties.Empty with
+                    Image = { OpenGraphImage.Empty with Url = "http://this.aint.nothing" } }.Properties
+                |> Array.ofSeq
+            Expect.hasLength props 2 "There should have been two properties"
+            Expect.equal props[0] ("og:type", "article") "Type not written correctly"
+            Expect.equal props[1] ("og:image", "http://this.aint.nothing") "Image URL not written correctly"
+        }
+        test "succeeds with all values" {
+            let props =
+                { Type            = Book
+                  Image           = { OpenGraphImage.Empty with Url = "http://this.image.file" }
+                  Audio           = Some { OpenGraphAudio.Empty with Url = "http://this.audio.file" }
+                  Description     = Some "This is a unit test"
+                  Determiner      = Some "a"
+                  Locale          = Some "en_US"
+                  LocaleAlternate = Some [ "en_UK"; "es_MX" ]
+                  Video           = Some { OpenGraphVideo.Empty with Url = "http://this.video.file" }
+                  Other           = Some [ { Name = "book.publisher"; Value = "Yep" } ] }.Properties
+                |> Array.ofSeq
+            Expect.hasLength props 10 "There should have been ten properties"
+            Expect.equal props[0] ("og:type", "book") "Type not written correctly"
+            Expect.equal props[1] ("og:image", "http://this.image.file") "Image URL not written correctly"
+            Expect.equal props[2] ("og:description", "This is a unit test") "Description not written correctly"
+            Expect.equal props[3] ("og:determiner", "a") "Determiner not written correctly"
+            Expect.equal props[4] ("og:locale", "en_US") "Locale not written correctly"
+            Expect.equal props[5] ("og:locale:alternate", "en_UK") "1st Alternate Locale not written correctly"
+            Expect.equal props[6] ("og:locale:alternate", "es_MX") "2nd Alternate Locale not written correctly"
+            Expect.equal props[7] ("og:audio", "http://this.audio.file") "Audio URL not written correctly"
+            Expect.equal props[8] ("og:video", "http://this.video.file") "Video URL not written correctly"
+            Expect.equal props[9] ("book.publisher", "Yep") "Other property not written correctly"
+        }
+    ]
+]
+
 /// Unit tests for the PodcastMedium type
 let podcastMediumTests = testList "PodcastMedium" [
     testList "Parse" [
@@ -407,6 +747,11 @@ let all = testList "SupportTypes" [
     explicitRatingTests
     episodeTests
     markupTextTests
+    openGraphAudioTests
+    openGraphImageTests
+    openGraphVideoTests
+    openGraphTypeTests
+    openGraphPropertiesTests
     podcastMediumTests
     postStatusTests
     customFeedSourceTests

src/MyWebLog.Tests/Domain/ViewModelsTests.fs

@@ -233,7 +233,7 @@ let testFullPost =
                    ImageUrl           = Some "uploads/podcast-cover.jpg"
                    Subtitle           = Some "Narration"
                    Explicit           = Some Clean
-                   Chapters           = None 
+                   Chapters           = None
                    ChapterFile        = Some "uploads/1970/01/chapters.txt"
                    ChapterType        = Some "chapters"
                    ChapterWaypoints   = Some true
@@ -666,7 +666,7 @@ let editPostModelTests = testList "EditPostModel" [
                                 { testFullPost.Episode.Value with
                                     Chapters    = Some []
                                     ChapterFile = None
-                                    ChapterType = None } } 
+                                    ChapterType = None } }
             Expect.equal model.ChapterSource "internal" "ChapterSource not filled properly"
         }
     ]
@@ -677,7 +677,7 @@ let editPostModelTests = testList "EditPostModel" [
         model.Source             <- "HTML"
         model.Text               <- "<p>An updated post!</p>"
         model.Tags               <- "Zebras, Aardvarks, , Turkeys"
-        model.Template           <- "updated" 
+        model.Template           <- "updated"
         model.CategoryIds        <- [| "cat-x"; "cat-y" |]
         model.MetaNames          <- [| "Zed Meta"; "A Meta" |]
         model.MetaValues         <- [| "A Value"; "Zed Value" |]
@@ -688,7 +688,7 @@ let editPostModelTests = testList "EditPostModel" [
         model.ImageUrl           <- "updated-cover.png"
         model.Subtitle           <- "Talking"
         model.Explicit           <- "no"
-        model.ChapterSource      <- "external" 
+        model.ChapterSource      <- "external"
         model.ChapterFile        <- "updated-chapters.txt"
         model.ChapterType        <- "indexes"
         model.TranscriptUrl      <- "updated-transcript.txt"
@@ -696,7 +696,7 @@ let editPostModelTests = testList "EditPostModel" [
         model.TranscriptLang     <- "ES-mx"
         model.SeasonNumber       <- 4
         model.SeasonDescription  <- "Season Fo"
-        model.EpisodeNumber      <- "432.1" 
+        model.EpisodeNumber      <- "432.1"
         model.EpisodeDescription <- "Four Three Two pt One"
         model
     testList "UpdatePost" [
@@ -760,7 +760,7 @@ let editPostModelTests = testList "EditPostModel" [
             minModel.SeasonNumber       <- 0
             minModel.SeasonDescription  <- ""
             minModel.EpisodeNumber      <- ""
-            minModel.EpisodeDescription <- "" 
+            minModel.EpisodeDescription <- ""
             let post = minModel.UpdatePost testFullPost (Noda.epoch + Duration.FromDays 500)
             Expect.isSome post.Episode "There should have been a podcast episode"
             let ep = post.Episode.Value
@@ -785,7 +785,7 @@ let editPostModelTests = testList "EditPostModel" [
         }
         test "succeeds for a podcast episode with internal chapters" {
             let minModel = updatedModel ()
-            minModel.ChapterSource <- "internal" 
+            minModel.ChapterSource <- "internal"
             minModel.ChapterFile   <- ""
             minModel.ChapterType   <- ""
             let post = minModel.UpdatePost testFullPost (Noda.epoch + Duration.FromDays 500)
@@ -977,7 +977,7 @@ let editUserModelTests = testList "EditUserModel" [
         let model =
             { Id              = "test-user"
               AccessLevel     = "WebLogAdmin"
-              Email           = "again@example.com" 
+              Email           = "again@example.com"
               Url             = ""
               FirstName       = "Another"
               LastName        = "One"
@@ -1115,10 +1115,10 @@ let postListItemTests = testList "PostListItem" [
                 { Post.Empty with
                     Id          = PostId "full-post"
                     AuthorId    = WebLogUserId "me"
-                    Status      = Published 
+                    Status      = Published
                     Title       = "Finished Product"
                     Permalink   = Permalink "2021/post.html"
-                    PublishedOn = Some (Noda.epoch + Duration.FromHours 12) 
+                    PublishedOn = Some (Noda.epoch + Duration.FromHours 12)
                     UpdatedOn   = Noda.epoch + Duration.FromHours 13
                     Text        = """<a href="/other-post.html">Click</a>"""
                     CategoryIds = [ CategoryId "z"; CategoryId "y" ]
@@ -1157,13 +1157,14 @@ let settingsModelTests = testList "SettingsModel" [
             let model =
                 SettingsModel.FromWebLog
                     { WebLog.Empty with
-                        Name         = "The Web Log"
-                        Slug         = "the-web-log"
-                        DefaultPage  = "this-one"
-                        PostsPerPage = 18
-                        TimeZone     = "America/Denver"
-                        ThemeId      = ThemeId "my-theme"
-                        AutoHtmx     = true }
+                        Name          = "The Web Log"
+                        Slug          = "the-web-log"
+                        DefaultPage   = "this-one"
+                        PostsPerPage  = 18
+                        TimeZone      = "America/Denver"
+                        ThemeId       = ThemeId "my-theme"
+                        AutoHtmx      = true
+                        AutoOpenGraph = false }
             Expect.equal model.Name "The Web Log" "Name not filled properly"
             Expect.equal model.Slug "the-web-log" "Slug not filled properly"
             Expect.equal model.Subtitle "" "Subtitle not filled properly"
@@ -1173,6 +1174,7 @@ let settingsModelTests = testList "SettingsModel" [
             Expect.equal model.ThemeId "my-theme" "ThemeId not filled properly"
             Expect.isTrue model.AutoHtmx "AutoHtmx should have been set"
             Expect.equal model.Uploads "Database" "Uploads not filled properly"
+            Expect.isFalse model.AutoOpenGraph "AutoOpenGraph should have been unset"
         }
         test "succeeds with a subtitle" {
             let model = SettingsModel.FromWebLog { WebLog.Empty with Subtitle = Some "sub here!" }
@@ -1182,15 +1184,16 @@ let settingsModelTests = testList "SettingsModel" [
     testList "Update" [
         test "succeeds with no subtitle" {
             let webLog =
-                { Name         = "Interesting"
-                  Slug         = "some-stuff"
-                  Subtitle     = ""
-                  DefaultPage  = "that-one"
-                  PostsPerPage = 8
-                  TimeZone     = "America/Chicago"
-                  ThemeId      = "test-theme"
-                  AutoHtmx     = true
-                  Uploads      = "Disk" }.Update WebLog.Empty
+                { Name          = "Interesting"
+                  Slug          = "some-stuff"
+                  Subtitle      = ""
+                  DefaultPage   = "that-one"
+                  PostsPerPage  = 8
+                  TimeZone      = "America/Chicago"
+                  ThemeId       = "test-theme"
+                  AutoHtmx      = true
+                  Uploads       = "Disk"
+                  AutoOpenGraph = false }.Update WebLog.Empty
             Expect.equal webLog.Name "Interesting" "Name not filled properly"
             Expect.equal webLog.Slug "some-stuff" "Slug not filled properly"
             Expect.isNone webLog.Subtitle "Subtitle should not have had a value"
@@ -1200,6 +1203,7 @@ let settingsModelTests = testList "SettingsModel" [
             Expect.equal webLog.ThemeId (ThemeId "test-theme") "ThemeId not filled properly"
             Expect.isTrue webLog.AutoHtmx "AutoHtmx should have been set"
             Expect.equal webLog.Uploads Disk "Uploads not filled properly"
+            Expect.isFalse webLog.AutoOpenGraph "AutoOpenGraph should have been unset"
         }
         test "succeeds with a subtitle" {
             let webLog = { SettingsModel.FromWebLog WebLog.Empty with Subtitle = "Sub" }.Update WebLog.Empty

src/MyWebLog.Tests/Program.fs

@@ -10,20 +10,19 @@ let sqliteOnly = (RethinkDbDataTests.env "SQLITE_ONLY" "0") = "1"
 let postgresOnly = (RethinkDbDataTests.env "PG_ONLY" "0") = "1"
 
 /// Whether any of the data tests are being isolated
-let dbOnly = rethinkOnly || sqliteOnly || postgresOnly
-
-/// Whether to only run the unit tests (skip database/integration tests)
-let unitOnly = (RethinkDbDataTests.env "UNIT_ONLY" "0") = "1"
+let allDatabases = not (rethinkOnly || sqliteOnly || postgresOnly)
 
 let allTests = testList "MyWebLog" [
-    if not dbOnly then testList "Domain" [ SupportTypesTests.all; DataTypesTests.all; ViewModelsTests.all ]
-    if not unitOnly then
-        testList "Data" [
-            if not dbOnly then ConvertersTests.all
-            if not dbOnly then UtilsTests.all
-            if not dbOnly || (dbOnly && rethinkOnly)  then RethinkDbDataTests.all
-            if not dbOnly || (dbOnly && sqliteOnly)   then SQLiteDataTests.all
-            if not dbOnly || (dbOnly && postgresOnly) then PostgresDataTests.all
+    // Skip unit tests if running an isolated database test
+    if allDatabases then
+        testList "Domain" [ SupportTypesTests.all; DataTypesTests.all; ViewModelsTests.all ]
+        testList "Data (Unit)" [ ConvertersTests.all; UtilsTests.all ]
+    // Whether to skip integration tests
+    if RethinkDbDataTests.env "UNIT_ONLY" "0" <> "1" then
+        testList "Data (Integration)" [
+            if allDatabases || rethinkOnly  then RethinkDbDataTests.all
+            if allDatabases || sqliteOnly   then SQLiteDataTests.all
+            if allDatabases || postgresOnly then PostgresDataTests.all
         ]
 ]