tests/test-time.lisp

   1 ;;; -*- Mode: Lisp -*-
   2 ;;; $Id$
   3 ;;;
   4 ;;; Copyright (c) 2000, 2001 onShore Development, Inc.
   5 ;;;
   6 ;;; Test time functions (time.lisp)
   7
   8 (in-package #:clsql-tests)
   9 #.(clsql-sys:locally-enable-sql-reader-syntax)
  10
  11 (def-view-class datetest ()
  12 e  ((testtimetz :column "testtimetz"
  13                 :type clsql-sys:wall-time
  14                 :db-kind :base
  15                 :db-constraints nil
  16                 :accessor testtimetz :initarg :testtimetz
  17                 :initform nil
  18                 :db-type "timestamp with time zone")
  19    (testtime :column "testtime"
  20              :type clsql-sys:wall-time
  21              :db-kind :base
  22              :db-constraints nil
  23              :accessor testtime :initarg :testtime
  24              :initform nil
  25              :db-type "timestamp without time zone")))
  26
  27 (def-dataset *ds-datetest*
  28   (:setup (lambda () (clsql-sys:create-view-from-class 'datetest)))
  29   (:cleanup "DROP TABLE datetest"))
  30
  31
  32 (def-dataset *cross-platform-datetest*
  33   (:setup (lambda () (create-table [datetest]
  34                                    '(([testtime] wall-time)))))
  35   (:cleanup (lambda ()
  36               (drop-table [datetest]))))
  37
  38
  39 (setq *rt-time*
  40       '(
  41
  42 ;; we use parse timestring a lot through here verifying other things
  43 ;; start off just checking that.
  44 (deftest :time/iso-parse/0
  45     (let* ((time1 (parse-timestring "2010-01-23")))
  46       (decode-time time1))
  47   0 0 0 0 23 1 2010 6)
  48
  49 (deftest :time/iso-parse/1
  50     (let* ((time1 (parse-timestring "2010-01-23T14:56:32Z")))
  51       (decode-time time1))
  52   0 32 56 14 23 1 2010 6)
  53
  54 (deftest :time/iso-parse/2
  55     (let* ((time1 (parse-timestring "2008-02-29 12:46:32")))
  56       (decode-time time1))
  57   0 32 46 12 29 2 2008 5)
  58
  59 (deftest :time/iso-parse/3
  60     (let* ((time1 (parse-timestring "2010-01-23 14:56:32.44")))
  61       (decode-time time1))
  62   440000 32 56 14 23 1 2010 6)
  63
  64 (deftest :time/iso-parse/4
  65     (let* ((time1 (parse-timestring "2010-01-23 14:56:32.0044")))
  66       (decode-time time1))
  67   4400 32 56 14 23 1 2010 6)
  68
  69 (deftest :time/iso-parse/5
  70     (let* ((time1 (parse-timestring "2010-01-23 14:56:32.000003")))
  71       (decode-time time1))
  72   3 32 56 14 23 1 2010 6)
  73
  74 (deftest :time/print-parse/1
  75     ;;make sure when we print and parse we get the same time.
  76     (let* ((time (clsql-sys:make-time :year 2010 :month 1 :day 4
  77                                       :hour 14 :minute 15 :second 44))
  78            (string-time (iso-timestring time))
  79            (time2 (parse-timestring string-time)))
  80       (decode-time time2))
  81   0 44 15 14 4 1 2010 1)
  82
  83 (deftest :time/print-parse/2
  84     ;;make sure when we print and parse we get the same time.
  85     (let* ((time (clsql-sys:make-time :year 2010 :month 1 :day 4
  86                                       :hour 14 :minute 15 :second 44 :usec 3))
  87            (string-time (iso-timestring time))
  88            (time2 (parse-timestring string-time)))
  89       (decode-time time2))
  90   3 44 15 14 4 1 2010 1)
  91
  92
  93 ;; relations of intervals
  94 (deftest :time/1
  95     (let* ((time-1 (clsql:parse-timestring "2002-01-01 10:00:00"))
  96            (time-2 (clsql:parse-timestring "2002-01-01 11:00:00"))
  97            (time-3 (clsql:parse-timestring "2002-01-01 12:00:00"))
  98            (time-4 (clsql:parse-timestring "2002-01-01 13:00:00"))
  99            (interval-1 (clsql:make-interval :start time-1 :end time-2))
 100            (interval-2 (clsql:make-interval :start time-2 :end time-3))
 101            (interval-3 (clsql:make-interval :start time-3 :end time-4))
 102            (interval-4 (clsql:make-interval :start time-1 :end time-3))
 103            (interval-5 (clsql:make-interval :start time-2 :end time-4))
 104            (interval-6 (clsql:make-interval :start time-1 :end time-4)))
 105       (flet ((my-assert (number relation i1 i2)
 106                (declare (ignore number))
 107                (let ((found-relation (clsql:interval-relation i1 i2)))
 108                  (equal relation found-relation))))
 109         (and
 110          (my-assert 1 :contains interval-1 interval-1)
 111          (my-assert 2 :precedes interval-1 interval-2)
 112          (my-assert 3 :precedes interval-1 interval-3)
 113          (my-assert 4 :contained interval-1 interval-4)
 114          (my-assert 5 :precedes interval-1 interval-5)
 115          (my-assert 6 :contained interval-1 interval-6)
 116          (my-assert 7 :follows interval-2 interval-1)
 117          (my-assert 8 :contains interval-2 interval-2)
 118          (my-assert 9 :precedes interval-2 interval-3)
 119          (my-assert 10 :contained interval-2 interval-4)
 120          (my-assert 11 :contained interval-2 interval-5)
 121          (my-assert 12 :contained interval-2 interval-6)
 122          (my-assert 13 :follows interval-3 interval-1)
 123          (my-assert 14 :follows interval-3 interval-2)
 124          (my-assert 15 :contains interval-3 interval-3)
 125          (my-assert 16 :follows interval-3 interval-4)
 126          (my-assert 17 :contained interval-3 interval-5)
 127          (my-assert 18 :contained interval-3 interval-6)
 128          (my-assert 19 :contains interval-4 interval-1)
 129          (my-assert 20 :contains interval-4 interval-2)
 130          (my-assert 21 :precedes interval-4 interval-3)
 131          (my-assert 22 :contains interval-4 interval-4)
 132          (my-assert 23 :overlaps interval-4 interval-5)
 133          (my-assert 24 :contained interval-4 interval-6)
 134          (my-assert 25 :follows interval-5 interval-1)
 135          (my-assert 26 :contains interval-5 interval-2)
 136          (my-assert 27 :contains interval-5 interval-3)
 137          (my-assert 28 :overlaps interval-5 interval-4)
 138          (my-assert 29 :contains interval-5 interval-5)
 139          (my-assert 30 :contained interval-5 interval-6)
 140          (my-assert 31 :contains interval-6 interval-1)
 141          (my-assert 32 :contains interval-6 interval-2)
 142          (my-assert 33 :contains interval-6 interval-3)
 143          (my-assert 34 :contains interval-6 interval-4)
 144          (my-assert 35 :contains interval-6 interval-5)
 145          (my-assert 36 :contains interval-6 interval-6))))
 146   t)
 147
 148 ;; adjacent intervals in list
 149 (deftest :time/2
 150   (let* ((interval-list nil)
 151          (time-1 (clsql:parse-timestring "2002-01-01 10:00:00"))
 152          (time-3 (clsql:parse-timestring "2002-01-01 12:00:00"))
 153          (time-4 (clsql:parse-timestring "2002-01-01 13:00:00")))
 154     (setf interval-list
 155           (clsql:interval-push interval-list (clsql:make-interval :start time-1 :end time-3
 156                                                       :type :open)))
 157     (setf interval-list
 158           (clsql:interval-push interval-list (clsql:make-interval :start time-3 :end time-4
 159                                                       :type :open)))
 160     (clsql:interval-relation (car interval-list) (cadr interval-list)))
 161   :precedes)
 162
 163 ;; nested intervals in list
 164 (deftest :time/3
 165     (let* ((interval-list nil)
 166            (time-1 (clsql:parse-timestring "2002-01-01 10:00:00"))
 167            (time-2 (clsql:parse-timestring "2002-01-01 11:00:00"))
 168            (time-3 (clsql:parse-timestring "2002-01-01 12:00:00"))
 169            (time-4 (clsql:parse-timestring "2002-01-01 13:00:00")))
 170       (setf interval-list
 171             (clsql:interval-push interval-list (clsql:make-interval :start time-1
 172                                                         :end time-4
 173                                                         :type :open)))
 174       (setf interval-list
 175             (clsql:interval-push interval-list (clsql:make-interval :start time-2
 176                                                         :end time-3
 177                                                         :type :closed)))
 178       (let* ((interval (car interval-list))
 179              (interval-contained
 180               (when interval (car (clsql:interval-contained interval)))))
 181         (when (and interval interval-contained)
 182           (and (clsql:time= (clsql:interval-start interval) time-1)
 183                (clsql:time= (clsql:interval-end interval) time-4)
 184                (eq (clsql:interval-type interval) :open)
 185                (clsql:time= (clsql:interval-start interval-contained) time-2)
 186                (clsql:time= (clsql:interval-end interval-contained) time-3)
 187                (eq (clsql:interval-type interval-contained) :closed)))))
 188   t)
 189
 190 ;; interval-edit - nonoverlapping
 191 (deftest :time/4
 192     (let* ((interval-list nil)
 193            (time-1 (clsql:parse-timestring "2002-01-01 10:00:00"))
 194            (time-2 (clsql:parse-timestring "2002-01-01 11:00:00"))
 195            (time-3 (clsql:parse-timestring "2002-01-01 12:00:00"))
 196            (time-4 (clsql:parse-timestring "2002-01-01 13:00:00")))
 197       (setf interval-list (clsql:interval-push interval-list (clsql:make-interval :start time-1 :end time-2 :type :open)))
 198       (setf interval-list (clsql:interval-push interval-list (clsql:make-interval :start time-3 :end time-4 :type :closed)))
 199       (setf interval-list (clsql:interval-edit interval-list time-1 time-1 time-3))
 200       ;; should be time-3 not time-2
 201       (clsql:time= (clsql:interval-end (car interval-list)) time-3))
 202   t)
 203
 204 ;; interval-edit - overlapping
 205 (deftest :time/5
 206     (let* ((interval-list nil)
 207            (time-1 (clsql:parse-timestring "2002-01-01 10:00:00"))
 208            (time-2 (clsql:parse-timestring "2002-01-01 11:00:00"))
 209            (time-3 (clsql:parse-timestring "2002-01-01 12:00:00"))
 210            (time-4 (clsql:parse-timestring "2002-01-01 13:00:00")))
 211       (setf interval-list (clsql:interval-push interval-list (clsql:make-interval :start time-1 :end time-2 :type :open)))
 212       (setf interval-list (clsql:interval-push interval-list (clsql:make-interval :start time-2 :end time-4 :type :closed)))
 213       (let ((pass t))
 214         (handler-case
 215             (progn
 216               (setf interval-list
 217                     (clsql:interval-edit interval-list time-1 time-1 time-3))
 218               (setf pass nil))
 219           (error nil))
 220         pass))
 221   t)
 222
 223 ;; interval-edit - nested intervals in list
 224 (deftest :time/6
 225     (let* ((interval-list nil)
 226            (time-1 (clsql:parse-timestring "2002-01-01 10:00:00"))
 227            (time-2 (clsql:parse-timestring "2002-01-01 11:00:00"))
 228            (time-3 (clsql:parse-timestring "2002-01-01 12:00:00"))
 229            (time-4 (clsql:parse-timestring "2002-01-01 13:00:00"))
 230            (time-5 (clsql:parse-timestring "2002-01-01 14:00:00"))
 231            (time-6 (clsql:parse-timestring "2002-01-01 15:00:00")))
 232       (setf interval-list (clsql:interval-push interval-list (clsql:make-interval :start time-1 :end time-6 :type :open)))
 233       (setf interval-list (clsql:interval-push interval-list (clsql:make-interval :start time-2 :end time-3 :type :closed)))
 234       (setf interval-list (clsql:interval-push interval-list (clsql:make-interval :start time-4 :end time-5 :type :closed)))
 235       (setf interval-list (clsql:interval-edit interval-list time-1 time-1 time-4))
 236       ;; should be time-4 not time-6
 237       (clsql:time= (clsql:interval-end (car interval-list)) time-4))
 238   t)
 239
 240 ;; Test the boundaries of Local Time with granularity of 1 year
 241 (deftest :time/7
 242     (let ((sec-in-year (* 60 60 24 365))
 243           (year (clsql:time-element (clsql:make-time) :year)))
 244       (dotimes (n 50 n)
 245         (let ((date (clsql:make-time :second (* n sec-in-year))))
 246           (unless (= (+ year n)
 247                      (clsql:time-element date :year))
 248             (return n)))))
 249   50)
 250
 251 ;; Test db-timestring
 252 (deftest :time/9
 253     (flet ((grab-year (dbstring)
 254              (parse-integer (subseq dbstring 1 5))))
 255       (let ((second-in-year (* 60 60 24 365)))
 256         (dotimes (n 2000 n)
 257           (let* ((second (* -1 n second-in-year))
 258                  (date (clsql:make-time :year 2525 :second second)))
 259             (unless
 260                 (= (grab-year (clsql:db-timestring date))
 261                    (clsql:time-element date :year))
 262               (return n))))))
 263   2000)
 264
 265 ;; Conversion between MJD and Gregorian
 266 (deftest :time/10
 267     (dotimes (base 10000 base)
 268       (unless (= (apply #'clsql:gregorian-to-mjd (clsql:mjd-to-gregorian base))
 269                  base)
 270         (return base)))
 271   10000)
 272
 273 ;; Clsql:Roll by minutes: +90
 274 (deftest :time/11
 275     (let ((now (clsql:get-time)))
 276       (clsql:time= (clsql:time+ now (clsql:make-duration :minute 90))
 277              (clsql:roll now :minute 90)))
 278   t)
 279
 280 ;;Clsql:Roll by minutes: +900
 281 (deftest :time/12
 282     (let ((now (clsql:get-time)))
 283       (clsql:time= (clsql:time+ now (clsql:make-duration :minute 900))
 284              (clsql:roll now :minute 900)))
 285   t)
 286
 287
 288 ;; Clsql:Roll by minutes: +900
 289 (deftest :time/13
 290     (let* ((now (clsql:get-time))
 291            (add-time (clsql:time+ now (clsql:make-duration :minute 9000)))
 292            (roll-time (clsql:roll now :minute 9000)))
 293       (clsql:time= add-time roll-time))
 294   t)
 295
 296
 297
 298 ;;; The cross platform dataset uses the 'timestamp' column type which is
 299 ;;; in sql-92, for all that means.
 300
 301 (deftest :time/cross-platform/no-usec/no-tz
 302     (with-dataset *cross-platform-datetest*
 303       (let ((time (parse-timestring "2008-09-09T14:37:29")))
 304         (clsql-sys:insert-records :into [datetest]
 305                                   :attributes '([testtime])
 306                                   :values (list time))
 307         (let ((testtime
 308                (first (clsql:select [testtime]
 309                                     :from [datetest] :flatp T
 310                                     :where [= [testtime] time] ))))
 311           (format-time nil (parse-timestring testtime) :format :iso)
 312           )))
 313   #.(format-time nil (parse-timestring "2008-09-09T14:37:29") :format :iso))
 314
 315 (deftest :time/cross-platform/no-usec/tz
 316     (with-dataset *cross-platform-datetest*
 317       (let ((time (parse-timestring "2008-09-09T14:37:29-04:00")))
 318         (clsql-sys:insert-records :into [datetest]
 319                                   :attributes '([testtime])
 320                                   :values (list time))
 321         (let ((testtime
 322                (first (clsql:select [testtime]
 323                                     :from [datetest] :flatp T
 324                                     :where [= [testtime] time] ))))
 325           (format-time nil (parse-timestring testtime) :format :iso)
 326           )))
 327   #.(format-time nil (parse-timestring "2008-09-09T14:37:29-04:00") :format :iso))
 328
 329 ;;;This test gets at the databases that only support miliseconds,
 330 ;;; not microseconds.
 331 (deftest :time/cross-platform/msec
 332     (with-dataset *cross-platform-datetest*
 333       (let ((time (parse-timestring "2008-09-09T14:37:29.423")))
 334         (clsql-sys:insert-records :into [datetest]
 335                                   :attributes '([testtime])
 336                                   :values (list time))
 337         (let ((testtime
 338                (first (clsql:select [testtime]
 339                                     :from [datetest] :flatp T
 340                                     :where [= [testtime] time] ))))
 341           (format-time nil (parse-timestring testtime) :format :iso)
 342           )))
 343   #.(format-time nil (parse-timestring "2008-09-09T14:37:29.423") :format :iso))
 344
 345 (deftest :time/cross-platform/usec/no-tz
 346     (with-dataset *cross-platform-datetest*
 347       (let ((time (parse-timestring "2008-09-09T14:37:29.000213")))
 348         (clsql-sys:insert-records :into [datetest]
 349                                   :attributes '([testtime])
 350                                   :values (list time))
 351         (let ((testtime
 352                (first (clsql:select [testtime]
 353                                     :from [datetest] :flatp T
 354                                     :where [= [testtime] time] ))))
 355           (format-time nil (parse-timestring testtime) :format :iso)
 356           )))
 357   #.(format-time nil (parse-timestring "2008-09-09T14:37:29.000213") :format :iso))
 358
 359 (deftest :time/cross-platform/usec/tz
 360     (with-dataset *cross-platform-datetest*
 361       (let ((time (parse-timestring "2008-09-09T14:37:29.000213-04:00")))
 362         (clsql-sys:insert-records :into [datetest]
 363                                   :attributes '([testtime])
 364                                   :values (list time))
 365         (let ((testtime
 366                (first (clsql:select [testtime]
 367                                     :from [datetest]
 368                                     :limit 1 :flatp T
 369                                     :where [= [testtime] time] ))))
 370           (format-time nil (parse-timestring testtime) :format :iso)
 371           )))
 372   #.(format-time nil (parse-timestring "2008-09-09T14:37:29.000213-04:00") :format :iso))
 373
 374
 375
 376
 377 ;;; All odbc databases use local times exclusively (they do not send timezone info)
 378 ;;; Postgresql can use timezones, except when being used over odbc.  This test when
 379 ;;; run through both postgres socket and postgres odbc should test a fairly
 380 ;;; broad swath of available problem space
 381 ;;;
 382 ;;; Things the following tests try to prove correct
 383 ;;;  * Reading and writing usec and usec-less times
 384 ;;;  * reading and writing timezones (Z=utc) when appropriate (eg: postgresql-socket)
 385 ;;;  * reading and writing localtimes when appropriate (eg: ODBC)
 386 ;;;  * reading and writing through both the oodml and fdml layers
 387
 388
 389
 390 (deftest :time/pg/fdml/usec
 391   (with-dataset *ds-datetest*
 392     (let ((time (parse-timestring "2008-09-09T14:37:29.000213-04:00")))
 393       (clsql-sys:insert-records :into [datetest]
 394                                 :attributes '([testtimetz] [testtime])
 395                                 :values (list time time))
 396       (destructuring-bind (testtimetz testtime)
 397           (first (clsql:select [testtimetz] [testtime]
 398                                :from [datetest]
 399                                :limit 1 :flatp T
 400                                :where [= [testtime] time] ))
 401         (values (iso-timestring (parse-timestring testtime))
 402                 (iso-timestring (parse-timestring testtimetz))))))
 403   #.(iso-timestring (parse-timestring "2008-09-09T14:37:29.000213-04:00"))
 404   #.(iso-timestring (parse-timestring "2008-09-09T14:37:29.000213-04:00")))
 405
 406 (deftest :time/pg/oodml/no-usec
 407   (with-dataset *ds-datetest*
 408     (let ((time (parse-timestring "2008-09-09T14:37:29-04:00")))
 409       (clsql-sys:update-records-from-instance
 410        (make-instance 'datetest :testtimetz time :testtime time))
 411       (let ((o (first (clsql:select
 412                           'datetest
 413                         :limit 1 :flatp T
 414                         :where [= [testtime] time] ))))
 415         (assert o (o) "o shouldnt be null here (we should have just inserted)")
 416         (update-records-from-instance o)
 417         (update-instance-from-records o)
 418         (values (iso-timestring (testtime o))
 419                 (iso-timestring (testtimetz o))))))
 420   #.(iso-timestring (parse-timestring "2008-09-09T14:37:29-04:00"))
 421   #.(iso-timestring (parse-timestring "2008-09-09T14:37:29-04:00")))
 422
 423 (deftest :time/pg/oodml/usec
 424     (with-dataset *ds-datetest*
 425       (let ((time (parse-timestring "2008-09-09T14:37:29.000278-04:00")))
 426         (clsql-sys:update-records-from-instance
 427          (make-instance 'datetest :testtimetz time :testtime time))
 428         (let ((o (first (clsql:select
 429                          'datetest
 430                          :limit 1 :flatp T
 431                          :where [= [testtime] time] ))))
 432           (assert o (o) "o shouldnt be null here (we should have just inserted)")
 433           (update-records-from-instance o)
 434           (update-instance-from-records o)
 435           (values (iso-timestring (testtime o))
 436                   (iso-timestring (testtimetz o)))
 437           )))
 438     #.(iso-timestring (parse-timestring "2008-09-09T14:37:29.000278-04:00"))
 439     #.(iso-timestring (parse-timestring "2008-09-09T14:37:29.000278-04:00")))
 440
 441 ))
 442
 443
 444 #.(clsql-sys:locally-disable-sql-reader-syntax)