Merge pull request #146 from metabase/emailreport_tests

Emailreport tests

src/metabase/api/emailreport.clj

 (ns metabase.api.emailreport
+  "/api/emailreport endpoints."
   (:require [korma.core :refer [where subselect fields order limit]]
             [compojure.core :refer [defroutes GET PUT POST DELETE]]
             [medley.core :refer :all]
             [metabase.api.common :refer :all]
             [metabase.db :refer :all]
             (metabase.models [common :as common]
-              [hydrate :refer :all]
-              [database :refer [databases-for-org]]
-              [emailreport :refer [EmailReport modes days-of-week times-of-day]]
-              [emailreport-executions :refer [EmailReportExecutions]]
-              [user :refer [users-for-org]])
+                             [hydrate :refer :all]
+                             [database :refer [databases-for-org]]
+                             [emailreport :refer [EmailReport modes-input days-of-week times-of-day]]
+                             [emailreport-executions :refer [EmailReportExecutions]]
+                             [user :refer [users-for-org]])
             [metabase.util :as util]))
 
 
@@ -20,7 +21,7 @@
   (let [dbs (databases-for-org org)
         users (users-for-org org)]
     {:permissions common/permissions
-     :modes modes
+     :modes modes-input
      :days_of_week days-of-week
      :times_of_day times-of-day
      :timezones common/timezones

src/metabase/models/common.clj

@@ -63,14 +63,13 @@
           :can_write (delay (user-can? :write <>))))
 
 (def timezones
-  ['GMT',
-   'UTC',
-   'US/Alaska',
-   'US/Arizona',
-   'US/Central',
-   'US/Eastern',
-   'US/Hawaii',
-   'US/Mountain',
-   'US/Pacific',
-   'America/Costa_Rica'
-   ])
+  ["GMT"
+   "UTC"
+   "US/Alaska"
+   "US/Arizona"
+   "US/Central"
+   "US/Eastern"
+   "US/Hawaii"
+   "US/Mountain"
+   "US/Pacific"
+   "America/Costa_Rica"])

src/metabase/models/emailreport.clj

@@ -11,14 +11,28 @@
             [metabase.util :as util]))
 
 
-;; Static Definitions
-
-(def mode-active 0)
-(def mode-disabled 1)
+;; ## Static Definitions
 
 (def modes
-  [{:id mode-active :name "Active"},
-   {:id mode-disabled :name "Disabled"}])
+  {:active   {:id 0
+              :name "Active"}
+   :disabled {:id 1
+              :name "Disabled"}})
+
+(def mode-kws
+  (set (keys modes)))
+
+(defn mode->id [mode]
+  {:pre [(contains? mode-kws mode)]}
+  (:id (modes mode)))
+
+(defn mode->name [mode]
+  {:pre [(contains? mode-kws mode)]}
+  (:name (modes mode)))
+
+(def modes-input
+  [{:id (mode->id :active),   :name (mode->name :active)}
+   {:id (mode->id :disabled), :name (mode->name :disabled)}])
 
 (def days-of-week
   [{:id "sun" :name "Sun"},
@@ -37,13 +51,15 @@
    {:id "midnight" :name "Midnight" :realhour 0}])
 
 
