fix tests around serialization of LSP types

Author: baronfel

src/LanguageServerProtocol.fs

@@ -12,7 +12,7 @@ module Server =
   open Newtonsoft.Json
   open Ionide.LanguageServerProtocol.JsonUtils
 
-  let private jsonRpcFormatter () =
+  let jsonRpcFormatter () =
     let f = new JsonMessageFormatter()
     f.JsonSerializer.NullValueHandling <- NullValueHandling.Ignore
     f.JsonSerializer.ConstructorHandling <- ConstructorHandling.AllowNonPublicDefaultConstructor

src/Types.fs

@@ -18,6 +18,14 @@ type U2<'a, 'b> =
 /// The LSP any type
 type LSPAny = JToken
 
+module LspError =
+  open StreamJsonRpc.Protocol
+  open StreamJsonRpc
+
+  let invalidParams message = LocalRpcException(message, ErrorCode = int JsonRpcErrorCode.InvalidParams)
+  let internalError message = LocalRpcException(message, ErrorCode = int JsonRpcErrorCode.InternalError)
+  let notImplemented () = NotImplementedException()
+
 type TextDocumentSyncKind =
   | None = 0
   | Full = 1

tests/Benchmarks.fs

@@ -11,6 +11,9 @@ open System
 open System.Collections.Concurrent
 open System.Collections.Generic
 open BenchmarkDotNet.Order
+open System.Text
+open Newtonsoft.Json
+open System.IO
 
 let inline private memorise (f: 'a -> 'b) : 'a -> 'b =
   let d = ConcurrentDictionary<'a, 'b>()
@@ -514,15 +517,23 @@ type MultipleTypesBenchmarks() =
   /// Some complex data which covers all converters
   let example = Example.createData (1234, 9, 5)
   let option = {| Some = Some 123; None = (None: int option) |}
+  let formatter = jsonRpcFormatter ()
+
+  let serialize item =
+    let sb = new StringBuilder()
+    use writer = new JsonTextWriter(new StringWriter(sb))
+    formatter.JsonSerializer.Serialize(writer, item)
+    JToken.Parse(sb.ToString())
 
   let withCounts (counts) data =
     data
     |> Array.collect (fun data -> counts |> Array.map (fun count -> [| box count; box data |]))
 
   member _.AllLsp_Roundtrip() =
+
     for o in allLsp do
       let json = inlayHint |> serialize
-      let res = json.ToObject(o.GetType(), jsonRpcFormatter.JsonSerializer)
+      let res = json.ToObject(o.GetType(), formatter.JsonSerializer)
       ()
 
   [<BenchmarkCategory("LSP"); Benchmark>]
@@ -534,7 +545,7 @@ type MultipleTypesBenchmarks() =
 
   member _.Example_Roundtrip() =
     let json = example |> serialize
-    let res = json.ToObject(example.GetType(), jsonRpcFormatter.JsonSerializer)
+    let res = json.ToObject(example.GetType(), formatter.JsonSerializer)
     ()
 
   [<BenchmarkCategory("Example"); Benchmark>]
@@ -550,7 +561,7 @@ type MultipleTypesBenchmarks() =
   member _.Option_Roundtrips(count: int) =
     for _ in 1..count do
       let json = option |> serialize
-      let _ = json.ToObject(option.GetType(), jsonRpcFormatter.JsonSerializer)
+      let _ = json.ToObject(option.GetType(), formatter.JsonSerializer)
       ()
 
   member _.SingleCaseUnion_ArgumentsSource() =
@@ -562,7 +573,7 @@ type MultipleTypesBenchmarks() =
   member _.SingleCaseUnion_Roundtrips(count: int, data: Example.SingleCaseUnion) =
     for _ in 1..count do
       let json = data |> serialize
-      let _ = json.ToObject(typeof<Example.SingleCaseUnion>, jsonRpcFormatter.JsonSerializer)
+      let _ = json.ToObject(typeof<Example.SingleCaseUnion>, formatter.JsonSerializer)
       ()
 
   member _.ErasedUnion_ArgumentsSource() =
@@ -582,7 +593,7 @@ type MultipleTypesBenchmarks() =
   member _.ErasedUnion_Roundtrips(count: int, data: Example.ErasedUnionData) =
     for _ in 1..count do
       let json = data |> serialize
-      let _ = json.ToObject(typeof<Example.ErasedUnionData>, jsonRpcFormatter.JsonSerializer)
+      let _ = json.ToObject(typeof<Example.ErasedUnionData>, formatter.JsonSerializer)
       ()
 
 

tests/Shotgun.fs

@@ -14,6 +14,9 @@ open Newtonsoft.Json.Linq
 open Expecto
 open Ionide.LanguageServerProtocol.Server
 open Ionide.LanguageServerProtocol.Types
+open System.Text
+open Newtonsoft.Json
+open System.IO
 
 // must be public
 type Gens =
@@ -85,8 +88,22 @@ type Gens =
 
 let private fsCheckConfig = { FsCheckConfig.defaultConfig with arbitrary = [ typeof<Gens> ] }
 
