import Test.HUnit
import System.IO
import System.Environment
import Data.String.Utils
import Network.Factual.API
import Data.Factual.Query.ReadQuery
import Data.Factual.Query.SchemaQuery
import Data.Factual.Query.ResolveQuery
import Data.Factual.Query.GeocodeQuery
import Data.Factual.Query.MatchQuery
import Data.Factual.Response
import qualified Data.Factual.Query.DiffsQuery as D
import qualified Data.Factual.Query as Q
import qualified Data.Map as M
import qualified Data.Factual.Write as W
import qualified Data.Factual.Query.FacetsQuery as F
import qualified Data.Factual.Query.GeopulseQuery as G
import qualified Data.Factual.Write.Submit as S
import qualified Data.Factual.Write.Insert as I
import qualified Data.Factual.Write.Flag as L
runUnitTests = runTestTT unitTests
runIntegrationTests = do
token <- getTokenFromCredentialsFile
runTestTT $ integrationTests token
getTokenFromCredentialsFile = do
home <- getEnv "HOME"
yaml <- readFile $ home ++ "/.factual/factual-auth.yaml"
let lines = split "\n" yaml
let lines' = filter (\x -> length (split ":" x) == 2) lines
let pairs = map (map strip . split ":") lines'
let key = last $ head $ filter (\x -> head x == "key") pairs
let secret = last $ head $ filter (\x -> head x == "secret") pairs
let token = generateToken key secret
return token
unitTests = TestList [ TestLabel "Place table test" placeTablePathTest
, TestLabel "Restaurants table test" restaurantsTablePathTest
, TestLabel "Hotels table test" hotelsTablePathTest
, TestLabel "Global table test" globalTablePathTest
, TestLabel "Crosswalk table test" crosswalkProductsTablePathTest
, TestLabel "Healthcare table test" healthcareTablePathTest
, TestLabel "World Geographies table test" worldGeographiesTablePathTest
, TestLabel "CPG table test" cpgTablePathTest
, TestLabel "Crosswalk Products table test" crosswalkProductsTablePathTest
, TestLabel "Monetize table test" monetizeTablePathTest
, TestLabel "Custom table test" customTablePathTest
, TestLabel "Geopulse test" geopulseTest
, TestLabel "Geocode test" geocodeTest
, TestLabel "And search test" andSearchPathTest
, TestLabel "Or search test" orSearchPathTest
, TestLabel "Select test" selectTest
, TestLabel "Limit test" limitTest
, TestLabel "Offset test" offsetTest
, TestLabel "Equal number filter test" equalNumFilterTest
, TestLabel "Equal string filter test" equalStrFilterTest
, TestLabel "Not equal number filter test" notEqualNumFilterTest
, TestLabel "Not equal string filter test" notEqualStrFilterTest
, TestLabel "In number list filter test" inNumListFilterTest
, TestLabel "In string list filter test" inStrListFilterTest
, TestLabel "Not in number list filter test" notInNumListFilterTest
, TestLabel "Not in string list filter test" notInStrListFilterTest
, TestLabel "Begins with filter test" beginsWithFilterTest
, TestLabel "Not begins with filter test" notBeginsWithFilterTest
, TestLabel "Begins with any filter test" beginsWithAnyFilterTest
, TestLabel "Not begins with any filter test" notBeginsWithAnyFilterTest
, TestLabel "Is blank filter test" isBlankFilterTest
, TestLabel "Is not blank filter test" isNotBlankFilterTest
, TestLabel "Greater than number filter test" greaterThanFilterTest
, TestLabel "Greater than or equal to number filter test" greaterThanOrEqualToFilterTest
, TestLabel "Less than number filter test" lessThanFilterTest
, TestLabel "Less than or equal to number filter test" lessThanOrEqualToFilterTest
, TestLabel "Search filter test" searchFilterTest
, TestLabel "And filter test" andFilterTest
, TestLabel "Or filter test" orFilterTest
, TestLabel "Geo test" geoTest
, TestLabel "Sort test" sortTest
, TestLabel "Include count test" includeCountTest
, TestLabel "Schema query test" schemaQueryTest
, TestLabel "Resolve query test" resolveQueryTest
, TestLabel "Match query test" matchQueryTest
, TestLabel "Facets test" facetsTest
, TestLabel "Diffs test" diffsTest
, TestLabel "Submit path test" submitPathTest
, TestLabel "Submit body test" submitBodyTest
, TestLabel "Insert path test" insertPathTest
, TestLabel "Insert body test" insertBodyTest
, TestLabel "Flag path test" flagPathTest
, TestLabel "Flag body test" flagBodyTest ]
integrationTests token = TestList [ TestLabel "Read test" (readIntegrationTest token)
, TestLabel "Unicode test" (unicodeIntegrationTest token)
, TestLabel "Schema test" (schemaIntegrationTest token)
, TestLabel "Resolve test" (resolveIntegrationTest token)
, TestLabel "Match test" (matchIntegrationTest token)
, TestLabel "Raw read test" (rawIntegrationTest token)
, TestLabel "Facets test" (facetsIntegrationTest token)
--, TestLabel "Diffs test" (diffsIntegrationTest token)
, TestLabel "Geopulse test" (geopulseIntegrationTest token)
, TestLabel "Geocode test" (geocodeIntegrationTest token)
, TestLabel "Multi test" (multiIntegrationTest token)
, TestLabel "Submit test" (submitIntegrationTest token)
, TestLabel "Insert test" (insertIntegrationTest token)
, TestLabel "Flag test" (flagIntegrationTest token)
, TestLabel "Error test" (errorIntegrationTest token) ]
placeTablePathTest = TestCase (do
let expected = "/t/places"
let queryPath = Q.path $ blankReadQuery { table = Places }
assertEqual "Correct path for places table" expected queryPath)
restaurantsTablePathTest = TestCase (do
let expected = "/t/restaurants-us"
let queryPath = Q.path $ blankReadQuery { table = RestaurantsUS }
assertEqual "Correct path for us restaurants table" expected queryPath)
hotelsTablePathTest = TestCase (do
let expected = "/t/hotels-us"
let queryPath = Q.path $ blankReadQuery { table = HotelsUS }
assertEqual "Correct path for us hotels table" expected queryPath)
globalTablePathTest = TestCase (do
let expected = "/t/global"
let queryPath = Q.path $ blankReadQuery { table = Global }
assertEqual "Correct path for global table" expected queryPath)
crosswalkTablePathTest = TestCase (do
let expected = "/t/crosswalk"
let queryPath = Q.path $ blankReadQuery { table = Crosswalk }
assertEqual "Correct path for crosswalk table" expected queryPath)
healthcareTablePathTest = TestCase (do
let expected = "/t/health-care-providers-us"
let queryPath = Q.path $ blankReadQuery { table = HealthCareProviders }
assertEqual "Correct path for health care providers table" expected queryPath)
worldGeographiesTablePathTest = TestCase (do
let expected = "/t/world-geographies"
let queryPath = Q.path $ blankReadQuery { table = WorldGeographies }
assertEqual "Correct path for world geographies table" expected queryPath)
cpgTablePathTest = TestCase (do
let expected = "/t/products-cpg"
let queryPath = Q.path $ blankReadQuery { table = ProductsCPG }
assertEqual "Correct path for products CPG table" expected queryPath)
crosswalkProductsTablePathTest = TestCase (do
let expected = "/t/products-crosswalk"
let queryPath = Q.path $ blankReadQuery { table = ProductsCrosswalk }
assertEqual "Correct path for products crosswalk table" expected queryPath)
monetizeTablePathTest = TestCase (do
let expected = "/places/monetize"
let queryPath = Q.path $ blankReadQuery { table = Monetize }
assertEqual "Correct path for monetize table" expected queryPath)
customTablePathTest = TestCase (do
let expected = "/t/foo"
let queryPath = Q.path $ blankReadQuery { table = Custom "foo" }
assertEqual "Correct path for custom table" expected queryPath)
geopulseTest = TestCase (do
let query = G.GeopulseQuery { G.geo = Point 34.06021 (-118.41828) , G.select = ["commercial_density"] }
let queryPath = Q.path query
let queryParams = Q.params query
assertEqual "Correct path for geopulse" queryPath "/places/geopulse"
assertEqual "Correct geo param" (queryParams M.! "geo") "{\"$point\":[34.06021,-118.41828]}"
assertEqual "Correct select param" (queryParams M.! "select") "commercial_density")
geocodeTest = TestCase (do
let query = GeocodeQuery $ Point 34.06021 (-118.41828)
let queryPath = Q.path query
let queryParams = Q.params query
assertEqual "Correct path for geocode" queryPath "/places/geocode"
assertEqual "Correct geo param" (queryParams M.! "geo") "{\"$point\":[34.06021,-118.41828]}")
andSearchPathTest = TestCase (do
let query = blankReadQuery { search = AndSearch ["foo", "bar"] }
let queryParams = Q.params query
assertEqual "Correct query value" (queryParams M.! "q") "foo bar")
orSearchPathTest = TestCase (do
let query = blankReadQuery { search = OrSearch ["foo", "bar"] }
let queryParams = Q.params query
assertEqual "Correct query value" (queryParams M.! "q") "foo,bar")
selectTest = TestCase (do
let query = blankReadQuery { select = ["foo", "bar"] }
let queryParams = Q.params query
assertEqual "Correct select value" (queryParams M.! "select") "foo,bar")
limitTest = TestCase (do
let query = blankReadQuery { limit = Just 321 }
let queryParams = Q.params query
assertEqual "Correct limit value" (queryParams M.! "limit") "321")
offsetTest = TestCase (do
let query = blankReadQuery { offset = Just 321 }
let queryParams = Q.params query
assertEqual "Correct offset value" (queryParams M.! "offset") "321")
equalNumFilterTest = TestCase (do
let query = blankReadQuery { filters = [EqualNum "field" 123.4] }
let queryParams = Q.params query
assertEqual "Correct filters value" (queryParams M.! "filters") "{\"field\":123.4}")
equalStrFilterTest = TestCase (do
let query = blankReadQuery { filters = [EqualStr "field" "value"] }
let queryParams = Q.params query
assertEqual "Correct filters value" (queryParams M.! "filters") "{\"field\":\"value\"}")
notEqualNumFilterTest = TestCase (do
let query = blankReadQuery { filters = [NotEqualNum "field" 123.4] }
let queryParams = Q.params query
assertEqual "Correct filters value" (queryParams M.! "filters") "{\"field\":{\"$neq\":123.4}}")
notEqualStrFilterTest = TestCase (do
let query = blankReadQuery { filters = [NotEqualStr "field" "value"] }
let queryParams = Q.params query
let expected = "{\"field\":{\"$neq\":\"value\"}}"
assertEqual "Correct filters value" (queryParams M.! "filters") expected)
inNumListFilterTest = TestCase (do
let query = blankReadQuery { filters = [InNumList "field" [123.4, 5432.1]] }
let queryParams = Q.params query
let expected = "{\"field\":{\"$in\":[123.4,5432.1]}}"
assertEqual "Correct filters value" (queryParams M.! "filters") expected)
inStrListFilterTest = TestCase (do
let query = blankReadQuery { filters = [InStrList "field" ["value","other"]] }
let queryParams = Q.params query
let expected = "{\"field\":{\"$in\":[\"value\",\"other\"]}}"
assertEqual "Correct filters value" (queryParams M.! "filters") expected)
notInNumListFilterTest = TestCase (do
let query = blankReadQuery { filters = [NotInNumList "field" [123.4, 5432.1]] }
let queryParams = Q.params query
let expected = "{\"field\":{\"$nin\":[123.4,5432.1]}}"
assertEqual "Correct filters value" (queryParams M.! "filters") expected)
notInStrListFilterTest = TestCase (do
let query = blankReadQuery { filters = [NotInStrList "field" ["value","other"]] }
let queryParams = Q.params query
let expected = "{\"field\":{\"$nin\":[\"value\",\"other\"]}}"
assertEqual "Correct filters value" (queryParams M.! "filters") expected)
beginsWithFilterTest = TestCase (do
let query = blankReadQuery { filters = [BeginsWith "field" "val"] }
let queryParams = Q.params query
let expected = "{\"field\":{\"$bw\":\"val\"}}"
assertEqual "Correct filters value" (queryParams M.! "filters") expected)
notBeginsWithFilterTest = TestCase (do
let query = blankReadQuery { filters = [NotBeginsWith "field" "val"] }
let queryParams = Q.params query
let expected = "{\"field\":{\"$nbw\":\"val\"}}"
assertEqual "Correct filters value" (queryParams M.! "filters") expected)
beginsWithAnyFilterTest = TestCase (do
let query = blankReadQuery { filters = [BeginsWithAny "field" ["val","ot"]] }
let queryParams = Q.params query
let expected = "{\"field\":{\"$bwin\":[\"val\",\"ot\"]}}"
assertEqual "Correct filters value" (queryParams M.! "filters") expected)
notBeginsWithAnyFilterTest = TestCase (do
let query = blankReadQuery { filters = [NotBeginsWithAny "field" ["val","ot"]] }
let queryParams = Q.params query
let expected = "{\"field\":{\"$nbwin\":[\"val\",\"ot\"]}}"
assertEqual "Correct filters value" (queryParams M.! "filters") expected)
isBlankFilterTest = TestCase (do
let query = blankReadQuery { filters = [IsBlank "field"] }
let queryParams = Q.params query
let expected = "{\"field\":{\"$blank\":true}}"
assertEqual "Correct filters value" (queryParams M.! "filters") expected)
isNotBlankFilterTest = TestCase (do
let query = blankReadQuery { filters = [IsNotBlank "field"] }
let queryParams = Q.params query
let expected = "{\"field\":{\"$blank\":false}}"
assertEqual "Correct filters value" (queryParams M.! "filters") expected)
greaterThanFilterTest = TestCase (do
let query = blankReadQuery { filters = [GreaterThan "field" 10.0] }
let queryParams = Q.params query
let expected = "{\"field\":{\"$gt\":10.0}}"
assertEqual "Correct filters value" (queryParams M.! "filters") expected)
greaterThanOrEqualToFilterTest = TestCase (do
let query = blankReadQuery { filters = [GreaterThanOrEqualTo "field" 10.0] }
let queryParams = Q.params query
let expected = "{\"field\":{\"$gte\":10.0}}"
assertEqual "Correct filters value" (queryParams M.! "filters") expected)
lessThanFilterTest = TestCase (do
let query = blankReadQuery { filters = [LessThan "field" 10.0] }
let queryParams = Q.params query
let expected = "{\"field\":{\"$lt\":10.0}}"
assertEqual "Correct filters value" (queryParams M.! "filters") expected)
lessThanOrEqualToFilterTest = TestCase (do
let query = blankReadQuery { filters = [LessThanOrEqualTo "field" 10.0] }
let queryParams = Q.params query
let expected = "{\"field\":{\"$lte\":10.0}}"
assertEqual "Correct filters value" (queryParams M.! "filters") expected)
searchFilterTest = TestCase (do
let query = blankReadQuery { filters = [SearchFilter "field" "value"] }
let queryParams = Q.params query
assertEqual "Correct filters value" (queryParams M.! "filters") "{\"field\":{\"$search\":\"value\"}}")
andFilterTest = TestCase (do
let query = blankReadQuery { filters = [And [IsBlank "field1", IsNotBlank "field2"]] }
let queryParams = Q.params query
let expected = "{\"$and\":[{\"field1\":{\"$blank\":true}},{\"field2\":{\"$blank\":false}}]}"
assertEqual "Correct filters value" (queryParams M.! "filters") expected)
orFilterTest = TestCase (do
let query = blankReadQuery { filters = [Or [IsBlank "field1", IsNotBlank "field2"]] }
let queryParams = Q.params query
let expected = "{\"$or\":[{\"field1\":{\"$blank\":true}},{\"field2\":{\"$blank\":false}}]}"
assertEqual "Correct filters value" (queryParams M.! "filters") expected)
geoTest = TestCase (do
let query = blankReadQuery { geo = Just (Circle 300.1 200.3 100.5) }
let queryParams = Q.params query
let expected = "{\"$circle\":{\"$center\":[300.1, 200.3],\"$meters\":100.5}}"
assertEqual "Correct geo value" (queryParams M.! "geo") expected)
sortTest = TestCase (do
let query = blankReadQuery { sort = [Asc "name", Desc "country"] }
let queryParams = Q.params query
let expected = "name:asc,country:desc"
assertEqual "Correct sort value" (queryParams M.! "sort") expected)
includeCountTest = TestCase (do
let query = blankReadQuery { includeCount = True }
let queryParams = Q.params query
assertEqual "Correct include_count value" (queryParams M.! "include_count") "true")
schemaQueryTest = TestCase (do
let queryPath = Q.path $ SchemaQuery Places
let expected = "/t/places/schema"
assertEqual "Correct path for a schema query" queryPath expected)
resolveQueryTest = TestCase (do
let query = ResolveQuery { values = [ResolveStr "field1" "value1", ResolveNum "field2" 32.1],
debug = False }
let queryPath = Q.path query
let queryParams = Q.params query
let expectedValues = "{\"field1\":\"value1\",\"field2\":32.1}"
assertEqual "Correct path" queryPath "/places/resolve"
assertEqual "Correct values" (queryParams M.! "values") expectedValues
assertEqual "Correct debug" (queryParams M.! "debug") "false")
matchQueryTest = TestCase (do
let query = MatchQuery [MatchStr "field1" "value1", MatchNum "field2" 32.1]
let queryPath = Q.path query
let queryParams = Q.params query
let expectedValues = "{\"field1\":\"value1\",\"field2\":32.1}"
assertEqual "Correct path" queryPath "/places/match"
assertEqual "Correct values" (queryParams M.! "values") expectedValues)
facetsTest = TestCase (do
let query = F.FacetsQuery { F.table = Places
, F.search = AndSearch ["starbucks"]
, F.select = ["locality", "region"]
, F.filters = [EqualStr "country" "US"]
, F.geo = Nothing
, F.limit = Just 10
, F.minCount = Just 2
, F.includeCount = False }
let queryPath = Q.path query
let queryParams = Q.params query
assertEqual "Correct path for a facets query" queryPath "/t/places/facets"
assertEqual "Correct q" (queryParams M.! "q") "starbucks"
assertEqual "Correct select" (queryParams M.! "select") "locality,region"
assertEqual "Correct filters" (queryParams M.! "filters") "{\"country\":\"US\"}"
assertEqual "Correct limit" (queryParams M.! "limit") "10"
assertEqual "Correct min count" (queryParams M.! "min_count") "2"
assertEqual "Correct include count" (queryParams M.! "include_count") "false")
diffsTest = TestCase (do
let query = D.DiffsQuery { D.table = Places, D.start = 1318890505254, D.end = 1318890516892 }
let queryPath = Q.path query
let queryParams = Q.params query
assertEqual "Correct path for a diffs query" queryPath "/t/places/diffs"
assertEqual "Correct start" (queryParams M.! "start") "1318890505254"
assertEqual "Correct end" (queryParams M.! "end") "1318890516892")
submitPathTest = TestCase (do
let expected = "/t/places/foobar/submit"
let writePath = W.path submitWrite
assertEqual "Correct path for submit" expected writePath)
submitBodyTest = TestCase (do
let expected = "user=user123&values={\"key\":\"val\"}"
let bodyParams = W.body submitWrite
assertEqual "Correct user" (bodyParams M.! "user") "user123"
assertEqual "Correct values" (bodyParams M.! "values") "{\"key\":\"val\"}")
insertPathTest = TestCase (do
let expected = "/t/places/foobar/insert"
let writePath = W.path insertWrite
assertEqual "Correct path for insert" expected writePath)
insertBodyTest = TestCase (do
let expected = "user=user123&values={\"key\":\"val\"}"
let bodyParams = W.body insertWrite
assertEqual "Correct user" (bodyParams M.! "user") "user123"
assertEqual "Correct values" (bodyParams M.! "values") "{\"key\":\"val\"}")
flagPathTest = TestCase (do
let expected = "/t/places/foobar/flag"
let path = W.path flagWrite
assertEqual "Correct path for flag" expected path)
flagBodyTest = TestCase (do
let bodyParams = W.body flagWrite
assertEqual "Correct problem" (bodyParams M.! "problem") "Duplicate"
assertEqual "Correct user" (bodyParams M.! "user") "user123"
assertEqual "Correct comment" (bodyParams M.! "comment") "There was a problem")
readIntegrationTest :: Token -> Test
readIntegrationTest token = TestCase (do
let query = ReadQuery { table = Places
, search = AndSearch ["McDonalds", "Burger King"]
, select = ["name"]
, limit = Just 50
, offset = Just 10
, includeCount = True
, geo = Just (Circle 34.06021 (-118.41828) 5000.0)
, sort = []
, filters = [EqualStr "name" "Stand"] }
result <- executeQuery (Options { token = token, timeout = Nothing }) query
assertEqual "Valid read query" "ok" (status result))
unicodeIntegrationTest :: Token -> Test
unicodeIntegrationTest token = TestCase (do
let query = ReadQuery { table = Global
, search = NoSearch
, select = []
, limit = Nothing
, offset = Nothing
, includeCount = False
, geo = Nothing
, sort = []
, filters = [EqualStr "locality" "בני ברק"] }
result <- executeQuery (Options { token = token, timeout = Nothing }) query
let resp = response result
let dat = lookupValue "data" resp
let row = (toList dat) !! 0
let loc = lookupString "locality" row
assertEqual "Correctly encoded locality" loc "בני ברק")
schemaIntegrationTest :: Token -> Test
schemaIntegrationTest token = TestCase (do
let query = SchemaQuery Places
result <- executeQuery (Options { token = token, timeout = Nothing }) query
assertEqual "Valid schema query" "ok" (status result))
resolveIntegrationTest :: Token -> Test
resolveIntegrationTest token = TestCase (do
let query = ResolveQuery { values = [ResolveStr "name" "McDonalds"],
debug = False }
result <- executeQuery (Options { token = token, timeout = Nothing }) query
assertEqual "Valid resolve query" "ok" (status result))
matchIntegrationTest :: Token -> Test
matchIntegrationTest token = TestCase (do
let query = MatchQuery [MatchStr "name" "McDonalds"]
result <- executeQuery (Options { token = token, timeout = Nothing }) query
assertEqual "Valid match query" "ok" (status result))
rawIntegrationTest :: Token -> Test
rawIntegrationTest token = TestCase (do
result <- get (Options { token = token, timeout = Nothing }) "/t/places" (M.fromList [("q", "starbucks")])
assertEqual "Valid read query" "ok" (status result))
facetsIntegrationTest token = TestCase (do
let query = F.FacetsQuery { F.table = Places
, F.search = AndSearch ["Starbucks"]
, F.select = ["country"]
, F.filters = []
, F.geo = Nothing
, F.limit = Just 100
, F.minCount = Just 1
, F.includeCount = False }
result <- executeQuery (Options { token = token, timeout = Nothing }) query
assertEqual "Valid facets query" "ok" (status result))
diffsIntegrationTest token = TestCase (do
let query = D.DiffsQuery { D.table = Custom "t7RSEV", D.start = 1339123455775, D.end = 1339124455775 }
result <- executeQuery (Options { token = token, timeout = Nothing }) query
assertEqual "Valid diffs query" "ok" (status result))
geopulseIntegrationTest token = TestCase (do
let query = G.GeopulseQuery { G.geo = Point 34.06021 (-118.41828)
, G.select = [] }
result <- executeQuery (Options { token = token, timeout = Nothing }) query
assertEqual "Valid geopulse query" "ok" (status result))
geocodeIntegrationTest token = TestCase (do
let query = GeocodeQuery $ Point 34.06021 (-118.41828)
result <- executeQuery (Options { token = token, timeout = Nothing }) query
assertEqual "Valid geopulse query" "ok" (status result))
multiIntegrationTest :: Token -> Test
multiIntegrationTest token = TestCase (do
let query1 = ReadQuery { table = Places
, search = AndSearch ["McDonalds", "Burger King"]
, select = ["name"]
, limit = Just 50
, offset = Just 10
, includeCount = True
, geo = Just (Circle 34.06021 (-118.41828) 5000.0)
, sort = []
, filters = [EqualStr "name" "Stand"] }
let query2 = query1 { filters = [EqualStr "name" "Xerox"] }
results <- executeMultiQuery (Options { token = token, timeout = Nothing }) $ M.fromList [("query1", query1), ("query2", query2)]
let result1 = results M.! "query1"
let result2 = results M.! "query2"
assertEqual "Valid multi query" ["ok","ok"] [status result1, status result2])
submitIntegrationTest :: Token -> Test
submitIntegrationTest token = TestCase (do
let newValues = M.fromList [ ("name","Factual")
, ("address","1801 Avenue of the Stars, Suite 1450")
, ("country","USA")
, ("locality","Los Angeles") ]
let write = S.Submit { S.table = Custom "t7RSEV"
, S.user = "drivertest"
, S.factualId = Nothing
, S.reference = Nothing
, S.comment = Nothing
, S.values = newValues }
result <- executeWrite (Options { token = token, timeout = Nothing }) write
assertEqual "Valid submit" "ok" (status result))
insertIntegrationTest :: Token -> Test
insertIntegrationTest token = TestCase (do
let newValues = M.fromList [ ("name","Factual")
, ("address","1801 Avenue of the Stars, Suite 1450")
, ("country","USA")
, ("locality","Los Angeles") ]
let write = I.Insert { I.table = Custom "t7RSEV"
, I.user = "drivertest"
, I.factualId = Nothing
, I.values = newValues }
result <- executeWrite (Options { token = token, timeout = Nothing }) write
assertEqual "Valid insert" "ok" (status result))
flagIntegrationTest :: Token -> Test
flagIntegrationTest token = TestCase (do
let write = L.Flag { L.table = Custom "t7RSEV"
, L.user = "drivertest"
, L.factualId = "97a38c06-cde1-402d-ad5a-4ae408530386"
, L.problem = L.Inaccurate
, L.comment = Nothing
, L.dataJSON = Nothing
, L.fields = Nothing
, L.reference = Nothing }
result <- executeWrite (Options { token = token, timeout = Nothing }) write
assertEqual "Valid flag" "ok" (status result))
errorIntegrationTest :: Token -> Test
errorIntegrationTest token = TestCase (do
result <- get (Options { token = token, timeout = Nothing }) "/t/foobarbaz" (M.empty)
assertEqual "Invalud read query" "error" (status result))
blankReadQuery :: ReadQuery
blankReadQuery = ReadQuery { table = Places
, search = AndSearch []
, select = []
, limit = Nothing
, offset = Nothing
, filters = []
, geo = Nothing
, sort = []
, includeCount = False }
submitWrite :: S.Submit
submitWrite = S.Submit { S.table = Places
, S.user = "user123"
, S.factualId = Just "foobar"
, S.reference = Nothing
, S.comment = Nothing
, S.values = M.fromList [("key", "val")] }
insertWrite :: I.Insert
insertWrite = I.Insert { I.table = Places
, I.user = "user123"
, I.factualId = Just "foobar"
, I.values = M.fromList [("key", "val")] }
flagWrite :: L.Flag
flagWrite = L.Flag { L.table = Places
, L.factualId = "foobar"
, L.problem = L.Duplicate
, L.user = "user123"
, L.comment = Just "There was a problem"
, L.dataJSON = Nothing
, L.fields = Nothing
, L.reference = Nothing }