tests/test-time.lisp

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