Merge pull request #101 from metabase/session_api_tests

Unit tests for Session API. new-sql-date -> new-sql-timestamp

src/metabase/api/session.clj

@@ -15,6 +15,7 @@
   (let-400 [user (sel :one :fields [User :id :password_salt :password] :email email (korma/where {:is_active true}))]
     (check (creds/bcrypt-verify (str (:password_salt user) password) (:password user)) [400 "password mismatch"])
     (let [session-id (str (java.util.UUID/randomUUID))]
+      (println "SESSION ID: " session-id)
       (ins Session
         :id session-id
         :user_id (:id user))

src/metabase/driver.clj

@@ -41,8 +41,8 @@
                          :version 0
                          :status "starting"
                          :error ""
-                         :started_at (util/new-sql-date)
-                         :finished_at (util/new-sql-date)
+                         :started_at (util/new-sql-timestamp)
+                         :finished_at (util/new-sql-timestamp)
                          :running_time 0
                          :result_rows 0
                          :result_file ""
@@ -85,7 +85,7 @@
   [query-execution msg]
   (let [updates {:status "failed"
                  :error msg
-                 :finished_at (util/new-sql-date)
+                 :finished_at (util/new-sql-timestamp)
                  :running_time (- (System/currentTimeMillis) (:start_time_millis query-execution))}]
     ;; record our query execution and format response
     (-> query-execution
@@ -104,7 +104,7 @@
   ;; record our query execution and format response
   (-> (util/assoc* query-execution
                    :status "completed"
-                   :finished_at (util/new-sql-date)
+                   :finished_at (util/new-sql-timestamp)
                    :running_time (- (System/currentTimeMillis) (:start_time_millis <>))
                    :result_rows (get query-result :row_count 0)
                    :result_data (if cache-result
@@ -126,4 +126,3 @@
       query-execution)
     ;; first time saving execution, so insert it
     (mapply ins QueryExecution query-execution)))
-

src/metabase/models/annotation.clj

@@ -13,13 +13,13 @@
 
 
 (defmethod pre-insert Annotation [_ annotation]
-  (let [defaults {:created_at (util/new-sql-date)
-                  :updated_at (util/new-sql-date)}]
+  (let [defaults {:created_at (util/new-sql-timestamp)
+                  :updated_at (util/new-sql-timestamp)}]
     (merge defaults annotation)))
 
 
 (defmethod pre-update Annotation [_ annotation]
-  (assoc annotation :updated_at (util/new-sql-date)))
+  (assoc annotation :updated_at (util/new-sql-timestamp)))
 
 
 (defmethod post-select Annotation [_ {:keys [organization_id author_id] :as annotation}]

src/metabase/models/card.clj

@@ -13,15 +13,15 @@
   (table :report_card))
 
 (defmethod pre-insert Card [_ {:keys [dataset_query visualization_settings] :as card}]
-  (let [defaults {:created_at (util/new-sql-date)
-                  :updated_at (util/new-sql-date)}]
+  (let [defaults {:created_at (util/new-sql-timestamp)
+                  :updated_at (util/new-sql-timestamp)}]
     (-> (merge defaults card)
         (assoc :dataset_query (json/write-str dataset_query)
                :visualization_settings (json/write-str visualization_settings)))))
 
 (defmethod pre-update Card [_ {:keys [dataset_query visualization_settings] :as card}]
   (assoc card
-         :updated_at (util/new-sql-date)
+         :updated_at (util/new-sql-timestamp)
          :dataset_query (json/write-str dataset_query)
          :visualization_settings (json/write-str visualization_settings)))
 

src/metabase/models/card_favorite.clj

@@ -3,7 +3,7 @@
             [metabase.db :refer :all]
             (metabase.models [card :refer [Card]]
                              [user :refer [User]])
-            [metabase.util :refer [new-sql-date]]))
+            [metabase.util :refer [new-sql-timestamp]]))
 
 (defentity CardFavorite
   (table :report_cardfavorite))
@@ -14,6 +14,6 @@
          :card (sel-fn :one Card :id card_id)))
 
 (defmethod pre-insert CardFavorite [_ card-favorite]
-  (let [defaults {:created_at (new-sql-date)
-                  :updated_at (new-sql-date)}]
+  (let [defaults {:created_at (new-sql-timestamp)
+                  :updated_at (new-sql-timestamp)}]
     (merge defaults card-favorite)))

src/metabase/models/dashboard.clj

@@ -11,13 +11,13 @@
   (table :report_dashboard))
 
 (defmethod pre-insert Dashboard [_ dashboard]
-  (let [defaults {:created_at (util/new-sql-date)
-                  :updated_at (util/new-sql-date)}]
+  (let [defaults {:created_at (util/new-sql-timestamp)
+                  :updated_at (util/new-sql-timestamp)}]
     (merge defaults dashboard)))
 
 (defmethod pre-update Dashboard [_ dashboard]
   (assoc dashboard
-         :updated_at (util/new-sql-date)))
+         :updated_at (util/new-sql-timestamp)))
 
 (defmethod post-select Dashboard [_ {:keys [id creator_id organization_id] :as dash}]
   (-> dash

src/metabase/models/dashboard_card.clj

@@ -27,12 +27,12 @@
              :dashboard (sel-fn :one "metabase.models.dashboard/Dashboard" :id dashboard_id))))
 
 (defmethod pre-insert DashboardCard [_ dashcard]
-  (let [defaults {:created_at (util/new-sql-date)
-                  :updated_at (util/new-sql-date)
+  (let [defaults {:created_at (util/new-sql-timestamp)
+                  :updated_at (util/new-sql-timestamp)
                   :sizeX 2
                   :sizeY 2}]
     (merge defaults dashcard)))
 
 (defmethod pre-update DashboardCard [_ dashcard]
   (assoc dashcard
-         :updated_at (util/new-sql-date))) ; is this useful in any way whatsoever???
+         :updated_at (util/new-sql-timestamp))) ; is this useful in any way whatsoever???

src/metabase/models/database.clj

@@ -69,14 +69,14 @@
 
 (defmethod pre-insert Database [_ {:keys [details engine] :as database}]
   (assoc database
-         :created_at (new-sql-date)
-         :updated_at (new-sql-date)
+         :created_at (new-sql-timestamp)
+         :updated_at (new-sql-timestamp)
          :details (json/write-str details)
          :engine (name engine)))
 
 (defmethod pre-update Database [_ {:keys [details] :as database}]
   (assoc database
-         :updated_at (new-sql-date)
+         :updated_at (new-sql-timestamp)
          :details (json/write-str details)))
 
 (defn databases-for-org

src/metabase/models/emailreport.clj

@@ -45,15 +45,15 @@
   (let [defaults {:public_perms perms-none
                   :mode mode-active
                   :version 1
-                  :created_at (util/new-sql-date)
-                  :updated_at (util/new-sql-date)}]
+                  :created_at (util/new-sql-timestamp)
+                  :updated_at (util/new-sql-timestamp)}]
     (-> (merge defaults report)
         (assoc :dataset_query (json/write-str dataset_query)
                :schedule (json/write-str schedule)))))
 
 (defmethod pre-update EmailReport [_ {:keys [version dataset_query schedule] :as report}]
   (assoc report
-    :updated_at (util/new-sql-date)
+    :updated_at (util/new-sql-timestamp)
     :dataset_query (json/write-str dataset_query)
     :schedule (json/write-str schedule)
     :version (+ 1 version)))

