tests/test-fddl.lisp

   1 ;;;; -*- Mode: LISP; Syntax: ANSI-Common-Lisp; Base: 10 -*-
   2 ;;;; ======================================================================
   3 ;;;; File:    test-fddl.lisp
   4 ;;;; Author:  Marcus Pearce <m.t.pearce@city.ac.uk>
   5 ;;;; Created: 30/03/2004
   6 ;;;; Updated: $Id$
   7 ;;;; ======================================================================
   8 ;;;;
   9 ;;;; Description ==========================================================
  10 ;;;; ======================================================================
  11 ;;;;
  12 ;;;; Tests for the CLSQL Functional Data Definition Language
  13 ;;;; (FDDL).
  14 ;;;;
  15 ;;;; ======================================================================
  16
  17 (in-package #:clsql-tests)
  18
  19 #.(clsql:locally-enable-sql-reader-syntax)
  20
  21 (setq *rt-fddl*
  22       '(
  23
  24 ;; list current tables
  25 (deftest :fddl/table/1
  26     (apply #'values
  27            (sort (mapcar #'string-downcase
  28                          (clsql:list-tables :owner *test-database-user*))
  29                  #'string>))
  30   "employee" "company" "clsql_object_v")
  31
  32 ;; create a table, test for its existence, drop it and test again
  33 (deftest :fddl/table/2
  34     (progn (clsql:create-table  [foo]
  35                                '(([id] integer)
  36                                  ([height] float)
  37                                  ([name] (string 24))
  38                                  ([comments] longchar)))
  39            (values
  40             (clsql:table-exists-p [foo] :owner *test-database-user*)
  41             (progn
  42               (clsql:drop-table [foo] :if-does-not-exist :ignore)
  43               (clsql:table-exists-p [foo] :owner *test-database-user*))))
  44   t nil)
  45
  46 ;; create a table, list its attributes and drop it
  47 (deftest :fddl/table/3
  48     (apply #'values
  49            (progn (clsql:create-table  [foo]
  50                                       '(([id] integer)
  51                                         ([height] float)
  52                                         ([name] (char 255))
  53                                         ([comments] longchar)))
  54                   (prog1
  55                       (sort (mapcar #'string-downcase
  56                                     (clsql:list-attributes [foo]))
  57                             #'string<)
  58                     (clsql:drop-table [foo] :if-does-not-exist :ignore))))
  59   "comments" "height" "id" "name")
  60
  61 (deftest :fddl/attributes/1
  62     (apply #'values
  63            (sort
  64             (mapcar #'string-downcase
  65                     (clsql:list-attributes [employee]
  66                                           :owner *test-database-user*))
  67             #'string<))
  68   "birthday" "companyid" "email" "emplid" "first_name" "groupid" "height"
  69   "last_name" "managerid" "married")
  70
  71 (deftest :fddl/attributes/2
  72     (apply #'values
  73            (sort
  74             (mapcar #'(lambda (a) (string-downcase (car a)))
  75                     (clsql:list-attribute-types [employee]
  76                                                :owner *test-database-user*))
  77             #'string<))
  78   "birthday" "companyid" "email" "emplid" "first_name" "groupid" "height"
  79   "last_name" "managerid" "married")
  80
  81 ;; create a view, test for existence, drop it and test again
  82 (deftest :fddl/view/1
  83     (progn (clsql:create-view [lenins-group]
  84                              ;;not in sqlite
  85                              ;;:column-list '([forename] [surname] [email])
  86                              :as [select [first-name] [last-name] [email]
  87                                          :from [employee]
  88                                          :where [= [managerid] 1]])
  89            (values
  90             (clsql:view-exists-p [lenins-group] :owner *test-database-user*)
  91             (progn
  92               (clsql:drop-view [lenins-group] :if-does-not-exist :ignore)
  93               (clsql:view-exists-p [lenins-group] :owner *test-database-user*))))
  94   t nil)
  95
  96 ;; create a view, list its attributes and drop it
  97 (deftest :fddl/view/2
  98     (progn (clsql:create-view [lenins-group]
  99                              ;;not in sqlite
 100                              ;;:column-list '([forename] [surname] [email])
 101                               :as [select [first-name] [last-name] [email]
 102                                           :from [employee]
 103                                           :where [= [managerid] 1]])
 104            (prog1
 105                (sort (mapcar #'string-downcase
 106                              (clsql:list-attributes [lenins-group]))
 107                      #'string<)
 108              (clsql:drop-view [lenins-group] :if-does-not-exist :ignore)))
 109   ("email" "first_name" "last_name"))
 110
 111 ;; create a view, select stuff from it and drop it
 112 (deftest :fddl/view/3
 113     (progn (clsql:create-view [lenins-group]
 114                               :as [select [first-name] [last-name] [email]
 115                                           :from [employee]
 116                                           :where [= [managerid] 1]])
 117            (let ((result
 118                   (list
 119                    ;; Shouldn't exist
 120                    (clsql:select [first-name] [last-name] [email]
 121                                 :from [lenins-group]
 122                                 :where [= [last-name] "Lenin"])
 123                    ;; Should exist
 124                    (car (clsql:select [first-name] [last-name] [email]
 125                                      :from [lenins-group]
 126                                      :where [= [last-name] "Stalin"])))))
 127              (clsql:drop-view [lenins-group] :if-does-not-exist :ignore)
 128              (apply #'values result)))
 129   nil ("Josef" "Stalin" "stalin@soviet.org"))
 130
 131 ;; not in sqlite
 132 (deftest :fddl/view/4
 133     (if (eql *test-database-type* :sqlite)
 134         (values nil '(("Josef" "Stalin" "stalin@soviet.org")))
 135         (progn (clsql:create-view [lenins-group]
 136                                  :column-list '([forename] [surname] [email])
 137                                  :as [select [first-name] [last-name] [email]
 138                                              :from [employee]
 139                                              :where [= [managerid] 1]])
 140                (let ((result
 141                       (list
 142                        ;; Shouldn't exist
 143                        (clsql:select [forename] [surname] [email]
 144                                     :from [lenins-group]
 145                                     :where [= [surname] "Lenin"])
 146                        ;; Should exist
 147                        (car (clsql:select [forename] [surname] [email]
 148                                          :from [lenins-group]
 149                                          :where [= [surname] "Stalin"])))))
 150                  (clsql:drop-view [lenins-group] :if-does-not-exist :ignore)
 151                  (apply #'values result))))
 152   nil ("Josef" "Stalin" "stalin@soviet.org"))
 153
 154 ;; create an index, test for existence, drop it and test again
 155 (deftest :fddl/index/1
 156     (progn (clsql:create-index [bar] :on [employee] :attributes
 157                               '([first-name] [last-name] [email]) :unique t)
 158            (values
 159             (clsql:index-exists-p [bar] :owner *test-database-user*)
 160             (progn
 161               (case *test-database-type*
 162                 (:mysql
 163                  (clsql:drop-index [bar] :on [employee]
 164                                   :if-does-not-exist :ignore))
 165                 (t
 166                  (clsql:drop-index [bar]:if-does-not-exist :ignore)))
 167               (clsql:view-exists-p [bar] :owner *test-database-user*))))
 168   t nil)
 169
 170 ;; create indexes with names as strings, symbols and in square brackets
 171 (deftest :fddl/index/2
 172     (let ((names '("foo" foo [foo]))
 173           (result '()))
 174       (dolist (name names)
 175         (clsql:create-index name :on [employee] :attributes '([emplid]))
 176         (push (clsql:index-exists-p name :owner *test-database-user*) result)
 177         (case *test-database-type*
 178           (:mysql
 179            (clsql:drop-index name :on [employee] :if-does-not-exist :ignore))
 180           (t (clsql:drop-index name :if-does-not-exist :ignore))))
 181       (apply #'values result))
 182   t t t)
 183
 184 ;; create an sequence, test for existence, drop it and test again
 185 (deftest :fddl/sequence/1
 186     (progn (clsql:create-sequence [foo])
 187            (values
 188             (clsql:sequence-exists-p [foo] :owner *test-database-user*)
 189             (progn
 190               (clsql:drop-sequence [foo] :if-does-not-exist :ignore)
 191               (clsql:sequence-exists-p [foo] :owner *test-database-user*))))
 192   t nil)
 193
 194 ;; create and increment a sequence
 195 (deftest :fddl/sequence/2
 196     (let ((val1 nil))
 197       (clsql:create-sequence [foo])
 198       (setf val1 (clsql:sequence-next [foo]))
 199       (prog1
 200           (< val1 (clsql:sequence-next [foo]))
 201         (clsql:drop-sequence [foo] :if-does-not-exist :ignore)))
 202   t)
 203
 204 ;; explicitly set the value of a sequence
 205 (deftest :fddl/sequence/3
 206     (progn
 207       (clsql:create-sequence [foo])
 208       (clsql:set-sequence-position [foo] 5)
 209       (prog1
 210           (clsql:sequence-next [foo])
 211         (clsql:drop-sequence [foo] :if-does-not-exist :ignore)))
 212   6)
 213
 214 ))
 215
 216 #.(clsql:restore-sql-reader-syntax-state)