r9407: add missing \#: to some test names

[clsql.git] / tests / test-oodml.lisp

diff --git a/tests/test-oodml.lisp b/tests/test-oodml.lisp
index 2e906b283f6c305280e4979d8e089d0581512f8f..3cde0a75602354d67d57069324976e52f7221893 100644 (file)
--- a/tests/test-oodml.lisp
+++ b/tests/test-oodml.lisp
@@ -105,33 +105,63 @@
             (employee-addresses employee2))
          ((t t 2 2 2)))
 
+        (deftest :oodml/select/11 
+         (values (mapcar #'(lambda (x) (slot-value x 'emplid))
+                         (clsql:select 'employee :order-by '(([emplid] :asc)) 
+                                       :flatp t))
+          (mapcar #'(lambda (x) (slot-value x 'emplid))
+                  (clsql:select 'employee :order-by '(([emplid] :desc)) 
+                                :flatp t)))
+         (1 2 3 4 5 6 7 8 9 10)
+         (10 9 8 7 6 5 4 3 2 1))
+
        ;; test retrieval is deferred
        (deftest :oodm/retrieval/1
            (every #'(lambda (e) (not (slot-boundp e 'company)))
             (select 'employee :flatp t :caching nil))
          t)
 
-       ;; :retrieval :immediate should be boundp before accessed
        (deftest :oodm/retrieval/2
+           (every #'(lambda (e) (not (slot-boundp e 'address)))
+            (select 'deferred-employee-address :flatp t :caching nil))
+         t)
+
+       ;; :retrieval :immediate should be boundp before accessed
+       (deftest :oodm/retrieval/3
            (every #'(lambda (ea) (slot-boundp ea 'address))
             (select 'employee-address :flatp t :caching nil))
          t)
 
-       (deftest :oodm/retrieval/3
+       (deftest :oodm/retrieval/4
            (mapcar #'(lambda (ea) (typep (slot-value ea 'address) 'address))
             (select 'employee-address :flatp t :caching nil))
          (t t t t t))
 
-       (deftest :oodm/retrieval/4
+       (deftest :oodm/retrieval/5
+           (mapcar #'(lambda (ea) (typep (slot-value ea 'address) 'address))
+            (select 'deferred-employee-address :flatp t :caching nil))
+         (t t t t t))
+
+       (deftest :oodm/retrieval/6
            (every #'(lambda (ea) (slot-boundp (slot-value ea 'address) 'addressid))
             (select 'employee-address :flatp t :caching nil))
          t)
 
-       (deftest :oodm/retrieval/5          
+       (deftest :oodm/retrieval/7
+           (every #'(lambda (ea) (slot-boundp (slot-value ea 'address) 'addressid))
+            (select 'deferred-employee-address :flatp t :caching nil))
+         t)
+
+       (deftest :oodm/retrieval/8          
            (mapcar #'(lambda (ea) (slot-value (slot-value ea 'address) 'street-number))
             (select 'employee-address :flatp t :order-by [aaddressid] :caching nil))
          (10 10 nil nil nil))
 
+       (deftest :oodm/retrieval/9
+           (mapcar #'(lambda (ea) (slot-value (slot-value ea 'address) 'street-number))
+            (select 'deferred-employee-address :flatp t :order-by [aaddressid] :caching nil))
+         (10 10 nil nil nil))
+
        ;; tests update-records-from-instance 
        (deftest :oodml/update-records/1
            (values
@@ -353,6 +383,76 @@
             collect (slot-value e 'last-name))
          ("Lenin" "Stalin" "Trotsky"))
 
-       ))
 
+      (deftest :oodml/cache/1
+         (progn
+           (setf (clsql-sys:record-caches *default-database*) nil)
+           (let ((employees (select 'employee)))
+             (every #'(lambda (a b) (eq a b))
+                    employees (select 'employee))))
+       t)
+
+       (deftest :oodml/cache/2
+           (let ((employees (select 'employee)))
+             (equal employees (select 'employee :flatp t)))
+         nil)
+       
+       (deftest :oodml/refresh/1
+           (let ((addresses (select 'address)))
+             (equal addresses (select 'address :refresh t)))
+         t)
+
+       (deftest :oodml/refresh/2
+           (let* ((addresses (select 'address :order-by [addressid] :flatp t))
+                  (city (slot-value (car addresses) 'city)))
+             (clsql:update-records [addr] 
+                              :av-pairs '((city_field "A new city"))
+                              :where [= [addressid] (slot-value (car addresses) 'addressid)])
+             (let* ((new-addresses (select 'address :order-by [addressid] :refresh t :flatp t))
+                    (new-city (slot-value (car addresses) 'city))
+)
+               (clsql:update-records [addr] 
+                                     :av-pairs `((city_field ,city))
+                                     :where [= [addressid] (slot-value (car addresses) 'addressid)])
+               (values (equal addresses new-addresses)
+                       city
+                       new-city)))
+         t "Leningrad" "A new city")
+       
+       (deftest :oodml/refresh/3
+           (let* ((addresses (select 'address :order-by [addressid] :flatp t)))
+             (values
+              (equal addresses (select 'address :refresh t :flatp t))
+              (equal addresses (select 'address :flatp t))))
+         nil nil)
+       
+       (deftest :oodml/refresh/4
+           (let* ((addresses (select 'address :order-by [addressid] :flatp t))
+                  (*db-auto-sync* t))
+             (make-instance 'address :addressid 1000 :city "A new address city")
+             (let ((new-addresses (select 'address :order-by [addressid] :flatp t :refresh t)))
+               (delete-records :from [addr] :where [= [addressid] 1000]) 
+               (values
+                (length addresses)
+                (length new-addresses)
+                (eq (first addresses) (first new-addresses))
+                (eq (second addresses) (second new-addresses)))))
+         2 3 t t)
+               
+             
+       (deftest :oodml/uoj/1
+           (progn
+             (let* ((dea-list (select 'deferred-employee-address :caching nil :order-by [ea_join aaddressid]
+                                      :flatp t))
+                    (dea-list-copy (copy-seq dea-list))
+                    (initially-unbound (every #'(lambda (dea) (not (slot-boundp dea 'address))) dea-list)))
+               (update-object-joins dea-list)
+               (values
+                initially-unbound
+                (equal dea-list dea-list-copy)
+                (every #'(lambda (dea) (slot-boundp dea 'address)) dea-list)
+                (every #'(lambda (dea) (typep (slot-value dea 'address) 'address)) dea-list)
+                (mapcar #'(lambda (dea) (slot-value (slot-value dea 'address) 'addressid)) dea-list))))
+         t t t t (1 1 2 2 2))
+       ))
 #.(clsql:restore-sql-reader-syntax-state)