+;; ## Entity
+
 (defentity EmailReport
   (table :report_emailreport))
 
 
 (defmethod pre-insert EmailReport [_ {:keys [dataset_query schedule] :as report}]
   (let [defaults {:public_perms perms-none
-                  :mode mode-active
+                  :mode (mode->id :active)
                   :version 1
                   :created_at (util/new-sql-timestamp)
                   :updated_at (util/new-sql-timestamp)}]

test/metabase/api/emailreport_test.clj

+(ns metabase.api.emailreport-test
+  "Tests for /api/emailreport endpoints."
+  (:require [expectations :refer :all]
+            [korma.core :refer :all]
+            [metabase.db :refer :all]
+            (metabase.models [common :as common]
+                             [database :refer [Database]]
+                             [emailreport :refer [EmailReport] :as emailreport])
+            [metabase.test.util :refer [match-$ expect-eval-actual-first random-name]]
+            [metabase.test-data :refer :all]))
+
+;; ## Helper Fns
+
+(defn create-email-report [& {:as kwargs}]
+  ((user->client :rasta) :post 200 "emailreport"
+   (merge {:name "My Cool Email Report"
+           :mode (emailreport/mode->id :active)
+           :public_perms common/perms-readwrite
+           :email_addresses ""
+           :recipients [{:id (user->id :lucky)}]
+           :dataset_query {:type "query"
+                           :query {:source_table (table->id :venues)
+                                   :filter [nil nil]
+                                   :aggregation ["rows"]
+                                   :breakout [nil]
+                                   :limit nil}
+                           :database (:id @test-db)}
+           :schedule {:days_of_week {:mon true
+                                     :tue true
+                                     :wed true
+                                     :thu true
+                                     :fri true
+                                     :sat true
+                                     :sun true}
+                      :time_of_day "morning"
+                      :timezone ""}
+           :organization (:id @test-org)}
+          kwargs)))
+
+;; ## GET /api/emailreport/form_input
+;; Test that we can get the form input options for the Test Org
+(expect-let [_ @test-db ; force lazy loading of Test Data / Metabase DB
+             _ (cascade-delete Database :name [not= "Test Database"])] ; Delete all Databases that aren't the Test DB
+  {:users #{{:id (user->id :rasta),     :name "Rasta Toucan"}
+            {:id (user->id :crowberto), :name "Crowberto Corv"}
+            {:id (user->id :lucky),     :name "Lucky Pigeon"}
+            {:id (user->id :trashbird), :name "Trash Bird"}}
+   :databases [{:id (:id @test-db)
+                :name "Test Database"}],
+   :timezones ["GMT"
+               "UTC"
+               "US/Alaska"
+               "US/Arizona"
+               "US/Central"
+               "US/Eastern"
+               "US/Hawaii"
+               "US/Mountain"
+               "US/Pacific"
+               "America/Costa_Rica"]
+   :times_of_day [{:id "morning",   :realhour 8,  :name "Morning"}
+                  {:id "midday",    :realhour 12, :name "Midday"}
+                  {:id "afternoon", :realhour 16, :name "Afternoon"}
+                  {:id "evening",   :realhour 20, :name "Evening"}
+                  {:id "midnight",  :realhour 0,  :name "Midnight"}]
+   :days_of_week [{:id "sun", :name "Sun"}
+                  {:id "mon", :name "Mon"}
+                  {:id "tue", :name "Tue"}
+                  {:id "wed", :name "Wed"}
+                  {:id "thu", :name "Thu"}
+                  {:id "fri", :name "Fri"}
+                  {:id "sat", :name "Sat"}]
+   :modes [{:name "Active", :id 0}
+           {:name "Disabled", :id 1}]
+   :permissions [{:name "None",         :id 0}
+                 {:name "Read Only",    :id 1}
+                 {:name "Read & Write", :id 2}]}
+  (-> ((user->client :rasta) :get 200 "emailreport/form_input" :org (:id @test-org)) ; convert to a set so test doesn't fail if order differs
+        (update-in [:users] set)))
+
+
+;; ## POST /api/emailreport
+(expect-eval-actual-first
+    (match-$ (sel :one EmailReport (order :id :DESC))
+      {:description nil
+       :email_addresses ""
+       :schedule {:days_of_week {:mon true
+                                 :tue true
+                                 :wed true
+                                 :thu true
+                                 :fri true
+                                 :sat true
+                                 :sun true}
+                  :timezone ""
+                  :time_of_day "morning"}
+       :organization_id (:id @test-org)
+       :name "My Cool Email Report"
+       :mode (emailreport/mode->id :active)
+       :creator_id (user->id :rasta)
+       :updated_at $
+       :dataset_query {:database (:id @test-db)
+                       :query {:limit nil
+                               :breakout [nil]
+                               :aggregation ["rows"]
+                               :filter [nil nil]
+                               :source_table (table->id :venues)}
+                       :type "query"}
+       :id $
+       :version 1
+       :public_perms common/perms-readwrite
+       :created_at $})
+  (create-email-report))
+
+;; ## GET /api/emailreport/:id
+(expect-eval-actual-first
+    (match-$ (sel :one EmailReport (order :id :DESC))
+      {:description nil
+       :email_addresses ""
+       :can_read true
+       :schedule {:days_of_week {:mon true
+                                 :tue true
+                                 :wed true
+                                 :thu true
+                                 :fri true
+                                 :sat true
+                                 :sun true}
+                  :timezone ""
+                  :time_of_day "morning"}
+       :creator (match-$ (fetch-user :rasta)
+                  {:common_name "Rasta Toucan"
+                   :date_joined $
+                   :last_name "Toucan"
+                   :id $
+                   :is_superuser false
+                   :last_login $
+                   :first_name "Rasta"
+                   :email "rasta@metabase.com"})
+       :can_write true
+       :organization_id (:id @test-org)
+       :name "My Cool Email Report"
+       :mode (emailreport/mode->id :active)
+       :organization {:id (:id @test-org)
+                      :slug "test"
+                      :name "Test Organization"
+                      :description nil
+                      :logo_url nil
+                      :inherits true}
+       :creator_id (user->id :rasta)
+       :updated_at $
+       :dataset_query {:database (:id @test-db)
+                       :query {:limit nil
+                               :breakout [nil]
+                               :aggregation ["rows"]
+                               :filter [nil nil]
+                               :source_table (table->id :venues)}
+                       :type "query"}
+       :id $
+       :version 1
+       :public_perms common/perms-readwrite
+       :created_at $})
+  (let [{id :id} (create-email-report)]
+    ((user->client :rasta) :get 200 (format "emailreport/%d" id))))
+
+;; ## DELETE /api/emailreport/:id
+(let [er-name (random-name)
+      er-exists? (fn [] (exists? EmailReport :name er-name))]
+  (expect-eval-actual-first
+      [false
+       true
+       false]
+    [(er-exists?)
+     (do (create-email-report :name er-name)
+         (er-exists?))
+     (let [{id :id} (sel :one EmailReport :name er-name)]
+       ((user->client :rasta) :delete 204 (format "emailreport/%d" id))
+       (er-exists?))]))

test/metabase/test_data.clj

@@ -122,15 +122,17 @@
      {:pre [(contains? usernames username)]}
      (:id (fetch-user username)))))
 
-(defn user->client
+(def user->client
   "Returns a `metabase.http-client/client` partially bound with the credentials for User with USERNAME.
    In addition, it forces lazy creation of the User if needed.
 
     ((user->client) :get 200 \"meta/table\")"
-  [username]
-  {:pre [(contains? usernames username)]}
-  (user->id username)                                 ; call a function that will force User to created if need be
-  (partial http/client (user->credentials username)))
+  (memoize
+   (fn [username]
+     {:pre [(contains? usernames username)]}
+     ;; Force lazy creation of User if need be
+     (user->id username)
+     (partial http/client (user->credentials username)))))
 
 (defn user->org-perm
   "Return the `OrgPerm` for User with USERNAME for the Test Org."