test fix

src/metabase/models/database.clj

@@ -18,6 +18,28 @@
          :can_read     (delay true)
          :can_write    (delay (:is_superuser @*current-user*))))
 
+ {:created_at #inst "2015-06-30T19:51:45.294000000-00:00",
+   :engine :h2,
+   :id 3,
+   :details
+   {:db
+    "file:/Users/camsaul/metabase/target/Test_Database;AUTO_SERVER=TRUE;DB_CLOSE_DELAY=-1"},
+   :updated_at #inst "2015-06-30T19:51:45.294000000-00:00",
+   :name "Test Database",
+   :organization_id nil,
+   :description nil}
+
+{:description nil,
+   :organization_id nil,
+   :name "Test Database",
+   :updated_at #inst "2015-06-30T19:51:45.294000000-00:00",
+   :details
+   {:db
+    "file:/Users/camsaul/metabase/target/Test_Database;AUTO_SERVER=TRUE;DB_CLOSE_DELAY=-1"},
+   :id 3,
+   :engine "h2",
+   :created_at #inst "2015-06-30T19:51:45.294000000-00:00"}
+
+
 (defmethod pre-cascade-delete Database [_ {:keys [id] :as database}]
-  (println (format "DATABASE %d IS GOING TO BE DESTROYED..." id))
   (cascade-delete 'metabase.models.table/Table :db_id id))

test/metabase/api/meta/db_test.clj

@@ -109,41 +109,33 @@
 (let [db-name (str "A" (random-name))] ; make sure this name comes before "Test Database"
   (expect-eval-actual-first
       (set (filter identity
-                   [(datasets/when-testing-dataset :h2
-                      (match-$ (sel :one Database :name db-name)
-                        {:created_at      $
-                         :engine          "postgres"
-                         :id              $
-                         :details         {:host "localhost", :port 5432, :dbname "fakedb", :user "cam"}
-                         :updated_at      $
-                         :name            $
-                         :organization_id nil
-                         :description     nil}))
-                    (datasets/when-testing-dataset :mongo
-                      (match-$ @mongo-test-data/mongo-test-db
-                        {:created_at      $
-                         :engine          "mongo"
-                         :id              $
-                         :details         $
-                         :updated_at      $
-                         :name            "Test Database"
-                         :organization_id nil
-                         :description     nil}))
-                    (match-$ (db)
-                      {:created_at      $
-                       :engine          "h2"
-                       :id              $
-                       :details         $
-                       :updated_at      $
-                       :name            "Test Database"
-                       :organization_id nil
-                       :description     nil})]))
+                   (conj (for [dataset-name datasets/all-valid-dataset-names]
+                           (datasets/when-testing-dataset dataset-name
+                             (match-$ (datasets/db (datasets/dataset-name->dataset dataset-name))
+                               {:created_at      $
+                                :engine          (name $engine)
+                                :id              $
+                                :details         $
+                                :updated_at      $
+                                :name            "Test Database"
+                                :organization_id nil
+                                :description     nil})))
+                         (datasets/when-testing-dataset :h2
+                           (match-$ (sel :one Database :name db-name)
+                             {:created_at      $
+                              :engine          "postgres"
+                              :id              $
+                              :details         {:host "localhost", :port 5432, :dbname "fakedb", :user "cam"}
+                              :updated_at      $
+                              :name            $
+                              :organization_id nil
+                              :description     nil})))))
     (do
       ;; Delete all the randomly created Databases we've made so far
       (cascade-delete Database :id [not-in (set (filter identity
-                                                        (for [dataset (datasets/all-valid-dataset-names)]
-                                                          (datasets/when-testing-dataset dataset
-                                                            (db-id)))))])
+                                                        (for [dataset-name datasets/all-valid-dataset-names]
+                                                          (datasets/when-testing-dataset dataset-name
+                                                            (:id (datasets/db (datasets/dataset-name->dataset dataset-name)))))))])
       ;; Add an extra DB so we have something to fetch besides the Test DB
       (create-db db-name)
       ;; Now hit the endpoint