src/metabase/models/field.clj

@@ -76,8 +76,8 @@
                :distinct-count (delay (field-distinct-count <>))))
 
 (defmethod pre-insert Field [_ field]
-  (let [defaults {:created_at (util/new-sql-date)
-                  :updated_at (util/new-sql-date)
+  (let [defaults {:created_at (util/new-sql-timestamp)
+                  :updated_at (util/new-sql-timestamp)
                   :active true
                   :preview_display true
                   :field_type :dimension

src/metabase/models/query.clj

@@ -28,8 +28,8 @@
    :database_id])
 
 (defmethod pre-insert Query [_ {:keys [details] :as query}]
-  (let [defaults {:created_at (new-sql-date)
-                  :updated_at (new-sql-date)
+  (let [defaults {:created_at (new-sql-timestamp)
+                  :updated_at (new-sql-timestamp)
                   :version 1}]
     (-> (merge defaults query)
         (assoc :details (json/write-str details)))))
@@ -40,7 +40,7 @@
       (assoc :details (json/write-str (if-not sql {}
                                         {:sql sql
                                          :timezone timezone}))
-             :updated_at (new-sql-date)
+             :updated_at (new-sql-timestamp)
              :version (+ 1 version))))
 
 (defmethod post-select Query [_ {:keys [creator_id database_id] :as query}]

src/metabase/models/session.clj

@@ -11,5 +11,5 @@
 
 
 (defmethod pre-insert Session [_ session]
-  (let [defaults {:created_at (util/new-sql-date)}]
+  (let [defaults {:created_at (util/new-sql-timestamp)}]
     (merge defaults session)))

src/metabase/models/table.clj

@@ -46,5 +46,5 @@
 
 (defmethod pre-insert Table [_ table]
   (assoc table
-         :created_at (util/new-sql-date)
-         :updated_at (util/new-sql-date)))
+         :created_at (util/new-sql-timestamp)
+         :updated_at (util/new-sql-timestamp)))

src/metabase/models/user.clj

@@ -43,8 +43,8 @@
              :common_name (str (:first_name user) " " (:last_name user)))))
 
 (defmethod pre-insert User [_ user]
-  (let [defaults {:date_joined (util/new-sql-date)
-                  :last_login (util/new-sql-date)
+  (let [defaults {:date_joined (util/new-sql-timestamp)
+                  :last_login (util/new-sql-timestamp)
                   :is_staff true
                   :is_active true
                   :is_superuser false}]

src/metabase/util.clj

@@ -79,13 +79,16 @@
         ~(if (empty? rest) `~'<>
              `(-assoc* ~@rest))))
 
-(defn new-sql-date
+(defn new-sql-timestamp
   "`java.sql.Date` doesn't have an empty constructor so this is a convenience that lets you make one with the current date.
-   (Some DBs like Postgres will get snippy if you don't use a `java.sql.Date`)."
+   (Some DBs like Postgres will get snippy if you don't use a `java.sql.Timestamp`)."
   []
   (-> (java.util.Date.)
-      .getTime
-      (java.sql.Date.)))
+      .getTime ; time in milliseconds
+      (/ 1000) ; we don't care about the ms so strip them out
+      int
+      (* 1000)
+      (java.sql.Timestamp.)))
 
 (defn parse-iso8601
   "parse a string value expected in the iso8601 format into a `java.sql.Date`."
@@ -135,4 +138,4 @@
   [v]
   (if (nil? v)
     false
-    (boolean (re-matches #"[a-z0-9!#$%&'*+/=?^_`{|}~-]+(?:\.[a-z0-9!#$%&'*+/=?^_`{|}~-]+)*@(?:[a-z0-9](?:[a-z0-9-]*[a-z0-9])?\.)+[a-z0-9](?:[a-z0-9-]*[a-z0-9])?" v))))
\ No newline at end of file
+    (boolean (re-matches #"[a-z0-9!#$%&'*+/=?^_`{|}~-]+(?:\.[a-z0-9!#$%&'*+/=?^_`{|}~-]+)*@(?:[a-z0-9](?:[a-z0-9-]*[a-z0-9])?\.)+[a-z0-9](?:[a-z0-9-]*[a-z0-9])?" v))))

test/metabase/api/card_test.clj

@@ -84,6 +84,18 @@
       (-> ((user->client :rasta) :get 200 (format "card/%d" id))
           (deserialize-dates :updated_at :created_at)))))
 
+;; ## PUT /api/card/:id
+;; Test that we can edit a Card
+(let [card-name (random-name)
+      updated-name (random-name)]
+  (expect-eval-actual-first
+      [card-name
+       updated-name]
+    (let [{id :id} (post-card card-name)]
+      [(sel :one :field [Card :name] :id id)
+       (do ((user->client :rasta) :put 200 (format "card/%d" id) {:name updated-name})
+           (sel :one :field [Card :name] :id id))])))
+
 ;; ## DELETE /api/card/:id
 ;; Check that we can delete a card
 (expect-eval-actual-first nil

test/metabase/api/session_test.clj

+(ns metabase.api.session-test
+  "Tests for /api/session"
+  (:require [expectations :refer :all]
+            [korma.core :refer :all]
+            [metabase.db :refer :all]
+            [metabase.http-client :refer :all]
+            [metabase.test-data :refer :all]
+            [metabase.models.session :refer [Session]]
+            [metabase.test.util :refer [expect-eval-actual-first]]))
+
+;; ## POST /api/session
+;; Test that we can login
+(expect-eval-actual-first
+    (sel :one :fields [Session :id] :user_id (user->id :rasta))
+  (do (del Session :user_id (user->id :rasta))                  ; delete all other sessions for the bird first
+      (client :post 200 "session" (user->credentials :rasta))))
+
+;; ## DELETE /api/session
+;; Test that we can logout
+(expect-eval-actual-first nil
+  (let [{session_id :id} ((user->client :rasta) :post 200 "session" (user->credentials :rasta))]
+    (assert session_id)
+    ((user->client :rasta) :delete 204 "session" :session_id session_id)
+    (sel :one Session :id session_id)))