-type private Roundtripper =
-  static member ThereAndBackAgain(input: 'a) = input |> serialize |> deserialize<'a>
+type private Roundtripper() =
+
+  static let formatter = jsonRpcFormatter ()
+
+  static member serialize item =
+    let sb = new StringBuilder()
+    use writer = new JsonTextWriter(new StringWriter(sb))
+    formatter.JsonSerializer.Serialize(writer, item)
+    JToken.Parse(sb.ToString())
+
+  static member deserialize<'T>(json: JToken) = json.ToObject<'T>(formatter.JsonSerializer)
+
+  static member ThereAndBackAgain(input: 'a) =
+    input
+    |> Roundtripper.serialize
+    |> Roundtripper.deserialize<'a>
 
   static member TestThereAndBackAgain(input: 'a) =
     let output = Roundtripper.ThereAndBackAgain input

tests/Tests.fs

@@ -10,6 +10,8 @@ open Newtonsoft.Json
 open Ionide.LanguageServerProtocol.JsonRpc
 open System.Collections.Generic
 open System.Runtime.Serialization
+open System.Text
+open System.IO
 
 type Record1 = { Name: string; Value: int }
 type Record2 = { Name: string; Position: int }
@@ -88,6 +90,16 @@ type ExtensionDataField =
     if isNull x.AdditionalData then
       x.AdditionalData <- Map.empty
 
+let private formatter = jsonRpcFormatter ()
+
+let serialize item =
+  let sb = new StringBuilder()
+  use writer = new JsonTextWriter(new StringWriter(sb))
+  formatter.JsonSerializer.Serialize(writer, item)
+  JToken.Parse(sb.ToString())
+
+let deserialize<'T> (json: JToken) = json.ToObject<'T>(formatter.JsonSerializer)
+
 let private serializationTests =
   testList
     "(de)serialization"
@@ -674,71 +686,7 @@ let private serializationTests =
           testCase "can deserialize null Version in VersionedTextDocumentIdentifier"
           <| fun _ ->
                let textDoc = { VersionedTextDocumentIdentifier.Uri = "..."; Version = None }
-               testThereAndBackAgain textDoc
-
-          testCase "serialize to name specified in JsonProperty in Response"
-          <| fun _ ->
-               let response: Response = { Version = "123"; Id = None; Error = None; Result = None }
-               let json = response |> serialize
-               // Version -> jsonrpc
-               Expect.isNone
-                 (json |> tryGetProperty (nameof response.Version))
-                 "Version should exist, but instead as jsonrpc"
-
-               Expect.isSome (json |> tryGetProperty "jsonrpc") "jsonrcp should exist because of Version"
-               // Id & Error optional -> not in json
-               Expect.isNone (json |> tryGetProperty (nameof response.Id)) "None Id shouldn't be in json"
-               Expect.isNone (json |> tryGetProperty (nameof response.Error)) "None Error shouldn't be in json"
-               // Result even when null/None
-               let prop =
-                 json
-                 |> tryGetProperty (nameof response.Result)
-                 |> Flip.Expect.wantSome "Result should exist even when null/None"
-
-               Expect.equal prop.Value.Type (JTokenType.Null) "Result should be null"
-          testCase "can (de)serialize empty response"
-          <| fun _ ->
-               let response: Response = { Version = "123"; Id = None; Error = None; Result = None }
-               testThereAndBackAgain response
-          testCase "can (de)serialize Response.Result"
-          <| fun _ ->
-               let response: Response =
-                 { Version = "123"
-                   Id = None
-                   Error = None
-                   Result = Some(JToken.Parse "\"some result\"") }
-
-               testThereAndBackAgain response
-          testCase "can (de)serialize Result when Error is None"
-          <| fun _ ->
-               // Note: It's either `Error` or `Result`, but not both together
-               let response: Response =
-                 { Version = "123"
-                   Id = Some 42
-                   Error = None
-                   Result = Some(JToken.Parse "\"some result\"") }
-
-               testThereAndBackAgain response
-          testCase "can (de)serialize Error when error is Some"
-          <| fun _ ->
-               let response: Response =
-                 { Version = "123"
-                   Id = Some 42
-                   Error = Some { Code = 13; Message = "oh no"; Data = Some(JToken.Parse "\"some data\"") }
-                   Result = None }
-
-               testThereAndBackAgain response
-          testCase "doesn't serialize Result when Error is Some"
-          <| fun _ ->
-               let response: Response =
-                 { Version = "123"
-                   Id = Some 42
-                   Error = Some { Code = 13; Message = "oh no"; Data = Some(JToken.Parse "\"some data\"") }
-                   Result = Some(JToken.Parse "\"some result\"") }
-
-               let output = thereAndBackAgain response
-               Expect.isSome output.Error "Error should be serialized"
-               Expect.isNone output.Result "Result should not be serialized when Error is Some" ]
+               testThereAndBackAgain textDoc ]
 
       testList
         (nameof InlayHint)

tests/Utils.fs

@@ -246,7 +246,7 @@ let tests =
           testCase "Client isn't lsp"
           <| fun _ ->
                let isLsp =
-                 typeof<Ionide.LanguageServerProtocol.Client.Client>
+                 typeof<Ionide.LanguageServerProtocol.ILspClient>
                  |> isLspType []
 
                Expect.isFalse isLsp "Client isn't lsp" ]