(use sublevel level leveldb lazy-seq posix test)

; attempting to open db that doesn't exist
(if (directory? "testdb")
  (delete-directory "testdb" #t))

(define db (sublevel (open-db "testdb") '()))

(test-group "get, put, delete"
  (test "put string key" #t (db-put db "asdf" "456"))
  (test "get string key" "456" (db-get db "asdf"))
  (test "delete string key" #t (db-delete db "asdf")))

(test-group "sublevel using string - get, put, delete"
  (define db2 (sublevel db '("two")))
  (test "sublevel put string key" #t (db-put db2 "asdf" "456"))
  (test "sublebel get string key" "456" (db-get db2 "asdf"))
  (test "root get string key" "456" (db-get db '("two" "asdf")))
  (test "sublevel delete string key" #t (db-delete db2 "asdf")))

(test-group "sublevel batches"
  (define db3 (sublevel db '("three")))
  (test "put values using batch" #t
        (db-batch db3 '((put "one" "foo")
                        (put "two" "bar")
                        (delete "two")
                        (put "three" "baz"))))
  (test "get foo back from batch" "foo" (db-get db3 "one"))
  (test-error "do not get bar back from batch" (db-get db3 "two"))
  (test "get baz back from batch" "baz" (db-get db3 "three"))
  (test "get foo back from batch" "foo" (db-get db "three\x00one"))
  (test-error "do not get bar back from batch" (db-get db "three\x00two"))
  (test "get baz back from batch" "baz" (db-get db "three\x00three")))

(test-group "stream keys from a sublevel"
  (define db4 (sublevel db '("four")))
  (db-batch db4 '((put "abc" "123")
                  (put "def" "456")
                  (put "ghi" "789")
                  (put "zzz" "000")))
  (test "get all keys inside prefix"
        '(("abc" "123") ("def" "456") ("ghi" "789") ("zzz" "000"))
        (lazy-seq->list (db-stream db4)))
  (test "get limited keys inside prefix"
        '(("abc" "123") ("def" "456"))
        (lazy-seq->list (db-stream db4 limit: 2)))
  (test "get range of keys inside prefix"
        '(("abc" "123") ("def" "456"))
        (lazy-seq->list (db-stream db4 start: "a" end: "g")))
  (test "get all keys outsdie prefix"
        '(("four\x00abc" "123")
          ("four\x00def" "456")
          ("four\x00ghi" "789")
          ("four\x00zzz" "000")
          ("three\x00one" "foo")
          ("three\x00three" "baz"))
        (lazy-seq->list (db-stream db)))
  (test "get limited keys outside prefix"
        '(("four\x00abc" "123")
          ("four\x00def" "456"))
        (lazy-seq->list (db-stream db limit: 2)))
  (test "get range of keys outside prefix"
        '(("four\x00abc" "123")
          ("four\x00def" "456"))
        (lazy-seq->list (db-stream db start: "four\x00a" end: "four\x00g")))
  (test "get key only results from stream"
        '("abc" "def" "ghi" "zzz")
        (lazy-seq->list (db-stream db4 key: #t value: #f)))
  (test "get value only results from stream"
        '("123" "456" "789" "000")
        (lazy-seq->list (db-stream db4 key: #f value: #t)))
  (test "get all keys inside prefix reversed"
        '(("zzz" "000") ("ghi" "789") ("def" "456") ("abc" "123"))
        (lazy-seq->list (db-stream db4 reverse: #t)))
  (test "get range of keys inside prefix reversed"
        '(("ghi" "789") ("def" "456"))
        (lazy-seq->list (db-stream db4 reverse: #t start: "gxx" end: "d"))))

(test-group "expand-sublevels"
  (define db1 (sublevel db '("one")))
  (test "expand key for single sublevel"
        '((put "one\x00foo" "123"))
        (expand-sublevels db db1 '((put "foo" "123"))))
  (test "expand multiple keys for single sublevel"
        '((put "one\x00foo" "123")
          (put "one\x00bar" "456")
          (delete "one\x00baz"))
        (expand-sublevels db db1
          '((put "foo" "123")
            (put "bar" "456")
            (delete "baz"))))
  (define db2 (sublevel db1 '("two")))
  (define db3 (sublevel db2 '("three")))
  (test "expand key for multiple sublevels"
        '((put "one\x00two\x00three\x00foo" "123"))
        (expand-sublevels db db3 '((put "foo" "123"))))
  (test "expand multiple keys for multiple sublevels"
        '((put "one\x00two\x00three\x00foo" "123")
          (put "one\x00two\x00three\x00bar" "456")
          (delete "one\x00two\x00three\x00baz"))
        (expand-sublevels db db3
          '((put "foo" "123")
            (put "bar" "456")
            (delete "baz"))))
  (test "expand some but not all sublevels"
        '((put "two\x00three\x00foo" "123")
          (put "two\x00three\x00bar" "456")
          (delete "two\x00three\x00baz"))
        (expand-sublevels db1 db3
          '((put "foo" "123")
            (put "bar" "456")
            (delete "baz"))))
  )

(test-exit)