| -- |
| -- Licensed to the Apache Software Foundation (ASF) under one |
| -- or more contributor license agreements. See the NOTICE file |
| -- distributed with this work for additional information |
| -- regarding copyright ownership. The ASF licenses this file |
| -- to you under the Apache License, Version 2.0 (the |
| -- "License"); you may not use this file except in compliance |
| -- with the License. You may obtain a copy of the License at |
| -- |
| -- http://www.apache.org/licenses/LICENSE-2.0 |
| -- |
| -- Unless required by applicable law or agreed to in writing, |
| -- software distributed under the License is distributed on an |
| -- "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY |
| -- KIND, either express or implied. See the License for the |
| -- specific language governing permissions and limitations |
| -- under the License. |
| -- |
| |
| module JSONSpec where |
| |
| import Test.Hspec |
| import Test.Hspec.QuickCheck (prop) |
| |
| import qualified Data.ByteString.Lazy as LBS |
| import qualified Data.ByteString.Lazy.Char8 as C |
| |
| import Thrift.Types |
| import Thrift.Transport |
| import Thrift.Transport.Memory |
| import Thrift.Protocol |
| import Thrift.Protocol.JSON |
| |
| tString :: [Char] -> ThriftVal |
| tString = TString . C.pack |
| |
| spec :: Spec |
| spec = do |
| describe "JSONProtocol" $ do |
| describe "bool" $ do |
| it "writes true as 1" $ do |
| let val = True |
| trans <- openMemoryBuffer |
| let proto = JSONProtocol trans |
| writeVal proto (TBool val) |
| bin <-tRead trans 100 |
| (C.unpack bin) `shouldBe` ['1'] |
| |
| it "writes false as 0" $ do |
| let val = False |
| trans <- openMemoryBuffer |
| let proto = JSONProtocol trans |
| writeVal proto (TBool val) |
| bin <- tRead trans 100 |
| (C.unpack bin) `shouldBe` ['0'] |
| |
| prop "round trip" $ \val -> do |
| trans <- openMemoryBuffer |
| let proto = JSONProtocol trans |
| writeVal proto $ TBool val |
| val2 <- readVal proto T_BOOL |
| val2 `shouldBe` (TBool val) |
| |
| describe "string" $ do |
| it "writes" $ do |
| trans <- openMemoryBuffer |
| let proto = JSONProtocol trans |
| writeVal proto (TString $ C.pack "\"a") |
| bin <- tRead trans 100 |
| (C.unpack bin) `shouldBe` "\"\\\"a\"" |
| |
| it "reads" $ do |
| trans <- openMemoryBuffer |
| let proto = JSONProtocol trans |
| tWrite trans $ C.pack "\"\\\"a\"" |
| val <- readVal proto (T_STRING) |
| val `shouldBe` (TString $ C.pack "\"a") |
| |
| prop "round trip" $ \val -> do |
| trans <- openMemoryBuffer |
| let proto = JSONProtocol trans |
| writeVal proto (TString $ C.pack val) |
| val2 <- readVal proto (T_STRING) |
| val2 `shouldBe` (TString $ C.pack val) |
| |
| describe "binary" $ do |
| it "writes with padding" $ do |
| trans <- openMemoryBuffer |
| let proto = JSONProtocol trans |
| writeVal proto (TBinary $ LBS.pack [1]) |
| bin <- tRead trans 100 |
| (C.unpack bin) `shouldBe` "\"AQ==\"" |
| |
| it "reads with padding" $ do |
| trans <- openMemoryBuffer |
| let proto = JSONProtocol trans |
| tWrite trans $ C.pack "\"AQ==\"" |
| val <- readVal proto (T_BINARY) |
| val `shouldBe` (TBinary $ LBS.pack [1]) |
| |
| it "reads without padding" $ do |
| trans <- openMemoryBuffer |
| let proto = JSONProtocol trans |
| tWrite trans $ C.pack "\"AQ\"" |
| val <- readVal proto (T_BINARY) |
| val `shouldBe` (TBinary $ LBS.pack [1]) |
| |
| prop "round trip" $ \val -> do |
| trans <- openMemoryBuffer |
| let proto = JSONProtocol trans |
| writeVal proto (TBinary $ LBS.pack val) |
| val2 <- readVal proto (T_BINARY) |
| val2 `shouldBe` (TBinary $ LBS.pack val) |
| |
| describe "list" $ do |
| it "writes empty list" $ do |
| trans <- openMemoryBuffer |
| let proto = JSONProtocol trans |
| writeVal proto (TList T_BYTE []) |
| bin <- tRead trans 100 |
| (C.unpack bin) `shouldBe` "[\"i8\",0]" |
| |
| it "reads empty" $ do |
| trans <- openMemoryBuffer |
| let proto = JSONProtocol trans |
| tWrite trans (C.pack "[\"i8\",0]") |
| val <- readVal proto (T_LIST T_BYTE) |
| val `shouldBe` (TList T_BYTE []) |
| |
| it "writes single element" $ do |
| trans <- openMemoryBuffer |
| let proto = JSONProtocol trans |
| writeVal proto (TList T_BYTE [TByte 0]) |
| bin <- tRead trans 100 |
| (C.unpack bin) `shouldBe` "[\"i8\",1,0]" |
| |
| it "reads single element" $ do |
| trans <- openMemoryBuffer |
| let proto = JSONProtocol trans |
| tWrite trans (C.pack "[\"i8\",1,0]") |
| val <- readVal proto (T_LIST T_BYTE) |
| val `shouldBe` (TList T_BYTE [TByte 0]) |
| |
| it "reads elements" $ do |
| trans <- openMemoryBuffer |
| let proto = JSONProtocol trans |
| tWrite trans (C.pack "[\"i8\",2,42, 43]") |
| val <- readVal proto (T_LIST T_BYTE) |
| val `shouldBe` (TList T_BYTE [TByte 42, TByte 43]) |
| |
| prop "round trip" $ \val -> do |
| trans <- openMemoryBuffer |
| let proto = JSONProtocol trans |
| writeVal proto $ (TList T_STRING $ map tString val) |
| val2 <- readVal proto $ T_LIST T_STRING |
| val2 `shouldBe` (TList T_STRING $ map tString val) |
| |
| describe "set" $ do |
| it "writes empty" $ do |
| trans <- openMemoryBuffer |
| let proto = JSONProtocol trans |
| writeVal proto (TSet T_BYTE []) |
| bin <- tRead trans 100 |
| (C.unpack bin) `shouldBe` "[\"i8\",0]" |
| |
| it "reads empty" $ do |
| trans <- openMemoryBuffer |
| let proto = JSONProtocol trans |
| tWrite trans (C.pack "[\"i8\",0]") |
| val <- readVal proto (T_SET T_BYTE) |
| val `shouldBe` (TSet T_BYTE []) |
| |
| it "reads single element" $ do |
| trans <- openMemoryBuffer |
| let proto = JSONProtocol trans |
| tWrite trans (C.pack "[\"i8\",1,0]") |
| val <- readVal proto (T_SET T_BYTE) |
| val `shouldBe` (TSet T_BYTE [TByte 0]) |
| |
| it "reads elements" $ do |
| trans <- openMemoryBuffer |
| let proto = JSONProtocol trans |
| tWrite trans (C.pack "[\"i8\",2,42, 43]") |
| val <- readVal proto (T_SET T_BYTE) |
| val `shouldBe` (TSet T_BYTE [TByte 42, TByte 43]) |
| |
| prop "round trip" $ \val -> do |
| trans <- openMemoryBuffer |
| let proto = JSONProtocol trans |
| writeVal proto $ (TSet T_STRING $ map tString val) |
| val2 <- readVal proto $ T_SET T_STRING |
| val2 `shouldBe` (TSet T_STRING $ map tString val) |
| |
| describe "map" $ do |
| it "writes empty" $ do |
| trans <- openMemoryBuffer |
| let proto = JSONProtocol trans |
| writeVal proto (TMap T_BYTE T_BYTE []) |
| bin <- tRead trans 100 |
| (C.unpack bin) `shouldBe`"[\"i8\",\"i8\",0,{}]" |
| |
| it "reads empty" $ do |
| trans <- openMemoryBuffer |
| let proto = JSONProtocol trans |
| tWrite trans (C.pack "[\"i8\",\"i8\",0,{}]") |
| val <- readVal proto (T_MAP T_BYTE T_BYTE) |
| val `shouldBe` (TMap T_BYTE T_BYTE []) |
| |
| it "reads string-string" $ do |
| let bin = "[\"str\",\"str\",2,{\"a\":\"2\",\"b\":\"blah\"}]" |
| trans <- openMemoryBuffer |
| let proto = JSONProtocol trans |
| tWrite trans (C.pack bin) |
| val <- readVal proto (T_MAP T_STRING T_STRING) |
| val`shouldBe` (TMap T_STRING T_STRING [(tString "a", tString "2"), (tString "b", tString "blah")]) |
| |
| prop "round trip" $ \val -> do |
| trans <- openMemoryBuffer |
| let proto = JSONProtocol trans |
| writeVal proto $ (TMap T_STRING T_STRING $ map toKV val) |
| val2 <- readVal proto $ T_MAP T_STRING T_STRING |
| val2 `shouldBe` (TMap T_STRING T_STRING $ map toKV val) |
| where |
| toKV v = (tString v, tString v) |
| |
