;;; cl-scopes/test/test-storage

;;;; testing facility for scopes/storage

(defpackage :scopes/test-storage
  (:use :common-lisp)
  (:local-nicknames (:storage :scopes/storage)
                    (:tracking :scopes/storage/tracking) 
                    (:t :scopes/testing))
  (:export #:*db-config-test*
           #:run #:run-all #:run-postgres #:run-sqlite)
  (:import-from :scopes/testing #:==))

(in-package :scopes/test-storage)

(defparameter *db-config-test* nil)

(defun run-all ()
  (run-sqlite)
  (run-postgres))

(defun run-sqlite ()
  (load "test/config-sqlite")
  (let ((storage:*db-config* *db-config-test*)
        (t:*test-suite* (t:test-suite "test-sqlite")))
    (run)))

(defun run-postgres ()
  (load "test/config-postgres")
  (let ((storage:*db-config* *db-config-test*)
        (t:*test-suite* (t:test-suite)))
    (run)))

(defun run ()
  (let* ((engine (storage:make-engine))
         (st (storage:make-storage engine)))
    (setf (storage:schema st) (getf (storage:db-options st) :schema))
    (test-track st)
    (t:show-result)))

(defun test-track (st)
  (let (cont tr tr2 (data (make-hash-table)))
    (setf cont (make-instance 'tracking:container :storage st))
    (defparameter cl-user::*cont cont)
    (storage:drop-table st :tracks)
    (tracking:create-table cont)
    (setf tr (tracking:make-item cont "t01" "john"))
    (== (tracking:head tr) '("t01" "john"))
    (== (tracking:head-plist tr) '(:username "john" :taskid "t01"))
    (== (tracking:data tr) nil)
    (setf (gethash :desc data) "scopes/storage: queries")
    (setf (tracking:data tr) data)
    (tracking:insert tr)
    (== (tracking:trackid tr) 1)
    (setf tr2 (tracking:get-track cont 1))
    (== (tracking:head tr2) '("t01" "john"))
    (== (gethash :desc (tracking:data tr2)) "scopes/storage: queries")
    ))