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